xapi.h

Go to the documentation of this file.

/*
 * Copyright (c) 2016, 2024, Oracle and/or its affiliates.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License, version 2.0, as
 * published by the Free Software Foundation.
 *
 * This program is designed to work with certain software (including
 * but not limited to OpenSSL) that is licensed under separate terms, as
 * designated in a particular file or component or in included license
 * documentation. The authors of MySQL hereby grant you an additional
 * permission to link the program and your derivative works with the
 * separately licensed software that they have either included with
 * the program or referenced in the documentation.
 *
 * Without limiting anything contained in the foregoing, this file,
 * which is part of Connector/C++, is also subject to the
 * Universal FOSS Exception, version 1.0, a copy of which can be found at
 * https://oss.oracle.com/licenses/universal-foss-exception.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License, version 2.0, for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */
 
#ifndef MYSQL_XAPI_H
#define MYSQL_XAPI_H
 
 
#ifdef  __cplusplus
extern "C" {
#endif
 
 
#include "common_constants.h"
#include "common/api.h"
 
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
 
// FIXME
#define STDCALL
 
 
typedef char object_id[16];
typedef object_id* MYSQLX_GUID;
 
#define RESULT_OK 0
 
#define RESULT_MORE_DATA 8
 
#define RESULT_NULL 16
 
#define RESULT_INFO 32
 
#define RESULT_WARNING 64
 
#define RESULT_ERROR   128
 
 
#define MYSQLX_MAX_ERROR_LEN 255
#define MYSQLX_NULL_TERMINATED 0xFFFFFFFF
 
#define MYSQLX_ERR_UNKNOWN 0xFFFF
 
#define MYSQLX_COLLATION_UNDEFINED 0
 
 
/*
  Error codes
*/
 
#define MYSQLX_ERROR_INDEX_OUT_OF_RANGE 1
 
/*
  Error messages
*/
 
#define MYSQLX_ERROR_INDEX_OUT_OF_RANGE_MSG "Index is out of range"
#define MYSQLX_ERROR_MISSING_SCHEMA_NAME_MSG "Missing schema name"
#define MYSQLX_ERROR_MISSING_TABLE_NAME_MSG "Missing table name"
#define MYSQLX_ERROR_MISSING_VIEW_NAME_MSG "Missing view name"
#define MYSQLX_ERROR_MISSING_COLLECTION_NAME_MSG "Missing collection name"
#define MYSQLX_ERROR_MISSING_COLLECTION_OPT_MSG "Missing collection options"
#define MYSQLX_ERROR_MISSING_VIEW_NAME_MSG "Missing view name"
#define MYSQLX_ERROR_MISSING_KEY_NAME_MSG "Missing key name"
#define MYSQLX_ERROR_MISSING_HOST_NAME "Missing host name"
#define MYSQLX_ERROR_MISSING_SOCKET_NAME "Missing socket name"
#define MYSQLX_ERROR_MISSING_CONN_INFO "Missing connecting information"
#define MYSQLX_ERROR_HANDLE_NULL_MSG "Handle cannot be NULL"
#define MYSQLX_ERROR_VIEW_INVALID_STMT_TYPE "Invalid statement type for View. Only SELECT type is supported"
#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"
#define MYSQLX_ERROR_MIX_PRIORITY "Mixing hosts with and without priority is not allowed"
#define MYSQLX_ERROR_DUPLICATED_OPTION "Option already defined"
#define MYSQLX_ERROR_MAX_PRIORITY "Priority should be a value between 0 and 100"
#define MYSQLX_ERROR_AUTH_METHOD "Unknown authentication method"
#define MYSQLX_ERROR_ROW_LOCKING "Row locking is supported only for SELECT and FIND"
#define MYSQLX_ERROR_WRONG_LOCKING_MODE "Wrong value for the row locking mode"
#define MYSQLX_ERROR_WRONG_EXPRESSION "Expression could not be parsed"
#define MYSQLX_ERROR_EMPTY_JSON "Empty JSON document string"
 
 
/* Opaque structures*/
 
typedef struct mysqlx_error_struct mysqlx_error_t;
 
 
typedef struct mysqlx_session_struct mysqlx_session_t;
 
typedef struct mysqlx_client_struct mysqlx_client_t;
 
 
typedef struct mysqlx_session_options_struct mysqlx_session_options_t;
 
typedef struct mysqlx_collection_options_struct mysqlx_collection_options_t;
 
typedef struct mysqlx_schema_struct mysqlx_schema_t;
 
 
typedef struct mysqlx_collection_struct mysqlx_collection_t;
 
 
typedef struct mysqlx_table_struct mysqlx_table_t;
 
 
typedef struct mysqlx_stmt_struct mysqlx_stmt_t;
 
typedef struct Mysqlx_diag_base mysqlx_object_t;
 
 
typedef struct mysqlx_row_struct mysqlx_row_t;
 
 
typedef struct mysqlx_result_struct mysqlx_result_t;
 
 
typedef enum mysqlx_data_type_enum
{
  MYSQLX_TYPE_UNDEFINED = 0,
 
  /* Column types as defined in protobuf (mysqlx_resultset.proto)*/
  MYSQLX_TYPE_SINT     = 1, 
  MYSQLX_TYPE_UINT  = 2,    
  MYSQLX_TYPE_DOUBLE   = 5, 
  MYSQLX_TYPE_FLOAT = 6,    
  MYSQLX_TYPE_BYTES    = 7, 
  MYSQLX_TYPE_TIME  = 10,   
  MYSQLX_TYPE_DATETIME = 12,
  MYSQLX_TYPE_SET  = 15,    
  MYSQLX_TYPE_ENUM     = 16,
  MYSQLX_TYPE_BIT  = 17,    
  MYSQLX_TYPE_DECIMAL  = 18,
  /* Column types from DevAPI (no number constants assigned, just names)*/
  MYSQLX_TYPE_BOOL     = 19,
  MYSQLX_TYPE_JSON     = 20,
  MYSQLX_TYPE_STRING   = 21,
  MYSQLX_TYPE_GEOMETRY = 22,
  MYSQLX_TYPE_TIMESTAMP= 23,
  MYSQLX_TYPE_NULL     = 100, 
  MYSQLX_TYPE_EXPR     = 101  
} mysqlx_data_type_t;
 
#define PARAM_SINT(A) (void*)MYSQLX_TYPE_SINT, (int64_t)A
#define PARAM_UINT(A) (void*)MYSQLX_TYPE_UINT, (uint64_t)A
#define PARAM_FLOAT(A) (void*)MYSQLX_TYPE_FLOAT, (double)A
#define PARAM_DOUBLE(A) (void*)MYSQLX_TYPE_DOUBLE, (double)A
#define PARAM_BYTES(DATA, SIZE) (void*)MYSQLX_TYPE_BYTES, (void*)DATA, (size_t)SIZE
#define PARAM_STRING(A) (void*)MYSQLX_TYPE_STRING, A
#define PARAM_EXPR(A) (void*)MYSQLX_TYPE_EXPR, A
#define PARAM_NULL() (void*)MYSQLX_TYPE_NULL
 
#define PARAM_END (void*)0
 
 
typedef enum mysqlx_sort_direction_enum
{
  SORT_ORDER_ASC = 1, 
  SORT_ORDER_DESC = 2 
} mysqlx_sort_direction_t;
 
 
#define PARAM_SORT_ASC(A) A, SORT_ORDER_ASC
#define PARAM_SORT_DESC(A) A, SORT_ORDER_DESC
 
typedef enum mysqlx_client_opt_type_enum
{
 
#define XAPI_CLIENT_OPT_ENUM_str(X,N)  MYSQLX_CLIENT_OPT_##X = -N,
#define XAPI_CLIENT_OPT_ENUM_bool(X,N)  MYSQLX_CLIENT_OPT_##X = -N,
#define XAPI_CLIENT_OPT_ENUM_num(X,N)  MYSQLX_CLIENT_OPT_##X = -N,
#define XAPI_CLIENT_OPT_ENUM_any(X,N)  MYSQLX_CLIENT_OPT_##X = -N,
 
  CLIENT_OPTION_LIST(XAPI_CLIENT_OPT_ENUM)
}
mysqlx_client_opt_type_t;
 
#define OPT_POOLING(A)     MYSQLX_CLIENT_OPT_POOLING, (int)(bool)(A)
#define OPT_POOL_MAX_SIZE(A) MYSQLX_CLIENT_OPT_POOL_MAX_SIZE, (uint64_t)(A)
#define OPT_POOL_QUEUE_TIMEOUT(A) MYSQLX_CLIENT_OPT_POOL_QUEUE_TIMEOUT, (uint64_t)(A)
#define OPT_POOL_MAX_IDLE_TIME(A) MYSQLX_CLIENT_OPT_POOL_MAX_IDLE_TIME, (uint64_t)(A)
 
typedef enum mysqlx_opt_type_enum
{
 
#define XAPI_OPT_ENUM_str(X,N)  MYSQLX_OPT_##X = N,
#define XAPI_OPT_ENUM_num(X,N)  MYSQLX_OPT_##X = N,
#define XAPI_OPT_ENUM_any(X,N)  MYSQLX_OPT_##X = N,
#define XAPI_OPT_ENUM_bool(X,N)  MYSQLX_OPT_##X = N,
 
  SESSION_OPTION_LIST(XAPI_OPT_ENUM)
  MYSQLX_OPT_LAST
}
mysqlx_opt_type_t;
 
#define OPT_HOST(A)     MYSQLX_OPT_HOST, (A)
#define OPT_PORT(A)     MYSQLX_OPT_PORT, (unsigned int)(A)
#ifndef _WIN32
#define OPT_SOCKET(A)   MYSQLX_OPT_SOCKET, (A)
#endif //_WIN32
#define OPT_DNS_SRV(A)  MYSQLX_OPT_DNS_SRV, (A)
#define OPT_USER(A)     MYSQLX_OPT_USER, (A)
#define OPT_PWD(A)      MYSQLX_OPT_PWD, (A)
#define OPT_DB(A)       MYSQLX_OPT_DB, (A)
#define OPT_SSL_MODE(A) MYSQLX_OPT_SSL_MODE, (A)
#define OPT_SSL_CA(A)   MYSQLX_OPT_SSL_CA, (A)
#define OPT_SSL_CAPATH(A)  MYSQLX_OPT_SSL_CAPATH, (A)
#define OPT_SSL_CRL(A)      MYSQLX_OPT_SSL_CRL, (A)
#define OPT_SSL_CRLPATH(A) MYSQLX_OPT_SSL_CRLPATH, (A)
#define OPT_PRIORITY(A) MYSQLX_OPT_PRIORITY, (unsigned int)(A)
#define OPT_AUTH(A)     MYSQLX_OPT_AUTH, (unsigned int)(A)
#define OPT_CONNECT_TIMEOUT(A) MYSQLX_OPT_CONNECT_TIMEOUT, (unsigned int)(A)
#define OPT_CONNECTION_ATTRIBUTES(A) MYSQLX_OPT_CONNECTION_ATTRIBUTES, (A)
#define OPT_TLS_VERSIONS(A) MYSQLX_OPT_TLS_VERSIONS, (A)
#define OPT_TLS_CIPHERSUITES(A) MYSQLX_OPT_TLS_CIPHERSUITES, (A)
#define OPT_COMPRESSION(A) MYSQLX_OPT_COMPRESSION, (unsigned int)(A)
#define OPT_COMPRESSION_ALGORITHMS(A) MYSQLX_OPT_COMPRESSION_ALGORITHMS, (const char*)(A)
#define OPT_READ_TIMEOUT(A) MYSQLX_OPT_READ_TIMEOUT, (unsigned int)(A)
#define OPT_WRITE_TIMEOUT(A) MYSQLX_OPT_WRITE_TIMEOUT, (unsigned int)(A)
 
 
typedef enum mysqlx_ssl_mode_enum
{
#define XAPI_SSL_MODE_ENUM(X,N)  SSL_MODE_##X = N,
 
  SSL_MODE_LIST(XAPI_SSL_MODE_ENUM)
}
mysqlx_ssl_mode_t;
 
typedef enum mysqlx_auth_method_enum
{
#define XAPI_AUTH_ENUM(X,N)  MYSQLX_AUTH_##X = N,
 
  AUTH_METHOD_LIST(XAPI_AUTH_ENUM)
}
mysqlx_auth_method_t;
 
typedef enum mysqlx_collection_opt_enum
{
 
#define XAPI_COLLECTION_OPT_ENUM(X,N)  MYSQLX_OPT_COLLECTION_##X = N,
 
  COLLECTION_OPTIONS_OPTION(XAPI_COLLECTION_OPT_ENUM)
  MYSQLX_OPT_COLLECTION_LAST
}
mysqlx_collection_opt_t;
 
typedef enum mysqlx_collection_validation_opt_enum
{
 
#define XAPI_COLLECTION_VALIDATION_OPT_ENUM(X,N)  MYSQLX_OPT_COLLECTION_VALIDATION_##X = 1024+N,
 
  COLLECTION_VALIDATION_OPTION(XAPI_COLLECTION_VALIDATION_OPT_ENUM)
  MYSQLX_OPT_COLLECTION_VALIDATION_LAST
}
mysqlx_collection_validation_opt_t;
 
typedef enum mysqlx_collection_validation_level_enum
{
 
#define XAPI_COLLECTION_VALIDATION_LEVEL_ENUM(X,N)  MYSQLX_OPT_COLLECTION_VALIDATION_LEVEL_##X = 2048+N,
 
  COLLECTION_VALIDATION_LEVEL(XAPI_COLLECTION_VALIDATION_LEVEL_ENUM)
  MYSQLX_OPT_COLLECTION_VALIDATION_LEVEL_LAST
}
mysqlx_collection_validation_level_t;
 
#define VALIDATION_OFF MYSQLX_OPT_COLLECTION_VALIDATION_LEVEL_OFF
#define VALIDATION_STRICT MYSQLX_OPT_COLLECTION_VALIDATION_LEVEL_STRICT
 
#define OPT_COLLECTION_REUSE(X) MYSQLX_OPT_COLLECTION_REUSE, (unsigned int)X
#define OPT_COLLECTION_VALIDATION(X) MYSQLX_OPT_COLLECTION_VALIDATION, (const char*)X
#define OPT_COLLECTION_VALIDATION_LEVEL(X) MYSQLX_OPT_COLLECTION_VALIDATION_LEVEL, (unsigned int)X
#define OPT_COLLECTION_VALIDATION_SCHEMA(X) MYSQLX_OPT_COLLECTION_VALIDATION_SCHEMA, (const char*)X
 
typedef enum mysqlx_compression_mode_enum
{
#define XAPI_COMPRESSION_ENUM(X,N)  MYSQLX_COMPRESSION_##X = N,
 
  COMPRESSION_MODE_LIST(XAPI_COMPRESSION_ENUM)
}
mysqlx_compression_mode_t;
 
typedef enum mysqlx_row_locking_enum
{
#define XAPI_ROW_LOCK_ENUM(X,N)  ROW_LOCK_##X = N,
 
  ROW_LOCK_NONE = 0,       
  LOCK_MODE_LIST(XAPI_ROW_LOCK_ENUM)
}
mysqlx_row_locking_t;
 
typedef enum mysqlx_lock_contention_enum
{
#define XAPI_LOCK_CONTENTION_ENUM(X,N)  LOCK_CONTENTION_##X = N,
 
  LOCK_CONTENTION_LIST(XAPI_LOCK_CONTENTION_ENUM)
}
mysqlx_lock_contention_t;
 
/*
  ====================================================================
  Client operations
  ====================================================================
*/
 
PUBLIC_API mysqlx_client_t *
mysqlx_get_client_from_url(const char *conn_string, const char *client_opts,
                           mysqlx_error_t **error);
 
 
PUBLIC_API mysqlx_client_t *
mysqlx_get_client_from_options(mysqlx_session_options_t *opt,
                               mysqlx_error_t **error);
 
PUBLIC_API void mysqlx_client_close(mysqlx_client_t *client);
 
/*
  ====================================================================
  Session operations
  ====================================================================
*/
 
PUBLIC_API mysqlx_session_t *
mysqlx_get_session_from_client(mysqlx_client_t *cli,
                               mysqlx_error_t **error);
 
PUBLIC_API mysqlx_session_t *
mysqlx_get_session(const char *host, int port, const char *user,
                   const char *password, const char *database,
                   mysqlx_error_t **error);
 
 
PUBLIC_API mysqlx_session_t *
mysqlx_get_session_from_url(const char *conn_string,
                            mysqlx_error_t **error);
 
PUBLIC_API mysqlx_session_t *
mysqlx_get_session_from_options(mysqlx_session_options_t *opt,
                                mysqlx_error_t **error);
 
 
 
PUBLIC_API void mysqlx_session_close(mysqlx_session_t *session);
 
 
PUBLIC_API int mysqlx_session_valid(mysqlx_session_t *sess);
 
PUBLIC_API mysqlx_result_t *
mysqlx_get_schemas(mysqlx_session_t *sess, const char *schema_pattern);
 
 
PUBLIC_API mysqlx_schema_t *
mysqlx_get_schema(mysqlx_session_t *sess, const char *schema_name,
                  unsigned int check);
 
 
PUBLIC_API mysqlx_result_t *
mysqlx_get_tables(mysqlx_schema_t *schema,
                  const char *table_pattern,
                  int get_views);
 
 
PUBLIC_API mysqlx_table_t *
mysqlx_get_table(mysqlx_schema_t *schema, const char *tab_name,
                      unsigned int check);
 
 
PUBLIC_API mysqlx_result_t *
mysqlx_get_collections(mysqlx_schema_t *schema,
                  const char *col_pattern);
 
 
PUBLIC_API mysqlx_collection_t *
mysqlx_get_collection(mysqlx_schema_t *schema, const char *col_name,
                      unsigned int check);
 
 
PUBLIC_API int
mysqlx_transaction_begin(mysqlx_session_t *sess);
 
 
PUBLIC_API int
mysqlx_transaction_commit(mysqlx_session_t *sess);
 
 
PUBLIC_API int
mysqlx_transaction_rollback(mysqlx_session_t *sess);
 
 
PUBLIC_API const char*
mysqlx_savepoint_set( mysqlx_session_t *sess, const char *name);
 
 
PUBLIC_API int
mysqlx_savepoint_release(mysqlx_session_t *sess, const char *name);
 
 
PUBLIC_API int
mysqlx_rollback_to(  mysqlx_session_t *sess, const char *name);
 
 
PUBLIC_API mysqlx_session_options_t * mysqlx_session_options_new();
 
 
PUBLIC_API void mysqlx_free_options(mysqlx_session_options_t *opt);
 
 
PUBLIC_API int
mysqlx_session_option_set(mysqlx_session_options_t *opth, ...);
 
 
PUBLIC_API int
mysqlx_session_option_get(mysqlx_session_options_t *opth, int opt,
                          ...);
 
/*
  ====================================================================
  SQL execution
  ====================================================================
*/
 
PUBLIC_API mysqlx_result_t * mysqlx_sql(mysqlx_session_t *sess,
                                        const char *query,
                                        size_t query_len);
 
 
PUBLIC_API mysqlx_result_t * mysqlx_sql_param(mysqlx_session_t *sess,
                                        const char *query,
                                        size_t query_len, ...);
 
 
PUBLIC_API mysqlx_stmt_t *
mysqlx_sql_new(mysqlx_session_t *sess, const char *query,
                 uint32_t length);
 
 
/*
  ====================================================================
  Collection operations
  ====================================================================
*/
 
PUBLIC_API int
mysqlx_collection_count(mysqlx_collection_t *collection, uint64_t *count);
 
 
PUBLIC_API mysqlx_result_t *
mysqlx_collection_find(mysqlx_collection_t *collection, const char *criteria);
 
 
PUBLIC_API mysqlx_result_t *
mysqlx_collection_add(mysqlx_collection_t *collection, ...);
 
 
PUBLIC_API mysqlx_result_t *
mysqlx_collection_remove(mysqlx_collection_t *collection, const char*criteria);
 
 
PUBLIC_API mysqlx_result_t *
mysqlx_collection_modify_set(mysqlx_collection_t *collection,
                             const char *criteria, ...);
 
 
PUBLIC_API mysqlx_result_t *
mysqlx_collection_modify_unset(mysqlx_collection_t *collection,
                               const char *criteria, ...);
 
 
PUBLIC_API mysqlx_result_t *
mysqlx_collection_modify_patch(mysqlx_collection_t *collection,
                               const char *criteria,
                               const char *patch_spec);
 
 
PUBLIC_API int
mysqlx_set_modify_patch(mysqlx_stmt_t *stmt,
                                   const char *patch_spec);
 
/*
  Deferred statement execution
  ----------------------------
*/
 
PUBLIC_API mysqlx_stmt_t *
mysqlx_collection_find_new(mysqlx_collection_t *collection);
 
 
PUBLIC_API int mysqlx_set_find_projection(mysqlx_stmt_t *stmt, const char *proj);
 
 
#define mysqlx_set_find_criteria mysqlx_set_where
 
 
/*
A macro defining a function for setting HAVING for FIND operation.
 
@see mysqlx_set_having()
@ingroup xapi_tbl
*/
 
#define mysqlx_set_find_having mysqlx_set_having
 
 
#define mysqlx_set_find_group_by mysqlx_set_group_by
 
 
#define mysqlx_set_find_limit_and_offset(STMT, LIM, OFFS) mysqlx_set_limit_and_offset(STMT, LIM, OFFS)
 
 
#define mysqlx_set_find_order_by mysqlx_set_order_by
 
 
#define mysqlx_set_find_row_locking mysqlx_set_row_locking
 
 
PUBLIC_API mysqlx_stmt_t *
mysqlx_collection_add_new(mysqlx_collection_t *collection);
 
 
PUBLIC_API int
mysqlx_set_add_document(mysqlx_stmt_t *stmt, const char *json_doc);
 
 
PUBLIC_API mysqlx_stmt_t *
mysqlx_collection_remove_new(mysqlx_collection_t *collection);
 
 
#define mysqlx_set_remove_criteria mysqlx_set_where
 
 
#define mysqlx_set_remove_order_by mysqlx_set_order_by
 
 
#define mysqlx_set_remove_limit_and_offset mysqlx_set_limit_and_offset
 
 
PUBLIC_API mysqlx_stmt_t *
mysqlx_collection_modify_new(mysqlx_collection_t *collection);
 
 
PUBLIC_API int
mysqlx_set_modify_set(mysqlx_stmt_t *stmt, ...);
 
 
PUBLIC_API int
mysqlx_set_modify_unset(mysqlx_stmt_t *stmt, ...);
 
 
PUBLIC_API int
mysqlx_set_modify_array_insert(mysqlx_stmt_t *stmt, ...);
 
 
PUBLIC_API int
mysqlx_set_modify_array_append(mysqlx_stmt_t *stmt, ...);
 
 
PUBLIC_API int mysqlx_set_modify_array_delete(mysqlx_stmt_t *stmt, ...);
 
 
#define mysqlx_set_modify_criteria mysqlx_set_where
 
 
/*
  ====================================================================
  Table operations
  ====================================================================
*/
 
 
PUBLIC_API int
mysqlx_table_count(mysqlx_table_t *table, uint64_t *count);
 
 
PUBLIC_API mysqlx_result_t *
mysqlx_table_select(mysqlx_table_t *table, const char *criteria);
 
 
PUBLIC_API mysqlx_result_t *
mysqlx_table_select_limit(mysqlx_table_t *table, const char *criteria,
                               uint64_t row_count, uint64_t offset, ...);
 
 
PUBLIC_API mysqlx_result_t *
mysqlx_table_insert(mysqlx_table_t *table, ...);
 
 
PUBLIC_API mysqlx_result_t *
mysqlx_table_delete(mysqlx_table_t *table, const char *criteria);
 
 
 
PUBLIC_API mysqlx_result_t *
mysqlx_table_update(mysqlx_table_t *table,
                    const char *criteria,
                    ...);
 
 
/*
  Deferred statement execution
  ----------------------------
*/
 
PUBLIC_API mysqlx_stmt_t *
mysqlx_table_select_new(mysqlx_table_t *table);
 
 
#define mysqlx_set_select_items mysqlx_set_items
 
 
#define mysqlx_set_select_where mysqlx_set_where
 
 
#define mysqlx_set_select_order_by mysqlx_set_order_by
 
 
/*
  A macro defining a function for setting HAVING for SELECT operation.
 
  @see mysqlx_set_having()
  @ingroup xapi_tbl
*/
 
#define mysqlx_set_select_having mysqlx_set_having
 
 
#define mysqlx_set_select_group_by mysqlx_set_group_by
 
 
#define mysqlx_set_select_limit_and_offset mysqlx_set_limit_and_offset
 
 
#define mysqlx_set_select_row_locking mysqlx_set_row_locking
 
 
PUBLIC_API mysqlx_stmt_t *
mysqlx_table_insert_new(mysqlx_table_t *table);
 
 
PUBLIC_API int
mysqlx_set_insert_columns(mysqlx_stmt_t *stmt, ...);
 
 
PUBLIC_API int
mysqlx_set_insert_row(mysqlx_stmt_t *stmt, ...);
 
 
PUBLIC_API mysqlx_stmt_t *
mysqlx_table_delete_new(mysqlx_table_t *table);
 
 
#define mysqlx_set_delete_where mysqlx_set_where
 
#define mysqlx_set_delete_limit(STMT, LIM) mysqlx_set_limit_and_offset(STMT, LIM, 0)
 
#define mysqlx_set_delete_order_by mysqlx_set_order_by
 
 
PUBLIC_API mysqlx_stmt_t *
mysqlx_table_update_new(mysqlx_table_t *table);
 
 
PUBLIC_API int mysqlx_set_update_values(mysqlx_stmt_t *stmt, ...);
 
 
#define mysqlx_set_update_where mysqlx_set_where
 
 
#define mysqlx_set_update_limit(STMT, LIM) mysqlx_set_limit_and_offset(STMT, LIM, 0)
 
 
#define mysqlx_set_update_order_by mysqlx_set_order_by
 
 
/*
  ====================================================================
  Statement execution
  ====================================================================
*/
 
PUBLIC_API mysqlx_result_t *
mysqlx_execute(mysqlx_stmt_t *stmt);
 
 
PUBLIC_API int mysqlx_stmt_bind(mysqlx_stmt_t *stmt, ...);
 
 
PUBLIC_API int mysqlx_set_items(mysqlx_stmt_t *stmt, ...);
 
 
PUBLIC_API int mysqlx_set_where(mysqlx_stmt_t *stmt, const char *where_expr);
 
 
PUBLIC_API int mysqlx_set_having(mysqlx_stmt_t *stmt, const char *having_expr);
 
 
PUBLIC_API int mysqlx_set_group_by(mysqlx_stmt_t *stmt, ...);
 
PUBLIC_API int mysqlx_set_order_by(mysqlx_stmt_t *stmt, ...);
 
 
PUBLIC_API int
mysqlx_set_limit_and_offset(mysqlx_stmt_t *stmt, uint64_t row_count,
                            uint64_t offset);
 
PUBLIC_API int
mysqlx_set_row_locking(mysqlx_stmt_t *stmt, int locking, int contention);
 
PUBLIC_API void mysqlx_free(void *obj);
 
 
/*
  ====================================================================
  Result handling
  ====================================================================
*/
 
PUBLIC_API mysqlx_row_t * mysqlx_row_fetch_one(mysqlx_result_t *res);
 
 
PUBLIC_API const char * mysqlx_json_fetch_one(mysqlx_result_t *res, size_t *out_length);
 
 
PUBLIC_API int mysqlx_next_result(mysqlx_result_t *res);
 
 
PUBLIC_API uint64_t
mysqlx_get_affected_count(mysqlx_result_t *res);
 
 
PUBLIC_API int
mysqlx_store_result(mysqlx_result_t *result, size_t *num);
 
 
PUBLIC_API int
mysqlx_get_count(mysqlx_result_t *result, size_t *num);
 
 
PUBLIC_API const char *
mysqlx_fetch_generated_id(mysqlx_result_t *result);
 
 
PUBLIC_API uint64_t
mysqlx_get_auto_increment_value(mysqlx_result_t *res);
 
 
PUBLIC_API int
mysqlx_get_bytes(mysqlx_row_t* row, uint32_t col,
                 uint64_t offset, void *buf, size_t *buf_len);
 
 
PUBLIC_API int
mysqlx_get_uint(mysqlx_row_t* row, uint32_t col, uint64_t* val);
 
 
PUBLIC_API int
mysqlx_get_sint(mysqlx_row_t* row, uint32_t col, int64_t* val);
 
 
PUBLIC_API int
mysqlx_get_float(mysqlx_row_t* row, uint32_t col, float* val);
 
 
PUBLIC_API int
mysqlx_get_double(mysqlx_row_t* row, uint32_t col, double *val);
 
 
PUBLIC_API void mysqlx_result_free(mysqlx_result_t *res);
 
 
/*
  Result metadata
  ---------------
*/
 
PUBLIC_API uint16_t
mysqlx_column_get_type(mysqlx_result_t *res, uint32_t pos);
 
 
PUBLIC_API uint16_t
mysqlx_column_get_collation(mysqlx_result_t *res, uint32_t pos);
 
 
PUBLIC_API uint32_t
mysqlx_column_get_length(mysqlx_result_t *res, uint32_t pos);
 
 
PUBLIC_API uint16_t
mysqlx_column_get_precision(mysqlx_result_t *res, uint32_t pos);
 
 
/*
  Get column flags.
 
  @param res result handle
  @param pos zero-based column number
 
  @return 32-bit unsigned integer containing column flags reported by
  server. TODO: Document these
 
  @ingroup xapi_md
*/
//PUBLIC_API uint32_t
//mysqlx_column_get_flags(mysqlx_result_t *res, uint32_t pos);
 
 
PUBLIC_API uint32_t
mysqlx_column_get_count(mysqlx_result_t *res);
 
 
PUBLIC_API const char *
mysqlx_column_get_name(mysqlx_result_t *res, uint32_t pos);
 
 
PUBLIC_API const char *
mysqlx_column_get_original_name(mysqlx_result_t *res, uint32_t pos);
 
 
PUBLIC_API const char *
mysqlx_column_get_table(mysqlx_result_t *res, uint32_t pos);
 
 
PUBLIC_API const char *
mysqlx_column_get_original_table(mysqlx_result_t *res, uint32_t pos);
 
 
PUBLIC_API const char *
mysqlx_column_get_schema(mysqlx_result_t *res, uint32_t pos);
 
 
PUBLIC_API const char *
mysqlx_column_get_catalog(mysqlx_result_t *res, uint32_t pos);
 
 
/*
  ====================================================================
  DDL statements
  ====================================================================
*/
 
PUBLIC_API int
mysqlx_schema_create(mysqlx_session_t *sess, const char *schema);
 
 
PUBLIC_API int
mysqlx_schema_drop(mysqlx_session_t *sess, const char *schema);
 
 
PUBLIC_API int
mysqlx_collection_create(mysqlx_schema_t *schema, const char *collection);
 
 
PUBLIC_API mysqlx_collection_options_t *
mysqlx_collection_options_new();
 
 
PUBLIC_API int
mysqlx_collection_options_set(mysqlx_collection_options_t * options,...);
 
 
PUBLIC_API int
mysqlx_collection_create_with_options(mysqlx_schema_t *schema,
                                      const char *collection,
                                      mysqlx_collection_options_t *options);
 
PUBLIC_API int
mysqlx_collection_create_with_json_options(mysqlx_schema_t *schema,
                                           const char *collection,
                                           const char* json_options);
 
PUBLIC_API int
mysqlx_collection_modify_with_options(mysqlx_schema_t *schema,
                                      const char *collection,
                                      mysqlx_collection_options_t *options);
 
PUBLIC_API int
mysqlx_collection_modify_with_json_options(mysqlx_schema_t *schema,
                                           const char* collection,
                                           const char* json_options);
 
 
 
PUBLIC_API int
mysqlx_collection_drop(mysqlx_schema_t *schema, const char *collection);
 
 
/*
  ====================================================================
  Diagnostics
  ====================================================================
*/
 
 
PUBLIC_API mysqlx_error_t * mysqlx_error(void *obj);
 
 
PUBLIC_API const char * mysqlx_error_message(void *obj);
 
 
PUBLIC_API unsigned int mysqlx_error_num(void *obj);
 
 
PUBLIC_API unsigned int mysqlx_result_warning_count(mysqlx_result_t *res);
 
 
PUBLIC_API mysqlx_error_t *
mysqlx_result_next_warning(mysqlx_result_t *res);
 
 
PUBLIC_API int
mysqlx_collection_create_index(mysqlx_collection_t *coll, const char *name,
                               const char *idx_spec);
 
PUBLIC_API int
mysqlx_collection_drop_index(mysqlx_collection_t *coll, const char *name);
 
 
#ifdef  __cplusplus
}
#endif
 
#endif /* __MYSQLX_H__*/