feat: Update client library API to use SORT syntax and enhance binlog tests

- Replace ORDER BY with SORT clause in client API (mygramclient.cpp/h)
- Rename order_by/order_desc parameters to sort_column/sort_desc for clarity
- Support MySQL-style LIMIT offset,count format when both are specified
- Change default sort behavior to descending (sort_desc = true)
- Update C API (mygramclient_c.cpp/h) to match new parameter names
- Add comprehensive binlog parsing tests with real event structures
- Add binlog reader unit tests for queue operations and event processing
- Test GTID, TABLE_MAP, WRITE_ROWS, UPDATE_ROWS, DELETE_ROWS event parsing
- Add multi-table routing and filter validation tests

Author: libraz

src/client/mygramclient.cpp

@@ -234,7 +234,7 @@ class MygramClient::Impl {
                                              uint32_t offset, const std::vector<std::string>& and_terms,
                                              const std::vector<std::string>& not_terms,
                                              const std::vector<std::pair<std::string, std::string>>& filters,
-                                             const std::string& order_by, bool order_desc) {
+                                             const std::string& sort_column, bool sort_desc) {
     // Build command
     std::ostringstream cmd;
     cmd << "SEARCH " << table << " " << EscapeQueryString(query);
@@ -251,19 +251,28 @@ class MygramClient::Impl {
       cmd << " FILTER " << key << " = " << EscapeQueryString(value);
     }
 
-    if (!order_by.empty()) {
-      cmd << " ORDER BY " << order_by << (order_desc ? " DESC" : " ASC");
-    } else if (order_desc) {
-      cmd << " ORDER DESC";
+    // SORT clause (replaces ORDER BY)
+    if (!sort_column.empty()) {
+      cmd << " SORT " << sort_column << (sort_desc ? " DESC" : " ASC");
+    } else if (!sort_desc) {
+      // Only add SORT ASC if explicitly requesting ascending order for primary key
+      cmd << " SORT ASC";
     }
+    // Default is SORT DESC (primary key descending), so no need to add it explicitly
 
-    if (limit > 0) {
+    // LIMIT clause - support MySQL-style offset,count format when both are specified
+    if (limit > 0 && offset > 0) {
+      cmd << " LIMIT " << offset << "," << limit;
+    } else if (limit > 0) {
       cmd << " LIMIT " << limit;
     }
 
-    if (offset > 0) {
-      cmd << " OFFSET " << offset;
-    }
+    // OFFSET clause - only needed if LIMIT didn't use offset,count format
+    // (This is redundant if we used LIMIT offset,count above, but kept for clarity)
+    // Note: The LIMIT offset,count format above already handles offset, so we skip this
+    // if (offset > 0 && limit == 0) {
+    //   cmd << " OFFSET " << offset;
+    // }
 
     auto result = SendCommand(cmd.str());
     if (auto* err = std::get_if<Error>(&result)) {
@@ -653,8 +662,8 @@ bool MygramClient::IsConnected() const {
 std::variant<SearchResponse, Error> MygramClient::Search(
     const std::string& table, const std::string& query, uint32_t limit, uint32_t offset,
     const std::vector<std::string>& and_terms, const std::vector<std::string>& not_terms,
-    const std::vector<std::pair<std::string, std::string>>& filters, const std::string& order_by, bool order_desc) {
-  return impl_->Search(table, query, limit, offset, and_terms, not_terms, filters, order_by, order_desc);
+    const std::vector<std::pair<std::string, std::string>>& filters, const std::string& sort_column, bool sort_desc) {
+  return impl_->Search(table, query, limit, offset, and_terms, not_terms, filters, sort_column, sort_desc);
 }
 
 std::variant<CountResponse, Error> MygramClient::Count(

src/client/mygramclient.h

@@ -197,8 +197,8 @@ class MygramClient {
    * @param and_terms Additional required terms
    * @param not_terms Excluded terms
    * @param filters Filter conditions (key=value pairs)
-   * @param order_by Column name for ORDER BY (empty for default)
-   * @param order_desc Sort descending (default: false = ascending)
+   * @param sort_column Column name for SORT clause (empty for primary key)
+   * @param sort_desc Sort descending (default: true = descending)
    * @return SearchResponse on success, Error on failure
    */
   std::variant<SearchResponse, Error> Search(
@@ -207,8 +207,8 @@ class MygramClient {
                               // - Default result limit
       uint32_t offset = 0, const std::vector<std::string>& and_terms = {},
       const std::vector<std::string>& not_terms = {},
-      const std::vector<std::pair<std::string, std::string>>& filters = {}, const std::string& order_by = "",
-      bool order_desc = false);
+      const std::vector<std::pair<std::string, std::string>>& filters = {}, const std::string& sort_column = "",
+      bool sort_desc = true);
 
   /**
    * @brief Count matching documents

src/client/mygramclient_c.cpp

@@ -120,13 +120,13 @@ int mygramclient_is_connected(const MygramClient_C* client) {
 int mygramclient_search(MygramClient_C* client, const char* table, const char* query, uint32_t limit, uint32_t offset,
                         MygramSearchResult_C** result) {
   return mygramclient_search_advanced(client, table, query, limit, offset, nullptr, 0, nullptr, 0, nullptr, nullptr, 0,
-                                      nullptr, 0, result);
+                                      nullptr, 1, result);  // Default sort_desc = 1 (descending)
 }
 
 int mygramclient_search_advanced(MygramClient_C* client, const char* table, const char* query, uint32_t limit,
                                  uint32_t offset, const char** and_terms, size_t and_count, const char** not_terms,
                                  size_t not_count, const char** filter_keys, const char** filter_values,
-                                 size_t filter_count, const char* order_by, int order_desc,
+                                 size_t filter_count, const char* sort_column, int sort_desc,
                                  MygramSearchResult_C** result) {
   if (client == nullptr || client->client == nullptr || table == nullptr || query == nullptr || result == nullptr) {
     return -1;
@@ -154,10 +154,10 @@ int mygramclient_search_advanced(MygramClient_C* client, const char* table, cons
     }
   }
 
-  std::string order_by_str = order_by != nullptr ? order_by : "";
+  std::string sort_column_str = sort_column != nullptr ? sort_column : "";
 
   auto search_result = client->client->Search(table, query, limit, offset, and_terms_vec, not_terms_vec, filters_vec,
-                                              order_by_str, order_desc != 0);
+                                              sort_column_str, sort_desc != 0);
 
   if (auto* err = std::get_if<Error>(&search_result)) {
     client->last_error = err->message;

src/client/mygramclient_c.h

@@ -138,15 +138,15 @@ int mygramclient_search(MygramClient_C* client, const char* table, const char* q
  * @param filter_keys Array of filter keys (can be NULL)
  * @param filter_values Array of filter values (can be NULL)
  * @param filter_count Number of filters
- * @param order_by Column name for ORDER BY (can be NULL)
- * @param order_desc Sort descending (0 = ascending, 1 = descending)
+ * @param sort_column Column name for SORT clause (can be NULL for primary key)
+ * @param sort_desc Sort descending (0 = ascending, 1 = descending, default 1)
  * @param result Output search results (caller must free with mygramclient_free_search_result)
  * @return 0 on success, -1 on error
  */
 int mygramclient_search_advanced(MygramClient_C* client, const char* table, const char* query, uint32_t limit,
                                  uint32_t offset, const char** and_terms, size_t and_count, const char** not_terms,
                                  size_t not_count, const char** filter_keys, const char** filter_values,
-                                 size_t filter_count, const char* order_by, int order_desc,
+                                 size_t filter_count, const char* sort_column, int sort_desc,
                                  MygramSearchResult_C** result);
 
 /**