Merge branch 'wl12496' Counting methods

Author: Bogdan Degtyariov

include/mysqlx/xapi.h

@@ -170,6 +170,7 @@ typedef object_id* MYSQLX_GUID;
 #define MYSQLX_ERROR_VIEW_TYPE_MSG "Statement must be of VIEW type"
 #define MYSQLX_ERROR_OUTPUT_BUFFER_NULL "The output buffer cannot be NULL"
 #define MYSQLX_ERROR_OUTPUT_BUFFER_ZERO "The output buffer cannot have zero length"
+#define MYSQLX_ERROR_OUTPUT_VARIABLE_NULL "The output variable cannot be NULL"
 #define MYSQLX_ERROR_OP_NOT_SUPPORTED "The operation is not supported by the function"
 #define MYSQLX_ERROR_WRONG_SSL_MODE "Wrong value for SSL Mode"
 #define MYSQLX_ERROR_NO_TLS_SUPPORT "Can not create TLS session - this connector is built without TLS support"
@@ -1201,6 +1202,22 @@ mysqlx_sql_new(mysqlx_session_t *sess, const char *query,
   ====================================================================
 */
 
+/**
+  Return a number of documents in a collection.
+
+  @param collection collection handle
+  @param[out] count the number of documents in a given collection
+          is returned through the parameter
+
+  @return `RESULT_OK` - on success; `RESULT_ERR` - on error
+
+  @ingroup xapi_coll
+*/
+
+PUBLIC_API int
+mysqlx_collection_count(mysqlx_collection_t *collection, uint64_t *count);
+
+
 /**
   Execute a collection FIND statement with a specific find
   criteria.
@@ -1724,6 +1741,22 @@ PUBLIC_API int mysqlx_set_modify_array_delete(mysqlx_stmt_t *stmt, ...);
 */
 
 
+/**
+  Return a number of rows in a table
+
+  @param table table handle
+  @param[out] the number of rows in a given table is returned
+          through the parameter
+
+  @return `RESULT_OK` - on success; `RESULT_ERR` - on error
+
+  @ingroup xapi_coll
+*/
+
+PUBLIC_API int
+mysqlx_table_count(mysqlx_table_t *table, uint64_t *count);
+
+
 /**
   Execute a table SELECT statement with a WHERE clause.
 
@@ -2568,13 +2601,19 @@ mysqlx_get_affected_count(mysqlx_result_t *res);
   handle is valid.
 
   @param result result handle
-  @param[out] num number of records buffered
+  @param[out] num number of records buffered. Zero is never returned. If the
+              number of records to buffer is zero the function returns
+              `RESULT_ERR`
 
   @return `RESULT_OK` - on success; `RESULT_ERR` - on error. If the error
           occurred it can be retrieved by `mysqlx_error()` function.
 
   @note Even in case of an error some rows/documents might be buffered if they
         were retrieved before the error occurred.
+  @note When called for second time on the same result the function
+        does not store anything because the data is already buffered.
+        Instead it returns the number of items that have not been
+        fetched yet.
 
   @ingroup xapi_res
 */
@@ -2583,6 +2622,27 @@ PUBLIC_API int
 mysqlx_store_result(mysqlx_result_t *result, size_t *num);
 
 
+/**
+  Function for getting the number of remaining cached items in a result.
+  If nothing is cached if will attempt to store result in the internal
+  cache like `mysqlx_store_result()`.
+
+  @param result result handle
+  @param[out] num number of records buffered.
+
+  @return `RESULT_OK` - on success; `RESULT_ERR` - on error. If the error
+          occurred it can be retrieved by `mysqlx_error()` function.
+
+  @note Even in case of an error some rows/documents might be buffered if they
+        were retrieved before the error occurred.
+
+  @ingroup xapi_res
+*/
+
+PUBLIC_API int
+mysqlx_get_count(mysqlx_result_t *result, size_t *num);
+
+
 /**
   Get identifiers of the documents added to the collection.
 

xapi/crud.cc

@@ -636,3 +636,28 @@ int mysqlx_stmt_struct::add_multiple_documents(va_list &args)
     set_diagnostic("No documents specified for ADD operation.", 0);
   return rc;
 }
+
+template <class T>
+uint64_t get_count(T &obj)
+{
+  mysqlx_session_struct &sess = obj.get_session();
+  mysqlx_stmt_struct *stmt =
+    sess.new_stmt<OP_SELECT>(obj);
+  if (!stmt)
+    throw_error("Failed to create statement");
+
+  if (RESULT_OK != mysqlx_set_items(stmt, "COUNT(*)", PARAM_END))
+    throw_error("Failed to bind parameter");
+
+  return stmt->exec()->read_row()->get(0).get_uint();
+}
+
+uint64_t mysqlx_collection_struct::count()
+{
+  return get_count(*this);
+}
+
+uint64_t mysqlx_table_struct::count()
+{
+  return get_count(*this);
+}

xapi/crud_internal.h

@@ -80,7 +80,6 @@ struct mysqlx_result_struct
       set_diagnostic(mysqlx_error_struct(m_reply->get_error()));
   }
 
-
   mysqlx_error_struct *get_next_warning();
 
   /*

xapi/mysqlx.cc

@@ -811,20 +811,35 @@ const char * STDCALL mysqlx_json_fetch_one(mysqlx_result_struct *res, size_t *le
 }
 
 
-int STDCALL
-mysqlx_store_result(mysqlx_result_struct *result, size_t *num)
+int STDCALL _store_result(mysqlx_result_struct *result, size_t *num,
+                          bool no_data_error)
 {
   SAFE_EXCEPTION_BEGIN(result, RESULT_ERROR)
-    if (!result->has_data())
+    if (no_data_error && !result->has_data())
       throw Mysqlx_exception("Attempt to store data for result without a data set");
-    cdk::row_count_t row_num = result->count();
-    if (num)
-      *num = row_num;
-    return RESULT_OK;
+
+  cdk::row_count_t row_num = result->count();
+  if (num)
+    *num = row_num;
+  return RESULT_OK;
   SAFE_EXCEPTION_END(result, RESULT_ERROR)
 }
 
 
+int STDCALL
+mysqlx_store_result(mysqlx_result_struct *result, size_t *num)
+{
+  return _store_result(result, num, true);
+}
+
+
+int STDCALL
+mysqlx_get_count(mysqlx_result_struct *result, size_t *num)
+{
+  return _store_result(result, num, false);
+}
+
+
 /*
   Accessing row fields
   -------------------------------------------------------------------------
@@ -1482,6 +1497,27 @@ mysqlx_table_delete(mysqlx_table_struct *table, const char *criteria)
 }
 
 
+int STDCALL
+mysqlx_table_count(mysqlx_table_t *table, uint64_t *count)
+{
+  SAFE_EXCEPTION_BEGIN(table, RESULT_ERROR)
+  PARAM_NULL_CHECK(count, table, MYSQLX_ERROR_OUTPUT_VARIABLE_NULL, RESULT_ERROR);
+  *count = table->count();
+  return RESULT_OK;
+  SAFE_EXCEPTION_END(table, RESULT_ERROR)
+}
+
+
+int STDCALL
+mysqlx_collection_count(mysqlx_collection_t *collection, uint64_t *count)
+{
+  SAFE_EXCEPTION_BEGIN(collection, RESULT_ERROR)
+  PARAM_NULL_CHECK(count, collection, MYSQLX_ERROR_OUTPUT_VARIABLE_NULL, RESULT_ERROR);
+  *count = collection->count();
+  return RESULT_OK;
+  SAFE_EXCEPTION_END(collection, RESULT_ERROR)
+}
+
 mysqlx_result_struct * STDCALL
 mysqlx_collection_find(mysqlx_collection_struct *collection, const char *criteria)
 {

xapi/mysqlx_cc_internal.h

@@ -395,6 +395,8 @@ struct mysqlx_collection_struct
     , m_sess(schema.get_session())
   {}
 
+  uint64_t count();
+
   bool exists()
   {
     return
@@ -453,6 +455,8 @@ struct mysqlx_table_struct
     , m_sess(schema.get_session())
   {}
 
+  uint64_t count();
+
   bool exists()
   {
     return

xapi/tests/test.h

@@ -56,7 +56,7 @@ using namespace ::std;
 }
 
 #define ERR_CHECK(A, C) if((A) == RESULT_ERROR) { \
-  cout << endl << "Error!" << mysqlx_stmt_error_message(C) << endl; \
+  cout << endl << "Error!" << mysqlx_error_message(C) << endl; \
   FAIL(); \
 }
 

xapi/tests/xapi_crud-t.cc

@@ -50,6 +50,93 @@
        "{\"_id\": \"C8B27676E8A1D1E12C250850273BD114\", \"a_key\": 5, \"b_key\": \"so long world\", \"c_key\": 88.888}"
   };
 
+TEST_F(xapi, test_count)
+{
+  mysqlx_result_t *res;
+  mysqlx_schema_t *schema;
+  mysqlx_collection_t *collection;
+  mysqlx_table_t *table;
+  mysqlx_stmt_t *stmt;
+  mysqlx_row_t *row;
+  const char *schema_name = "cc_crud_test";
+  const char *coll_name = "coll_test";
+  const char *tab_name = "tab_test";
+  char buf[512];
+  int i, j;
+  size_t count = 0;
+  uint64_t rec_count = 0;
+
+  AUTHENTICATE();
+
+  mysqlx_schema_drop(get_session(), schema_name);
+  ERR_CHECK(mysqlx_schema_create(get_session(), schema_name),
+            get_session());
+  schema = mysqlx_get_schema(get_session(), schema_name, 0);
+  ERR_CHECK(mysqlx_collection_create(schema, coll_name), schema);
+  collection = mysqlx_get_collection(schema, coll_name, 0);
+
+  ERR_CHECK(mysqlx_collection_count(collection, &rec_count), collection);
+  EXPECT_EQ(0, rec_count);
+
+  stmt = mysqlx_collection_add_new(collection);
+  for (i = 0; i < 100; ++i)
+  {
+    sprintf(buf, "{\"name\" : \"name %02d\"}", i);
+    ERR_CHECK(mysqlx_set_add_document(stmt, buf), stmt);
+  }
+  CRUD_CHECK(res = mysqlx_execute(stmt), stmt);
+  rec_count = 0;
+  ERR_CHECK(mysqlx_collection_count(collection, &rec_count), collection);
+  EXPECT_EQ(100, rec_count);
+
+  sprintf(buf, "CREATE TABLE %s.%s (id int)",
+            schema_name, tab_name);
+  CRUD_CHECK(res = mysqlx_sql(get_session(), buf, MYSQLX_NULL_TERMINATED),
+             get_session());
+  table = mysqlx_get_table(schema, tab_name, 0);
+  ERR_CHECK(mysqlx_table_count(table, &rec_count), table);
+  EXPECT_EQ(0, rec_count);
+
+  stmt = mysqlx_table_insert_new(table);
+  for (i = 0; i < 100; ++i)
+  {
+    ERR_CHECK(mysqlx_set_insert_row(stmt, PARAM_UINT(i), PARAM_END), stmt);
+  }
+  CRUD_CHECK(res = mysqlx_execute(stmt), stmt);
+  ERR_CHECK(mysqlx_table_count(table, &rec_count), table);
+  EXPECT_EQ(100, rec_count);
+
+  stmt = mysqlx_table_select_new(table);
+  ERR_CHECK(mysqlx_set_select_where(stmt, "id < 10"), stmt);
+  ERR_CHECK(mysqlx_set_select_order_by(stmt, "id", SORT_ORDER_ASC, PARAM_END), stmt);
+  CRUD_CHECK(res = mysqlx_execute(stmt), stmt);
+
+  ERR_CHECK(mysqlx_get_count(res, &count), res);
+  EXPECT_EQ(10, count);
+
+  ERR_CHECK(mysqlx_get_count(res, &count), res);
+  EXPECT_EQ(10, count);
+
+  j = 0;
+  while ((row = mysqlx_row_fetch_one(res)) != NULL)
+  {
+    // Call again to make sure rows are inact
+    int64_t id = 0;
+
+    ERR_CHECK(mysqlx_get_count(res, &count), res);
+    EXPECT_EQ((9 - j), count);
+    ERR_CHECK(mysqlx_get_sint(row, 0, &id), row);
+    EXPECT_EQ(j, id);
+    ++j;
+  }
+  EXPECT_EQ(10, j);
+
+  // Check how mysqlx_get_count() handles next result
+  EXPECT_EQ(RESULT_NULL, mysqlx_next_result(res));
+  ERR_CHECK(mysqlx_get_count(res, &count), res);
+  EXPECT_EQ(0, count);
+}
+
 TEST_F(xapi, test_merge_patch)
 {
   SKIP_IF_NO_XPLUGIN