cpp/api/adbc_8h_source.html

// Licensed to the Apache Software Foundation (ASF) under one

// or more contributor license agreements.  See the NOTICE file

// distributed with this work for additional information

// regarding copyright ownership.  The ASF licenses this file

// to you under the Apache License, Version 2.0 (the

// "License"); you may not use this file except in compliance

// with the License.  You may obtain a copy of the License at

//

//   http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing,

// software distributed under the License is distributed on an

// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

// KIND, either express or implied.  See the License for the

// specific language governing permissions and limitations

// under the License.


#pragma once


#include <stddef.h>

#include <stdint.h>


#ifdef __cplusplus

extern "C" {

#endif


// Extra guard for versions of Arrow without the canonical guard

#ifndef ARROW_FLAG_DICTIONARY_ORDERED


#ifndef ARROW_C_DATA_INTERFACE

#define ARROW_C_DATA_INTERFACE


#define ARROW_FLAG_DICTIONARY_ORDERED 1

#define ARROW_FLAG_NULLABLE 2

#define ARROW_FLAG_MAP_KEYS_SORTED 4


struct ArrowSchema {

  // Array type description

  const char* format;

  const char* name;

  const char* metadata;

  int64_t flags;

  int64_t n_children;

  struct ArrowSchema** children;

  struct ArrowSchema* dictionary;


  // Release callback

  void (*release)(struct ArrowSchema*);

  // Opaque producer-specific data

  void* private_data;

};


struct ArrowArray {

  // Array data description

  int64_t length;

  int64_t null_count;

  int64_t offset;

  int64_t n_buffers;

  int64_t n_children;

  const void** buffers;

  struct ArrowArray** children;

  struct ArrowArray* dictionary;


  // Release callback

  void (*release)(struct ArrowArray*);

  // Opaque producer-specific data

  void* private_data;

};


#endif  // ARROW_C_DATA_INTERFACE


#ifndef ARROW_C_STREAM_INTERFACE

#define ARROW_C_STREAM_INTERFACE


struct ArrowArrayStream {

  // Callback to get the stream type

  // (will be the same for all arrays in the stream).

  //

  // Return value: 0 if successful, an `errno`-compatible error code otherwise.

  //

  // If successful, the ArrowSchema must be released independently from the stream.

  int (*get_schema)(struct ArrowArrayStream*, struct ArrowSchema* out);


  // Callback to get the next array

  // (if no error and the array is released, the stream has ended)

  //

  // Return value: 0 if successful, an `errno`-compatible error code otherwise.

  //

  // If successful, the ArrowArray must be released independently from the stream.

  int (*get_next)(struct ArrowArrayStream*, struct ArrowArray* out);


  // Callback to get optional detailed error information.

  // This must only be called if the last stream operation failed

  // with a non-0 return code.

  //

  // Return value: pointer to a null-terminated character array describing

  // the last error, or NULL if no description is available.

  //

  // The returned pointer is only valid until the next operation on this stream

  // (including release).

  const char* (*get_last_error)(struct ArrowArrayStream*);


  // Release callback: release the stream's own resources.

  // Note that arrays returned by `get_next` must be individually released.

  void (*release)(struct ArrowArrayStream*);


  // Opaque producer-specific data

  void* private_data;

};


#endif  // ARROW_C_STREAM_INTERFACE

#endif  // ARROW_FLAG_DICTIONARY_ORDERED


#ifndef ADBC

#define ADBC


// Storage class macros for Windows

// Allow overriding/aliasing with application-defined macros

#if !defined(ADBC_EXPORT)

#if defined(_WIN32)

#if defined(ADBC_EXPORTING)

#define ADBC_EXPORT __declspec(dllexport)

#else

#define ADBC_EXPORT __declspec(dllimport)

#endif  // defined(ADBC_EXPORTING)

#else

#define ADBC_EXPORT

#endif  // defined(_WIN32)

#endif  // !defined(ADBC_EXPORT)


typedef uint8_t AdbcStatusCode;


#define ADBC_STATUS_OK 0

#define ADBC_STATUS_UNKNOWN 1

#define ADBC_STATUS_NOT_IMPLEMENTED 2

#define ADBC_STATUS_NOT_FOUND 3

#define ADBC_STATUS_ALREADY_EXISTS 4

#define ADBC_STATUS_INVALID_ARGUMENT 5

#define ADBC_STATUS_INVALID_STATE 6

#define ADBC_STATUS_INVALID_DATA 7

#define ADBC_STATUS_INTEGRITY 8

#define ADBC_STATUS_INTERNAL 9

#define ADBC_STATUS_IO 10

#define ADBC_STATUS_CANCELLED 11

#define ADBC_STATUS_TIMEOUT 12

#define ADBC_STATUS_UNAUTHENTICATED 13

#define ADBC_STATUS_UNAUTHORIZED 14


#define ADBC_ERROR_VENDOR_CODE_PRIVATE_DATA INT32_MIN


struct ADBC_EXPORT AdbcError {

  char* message;


  int32_t vendor_code;


  char sqlstate[5];


  void (*release)(struct AdbcError* error);


  void* private_data;


  struct AdbcDriver* private_driver;

};


#ifdef __cplusplus

#define ADBC_ERROR_INIT                           \

  (AdbcError{nullptr,                             \

             ADBC_ERROR_VENDOR_CODE_PRIVATE_DATA, \

             {0, 0, 0, 0, 0},                     \

             nullptr,                             \

             nullptr,                             \

             nullptr})

#else


#define ADBC_ERROR_INIT \

  ((struct AdbcError){  \

      NULL, ADBC_ERROR_VENDOR_CODE_PRIVATE_DATA, {0, 0, 0, 0, 0}, NULL, NULL, NULL})


#endif


#define ADBC_ERROR_1_0_0_SIZE (offsetof(struct AdbcError, private_data))

#define ADBC_ERROR_1_1_0_SIZE (sizeof(struct AdbcError))


struct ADBC_EXPORT AdbcErrorDetail {

  const char* key;

  const uint8_t* value;

  size_t value_length;

};


ADBC_EXPORT

int AdbcErrorGetDetailCount(const struct AdbcError* error);


ADBC_EXPORT

struct AdbcErrorDetail AdbcErrorGetDetail(const struct AdbcError* error, int index);


ADBC_EXPORT

const struct AdbcError* AdbcErrorFromArrayStream(struct ArrowArrayStream* stream,

                                                 AdbcStatusCode* status);


#define ADBC_VERSION_1_0_0 1000000


#define ADBC_VERSION_1_1_0 1001000


#define ADBC_OPTION_VALUE_ENABLED "true"

#define ADBC_OPTION_VALUE_DISABLED "false"


#define ADBC_OPTION_URI "uri"

#define ADBC_OPTION_USERNAME "username"

#define ADBC_OPTION_PASSWORD "password"


#define ADBC_INFO_VENDOR_NAME 0

#define ADBC_INFO_VENDOR_VERSION 1

#define ADBC_INFO_VENDOR_ARROW_VERSION 2

#define ADBC_INFO_VENDOR_SQL 3

#define ADBC_INFO_VENDOR_SUBSTRAIT 4

#define ADBC_INFO_VENDOR_SUBSTRAIT_MIN_VERSION 5

#define ADBC_INFO_VENDOR_SUBSTRAIT_MAX_VERSION 6


#define ADBC_INFO_DRIVER_NAME 100

#define ADBC_INFO_DRIVER_VERSION 101

#define ADBC_INFO_DRIVER_ARROW_VERSION 102

#define ADBC_INFO_DRIVER_ADBC_VERSION 103


#define ADBC_OBJECT_DEPTH_ALL 0

#define ADBC_OBJECT_DEPTH_CATALOGS 1

#define ADBC_OBJECT_DEPTH_DB_SCHEMAS 2

#define ADBC_OBJECT_DEPTH_TABLES 3

#define ADBC_OBJECT_DEPTH_COLUMNS ADBC_OBJECT_DEPTH_ALL


#define ADBC_STATISTIC_AVERAGE_BYTE_WIDTH_KEY 0

#define ADBC_STATISTIC_AVERAGE_BYTE_WIDTH_NAME "adbc.statistic.byte_width"

#define ADBC_STATISTIC_DISTINCT_COUNT_KEY 1

#define ADBC_STATISTIC_DISTINCT_COUNT_NAME "adbc.statistic.distinct_count"

#define ADBC_STATISTIC_MAX_BYTE_WIDTH_KEY 2

#define ADBC_STATISTIC_MAX_BYTE_WIDTH_NAME "adbc.statistic.max_byte_width"

#define ADBC_STATISTIC_MAX_VALUE_KEY 3

#define ADBC_STATISTIC_MAX_VALUE_NAME "adbc.statistic.max_value"

#define ADBC_STATISTIC_MIN_VALUE_KEY 4

#define ADBC_STATISTIC_MIN_VALUE_NAME "adbc.statistic.min_value"

#define ADBC_STATISTIC_NULL_COUNT_KEY 5

#define ADBC_STATISTIC_NULL_COUNT_NAME "adbc.statistic.null_count"

#define ADBC_STATISTIC_ROW_COUNT_KEY 6

#define ADBC_STATISTIC_ROW_COUNT_NAME "adbc.statistic.row_count"


#define ADBC_CONNECTION_OPTION_AUTOCOMMIT "adbc.connection.autocommit"


#define ADBC_CONNECTION_OPTION_READ_ONLY "adbc.connection.readonly"


#define ADBC_CONNECTION_OPTION_CURRENT_CATALOG "adbc.connection.catalog"


#define ADBC_CONNECTION_OPTION_CURRENT_DB_SCHEMA "adbc.connection.db_schema"


#define ADBC_STATEMENT_OPTION_INCREMENTAL "adbc.statement.exec.incremental"


#define ADBC_STATEMENT_OPTION_PROGRESS "adbc.statement.exec.progress"


#define ADBC_STATEMENT_OPTION_MAX_PROGRESS "adbc.statement.exec.max_progress"


#define ADBC_CONNECTION_OPTION_ISOLATION_LEVEL \

  "adbc.connection.transaction.isolation_level"


#define ADBC_OPTION_ISOLATION_LEVEL_DEFAULT \

  "adbc.connection.transaction.isolation.default"


#define ADBC_OPTION_ISOLATION_LEVEL_READ_UNCOMMITTED \

  "adbc.connection.transaction.isolation.read_uncommitted"


#define ADBC_OPTION_ISOLATION_LEVEL_READ_COMMITTED \

  "adbc.connection.transaction.isolation.read_committed"


#define ADBC_OPTION_ISOLATION_LEVEL_REPEATABLE_READ \

  "adbc.connection.transaction.isolation.repeatable_read"


#define ADBC_OPTION_ISOLATION_LEVEL_SNAPSHOT \

  "adbc.connection.transaction.isolation.snapshot"


#define ADBC_OPTION_ISOLATION_LEVEL_SERIALIZABLE \

  "adbc.connection.transaction.isolation.serializable"


#define ADBC_OPTION_ISOLATION_LEVEL_LINEARIZABLE \

  "adbc.connection.transaction.isolation.linearizable"


#define ADBC_INGEST_OPTION_TARGET_TABLE "adbc.ingest.target_table"

#define ADBC_INGEST_OPTION_MODE "adbc.ingest.mode"

#define ADBC_INGEST_OPTION_MODE_CREATE "adbc.ingest.mode.create"

#define ADBC_INGEST_OPTION_MODE_APPEND "adbc.ingest.mode.append"

#define ADBC_INGEST_OPTION_MODE_REPLACE "adbc.ingest.mode.replace"

#define ADBC_INGEST_OPTION_MODE_CREATE_APPEND "adbc.ingest.mode.create_append"

#define ADBC_INGEST_OPTION_TARGET_CATALOG "adbc.ingest.target_catalog"

#define ADBC_INGEST_OPTION_TARGET_DB_SCHEMA "adbc.ingest.target_db_schema"

#define ADBC_INGEST_OPTION_TEMPORARY "adbc.ingest.temporary"


struct ADBC_EXPORT AdbcDatabase {

  void* private_data;

  struct AdbcDriver* private_driver;

};


struct ADBC_EXPORT AdbcConnection {

  void* private_data;

  struct AdbcDriver* private_driver;

};


struct ADBC_EXPORT AdbcStatement {

  void* private_data;


  struct AdbcDriver* private_driver;

};


struct AdbcPartitions {

  size_t num_partitions;


  const uint8_t** partitions;


  const size_t* partition_lengths;


  void* private_data;


  void (*release)(struct AdbcPartitions* partitions);

};


struct ADBC_EXPORT AdbcDriver {

  void* private_data;

  void* private_manager;


  AdbcStatusCode (*release)(struct AdbcDriver* driver, struct AdbcError* error);


  AdbcStatusCode (*DatabaseInit)(struct AdbcDatabase*, struct AdbcError*);

  AdbcStatusCode (*DatabaseNew)(struct AdbcDatabase*, struct AdbcError*);

  AdbcStatusCode (*DatabaseSetOption)(struct AdbcDatabase*, const char*, const char*,

                                      struct AdbcError*);

  AdbcStatusCode (*DatabaseRelease)(struct AdbcDatabase*, struct AdbcError*);


  AdbcStatusCode (*ConnectionCommit)(struct AdbcConnection*, struct AdbcError*);

  AdbcStatusCode (*ConnectionGetInfo)(struct AdbcConnection*, const uint32_t*, size_t,

                                      struct ArrowArrayStream*, struct AdbcError*);

  AdbcStatusCode (*ConnectionGetObjects)(struct AdbcConnection*, int, const char*,

                                         const char*, const char*, const char**,

                                         const char*, struct ArrowArrayStream*,

                                         struct AdbcError*);

  AdbcStatusCode (*ConnectionGetTableSchema)(struct AdbcConnection*, const char*,

                                             const char*, const char*,

                                             struct ArrowSchema*, struct AdbcError*);

  AdbcStatusCode (*ConnectionGetTableTypes)(struct AdbcConnection*,

                                            struct ArrowArrayStream*, struct AdbcError*);

  AdbcStatusCode (*ConnectionInit)(struct AdbcConnection*, struct AdbcDatabase*,

                                   struct AdbcError*);

  AdbcStatusCode (*ConnectionNew)(struct AdbcConnection*, struct AdbcError*);

  AdbcStatusCode (*ConnectionSetOption)(struct AdbcConnection*, const char*, const char*,

                                        struct AdbcError*);

  AdbcStatusCode (*ConnectionReadPartition)(struct AdbcConnection*, const uint8_t*,

                                            size_t, struct ArrowArrayStream*,

                                            struct AdbcError*);

  AdbcStatusCode (*ConnectionRelease)(struct AdbcConnection*, struct AdbcError*);

  AdbcStatusCode (*ConnectionRollback)(struct AdbcConnection*, struct AdbcError*);


  AdbcStatusCode (*StatementBind)(struct AdbcStatement*, struct ArrowArray*,

                                  struct ArrowSchema*, struct AdbcError*);

  AdbcStatusCode (*StatementBindStream)(struct AdbcStatement*, struct ArrowArrayStream*,

                                        struct AdbcError*);

  AdbcStatusCode (*StatementExecuteQuery)(struct AdbcStatement*, struct ArrowArrayStream*,

                                          int64_t*, struct AdbcError*);

  AdbcStatusCode (*StatementExecutePartitions)(struct AdbcStatement*, struct ArrowSchema*,

                                               struct AdbcPartitions*, int64_t*,

                                               struct AdbcError*);

  AdbcStatusCode (*StatementGetParameterSchema)(struct AdbcStatement*,

                                                struct ArrowSchema*, struct AdbcError*);

  AdbcStatusCode (*StatementNew)(struct AdbcConnection*, struct AdbcStatement*,

                                 struct AdbcError*);

  AdbcStatusCode (*StatementPrepare)(struct AdbcStatement*, struct AdbcError*);

  AdbcStatusCode (*StatementRelease)(struct AdbcStatement*, struct AdbcError*);

  AdbcStatusCode (*StatementSetOption)(struct AdbcStatement*, const char*, const char*,

                                       struct AdbcError*);

  AdbcStatusCode (*StatementSetSqlQuery)(struct AdbcStatement*, const char*,

                                         struct AdbcError*);

  AdbcStatusCode (*StatementSetSubstraitPlan)(struct AdbcStatement*, const uint8_t*,

                                              size_t, struct AdbcError*);


  int (*ErrorGetDetailCount)(const struct AdbcError* error);

  struct AdbcErrorDetail (*ErrorGetDetail)(const struct AdbcError* error, int index);

  const struct AdbcError* (*ErrorFromArrayStream)(struct ArrowArrayStream* stream,

                                                  AdbcStatusCode* status);


  AdbcStatusCode (*DatabaseGetOption)(struct AdbcDatabase*, const char*, char*, size_t*,

                                      struct AdbcError*);

  AdbcStatusCode (*DatabaseGetOptionBytes)(struct AdbcDatabase*, const char*, uint8_t*,

                                           size_t*, struct AdbcError*);

  AdbcStatusCode (*DatabaseGetOptionDouble)(struct AdbcDatabase*, const char*, double*,

                                            struct AdbcError*);

  AdbcStatusCode (*DatabaseGetOptionInt)(struct AdbcDatabase*, const char*, int64_t*,

                                         struct AdbcError*);

  AdbcStatusCode (*DatabaseSetOptionBytes)(struct AdbcDatabase*, const char*,

                                           const uint8_t*, size_t, struct AdbcError*);

  AdbcStatusCode (*DatabaseSetOptionDouble)(struct AdbcDatabase*, const char*, double,

                                            struct AdbcError*);

  AdbcStatusCode (*DatabaseSetOptionInt)(struct AdbcDatabase*, const char*, int64_t,

                                         struct AdbcError*);


  AdbcStatusCode (*ConnectionCancel)(struct AdbcConnection*, struct AdbcError*);

  AdbcStatusCode (*ConnectionGetOption)(struct AdbcConnection*, const char*, char*,

                                        size_t*, struct AdbcError*);

  AdbcStatusCode (*ConnectionGetOptionBytes)(struct AdbcConnection*, const char*,

                                             uint8_t*, size_t*, struct AdbcError*);

  AdbcStatusCode (*ConnectionGetOptionDouble)(struct AdbcConnection*, const char*,

                                              double*, struct AdbcError*);

  AdbcStatusCode (*ConnectionGetOptionInt)(struct AdbcConnection*, const char*, int64_t*,

                                           struct AdbcError*);

  AdbcStatusCode (*ConnectionGetStatistics)(struct AdbcConnection*, const char*,

                                            const char*, const char*, char,

                                            struct ArrowArrayStream*, struct AdbcError*);

  AdbcStatusCode (*ConnectionGetStatisticNames)(struct AdbcConnection*,

                                                struct ArrowArrayStream*,

                                                struct AdbcError*);

  AdbcStatusCode (*ConnectionSetOptionBytes)(struct AdbcConnection*, const char*,

                                             const uint8_t*, size_t, struct AdbcError*);

  AdbcStatusCode (*ConnectionSetOptionDouble)(struct AdbcConnection*, const char*, double,

                                              struct AdbcError*);

  AdbcStatusCode (*ConnectionSetOptionInt)(struct AdbcConnection*, const char*, int64_t,

                                           struct AdbcError*);


  AdbcStatusCode (*StatementCancel)(struct AdbcStatement*, struct AdbcError*);

  AdbcStatusCode (*StatementExecuteSchema)(struct AdbcStatement*, struct ArrowSchema*,

                                           struct AdbcError*);

  AdbcStatusCode (*StatementGetOption)(struct AdbcStatement*, const char*, char*, size_t*,

                                       struct AdbcError*);

  AdbcStatusCode (*StatementGetOptionBytes)(struct AdbcStatement*, const char*, uint8_t*,

                                            size_t*, struct AdbcError*);

  AdbcStatusCode (*StatementGetOptionDouble)(struct AdbcStatement*, const char*, double*,

                                             struct AdbcError*);

  AdbcStatusCode (*StatementGetOptionInt)(struct AdbcStatement*, const char*, int64_t*,

                                          struct AdbcError*);

  AdbcStatusCode (*StatementSetOptionBytes)(struct AdbcStatement*, const char*,

                                            const uint8_t*, size_t, struct AdbcError*);

  AdbcStatusCode (*StatementSetOptionDouble)(struct AdbcStatement*, const char*, double,

                                             struct AdbcError*);

  AdbcStatusCode (*StatementSetOptionInt)(struct AdbcStatement*, const char*, int64_t,

                                          struct AdbcError*);


};


#define ADBC_DRIVER_1_0_0_SIZE (offsetof(struct AdbcDriver, ErrorGetDetailCount))


#define ADBC_DRIVER_1_1_0_SIZE (sizeof(struct AdbcDriver))


ADBC_EXPORT

AdbcStatusCode AdbcDatabaseNew(struct AdbcDatabase* database, struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcDatabaseGetOption(struct AdbcDatabase* database, const char* key,

                                     char* value, size_t* length,

                                     struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcDatabaseGetOptionBytes(struct AdbcDatabase* database, const char* key,

                                          uint8_t* value, size_t* length,

                                          struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcDatabaseGetOptionDouble(struct AdbcDatabase* database, const char* key,

                                           double* value, struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcDatabaseGetOptionInt(struct AdbcDatabase* database, const char* key,

                                        int64_t* value, struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcDatabaseSetOption(struct AdbcDatabase* database, const char* key,

                                     const char* value, struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcDatabaseSetOptionBytes(struct AdbcDatabase* database, const char* key,

                                          const uint8_t* value, size_t length,

                                          struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcDatabaseSetOptionDouble(struct AdbcDatabase* database, const char* key,

                                           double value, struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcDatabaseSetOptionInt(struct AdbcDatabase* database, const char* key,

                                        int64_t value, struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcDatabaseInit(struct AdbcDatabase* database, struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcDatabaseRelease(struct AdbcDatabase* database,

                                   struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcConnectionNew(struct AdbcConnection* connection,

                                 struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcConnectionSetOption(struct AdbcConnection* connection, const char* key,

                                       const char* value, struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcConnectionSetOptionBytes(struct AdbcConnection* connection,

                                            const char* key, const uint8_t* value,

                                            size_t length, struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcConnectionSetOptionInt(struct AdbcConnection* connection,

                                          const char* key, int64_t value,

                                          struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcConnectionSetOptionDouble(struct AdbcConnection* connection,

                                             const char* key, double value,

                                             struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcConnectionInit(struct AdbcConnection* connection,

                                  struct AdbcDatabase* database, struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcConnectionRelease(struct AdbcConnection* connection,

                                     struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcConnectionCancel(struct AdbcConnection* connection,

                                    struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcConnectionGetInfo(struct AdbcConnection* connection,

                                     const uint32_t* info_codes, size_t info_codes_length,

                                     struct ArrowArrayStream* out,

                                     struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcConnectionGetObjects(struct AdbcConnection* connection, int depth,

                                        const char* catalog, const char* db_schema,

                                        const char* table_name, const char** table_type,

                                        const char* column_name,

                                        struct ArrowArrayStream* out,

                                        struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcConnectionGetOption(struct AdbcConnection* connection, const char* key,

                                       char* value, size_t* length,

                                       struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcConnectionGetOptionBytes(struct AdbcConnection* connection,

                                            const char* key, uint8_t* value,

                                            size_t* length, struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcConnectionGetOptionInt(struct AdbcConnection* connection,

                                          const char* key, int64_t* value,

                                          struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcConnectionGetOptionDouble(struct AdbcConnection* connection,

                                             const char* key, double* value,

                                             struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcConnectionGetStatistics(struct AdbcConnection* connection,

                                           const char* catalog, const char* db_schema,

                                           const char* table_name, char approximate,

                                           struct ArrowArrayStream* out,

                                           struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcConnectionGetStatisticNames(struct AdbcConnection* connection,

                                               struct ArrowArrayStream* out,

                                               struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcConnectionGetTableSchema(struct AdbcConnection* connection,

                                            const char* catalog, const char* db_schema,

                                            const char* table_name,

                                            struct ArrowSchema* schema,

                                            struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcConnectionGetTableTypes(struct AdbcConnection* connection,

                                           struct ArrowArrayStream* out,

                                           struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcConnectionReadPartition(struct AdbcConnection* connection,

                                           const uint8_t* serialized_partition,

                                           size_t serialized_length,

                                           struct ArrowArrayStream* out,

                                           struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcConnectionCommit(struct AdbcConnection* connection,

                                    struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcConnectionRollback(struct AdbcConnection* connection,

                                      struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcStatementNew(struct AdbcConnection* connection,

                                struct AdbcStatement* statement, struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcStatementRelease(struct AdbcStatement* statement,

                                    struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcStatementExecuteQuery(struct AdbcStatement* statement,

                                         struct ArrowArrayStream* out,

                                         int64_t* rows_affected, struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcStatementExecuteSchema(struct AdbcStatement* statement,

                                          struct ArrowSchema* schema,

                                          struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcStatementPrepare(struct AdbcStatement* statement,

                                    struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcStatementSetSqlQuery(struct AdbcStatement* statement,

                                        const char* query, struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcStatementSetSubstraitPlan(struct AdbcStatement* statement,

                                             const uint8_t* plan, size_t length,

                                             struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcStatementBind(struct AdbcStatement* statement,

                                 struct ArrowArray* values, struct ArrowSchema* schema,

                                 struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcStatementBindStream(struct AdbcStatement* statement,

                                       struct ArrowArrayStream* stream,

                                       struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcStatementCancel(struct AdbcStatement* statement,

                                   struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcStatementGetOption(struct AdbcStatement* statement, const char* key,

                                      char* value, size_t* length,

                                      struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcStatementGetOptionBytes(struct AdbcStatement* statement,

                                           const char* key, uint8_t* value,

                                           size_t* length, struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcStatementGetOptionInt(struct AdbcStatement* statement, const char* key,

                                         int64_t* value, struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcStatementGetOptionDouble(struct AdbcStatement* statement,

                                            const char* key, double* value,

                                            struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcStatementGetParameterSchema(struct AdbcStatement* statement,

                                               struct ArrowSchema* schema,

                                               struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcStatementSetOption(struct AdbcStatement* statement, const char* key,

                                      const char* value, struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcStatementSetOptionBytes(struct AdbcStatement* statement,

                                           const char* key, const uint8_t* value,

                                           size_t length, struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcStatementSetOptionInt(struct AdbcStatement* statement, const char* key,

                                         int64_t value, struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcStatementSetOptionDouble(struct AdbcStatement* statement,

                                            const char* key, double value,

                                            struct AdbcError* error);


ADBC_EXPORT

AdbcStatusCode AdbcStatementExecutePartitions(struct AdbcStatement* statement,

                                              struct ArrowSchema* schema,

                                              struct AdbcPartitions* partitions,

                                              int64_t* rows_affected,

                                              struct AdbcError* error);


typedef AdbcStatusCode (*AdbcDriverInitFunc)(int version, void* driver,

                                             struct AdbcError* error);


#endif  // ADBC


#ifdef __cplusplus

}

#endif

AdbcConnectionGetOptionBytes
AdbcStatusCode AdbcConnectionGetOptionBytes(struct AdbcConnection *connection, const char *key, uint8_t *value, size_t *length, struct AdbcError *error)
Get a bytestring option of the connection.

AdbcConnectionGetObjects
AdbcStatusCode AdbcConnectionGetObjects(struct AdbcConnection *connection, int depth, const char *catalog, const char *db_schema, const char *table_name, const char **table_type, const char *column_name, struct ArrowArrayStream *out, struct AdbcError *error)
Get a hierarchical view of all catalogs, database schemas, tables, and columns.

AdbcConnectionGetTableTypes
AdbcStatusCode AdbcConnectionGetTableTypes(struct AdbcConnection *connection, struct ArrowArrayStream *out, struct AdbcError *error)
Get a list of table types in the database.

AdbcConnectionGetStatisticNames
AdbcStatusCode AdbcConnectionGetStatisticNames(struct AdbcConnection *connection, struct ArrowArrayStream *out, struct AdbcError *error)
Get the names of statistics specific to this driver.

AdbcConnectionGetOptionInt
AdbcStatusCode AdbcConnectionGetOptionInt(struct AdbcConnection *connection, const char *key, int64_t *value, struct AdbcError *error)
Get an integer option of the connection.

AdbcConnectionGetOptionDouble
AdbcStatusCode AdbcConnectionGetOptionDouble(struct AdbcConnection *connection, const char *key, double *value, struct AdbcError *error)
Get a double option of the connection.

AdbcConnectionGetStatistics
AdbcStatusCode AdbcConnectionGetStatistics(struct AdbcConnection *connection, const char *catalog, const char *db_schema, const char *table_name, char approximate, struct ArrowArrayStream *out, struct AdbcError *error)
Get statistics about the data distribution of table(s).

AdbcConnectionGetOption
AdbcStatusCode AdbcConnectionGetOption(struct AdbcConnection *connection, const char *key, char *value, size_t *length, struct AdbcError *error)
Get a string option of the connection.

AdbcConnectionGetInfo
AdbcStatusCode AdbcConnectionGetInfo(struct AdbcConnection *connection, const uint32_t *info_codes, size_t info_codes_length, struct ArrowArrayStream *out, struct AdbcError *error)
Get metadata about the database/driver.

AdbcConnectionGetTableSchema
AdbcStatusCode AdbcConnectionGetTableSchema(struct AdbcConnection *connection, const char *catalog, const char *db_schema, const char *table_name, struct ArrowSchema *schema, struct AdbcError *error)
Get the Arrow schema of a table.

AdbcConnectionReadPartition
AdbcStatusCode AdbcConnectionReadPartition(struct AdbcConnection *connection, const uint8_t *serialized_partition, size_t serialized_length, struct ArrowArrayStream *out, struct AdbcError *error)
Construct a statement for a partition of a query. The results can then be read independently.

AdbcConnectionCommit
AdbcStatusCode AdbcConnectionCommit(struct AdbcConnection *connection, struct AdbcError *error)
Commit any pending transactions. Only used if autocommit is disabled.

AdbcConnectionRollback
AdbcStatusCode AdbcConnectionRollback(struct AdbcConnection *connection, struct AdbcError *error)
Roll back any pending transactions. Only used if autocommit is disabled.

AdbcConnection::private_data
void * private_data
Opaque implementation-defined state. This field is NULLPTR iff the connection is unintialized/freed.
Definition adbc.h:834

AdbcConnection::private_driver
struct AdbcDriver * private_driver
The associated driver (used by the driver manager to help track state).
Definition adbc.h:837

AdbcConnectionSetOption
AdbcStatusCode AdbcConnectionSetOption(struct AdbcConnection *connection, const char *key, const char *value, struct AdbcError *error)
Set a char* option.

AdbcConnectionCancel
AdbcStatusCode AdbcConnectionCancel(struct AdbcConnection *connection, struct AdbcError *error)
Cancel the in-progress operation on a connection.

AdbcConnectionNew
AdbcStatusCode AdbcConnectionNew(struct AdbcConnection *connection, struct AdbcError *error)
Allocate a new (but uninitialized) connection.

AdbcConnectionSetOptionInt
AdbcStatusCode AdbcConnectionSetOptionInt(struct AdbcConnection *connection, const char *key, int64_t value, struct AdbcError *error)
Set an integer option.

AdbcConnectionSetOptionBytes
AdbcStatusCode AdbcConnectionSetOptionBytes(struct AdbcConnection *connection, const char *key, const uint8_t *value, size_t length, struct AdbcError *error)
Set a bytestring option on a connection.

AdbcConnectionRelease
AdbcStatusCode AdbcConnectionRelease(struct AdbcConnection *connection, struct AdbcError *error)
Destroy this connection.

AdbcConnectionInit
AdbcStatusCode AdbcConnectionInit(struct AdbcConnection *connection, struct AdbcDatabase *database, struct AdbcError *error)
Finish setting options and initialize the connection.

AdbcConnectionSetOptionDouble
AdbcStatusCode AdbcConnectionSetOptionDouble(struct AdbcConnection *connection, const char *key, double value, struct AdbcError *error)
Set a double option.

AdbcConnection
An active database connection.
Definition adbc.h:831

AdbcDatabase::private_data
void * private_data
Opaque implementation-defined state. This field is NULLPTR iff the connection is unintialized/freed.
Definition adbc.h:811

AdbcDatabase::private_driver
struct AdbcDriver * private_driver
The associated driver (used by the driver manager to help track state).
Definition adbc.h:814

AdbcDatabaseSetOptionDouble
AdbcStatusCode AdbcDatabaseSetOptionDouble(struct AdbcDatabase *database, const char *key, double value, struct AdbcError *error)
Set a double option on a database.

AdbcDatabaseGetOptionBytes
AdbcStatusCode AdbcDatabaseGetOptionBytes(struct AdbcDatabase *database, const char *key, uint8_t *value, size_t *length, struct AdbcError *error)
Get a bytestring option of the database.

AdbcDatabaseGetOptionInt
AdbcStatusCode AdbcDatabaseGetOptionInt(struct AdbcDatabase *database, const char *key, int64_t *value, struct AdbcError *error)
Get an integer option of the database.

AdbcDatabaseNew
AdbcStatusCode AdbcDatabaseNew(struct AdbcDatabase *database, struct AdbcError *error)
Allocate a new (but uninitialized) database.

AdbcDatabaseRelease
AdbcStatusCode AdbcDatabaseRelease(struct AdbcDatabase *database, struct AdbcError *error)
Destroy this database. No connections may exist.

AdbcDatabaseInit
AdbcStatusCode AdbcDatabaseInit(struct AdbcDatabase *database, struct AdbcError *error)
Finish setting options and initialize the database.

AdbcDatabaseGetOptionDouble
AdbcStatusCode AdbcDatabaseGetOptionDouble(struct AdbcDatabase *database, const char *key, double *value, struct AdbcError *error)
Get a double option of the database.

AdbcDatabaseSetOption
AdbcStatusCode AdbcDatabaseSetOption(struct AdbcDatabase *database, const char *key, const char *value, struct AdbcError *error)
Set a char* option.

AdbcDatabaseGetOption
AdbcStatusCode AdbcDatabaseGetOption(struct AdbcDatabase *database, const char *key, char *value, size_t *length, struct AdbcError *error)
Get a string option of the database.

AdbcDatabaseSetOptionInt
AdbcStatusCode AdbcDatabaseSetOptionInt(struct AdbcDatabase *database, const char *key, int64_t value, struct AdbcError *error)
Set an integer option on a database.

AdbcDatabaseSetOptionBytes
AdbcStatusCode AdbcDatabaseSetOptionBytes(struct AdbcDatabase *database, const char *key, const uint8_t *value, size_t length, struct AdbcError *error)
Set a bytestring option on a database.

AdbcDatabase
An instance of a database.
Definition adbc.h:808

AdbcDriver::private_manager
void * private_manager
Opaque driver manager-defined state. This field is NULL if the driver is unintialized/freed (but it n...
Definition adbc.h:944

AdbcDriver::private_data
void * private_data
Opaque driver-defined state. This field is NULL if the driver is unintialized/freed (but it need not ...
Definition adbc.h:940

AdbcDriverInitFunc
AdbcStatusCode(* AdbcDriverInitFunc)(int version, void *driver, struct AdbcError *error)
Common entry point for drivers via the driver manager (which uses dlopen(3)/LoadLibrary)....
Definition adbc.h:2347

AdbcDriver
An instance of an initialized database driver.
Definition adbc.h:936

AdbcError::vendor_code
int32_t vendor_code
A vendor-specific error code, if applicable.
Definition adbc.h:274

AdbcError::private_data
void * private_data
Opaque implementation-defined state.
Definition adbc.h:294

AdbcErrorDetail::key
const char * key
The metadata key.
Definition adbc.h:352

AdbcError::message
char * message
The error message.
Definition adbc.h:271

AdbcError::private_driver
struct AdbcDriver * private_driver
The associated driver (used by the driver manager to help track state).
Definition adbc.h:303

AdbcErrorDetail::value_length
size_t value_length
The length of the metadata value.
Definition adbc.h:356

AdbcErrorDetail::value
const uint8_t * value
The binary metadata value.
Definition adbc.h:354

AdbcErrorFromArrayStream
const struct AdbcError * AdbcErrorFromArrayStream(struct ArrowArrayStream *stream, AdbcStatusCode *status)
Get an ADBC error from an ArrowArrayStream created by a driver.

AdbcStatusCode
uint8_t AdbcStatusCode
Error codes for operations that may fail.
Definition adbc.h:176

AdbcErrorGetDetailCount
int AdbcErrorGetDetailCount(const struct AdbcError *error)
Get the number of metadata values available in an error.

AdbcErrorGetDetail
struct AdbcErrorDetail AdbcErrorGetDetail(const struct AdbcError *error, int index)
Get a metadata value in an error by index.

AdbcError
A detailed error message for an operation.
Definition adbc.h:269

AdbcErrorDetail
Extra key-value metadata for an error.
Definition adbc.h:350

AdbcPartitions::partition_lengths
const size_t * partition_lengths
The length of each corresponding entry in partitions.
Definition adbc.h:907

AdbcPartitions::private_data
void * private_data
Opaque implementation-defined state. This field is NULLPTR iff the connection is unintialized/freed.
Definition adbc.h:911

AdbcPartitions::release
void(* release)(struct AdbcPartitions *partitions)
Release the contained partitions.
Definition adbc.h:917

AdbcPartitions::num_partitions
size_t num_partitions
The number of partitions.
Definition adbc.h:899

AdbcPartitions::partitions
const uint8_t ** partitions
The partitions of the result set, where each entry (up to num_partitions entries) is an opaque identi...
Definition adbc.h:904

AdbcStatementExecutePartitions
AdbcStatusCode AdbcStatementExecutePartitions(struct AdbcStatement *statement, struct ArrowSchema *schema, struct AdbcPartitions *partitions, int64_t *rows_affected, struct AdbcError *error)
Execute a statement and get the results as a partitioned result set.

AdbcPartitions
The partitions of a distributed/partitioned result set.
Definition adbc.h:897

AdbcStatementSetSqlQuery
AdbcStatusCode AdbcStatementSetSqlQuery(struct AdbcStatement *statement, const char *query, struct AdbcError *error)
Set the SQL query to execute.

AdbcStatementSetSubstraitPlan
AdbcStatusCode AdbcStatementSetSubstraitPlan(struct AdbcStatement *statement, const uint8_t *plan, size_t length, struct AdbcError *error)
Set the Substrait plan to execute.

AdbcStatement::private_data
void * private_data
Opaque implementation-defined state. This field is NULLPTR iff the connection is unintialized/freed.
Definition adbc.h:872

AdbcStatement::private_driver
struct AdbcDriver * private_driver
The associated driver (used by the driver manager to help track state).
Definition adbc.h:876

AdbcStatementExecuteQuery
AdbcStatusCode AdbcStatementExecuteQuery(struct AdbcStatement *statement, struct ArrowArrayStream *out, int64_t *rows_affected, struct AdbcError *error)
Execute a statement and get the results.

AdbcStatementCancel
AdbcStatusCode AdbcStatementCancel(struct AdbcStatement *statement, struct AdbcError *error)
Cancel execution of an in-progress query.

AdbcStatementGetParameterSchema
AdbcStatusCode AdbcStatementGetParameterSchema(struct AdbcStatement *statement, struct ArrowSchema *schema, struct AdbcError *error)
Get the schema for bound parameters.

AdbcStatementSetOptionInt
AdbcStatusCode AdbcStatementSetOptionInt(struct AdbcStatement *statement, const char *key, int64_t value, struct AdbcError *error)
Set an integer option on a statement.

AdbcStatementExecuteSchema
AdbcStatusCode AdbcStatementExecuteSchema(struct AdbcStatement *statement, struct ArrowSchema *schema, struct AdbcError *error)
Get the schema of the result set of a query without executing it.

AdbcStatementRelease
AdbcStatusCode AdbcStatementRelease(struct AdbcStatement *statement, struct AdbcError *error)
Destroy a statement.

AdbcStatementSetOption
AdbcStatusCode AdbcStatementSetOption(struct AdbcStatement *statement, const char *key, const char *value, struct AdbcError *error)
Set a string option on a statement.

AdbcStatementPrepare
AdbcStatusCode AdbcStatementPrepare(struct AdbcStatement *statement, struct AdbcError *error)
Turn this statement into a prepared statement to be executed multiple times.

AdbcStatementGetOptionDouble
AdbcStatusCode AdbcStatementGetOptionDouble(struct AdbcStatement *statement, const char *key, double *value, struct AdbcError *error)
Get a double option of the statement.

AdbcStatementSetOptionBytes
AdbcStatusCode AdbcStatementSetOptionBytes(struct AdbcStatement *statement, const char *key, const uint8_t *value, size_t length, struct AdbcError *error)
Set a bytestring option on a statement.

AdbcStatementBindStream
AdbcStatusCode AdbcStatementBindStream(struct AdbcStatement *statement, struct ArrowArrayStream *stream, struct AdbcError *error)
Bind Arrow data. This can be used for bulk inserts or prepared statements.

AdbcStatementBind
AdbcStatusCode AdbcStatementBind(struct AdbcStatement *statement, struct ArrowArray *values, struct ArrowSchema *schema, struct AdbcError *error)
Bind Arrow data. This can be used for bulk inserts or prepared statements.

AdbcStatementGetOption
AdbcStatusCode AdbcStatementGetOption(struct AdbcStatement *statement, const char *key, char *value, size_t *length, struct AdbcError *error)
Get a string option of the statement.

AdbcStatementGetOptionInt
AdbcStatusCode AdbcStatementGetOptionInt(struct AdbcStatement *statement, const char *key, int64_t *value, struct AdbcError *error)
Get an integer option of the statement.

AdbcStatementNew
AdbcStatusCode AdbcStatementNew(struct AdbcConnection *connection, struct AdbcStatement *statement, struct AdbcError *error)
Create a new statement for a given connection.

AdbcStatementGetOptionBytes
AdbcStatusCode AdbcStatementGetOptionBytes(struct AdbcStatement *statement, const char *key, uint8_t *value, size_t *length, struct AdbcError *error)
Get a bytestring option of the statement.

AdbcStatementSetOptionDouble
AdbcStatusCode AdbcStatementSetOptionDouble(struct AdbcStatement *statement, const char *key, double value, struct AdbcError *error)
Set a double option on a statement.

AdbcStatement
A container for all state needed to execute a database query, such as the query itself,...
Definition adbc.h:869