This is an automated email from the ASF dual-hosted git repository.
lidavidm pushed a commit to branch spec-1.1.0
in repository https://gitbox.apache.org/repos/asf/arrow-adbc.git
The following commit(s) were added to refs/heads/spec-1.1.0 by this push:
new a06e53a8 chore(go): fix up minor Go things in 1.1.0 draft (#926)
a06e53a8 is described below
commit a06e53a80c118c7b78f5891776f51777280d55f7
Author: David Li <[email protected]>
AuthorDate: Fri Jul 21 16:22:30 2023 -0400
chore(go): fix up minor Go things in 1.1.0 draft (#926)
---
adbc.h | 32 ++--
go/adbc/driver/flightsql/record_reader.go | 7 +-
go/adbc/driver/flightsql/utils.go | 4 +-
go/adbc/drivermgr/adbc.h | 32 ++--
go/adbc/pkg/_tmpl/driver.go.tmpl | 2 +
go/adbc/pkg/_tmpl/utils.c.tmpl | 271 ++++++++++++++++++++++-------
go/adbc/pkg/flightsql/driver.go | 2 +
go/adbc/pkg/flightsql/utils.c | 274 +++++++++++++++++++++++-------
go/adbc/pkg/panicdummy/driver.go | 2 +
go/adbc/pkg/panicdummy/utils.c | 274 +++++++++++++++++++++++-------
go/adbc/pkg/snowflake/driver.go | 2 +
go/adbc/pkg/snowflake/utils.c | 274 +++++++++++++++++++++++-------
12 files changed, 901 insertions(+), 275 deletions(-)
diff --git a/adbc.h b/adbc.h
index 7708d6db..badfc7d6 100644
--- a/adbc.h
+++ b/adbc.h
@@ -1066,7 +1066,7 @@ AdbcStatusCode AdbcDatabaseGetOptionBytes(struct
AdbcDatabase* database, const c
uint8_t* value, size_t* length,
struct AdbcError* error);
-/// \brief Get an integer option of the database.
+/// \brief Get a double option of the database.
///
/// This must always be thread-safe (other operations are not).
///
@@ -1075,8 +1075,8 @@ AdbcStatusCode AdbcDatabaseGetOptionBytes(struct
AdbcDatabase* database, const c
/// the type specified in the option. (For example, an option set via
/// SetOptionDouble must be retrievable via GetOptionDouble.) Drivers
/// may also support getting a converted option value via other
-/// getters if needed. (For example, getting the integer
-/// representation of a double option.)
+/// getters if needed. (For example, getting the double
+/// representation of an integer option.)
///
/// \since ADBC API revision 1.1.0
/// \addtogroup adbc-1.1.0
@@ -1086,10 +1086,10 @@ AdbcStatusCode AdbcDatabaseGetOptionBytes(struct
AdbcDatabase* database, const c
/// \param[out] error An optional location to return an error
/// message if necessary.
/// \return ADBC_STATUS_NOT_FOUND if the option is not recognized.
-AdbcStatusCode AdbcDatabaseGetOptionInt(struct AdbcDatabase* database, const
char* key,
- int64_t* value, struct AdbcError*
error);
+AdbcStatusCode AdbcDatabaseGetOptionDouble(struct AdbcDatabase* database,
const char* key,
+ double* value, struct AdbcError*
error);
-/// \brief Get a double option of the database.
+/// \brief Get an integer option of the database.
///
/// This must always be thread-safe (other operations are not).
///
@@ -1098,8 +1098,8 @@ AdbcStatusCode AdbcDatabaseGetOptionInt(struct
AdbcDatabase* database, const cha
/// the type specified in the option. (For example, an option set via
/// SetOptionDouble must be retrievable via GetOptionDouble.) Drivers
/// may also support getting a converted option value via other
-/// getters if needed. (For example, getting the double
-/// representation of an integer option.)
+/// getters if needed. (For example, getting the integer
+/// representation of a double option.)
///
/// \since ADBC API revision 1.1.0
/// \addtogroup adbc-1.1.0
@@ -1109,8 +1109,8 @@ AdbcStatusCode AdbcDatabaseGetOptionInt(struct
AdbcDatabase* database, const cha
/// \param[out] error An optional location to return an error
/// message if necessary.
/// \return ADBC_STATUS_NOT_FOUND if the option is not recognized.
-AdbcStatusCode AdbcDatabaseGetOptionDouble(struct AdbcDatabase* database,
const char* key,
- double* value, struct AdbcError*
error);
+AdbcStatusCode AdbcDatabaseGetOptionInt(struct AdbcDatabase* database, const
char* key,
+ int64_t* value, struct AdbcError*
error);
/// \brief Set a char* option.
///
@@ -1143,7 +1143,7 @@ AdbcStatusCode AdbcDatabaseSetOptionBytes(struct
AdbcDatabase* database, const c
const uint8_t* value, size_t length,
struct AdbcError* error);
-/// \brief Set an integer option on a database.
+/// \brief Set a double option on a database.
///
/// \since ADBC API revision 1.1.0
/// \addtogroup adbc-1.1.0
@@ -1154,10 +1154,10 @@ AdbcStatusCode AdbcDatabaseSetOptionBytes(struct
AdbcDatabase* database, const c
/// message if necessary.
/// \return ADBC_STATUS_NOT_IMPLEMENTED if the option is not recognized
ADBC_EXPORT
-AdbcStatusCode AdbcDatabaseSetOptionInt(struct AdbcDatabase* database, const
char* key,
- int64_t value, struct AdbcError*
error);
+AdbcStatusCode AdbcDatabaseSetOptionDouble(struct AdbcDatabase* database,
const char* key,
+ double value, struct AdbcError*
error);
-/// \brief Set a double option on a database.
+/// \brief Set an integer option on a database.
///
/// \since ADBC API revision 1.1.0
/// \addtogroup adbc-1.1.0
@@ -1168,8 +1168,8 @@ AdbcStatusCode AdbcDatabaseSetOptionInt(struct
AdbcDatabase* database, const cha
/// message if necessary.
/// \return ADBC_STATUS_NOT_IMPLEMENTED if the option is not recognized
ADBC_EXPORT
-AdbcStatusCode AdbcDatabaseSetOptionDouble(struct AdbcDatabase* database,
const char* key,
- double value, struct AdbcError*
error);
+AdbcStatusCode AdbcDatabaseSetOptionInt(struct AdbcDatabase* database, const
char* key,
+ int64_t value, struct AdbcError*
error);
/// \brief Finish setting options and initialize the database.
///
diff --git a/go/adbc/driver/flightsql/record_reader.go
b/go/adbc/driver/flightsql/record_reader.go
index acf59693..fa62a052 100644
--- a/go/adbc/driver/flightsql/record_reader.go
+++ b/go/adbc/driver/flightsql/record_reader.go
@@ -88,9 +88,10 @@ func newRecordReader(ctx context.Context, alloc
memory.Allocator, cl *flightsql.
Code: adbc.StatusInvalidState}
}
} else {
- rdr, err := doGet(ctx, cl, endpoints[0], clCache, opts...)
+ firstEndpoint := endpoints[0]
+ rdr, err := doGet(ctx, cl, firstEndpoint, clCache, opts...)
if err != nil {
- return nil, adbcFromFlightStatus(err, "DoGet: endpoint
0: remote: %s", endpoints[0].Location)
+ return nil, adbcFromFlightStatus(err, "DoGet: endpoint
0: remote: %s", firstEndpoint.Location)
}
schema = rdr.Schema()
group.Go(func() error {
@@ -104,7 +105,7 @@ func newRecordReader(ctx context.Context, alloc
memory.Allocator, cl *flightsql.
rec.Retain()
ch <- rec
}
- return adbcFromFlightStatus(rdr.Err(), "DoGet: endpoint
0: remote: %s", endpoints[0].Location)
+ return adbcFromFlightStatus(rdr.Err(), "DoGet: endpoint
0: remote: %s", firstEndpoint.Location)
})
endpoints = endpoints[1:]
diff --git a/go/adbc/driver/flightsql/utils.go
b/go/adbc/driver/flightsql/utils.go
index ae7fcea7..8c1263f9 100644
--- a/go/adbc/driver/flightsql/utils.go
+++ b/go/adbc/driver/flightsql/utils.go
@@ -87,8 +87,8 @@ func adbcFromFlightStatus(err error, context string, args
...any) error {
}
return adbc.Error{
- Msg: fmt.Sprintf("[FlightSQL] %s (%s; %s)",
grpcStatus.Message(), grpcStatus.Code(), fmt.Sprintf(context, args...)),
- Code: adbcCode,
+ Msg: fmt.Sprintf("[FlightSQL] %s (%s; %s)",
grpcStatus.Message(), grpcStatus.Code(), fmt.Sprintf(context, args...)),
+ Code: adbcCode,
Details: details,
}
}
diff --git a/go/adbc/drivermgr/adbc.h b/go/adbc/drivermgr/adbc.h
index 7708d6db..badfc7d6 100644
--- a/go/adbc/drivermgr/adbc.h
+++ b/go/adbc/drivermgr/adbc.h
@@ -1066,7 +1066,7 @@ AdbcStatusCode AdbcDatabaseGetOptionBytes(struct
AdbcDatabase* database, const c
uint8_t* value, size_t* length,
struct AdbcError* error);
-/// \brief Get an integer option of the database.
+/// \brief Get a double option of the database.
///
/// This must always be thread-safe (other operations are not).
///
@@ -1075,8 +1075,8 @@ AdbcStatusCode AdbcDatabaseGetOptionBytes(struct
AdbcDatabase* database, const c
/// the type specified in the option. (For example, an option set via
/// SetOptionDouble must be retrievable via GetOptionDouble.) Drivers
/// may also support getting a converted option value via other
-/// getters if needed. (For example, getting the integer
-/// representation of a double option.)
+/// getters if needed. (For example, getting the double
+/// representation of an integer option.)
///
/// \since ADBC API revision 1.1.0
/// \addtogroup adbc-1.1.0
@@ -1086,10 +1086,10 @@ AdbcStatusCode AdbcDatabaseGetOptionBytes(struct
AdbcDatabase* database, const c
/// \param[out] error An optional location to return an error
/// message if necessary.
/// \return ADBC_STATUS_NOT_FOUND if the option is not recognized.
-AdbcStatusCode AdbcDatabaseGetOptionInt(struct AdbcDatabase* database, const
char* key,
- int64_t* value, struct AdbcError*
error);
+AdbcStatusCode AdbcDatabaseGetOptionDouble(struct AdbcDatabase* database,
const char* key,
+ double* value, struct AdbcError*
error);
-/// \brief Get a double option of the database.
+/// \brief Get an integer option of the database.
///
/// This must always be thread-safe (other operations are not).
///
@@ -1098,8 +1098,8 @@ AdbcStatusCode AdbcDatabaseGetOptionInt(struct
AdbcDatabase* database, const cha
/// the type specified in the option. (For example, an option set via
/// SetOptionDouble must be retrievable via GetOptionDouble.) Drivers
/// may also support getting a converted option value via other
-/// getters if needed. (For example, getting the double
-/// representation of an integer option.)
+/// getters if needed. (For example, getting the integer
+/// representation of a double option.)
///
/// \since ADBC API revision 1.1.0
/// \addtogroup adbc-1.1.0
@@ -1109,8 +1109,8 @@ AdbcStatusCode AdbcDatabaseGetOptionInt(struct
AdbcDatabase* database, const cha
/// \param[out] error An optional location to return an error
/// message if necessary.
/// \return ADBC_STATUS_NOT_FOUND if the option is not recognized.
-AdbcStatusCode AdbcDatabaseGetOptionDouble(struct AdbcDatabase* database,
const char* key,
- double* value, struct AdbcError*
error);
+AdbcStatusCode AdbcDatabaseGetOptionInt(struct AdbcDatabase* database, const
char* key,
+ int64_t* value, struct AdbcError*
error);
/// \brief Set a char* option.
///
@@ -1143,7 +1143,7 @@ AdbcStatusCode AdbcDatabaseSetOptionBytes(struct
AdbcDatabase* database, const c
const uint8_t* value, size_t length,
struct AdbcError* error);
-/// \brief Set an integer option on a database.
+/// \brief Set a double option on a database.
///
/// \since ADBC API revision 1.1.0
/// \addtogroup adbc-1.1.0
@@ -1154,10 +1154,10 @@ AdbcStatusCode AdbcDatabaseSetOptionBytes(struct
AdbcDatabase* database, const c
/// message if necessary.
/// \return ADBC_STATUS_NOT_IMPLEMENTED if the option is not recognized
ADBC_EXPORT
-AdbcStatusCode AdbcDatabaseSetOptionInt(struct AdbcDatabase* database, const
char* key,
- int64_t value, struct AdbcError*
error);
+AdbcStatusCode AdbcDatabaseSetOptionDouble(struct AdbcDatabase* database,
const char* key,
+ double value, struct AdbcError*
error);
-/// \brief Set a double option on a database.
+/// \brief Set an integer option on a database.
///
/// \since ADBC API revision 1.1.0
/// \addtogroup adbc-1.1.0
@@ -1168,8 +1168,8 @@ AdbcStatusCode AdbcDatabaseSetOptionInt(struct
AdbcDatabase* database, const cha
/// message if necessary.
/// \return ADBC_STATUS_NOT_IMPLEMENTED if the option is not recognized
ADBC_EXPORT
-AdbcStatusCode AdbcDatabaseSetOptionDouble(struct AdbcDatabase* database,
const char* key,
- double value, struct AdbcError*
error);
+AdbcStatusCode AdbcDatabaseSetOptionInt(struct AdbcDatabase* database, const
char* key,
+ int64_t value, struct AdbcError*
error);
/// \brief Finish setting options and initialize the database.
///
diff --git a/go/adbc/pkg/_tmpl/driver.go.tmpl b/go/adbc/pkg/_tmpl/driver.go.tmpl
index 3a0c993c..0b827ca3 100644
--- a/go/adbc/pkg/_tmpl/driver.go.tmpl
+++ b/go/adbc/pkg/_tmpl/driver.go.tmpl
@@ -997,6 +997,7 @@ func {{.Prefix}}ConnectionGetObjects(cnxn
*C.struct_AdbcConnection, depth C.int,
if e != nil {
return C.AdbcStatusCode(conn.errToAdbcErr(err, e))
}
+ defer rdr.Release()
cdata.ExportRecordReader(rdr, toCdataStream(out))
return C.ADBC_STATUS_OK
}
@@ -1024,6 +1025,7 @@ func {{.Prefix}}ConnectionGetStatistics(cnxn
*C.struct_AdbcConnection, catalog,
return C.AdbcStatusCode(conn.errToAdbcErr(err, e))
}
+ defer rdr.Release()
cdata.ExportRecordReader(rdr, toCdataStream(out))
return C.ADBC_STATUS_OK
}
diff --git a/go/adbc/pkg/_tmpl/utils.c.tmpl b/go/adbc/pkg/_tmpl/utils.c.tmpl
index 38222875..4b90a6d0 100644
--- a/go/adbc/pkg/_tmpl/utils.c.tmpl
+++ b/go/adbc/pkg/_tmpl/utils.c.tmpl
@@ -17,7 +17,7 @@
// clang-format off
//go:build driverlib
-// clang-format on
+// clang-format on
#include "utils.h"
@@ -33,43 +33,70 @@ void {{.Prefix}}_release_error(struct AdbcError* error) {
error->release = NULL;
}
-AdbcStatusCode AdbcDatabaseNew(struct AdbcDatabase* database, struct
AdbcError* error) {
- return {{.Prefix}}DatabaseNew(database, error);
+AdbcStatusCode AdbcDatabaseGetOption(struct AdbcDatabase* database, const
char* key,
+ char* value, size_t* length,
+ struct AdbcError* error) {
+ return {{.Prefix}}DatabaseGetOption(database, key, value, length, error);
}
-AdbcStatusCode AdbcDatabaseSetOption(struct AdbcDatabase* database, const
char* key,
- const char* value, struct AdbcError*
error) {
- return {{.Prefix}}DatabaseSetOption(database, key, value, error);
+AdbcStatusCode AdbcDatabaseGetOptionBytes(struct AdbcDatabase* database, const
char* key,
+ uint8_t* value, size_t* length,
+ struct AdbcError* error) {
+ return {{.Prefix}}DatabaseGetOptionBytes(database, key, value, length,
error);
+}
+
+AdbcStatusCode AdbcDatabaseGetOptionDouble(struct AdbcDatabase* database,
const char* key,
+ double* value, struct AdbcError*
error) {
+ return {{.Prefix}}DatabaseGetOptionDouble(database, key, value, error);
+}
+
+AdbcStatusCode AdbcDatabaseGetOptionInt(struct AdbcDatabase* database, const
char* key,
+ int64_t* value, struct AdbcError*
error) {
+ return {{.Prefix}}DatabaseGetOptionInt(database, key, value, error);
}
AdbcStatusCode AdbcDatabaseInit(struct AdbcDatabase* database, struct
AdbcError* error) {
return {{.Prefix}}DatabaseInit(database, error);
}
+AdbcStatusCode AdbcDatabaseNew(struct AdbcDatabase* database, struct
AdbcError* error) {
+ return {{.Prefix}}DatabaseNew(database, error);
+}
+
AdbcStatusCode AdbcDatabaseRelease(struct AdbcDatabase* database,
struct AdbcError* error) {
return {{.Prefix}}DatabaseRelease(database, error);
}
-AdbcStatusCode AdbcConnectionNew(struct AdbcConnection* connection,
- struct AdbcError* error) {
- return {{.Prefix}}ConnectionNew(connection, error);
+AdbcStatusCode AdbcDatabaseSetOption(struct AdbcDatabase* database, const
char* key,
+ const char* value, struct AdbcError*
error) {
+ return {{.Prefix}}DatabaseSetOption(database, key, value, error);
}
-AdbcStatusCode AdbcConnectionSetOption(struct AdbcConnection* connection,
const char* key,
- const char* value, struct AdbcError*
error) {
- return {{.Prefix}}ConnectionSetOption(connection, key, value, error);
+AdbcStatusCode AdbcDatabaseSetOptionBytes(struct AdbcDatabase* database, const
char* key,
+ const uint8_t* value, size_t length,
+ struct AdbcError* error) {
+ return {{.Prefix}}DatabaseSetOptionBytes(database, key, value, length,
error);
}
-AdbcStatusCode AdbcConnectionInit(struct AdbcConnection* connection,
- struct AdbcDatabase* database,
- struct AdbcError* error) {
- return {{.Prefix}}ConnectionInit(connection, database, error);
+AdbcStatusCode AdbcDatabaseSetOptionDouble(struct AdbcDatabase* database,
const char* key,
+ double value, struct AdbcError*
error) {
+ return {{.Prefix}}DatabaseSetOptionDouble(database, key, value, error);
}
-AdbcStatusCode AdbcConnectionRelease(struct AdbcConnection* connection,
- struct AdbcError* error) {
- return {{.Prefix}}ConnectionRelease(connection, error);
+AdbcStatusCode AdbcDatabaseSetOptionInt(struct AdbcDatabase* database, const
char* key,
+ int64_t value, struct AdbcError*
error) {
+ return {{.Prefix}}DatabaseSetOptionInt(database, key, value, error);
+}
+
+AdbcStatusCode AdbcConnectionCancel(struct AdbcConnection* connection,
+ struct AdbcError* error) {
+ return {{.Prefix}}ConnectionCancel(connection, error);
+}
+
+AdbcStatusCode AdbcConnectionCommit(struct AdbcConnection* connection,
+ struct AdbcError* error) {
+ return {{.Prefix}}ConnectionCommit(connection, error);
}
AdbcStatusCode AdbcConnectionGetInfo(struct AdbcConnection* connection,
@@ -77,7 +104,8 @@ AdbcStatusCode AdbcConnectionGetInfo(struct AdbcConnection*
connection,
struct ArrowArrayStream* out,
struct AdbcError* error) {
if (out) memset(out, 0, sizeof(*out));
- return {{.Prefix}}ConnectionGetInfo(connection, info_codes,
info_codes_length, out, error);
+ return {{.Prefix}}ConnectionGetInfo(connection, info_codes,
info_codes_length,
+ out, error);
}
AdbcStatusCode AdbcConnectionGetObjects(struct AdbcConnection* connection, int
depth,
@@ -88,7 +116,46 @@ AdbcStatusCode AdbcConnectionGetObjects(struct
AdbcConnection* connection, int d
struct AdbcError* error) {
if (out) memset(out, 0, sizeof(*out));
return {{.Prefix}}ConnectionGetObjects(connection, depth, catalog,
db_schema, table_name,
- table_type, column_name, out, error);
+ table_type, column_name, out, error);
+}
+
+AdbcStatusCode AdbcConnectionGetOption(struct AdbcConnection* connection,
const char* key,
+ char* value, size_t* length,
+ struct AdbcError* error) {
+ return {{.Prefix}}ConnectionGetOption(connection, key, value, length, error);
+}
+
+AdbcStatusCode AdbcConnectionGetOptionBytes(struct AdbcConnection* connection,
+ const char* key, uint8_t* value,
+ size_t* length, struct AdbcError*
error) {
+ return {{.Prefix}}ConnectionGetOptionBytes(connection, key, value, length,
error);
+}
+
+AdbcStatusCode AdbcConnectionGetOptionDouble(struct AdbcConnection* connection,
+ const char* key, double* value,
+ struct AdbcError* error) {
+ return {{.Prefix}}ConnectionGetOptionDouble(connection, key, value, error);
+}
+
+AdbcStatusCode AdbcConnectionGetOptionInt(struct AdbcConnection* connection,
+ const char* key, int64_t* value,
+ struct AdbcError* error) {
+ return {{.Prefix}}ConnectionGetOptionInt(connection, key, value, error);
+}
+
+AdbcStatusCode AdbcConnectionGetStatistics(struct AdbcConnection* connection,
+ const char* catalog, const char*
db_schema,
+ const char* table_name, char
approximate,
+ struct ArrowArrayStream* out,
+ struct AdbcError* error) {
+ return {{.Prefix}}ConnectionGetStatistics(connection, catalog, db_schema,
table_name,
+ approximate, out, error);
+}
+
+AdbcStatusCode AdbcConnectionGetStatisticNames(struct AdbcConnection*
connection,
+ struct ArrowArrayStream* out,
+ struct AdbcError* error) {
+ return {{.Prefix}}ConnectionGetStatisticNames(connection, out, error);
}
AdbcStatusCode AdbcConnectionGetTableSchema(struct AdbcConnection* connection,
@@ -108,6 +175,17 @@ AdbcStatusCode AdbcConnectionGetTableTypes(struct
AdbcConnection* connection,
return {{.Prefix}}ConnectionGetTableTypes(connection, out, error);
}
+AdbcStatusCode AdbcConnectionInit(struct AdbcConnection* connection,
+ struct AdbcDatabase* database,
+ struct AdbcError* error) {
+ return {{.Prefix}}ConnectionInit(connection, database, error);
+}
+
+AdbcStatusCode AdbcConnectionNew(struct AdbcConnection* connection,
+ struct AdbcError* error) {
+ return {{.Prefix}}ConnectionNew(connection, error);
+}
+
AdbcStatusCode AdbcConnectionReadPartition(struct AdbcConnection* connection,
const uint8_t* serialized_partition,
size_t serialized_length,
@@ -118,9 +196,9 @@ AdbcStatusCode AdbcConnectionReadPartition(struct
AdbcConnection* connection,
serialized_length, out, error);
}
-AdbcStatusCode AdbcConnectionCommit(struct AdbcConnection* connection,
- struct AdbcError* error) {
- return {{.Prefix}}ConnectionCommit(connection, error);
+AdbcStatusCode AdbcConnectionRelease(struct AdbcConnection* connection,
+ struct AdbcError* error) {
+ return {{.Prefix}}ConnectionRelease(connection, error);
}
AdbcStatusCode AdbcConnectionRollback(struct AdbcConnection* connection,
@@ -128,39 +206,32 @@ AdbcStatusCode AdbcConnectionRollback(struct
AdbcConnection* connection,
return {{.Prefix}}ConnectionRollback(connection, error);
}
-AdbcStatusCode AdbcStatementNew(struct AdbcConnection* connection,
- struct AdbcStatement* statement,
- struct AdbcError* error) {
- return {{.Prefix}}StatementNew(connection, statement, error);
+AdbcStatusCode AdbcConnectionSetOption(struct AdbcConnection* connection,
const char* key,
+ const char* value, struct AdbcError*
error) {
+ return {{.Prefix}}ConnectionSetOption(connection, key, value, error);
}
-AdbcStatusCode AdbcStatementRelease(struct AdbcStatement* statement,
- struct AdbcError* error) {
- return {{.Prefix}}StatementRelease(statement, error);
+AdbcStatusCode AdbcConnectionSetOptionBytes(struct AdbcConnection* connection,
+ const char* key, const uint8_t*
value,
+ size_t length, struct AdbcError*
error) {
+ return {{.Prefix}}ConnectionSetOptionBytes(connection, key, value, length,
error);
}
-AdbcStatusCode AdbcStatementExecuteQuery(struct AdbcStatement* statement,
- struct ArrowArrayStream* out,
- int64_t* rows_affected,
- struct AdbcError* error) {
- if (out) memset(out, 0, sizeof(*out));
- return {{.Prefix}}StatementExecuteQuery(statement, out, rows_affected,
error);
-}
-
-AdbcStatusCode AdbcStatementPrepare(struct AdbcStatement* statement,
- struct AdbcError* error) {
- return {{.Prefix}}StatementPrepare(statement, error);
+AdbcStatusCode AdbcConnectionSetOptionDouble(struct AdbcConnection* connection,
+ const char* key, double value,
+ struct AdbcError* error) {
+ return {{.Prefix}}ConnectionSetOptionDouble(connection, key, value, error);
}
-AdbcStatusCode AdbcStatementSetSqlQuery(struct AdbcStatement* statement,
- const char* query, struct AdbcError*
error) {
- return {{.Prefix}}StatementSetSqlQuery(statement, query, error);
+AdbcStatusCode AdbcConnectionSetOptionInt(struct AdbcConnection* connection,
+ const char* key, int64_t value,
+ struct AdbcError* error) {
+ return {{.Prefix}}ConnectionSetOptionInt(connection, key, value, error);
}
-AdbcStatusCode AdbcStatementSetSubstraitPlan(struct AdbcStatement* statement,
- const uint8_t* plan, size_t
length,
- struct AdbcError* error) {
- return {{.Prefix}}StatementSetSubstraitPlan(statement, plan, length, error);
+AdbcStatusCode AdbcStatementCancel(struct AdbcStatement* statement,
+ struct AdbcError* error) {
+ return {{.Prefix}}StatementCancel(statement, error);
}
AdbcStatusCode AdbcStatementBind(struct AdbcStatement* statement,
@@ -175,6 +246,56 @@ AdbcStatusCode AdbcStatementBindStream(struct
AdbcStatement* statement,
return {{.Prefix}}StatementBindStream(statement, stream, error);
}
+AdbcStatusCode AdbcStatementExecutePartitions(struct AdbcStatement* statement,
+ struct ArrowSchema* schema,
+ struct AdbcPartitions*
partitions,
+ int64_t* rows_affected,
+ struct AdbcError* error) {
+ if (schema) memset(schema, 0, sizeof(*schema));
+ if (partitions) memset(partitions, 0, sizeof(*partitions));
+ return {{.Prefix}}StatementExecutePartitions(statement, schema, partitions,
+ rows_affected, error);
+}
+
+AdbcStatusCode AdbcStatementExecuteQuery(struct AdbcStatement* statement,
+ struct ArrowArrayStream* out,
+ int64_t* rows_affected,
+ struct AdbcError* error) {
+ if (out) memset(out, 0, sizeof(*out));
+ return {{.Prefix}}StatementExecuteQuery(statement, out, rows_affected,
error);
+}
+
+AdbcStatusCode AdbcStatementExecuteSchema(struct AdbcStatement* statement,
+ struct ArrowSchema* schema,
+ struct AdbcError* error) {
+ if (schema) memset(schema, 0, sizeof(*schema));
+ return {{.Prefix}}StatementExecuteSchema(statement, schema, error);
+}
+
+AdbcStatusCode AdbcStatementGetOption(struct AdbcStatement* statement, const
char* key,
+ char* value, size_t* length,
+ struct AdbcError* error) {
+ return {{.Prefix}}StatementGetOption(statement, key, value, length, error);
+}
+
+AdbcStatusCode AdbcStatementGetOptionBytes(struct AdbcStatement* statement,
+ const char* key, uint8_t* value,
+ size_t* length, struct AdbcError*
error) {
+ return {{.Prefix}}StatementGetOptionBytes(statement, key, value, length,
error);
+}
+
+AdbcStatusCode AdbcStatementGetOptionDouble(struct AdbcStatement* statement,
+ const char* key, double* value,
+ struct AdbcError* error) {
+ return {{.Prefix}}StatementGetOptionDouble(statement, key, value, error);
+}
+
+AdbcStatusCode AdbcStatementGetOptionInt(struct AdbcStatement* statement,
+ const char* key, int64_t* value,
+ struct AdbcError* error) {
+ return {{.Prefix}}StatementGetOptionInt(statement, key, value, error);
+}
+
AdbcStatusCode AdbcStatementGetParameterSchema(struct AdbcStatement* statement,
struct ArrowSchema* schema,
struct AdbcError* error) {
@@ -182,20 +303,54 @@ AdbcStatusCode AdbcStatementGetParameterSchema(struct
AdbcStatement* statement,
return {{.Prefix}}StatementGetParameterSchema(statement, schema, error);
}
+AdbcStatusCode AdbcStatementNew(struct AdbcConnection* connection,
+ struct AdbcStatement* statement,
+ struct AdbcError* error) {
+ return {{.Prefix}}StatementNew(connection, statement, error);
+}
+
+AdbcStatusCode AdbcStatementPrepare(struct AdbcStatement* statement,
+ struct AdbcError* error) {
+ return {{.Prefix}}StatementPrepare(statement, error);
+}
+
+AdbcStatusCode AdbcStatementRelease(struct AdbcStatement* statement,
+ struct AdbcError* error) {
+ return {{.Prefix}}StatementRelease(statement, error);
+}
+
+AdbcStatusCode AdbcStatementSetSqlQuery(struct AdbcStatement* statement,
+ const char* query, struct AdbcError*
error) {
+ return {{.Prefix}}StatementSetSqlQuery(statement, query, error);
+}
+
+AdbcStatusCode AdbcStatementSetSubstraitPlan(struct AdbcStatement* statement,
+ const uint8_t* plan, size_t
length,
+ struct AdbcError* error) {
+ return {{.Prefix}}StatementSetSubstraitPlan(statement, plan, length, error);
+}
+
AdbcStatusCode AdbcStatementSetOption(struct AdbcStatement* statement, const
char* key,
const char* value, struct AdbcError*
error) {
return {{.Prefix}}StatementSetOption(statement, key, value, error);
}
-AdbcStatusCode AdbcStatementExecutePartitions(struct AdbcStatement* statement,
- struct ArrowSchema* schema,
- struct AdbcPartitions*
partitions,
- int64_t* rows_affected,
- struct AdbcError* error) {
- if (schema) memset(schema, 0, sizeof(*schema));
- if (partitions) memset(partitions, 0, sizeof(*partitions));
- return {{.Prefix}}StatementExecutePartitions(statement, schema, partitions,
rows_affected,
- error);
+AdbcStatusCode AdbcStatementSetOptionBytes(struct AdbcStatement* statement,
+ const char* key, const uint8_t*
value,
+ size_t length, struct AdbcError*
error) {
+ return {{.Prefix}}StatementSetOptionBytes(statement, key, value, length,
error);
+}
+
+AdbcStatusCode AdbcStatementSetOptionDouble(struct AdbcStatement* statement,
+ const char* key, double value,
+ struct AdbcError* error) {
+ return {{.Prefix}}StatementSetOptionDouble(statement, key, value, error);
+}
+
+AdbcStatusCode AdbcStatementSetOptionInt(struct AdbcStatement* statement,
+ const char* key, int64_t value,
+ struct AdbcError* error) {
+ return {{.Prefix}}StatementSetOptionInt(statement, key, value, error);
}
ADBC_EXPORT
diff --git a/go/adbc/pkg/flightsql/driver.go b/go/adbc/pkg/flightsql/driver.go
index 73f58123..f15330bd 100644
--- a/go/adbc/pkg/flightsql/driver.go
+++ b/go/adbc/pkg/flightsql/driver.go
@@ -1001,6 +1001,7 @@ func FlightSQLConnectionGetObjects(cnxn
*C.struct_AdbcConnection, depth C.int, c
if e != nil {
return C.AdbcStatusCode(conn.errToAdbcErr(err, e))
}
+ defer rdr.Release()
cdata.ExportRecordReader(rdr, toCdataStream(out))
return C.ADBC_STATUS_OK
}
@@ -1028,6 +1029,7 @@ func FlightSQLConnectionGetStatistics(cnxn
*C.struct_AdbcConnection, catalog, db
return C.AdbcStatusCode(conn.errToAdbcErr(err, e))
}
+ defer rdr.Release()
cdata.ExportRecordReader(rdr, toCdataStream(out))
return C.ADBC_STATUS_OK
}
diff --git a/go/adbc/pkg/flightsql/utils.c b/go/adbc/pkg/flightsql/utils.c
index 41777a98..0cffb116 100644
--- a/go/adbc/pkg/flightsql/utils.c
+++ b/go/adbc/pkg/flightsql/utils.c
@@ -35,43 +35,70 @@ void FlightSQL_release_error(struct AdbcError* error) {
error->release = NULL;
}
-AdbcStatusCode AdbcDatabaseNew(struct AdbcDatabase* database, struct
AdbcError* error) {
- return FlightSQLDatabaseNew(database, error);
+AdbcStatusCode AdbcDatabaseGetOption(struct AdbcDatabase* database, const
char* key,
+ char* value, size_t* length,
+ struct AdbcError* error) {
+ return FlightSQLDatabaseGetOption(database, key, value, length, error);
}
-AdbcStatusCode AdbcDatabaseSetOption(struct AdbcDatabase* database, const
char* key,
- const char* value, struct AdbcError*
error) {
- return FlightSQLDatabaseSetOption(database, key, value, error);
+AdbcStatusCode AdbcDatabaseGetOptionBytes(struct AdbcDatabase* database, const
char* key,
+ uint8_t* value, size_t* length,
+ struct AdbcError* error) {
+ return FlightSQLDatabaseGetOptionBytes(database, key, value, length, error);
+}
+
+AdbcStatusCode AdbcDatabaseGetOptionDouble(struct AdbcDatabase* database,
const char* key,
+ double* value, struct AdbcError*
error) {
+ return FlightSQLDatabaseGetOptionDouble(database, key, value, error);
+}
+
+AdbcStatusCode AdbcDatabaseGetOptionInt(struct AdbcDatabase* database, const
char* key,
+ int64_t* value, struct AdbcError*
error) {
+ return FlightSQLDatabaseGetOptionInt(database, key, value, error);
}
AdbcStatusCode AdbcDatabaseInit(struct AdbcDatabase* database, struct
AdbcError* error) {
return FlightSQLDatabaseInit(database, error);
}
+AdbcStatusCode AdbcDatabaseNew(struct AdbcDatabase* database, struct
AdbcError* error) {
+ return FlightSQLDatabaseNew(database, error);
+}
+
AdbcStatusCode AdbcDatabaseRelease(struct AdbcDatabase* database,
struct AdbcError* error) {
return FlightSQLDatabaseRelease(database, error);
}
-AdbcStatusCode AdbcConnectionNew(struct AdbcConnection* connection,
- struct AdbcError* error) {
- return FlightSQLConnectionNew(connection, error);
+AdbcStatusCode AdbcDatabaseSetOption(struct AdbcDatabase* database, const
char* key,
+ const char* value, struct AdbcError*
error) {
+ return FlightSQLDatabaseSetOption(database, key, value, error);
}
-AdbcStatusCode AdbcConnectionSetOption(struct AdbcConnection* connection,
const char* key,
- const char* value, struct AdbcError*
error) {
- return FlightSQLConnectionSetOption(connection, key, value, error);
+AdbcStatusCode AdbcDatabaseSetOptionBytes(struct AdbcDatabase* database, const
char* key,
+ const uint8_t* value, size_t length,
+ struct AdbcError* error) {
+ return FlightSQLDatabaseSetOptionBytes(database, key, value, length, error);
}
-AdbcStatusCode AdbcConnectionInit(struct AdbcConnection* connection,
- struct AdbcDatabase* database,
- struct AdbcError* error) {
- return FlightSQLConnectionInit(connection, database, error);
+AdbcStatusCode AdbcDatabaseSetOptionDouble(struct AdbcDatabase* database,
const char* key,
+ double value, struct AdbcError*
error) {
+ return FlightSQLDatabaseSetOptionDouble(database, key, value, error);
}
-AdbcStatusCode AdbcConnectionRelease(struct AdbcConnection* connection,
- struct AdbcError* error) {
- return FlightSQLConnectionRelease(connection, error);
+AdbcStatusCode AdbcDatabaseSetOptionInt(struct AdbcDatabase* database, const
char* key,
+ int64_t value, struct AdbcError*
error) {
+ return FlightSQLDatabaseSetOptionInt(database, key, value, error);
+}
+
+AdbcStatusCode AdbcConnectionCancel(struct AdbcConnection* connection,
+ struct AdbcError* error) {
+ return FlightSQLConnectionCancel(connection, error);
+}
+
+AdbcStatusCode AdbcConnectionCommit(struct AdbcConnection* connection,
+ struct AdbcError* error) {
+ return FlightSQLConnectionCommit(connection, error);
}
AdbcStatusCode AdbcConnectionGetInfo(struct AdbcConnection* connection,
@@ -79,8 +106,8 @@ AdbcStatusCode AdbcConnectionGetInfo(struct AdbcConnection*
connection,
struct ArrowArrayStream* out,
struct AdbcError* error) {
if (out) memset(out, 0, sizeof(*out));
- return FlightSQLConnectionGetInfo(connection, info_codes, info_codes_length,
out,
- error);
+ return FlightSQLConnectionGetInfo(connection, info_codes, info_codes_length,
+ out, error);
}
AdbcStatusCode AdbcConnectionGetObjects(struct AdbcConnection* connection, int
depth,
@@ -91,7 +118,46 @@ AdbcStatusCode AdbcConnectionGetObjects(struct
AdbcConnection* connection, int d
struct AdbcError* error) {
if (out) memset(out, 0, sizeof(*out));
return FlightSQLConnectionGetObjects(connection, depth, catalog, db_schema,
table_name,
- table_type, column_name, out, error);
+ table_type, column_name, out, error);
+}
+
+AdbcStatusCode AdbcConnectionGetOption(struct AdbcConnection* connection,
const char* key,
+ char* value, size_t* length,
+ struct AdbcError* error) {
+ return FlightSQLConnectionGetOption(connection, key, value, length, error);
+}
+
+AdbcStatusCode AdbcConnectionGetOptionBytes(struct AdbcConnection* connection,
+ const char* key, uint8_t* value,
+ size_t* length, struct AdbcError*
error) {
+ return FlightSQLConnectionGetOptionBytes(connection, key, value, length,
error);
+}
+
+AdbcStatusCode AdbcConnectionGetOptionDouble(struct AdbcConnection* connection,
+ const char* key, double* value,
+ struct AdbcError* error) {
+ return FlightSQLConnectionGetOptionDouble(connection, key, value, error);
+}
+
+AdbcStatusCode AdbcConnectionGetOptionInt(struct AdbcConnection* connection,
+ const char* key, int64_t* value,
+ struct AdbcError* error) {
+ return FlightSQLConnectionGetOptionInt(connection, key, value, error);
+}
+
+AdbcStatusCode AdbcConnectionGetStatistics(struct AdbcConnection* connection,
+ const char* catalog, const char*
db_schema,
+ const char* table_name, char
approximate,
+ struct ArrowArrayStream* out,
+ struct AdbcError* error) {
+ return FlightSQLConnectionGetStatistics(connection, catalog, db_schema,
table_name,
+ approximate, out, error);
+}
+
+AdbcStatusCode AdbcConnectionGetStatisticNames(struct AdbcConnection*
connection,
+ struct ArrowArrayStream* out,
+ struct AdbcError* error) {
+ return FlightSQLConnectionGetStatisticNames(connection, out, error);
}
AdbcStatusCode AdbcConnectionGetTableSchema(struct AdbcConnection* connection,
@@ -101,7 +167,7 @@ AdbcStatusCode AdbcConnectionGetTableSchema(struct
AdbcConnection* connection,
struct AdbcError* error) {
if (schema) memset(schema, 0, sizeof(*schema));
return FlightSQLConnectionGetTableSchema(connection, catalog, db_schema,
table_name,
- schema, error);
+ schema, error);
}
AdbcStatusCode AdbcConnectionGetTableTypes(struct AdbcConnection* connection,
@@ -111,6 +177,17 @@ AdbcStatusCode AdbcConnectionGetTableTypes(struct
AdbcConnection* connection,
return FlightSQLConnectionGetTableTypes(connection, out, error);
}
+AdbcStatusCode AdbcConnectionInit(struct AdbcConnection* connection,
+ struct AdbcDatabase* database,
+ struct AdbcError* error) {
+ return FlightSQLConnectionInit(connection, database, error);
+}
+
+AdbcStatusCode AdbcConnectionNew(struct AdbcConnection* connection,
+ struct AdbcError* error) {
+ return FlightSQLConnectionNew(connection, error);
+}
+
AdbcStatusCode AdbcConnectionReadPartition(struct AdbcConnection* connection,
const uint8_t* serialized_partition,
size_t serialized_length,
@@ -118,12 +195,12 @@ AdbcStatusCode AdbcConnectionReadPartition(struct
AdbcConnection* connection,
struct AdbcError* error) {
if (out) memset(out, 0, sizeof(*out));
return FlightSQLConnectionReadPartition(connection, serialized_partition,
- serialized_length, out, error);
+ serialized_length, out, error);
}
-AdbcStatusCode AdbcConnectionCommit(struct AdbcConnection* connection,
- struct AdbcError* error) {
- return FlightSQLConnectionCommit(connection, error);
+AdbcStatusCode AdbcConnectionRelease(struct AdbcConnection* connection,
+ struct AdbcError* error) {
+ return FlightSQLConnectionRelease(connection, error);
}
AdbcStatusCode AdbcConnectionRollback(struct AdbcConnection* connection,
@@ -131,39 +208,32 @@ AdbcStatusCode AdbcConnectionRollback(struct
AdbcConnection* connection,
return FlightSQLConnectionRollback(connection, error);
}
-AdbcStatusCode AdbcStatementNew(struct AdbcConnection* connection,
- struct AdbcStatement* statement,
- struct AdbcError* error) {
- return FlightSQLStatementNew(connection, statement, error);
+AdbcStatusCode AdbcConnectionSetOption(struct AdbcConnection* connection,
const char* key,
+ const char* value, struct AdbcError*
error) {
+ return FlightSQLConnectionSetOption(connection, key, value, error);
}
-AdbcStatusCode AdbcStatementRelease(struct AdbcStatement* statement,
- struct AdbcError* error) {
- return FlightSQLStatementRelease(statement, error);
+AdbcStatusCode AdbcConnectionSetOptionBytes(struct AdbcConnection* connection,
+ const char* key, const uint8_t*
value,
+ size_t length, struct AdbcError*
error) {
+ return FlightSQLConnectionSetOptionBytes(connection, key, value, length,
error);
}
-AdbcStatusCode AdbcStatementExecuteQuery(struct AdbcStatement* statement,
- struct ArrowArrayStream* out,
- int64_t* rows_affected,
- struct AdbcError* error) {
- if (out) memset(out, 0, sizeof(*out));
- return FlightSQLStatementExecuteQuery(statement, out, rows_affected, error);
-}
-
-AdbcStatusCode AdbcStatementPrepare(struct AdbcStatement* statement,
- struct AdbcError* error) {
- return FlightSQLStatementPrepare(statement, error);
+AdbcStatusCode AdbcConnectionSetOptionDouble(struct AdbcConnection* connection,
+ const char* key, double value,
+ struct AdbcError* error) {
+ return FlightSQLConnectionSetOptionDouble(connection, key, value, error);
}
-AdbcStatusCode AdbcStatementSetSqlQuery(struct AdbcStatement* statement,
- const char* query, struct AdbcError*
error) {
- return FlightSQLStatementSetSqlQuery(statement, query, error);
+AdbcStatusCode AdbcConnectionSetOptionInt(struct AdbcConnection* connection,
+ const char* key, int64_t value,
+ struct AdbcError* error) {
+ return FlightSQLConnectionSetOptionInt(connection, key, value, error);
}
-AdbcStatusCode AdbcStatementSetSubstraitPlan(struct AdbcStatement* statement,
- const uint8_t* plan, size_t
length,
- struct AdbcError* error) {
- return FlightSQLStatementSetSubstraitPlan(statement, plan, length, error);
+AdbcStatusCode AdbcStatementCancel(struct AdbcStatement* statement,
+ struct AdbcError* error) {
+ return FlightSQLStatementCancel(statement, error);
}
AdbcStatusCode AdbcStatementBind(struct AdbcStatement* statement,
@@ -178,6 +248,56 @@ AdbcStatusCode AdbcStatementBindStream(struct
AdbcStatement* statement,
return FlightSQLStatementBindStream(statement, stream, error);
}
+AdbcStatusCode AdbcStatementExecutePartitions(struct AdbcStatement* statement,
+ struct ArrowSchema* schema,
+ struct AdbcPartitions*
partitions,
+ int64_t* rows_affected,
+ struct AdbcError* error) {
+ if (schema) memset(schema, 0, sizeof(*schema));
+ if (partitions) memset(partitions, 0, sizeof(*partitions));
+ return FlightSQLStatementExecutePartitions(statement, schema, partitions,
+ rows_affected, error);
+}
+
+AdbcStatusCode AdbcStatementExecuteQuery(struct AdbcStatement* statement,
+ struct ArrowArrayStream* out,
+ int64_t* rows_affected,
+ struct AdbcError* error) {
+ if (out) memset(out, 0, sizeof(*out));
+ return FlightSQLStatementExecuteQuery(statement, out, rows_affected, error);
+}
+
+AdbcStatusCode AdbcStatementExecuteSchema(struct AdbcStatement* statement,
+ struct ArrowSchema* schema,
+ struct AdbcError* error) {
+ if (schema) memset(schema, 0, sizeof(*schema));
+ return FlightSQLStatementExecuteSchema(statement, schema, error);
+}
+
+AdbcStatusCode AdbcStatementGetOption(struct AdbcStatement* statement, const
char* key,
+ char* value, size_t* length,
+ struct AdbcError* error) {
+ return FlightSQLStatementGetOption(statement, key, value, length, error);
+}
+
+AdbcStatusCode AdbcStatementGetOptionBytes(struct AdbcStatement* statement,
+ const char* key, uint8_t* value,
+ size_t* length, struct AdbcError*
error) {
+ return FlightSQLStatementGetOptionBytes(statement, key, value, length,
error);
+}
+
+AdbcStatusCode AdbcStatementGetOptionDouble(struct AdbcStatement* statement,
+ const char* key, double* value,
+ struct AdbcError* error) {
+ return FlightSQLStatementGetOptionDouble(statement, key, value, error);
+}
+
+AdbcStatusCode AdbcStatementGetOptionInt(struct AdbcStatement* statement,
+ const char* key, int64_t* value,
+ struct AdbcError* error) {
+ return FlightSQLStatementGetOptionInt(statement, key, value, error);
+}
+
AdbcStatusCode AdbcStatementGetParameterSchema(struct AdbcStatement* statement,
struct ArrowSchema* schema,
struct AdbcError* error) {
@@ -185,20 +305,54 @@ AdbcStatusCode AdbcStatementGetParameterSchema(struct
AdbcStatement* statement,
return FlightSQLStatementGetParameterSchema(statement, schema, error);
}
+AdbcStatusCode AdbcStatementNew(struct AdbcConnection* connection,
+ struct AdbcStatement* statement,
+ struct AdbcError* error) {
+ return FlightSQLStatementNew(connection, statement, error);
+}
+
+AdbcStatusCode AdbcStatementPrepare(struct AdbcStatement* statement,
+ struct AdbcError* error) {
+ return FlightSQLStatementPrepare(statement, error);
+}
+
+AdbcStatusCode AdbcStatementRelease(struct AdbcStatement* statement,
+ struct AdbcError* error) {
+ return FlightSQLStatementRelease(statement, error);
+}
+
+AdbcStatusCode AdbcStatementSetSqlQuery(struct AdbcStatement* statement,
+ const char* query, struct AdbcError*
error) {
+ return FlightSQLStatementSetSqlQuery(statement, query, error);
+}
+
+AdbcStatusCode AdbcStatementSetSubstraitPlan(struct AdbcStatement* statement,
+ const uint8_t* plan, size_t
length,
+ struct AdbcError* error) {
+ return FlightSQLStatementSetSubstraitPlan(statement, plan, length, error);
+}
+
AdbcStatusCode AdbcStatementSetOption(struct AdbcStatement* statement, const
char* key,
const char* value, struct AdbcError*
error) {
return FlightSQLStatementSetOption(statement, key, value, error);
}
-AdbcStatusCode AdbcStatementExecutePartitions(struct AdbcStatement* statement,
- struct ArrowSchema* schema,
- struct AdbcPartitions*
partitions,
- int64_t* rows_affected,
- struct AdbcError* error) {
- if (schema) memset(schema, 0, sizeof(*schema));
- if (partitions) memset(partitions, 0, sizeof(*partitions));
- return FlightSQLStatementExecutePartitions(statement, schema, partitions,
rows_affected,
- error);
+AdbcStatusCode AdbcStatementSetOptionBytes(struct AdbcStatement* statement,
+ const char* key, const uint8_t*
value,
+ size_t length, struct AdbcError*
error) {
+ return FlightSQLStatementSetOptionBytes(statement, key, value, length,
error);
+}
+
+AdbcStatusCode AdbcStatementSetOptionDouble(struct AdbcStatement* statement,
+ const char* key, double value,
+ struct AdbcError* error) {
+ return FlightSQLStatementSetOptionDouble(statement, key, value, error);
+}
+
+AdbcStatusCode AdbcStatementSetOptionInt(struct AdbcStatement* statement,
+ const char* key, int64_t value,
+ struct AdbcError* error) {
+ return FlightSQLStatementSetOptionInt(statement, key, value, error);
}
ADBC_EXPORT
diff --git a/go/adbc/pkg/panicdummy/driver.go b/go/adbc/pkg/panicdummy/driver.go
index 885d62ec..ac430ddb 100644
--- a/go/adbc/pkg/panicdummy/driver.go
+++ b/go/adbc/pkg/panicdummy/driver.go
@@ -1001,6 +1001,7 @@ func PanicDummyConnectionGetObjects(cnxn
*C.struct_AdbcConnection, depth C.int,
if e != nil {
return C.AdbcStatusCode(conn.errToAdbcErr(err, e))
}
+ defer rdr.Release()
cdata.ExportRecordReader(rdr, toCdataStream(out))
return C.ADBC_STATUS_OK
}
@@ -1028,6 +1029,7 @@ func PanicDummyConnectionGetStatistics(cnxn
*C.struct_AdbcConnection, catalog, d
return C.AdbcStatusCode(conn.errToAdbcErr(err, e))
}
+ defer rdr.Release()
cdata.ExportRecordReader(rdr, toCdataStream(out))
return C.ADBC_STATUS_OK
}
diff --git a/go/adbc/pkg/panicdummy/utils.c b/go/adbc/pkg/panicdummy/utils.c
index d0a29366..4c3e0702 100644
--- a/go/adbc/pkg/panicdummy/utils.c
+++ b/go/adbc/pkg/panicdummy/utils.c
@@ -35,43 +35,70 @@ void PanicDummy_release_error(struct AdbcError* error) {
error->release = NULL;
}
-AdbcStatusCode AdbcDatabaseNew(struct AdbcDatabase* database, struct
AdbcError* error) {
- return PanicDummyDatabaseNew(database, error);
+AdbcStatusCode AdbcDatabaseGetOption(struct AdbcDatabase* database, const
char* key,
+ char* value, size_t* length,
+ struct AdbcError* error) {
+ return PanicDummyDatabaseGetOption(database, key, value, length, error);
}
-AdbcStatusCode AdbcDatabaseSetOption(struct AdbcDatabase* database, const
char* key,
- const char* value, struct AdbcError*
error) {
- return PanicDummyDatabaseSetOption(database, key, value, error);
+AdbcStatusCode AdbcDatabaseGetOptionBytes(struct AdbcDatabase* database, const
char* key,
+ uint8_t* value, size_t* length,
+ struct AdbcError* error) {
+ return PanicDummyDatabaseGetOptionBytes(database, key, value, length, error);
+}
+
+AdbcStatusCode AdbcDatabaseGetOptionDouble(struct AdbcDatabase* database,
const char* key,
+ double* value, struct AdbcError*
error) {
+ return PanicDummyDatabaseGetOptionDouble(database, key, value, error);
+}
+
+AdbcStatusCode AdbcDatabaseGetOptionInt(struct AdbcDatabase* database, const
char* key,
+ int64_t* value, struct AdbcError*
error) {
+ return PanicDummyDatabaseGetOptionInt(database, key, value, error);
}
AdbcStatusCode AdbcDatabaseInit(struct AdbcDatabase* database, struct
AdbcError* error) {
return PanicDummyDatabaseInit(database, error);
}
+AdbcStatusCode AdbcDatabaseNew(struct AdbcDatabase* database, struct
AdbcError* error) {
+ return PanicDummyDatabaseNew(database, error);
+}
+
AdbcStatusCode AdbcDatabaseRelease(struct AdbcDatabase* database,
struct AdbcError* error) {
return PanicDummyDatabaseRelease(database, error);
}
-AdbcStatusCode AdbcConnectionNew(struct AdbcConnection* connection,
- struct AdbcError* error) {
- return PanicDummyConnectionNew(connection, error);
+AdbcStatusCode AdbcDatabaseSetOption(struct AdbcDatabase* database, const
char* key,
+ const char* value, struct AdbcError*
error) {
+ return PanicDummyDatabaseSetOption(database, key, value, error);
}
-AdbcStatusCode AdbcConnectionSetOption(struct AdbcConnection* connection,
const char* key,
- const char* value, struct AdbcError*
error) {
- return PanicDummyConnectionSetOption(connection, key, value, error);
+AdbcStatusCode AdbcDatabaseSetOptionBytes(struct AdbcDatabase* database, const
char* key,
+ const uint8_t* value, size_t length,
+ struct AdbcError* error) {
+ return PanicDummyDatabaseSetOptionBytes(database, key, value, length, error);
}
-AdbcStatusCode AdbcConnectionInit(struct AdbcConnection* connection,
- struct AdbcDatabase* database,
- struct AdbcError* error) {
- return PanicDummyConnectionInit(connection, database, error);
+AdbcStatusCode AdbcDatabaseSetOptionDouble(struct AdbcDatabase* database,
const char* key,
+ double value, struct AdbcError*
error) {
+ return PanicDummyDatabaseSetOptionDouble(database, key, value, error);
}
-AdbcStatusCode AdbcConnectionRelease(struct AdbcConnection* connection,
- struct AdbcError* error) {
- return PanicDummyConnectionRelease(connection, error);
+AdbcStatusCode AdbcDatabaseSetOptionInt(struct AdbcDatabase* database, const
char* key,
+ int64_t value, struct AdbcError*
error) {
+ return PanicDummyDatabaseSetOptionInt(database, key, value, error);
+}
+
+AdbcStatusCode AdbcConnectionCancel(struct AdbcConnection* connection,
+ struct AdbcError* error) {
+ return PanicDummyConnectionCancel(connection, error);
+}
+
+AdbcStatusCode AdbcConnectionCommit(struct AdbcConnection* connection,
+ struct AdbcError* error) {
+ return PanicDummyConnectionCommit(connection, error);
}
AdbcStatusCode AdbcConnectionGetInfo(struct AdbcConnection* connection,
@@ -79,8 +106,8 @@ AdbcStatusCode AdbcConnectionGetInfo(struct AdbcConnection*
connection,
struct ArrowArrayStream* out,
struct AdbcError* error) {
if (out) memset(out, 0, sizeof(*out));
- return PanicDummyConnectionGetInfo(connection, info_codes,
info_codes_length, out,
- error);
+ return PanicDummyConnectionGetInfo(connection, info_codes, info_codes_length,
+ out, error);
}
AdbcStatusCode AdbcConnectionGetObjects(struct AdbcConnection* connection, int
depth,
@@ -91,7 +118,46 @@ AdbcStatusCode AdbcConnectionGetObjects(struct
AdbcConnection* connection, int d
struct AdbcError* error) {
if (out) memset(out, 0, sizeof(*out));
return PanicDummyConnectionGetObjects(connection, depth, catalog, db_schema,
table_name,
- table_type, column_name, out, error);
+ table_type, column_name, out, error);
+}
+
+AdbcStatusCode AdbcConnectionGetOption(struct AdbcConnection* connection,
const char* key,
+ char* value, size_t* length,
+ struct AdbcError* error) {
+ return PanicDummyConnectionGetOption(connection, key, value, length, error);
+}
+
+AdbcStatusCode AdbcConnectionGetOptionBytes(struct AdbcConnection* connection,
+ const char* key, uint8_t* value,
+ size_t* length, struct AdbcError*
error) {
+ return PanicDummyConnectionGetOptionBytes(connection, key, value, length,
error);
+}
+
+AdbcStatusCode AdbcConnectionGetOptionDouble(struct AdbcConnection* connection,
+ const char* key, double* value,
+ struct AdbcError* error) {
+ return PanicDummyConnectionGetOptionDouble(connection, key, value, error);
+}
+
+AdbcStatusCode AdbcConnectionGetOptionInt(struct AdbcConnection* connection,
+ const char* key, int64_t* value,
+ struct AdbcError* error) {
+ return PanicDummyConnectionGetOptionInt(connection, key, value, error);
+}
+
+AdbcStatusCode AdbcConnectionGetStatistics(struct AdbcConnection* connection,
+ const char* catalog, const char*
db_schema,
+ const char* table_name, char
approximate,
+ struct ArrowArrayStream* out,
+ struct AdbcError* error) {
+ return PanicDummyConnectionGetStatistics(connection, catalog, db_schema,
table_name,
+ approximate, out, error);
+}
+
+AdbcStatusCode AdbcConnectionGetStatisticNames(struct AdbcConnection*
connection,
+ struct ArrowArrayStream* out,
+ struct AdbcError* error) {
+ return PanicDummyConnectionGetStatisticNames(connection, out, error);
}
AdbcStatusCode AdbcConnectionGetTableSchema(struct AdbcConnection* connection,
@@ -101,7 +167,7 @@ AdbcStatusCode AdbcConnectionGetTableSchema(struct
AdbcConnection* connection,
struct AdbcError* error) {
if (schema) memset(schema, 0, sizeof(*schema));
return PanicDummyConnectionGetTableSchema(connection, catalog, db_schema,
table_name,
- schema, error);
+ schema, error);
}
AdbcStatusCode AdbcConnectionGetTableTypes(struct AdbcConnection* connection,
@@ -111,6 +177,17 @@ AdbcStatusCode AdbcConnectionGetTableTypes(struct
AdbcConnection* connection,
return PanicDummyConnectionGetTableTypes(connection, out, error);
}
+AdbcStatusCode AdbcConnectionInit(struct AdbcConnection* connection,
+ struct AdbcDatabase* database,
+ struct AdbcError* error) {
+ return PanicDummyConnectionInit(connection, database, error);
+}
+
+AdbcStatusCode AdbcConnectionNew(struct AdbcConnection* connection,
+ struct AdbcError* error) {
+ return PanicDummyConnectionNew(connection, error);
+}
+
AdbcStatusCode AdbcConnectionReadPartition(struct AdbcConnection* connection,
const uint8_t* serialized_partition,
size_t serialized_length,
@@ -118,12 +195,12 @@ AdbcStatusCode AdbcConnectionReadPartition(struct
AdbcConnection* connection,
struct AdbcError* error) {
if (out) memset(out, 0, sizeof(*out));
return PanicDummyConnectionReadPartition(connection, serialized_partition,
- serialized_length, out, error);
+ serialized_length, out, error);
}
-AdbcStatusCode AdbcConnectionCommit(struct AdbcConnection* connection,
- struct AdbcError* error) {
- return PanicDummyConnectionCommit(connection, error);
+AdbcStatusCode AdbcConnectionRelease(struct AdbcConnection* connection,
+ struct AdbcError* error) {
+ return PanicDummyConnectionRelease(connection, error);
}
AdbcStatusCode AdbcConnectionRollback(struct AdbcConnection* connection,
@@ -131,39 +208,32 @@ AdbcStatusCode AdbcConnectionRollback(struct
AdbcConnection* connection,
return PanicDummyConnectionRollback(connection, error);
}
-AdbcStatusCode AdbcStatementNew(struct AdbcConnection* connection,
- struct AdbcStatement* statement,
- struct AdbcError* error) {
- return PanicDummyStatementNew(connection, statement, error);
+AdbcStatusCode AdbcConnectionSetOption(struct AdbcConnection* connection,
const char* key,
+ const char* value, struct AdbcError*
error) {
+ return PanicDummyConnectionSetOption(connection, key, value, error);
}
-AdbcStatusCode AdbcStatementRelease(struct AdbcStatement* statement,
- struct AdbcError* error) {
- return PanicDummyStatementRelease(statement, error);
+AdbcStatusCode AdbcConnectionSetOptionBytes(struct AdbcConnection* connection,
+ const char* key, const uint8_t*
value,
+ size_t length, struct AdbcError*
error) {
+ return PanicDummyConnectionSetOptionBytes(connection, key, value, length,
error);
}
-AdbcStatusCode AdbcStatementExecuteQuery(struct AdbcStatement* statement,
- struct ArrowArrayStream* out,
- int64_t* rows_affected,
- struct AdbcError* error) {
- if (out) memset(out, 0, sizeof(*out));
- return PanicDummyStatementExecuteQuery(statement, out, rows_affected, error);
+AdbcStatusCode AdbcConnectionSetOptionDouble(struct AdbcConnection* connection,
+ const char* key, double value,
+ struct AdbcError* error) {
+ return PanicDummyConnectionSetOptionDouble(connection, key, value, error);
}
-AdbcStatusCode AdbcStatementPrepare(struct AdbcStatement* statement,
- struct AdbcError* error) {
- return PanicDummyStatementPrepare(statement, error);
+AdbcStatusCode AdbcConnectionSetOptionInt(struct AdbcConnection* connection,
+ const char* key, int64_t value,
+ struct AdbcError* error) {
+ return PanicDummyConnectionSetOptionInt(connection, key, value, error);
}
-AdbcStatusCode AdbcStatementSetSqlQuery(struct AdbcStatement* statement,
- const char* query, struct AdbcError*
error) {
- return PanicDummyStatementSetSqlQuery(statement, query, error);
-}
-
-AdbcStatusCode AdbcStatementSetSubstraitPlan(struct AdbcStatement* statement,
- const uint8_t* plan, size_t
length,
- struct AdbcError* error) {
- return PanicDummyStatementSetSubstraitPlan(statement, plan, length, error);
+AdbcStatusCode AdbcStatementCancel(struct AdbcStatement* statement,
+ struct AdbcError* error) {
+ return PanicDummyStatementCancel(statement, error);
}
AdbcStatusCode AdbcStatementBind(struct AdbcStatement* statement,
@@ -178,6 +248,56 @@ AdbcStatusCode AdbcStatementBindStream(struct
AdbcStatement* statement,
return PanicDummyStatementBindStream(statement, stream, error);
}
+AdbcStatusCode AdbcStatementExecutePartitions(struct AdbcStatement* statement,
+ struct ArrowSchema* schema,
+ struct AdbcPartitions*
partitions,
+ int64_t* rows_affected,
+ struct AdbcError* error) {
+ if (schema) memset(schema, 0, sizeof(*schema));
+ if (partitions) memset(partitions, 0, sizeof(*partitions));
+ return PanicDummyStatementExecutePartitions(statement, schema, partitions,
+ rows_affected, error);
+}
+
+AdbcStatusCode AdbcStatementExecuteQuery(struct AdbcStatement* statement,
+ struct ArrowArrayStream* out,
+ int64_t* rows_affected,
+ struct AdbcError* error) {
+ if (out) memset(out, 0, sizeof(*out));
+ return PanicDummyStatementExecuteQuery(statement, out, rows_affected, error);
+}
+
+AdbcStatusCode AdbcStatementExecuteSchema(struct AdbcStatement* statement,
+ struct ArrowSchema* schema,
+ struct AdbcError* error) {
+ if (schema) memset(schema, 0, sizeof(*schema));
+ return PanicDummyStatementExecuteSchema(statement, schema, error);
+}
+
+AdbcStatusCode AdbcStatementGetOption(struct AdbcStatement* statement, const
char* key,
+ char* value, size_t* length,
+ struct AdbcError* error) {
+ return PanicDummyStatementGetOption(statement, key, value, length, error);
+}
+
+AdbcStatusCode AdbcStatementGetOptionBytes(struct AdbcStatement* statement,
+ const char* key, uint8_t* value,
+ size_t* length, struct AdbcError*
error) {
+ return PanicDummyStatementGetOptionBytes(statement, key, value, length,
error);
+}
+
+AdbcStatusCode AdbcStatementGetOptionDouble(struct AdbcStatement* statement,
+ const char* key, double* value,
+ struct AdbcError* error) {
+ return PanicDummyStatementGetOptionDouble(statement, key, value, error);
+}
+
+AdbcStatusCode AdbcStatementGetOptionInt(struct AdbcStatement* statement,
+ const char* key, int64_t* value,
+ struct AdbcError* error) {
+ return PanicDummyStatementGetOptionInt(statement, key, value, error);
+}
+
AdbcStatusCode AdbcStatementGetParameterSchema(struct AdbcStatement* statement,
struct ArrowSchema* schema,
struct AdbcError* error) {
@@ -185,20 +305,54 @@ AdbcStatusCode AdbcStatementGetParameterSchema(struct
AdbcStatement* statement,
return PanicDummyStatementGetParameterSchema(statement, schema, error);
}
+AdbcStatusCode AdbcStatementNew(struct AdbcConnection* connection,
+ struct AdbcStatement* statement,
+ struct AdbcError* error) {
+ return PanicDummyStatementNew(connection, statement, error);
+}
+
+AdbcStatusCode AdbcStatementPrepare(struct AdbcStatement* statement,
+ struct AdbcError* error) {
+ return PanicDummyStatementPrepare(statement, error);
+}
+
+AdbcStatusCode AdbcStatementRelease(struct AdbcStatement* statement,
+ struct AdbcError* error) {
+ return PanicDummyStatementRelease(statement, error);
+}
+
+AdbcStatusCode AdbcStatementSetSqlQuery(struct AdbcStatement* statement,
+ const char* query, struct AdbcError*
error) {
+ return PanicDummyStatementSetSqlQuery(statement, query, error);
+}
+
+AdbcStatusCode AdbcStatementSetSubstraitPlan(struct AdbcStatement* statement,
+ const uint8_t* plan, size_t
length,
+ struct AdbcError* error) {
+ return PanicDummyStatementSetSubstraitPlan(statement, plan, length, error);
+}
+
AdbcStatusCode AdbcStatementSetOption(struct AdbcStatement* statement, const
char* key,
const char* value, struct AdbcError*
error) {
return PanicDummyStatementSetOption(statement, key, value, error);
}
-AdbcStatusCode AdbcStatementExecutePartitions(struct AdbcStatement* statement,
- struct ArrowSchema* schema,
- struct AdbcPartitions*
partitions,
- int64_t* rows_affected,
- struct AdbcError* error) {
- if (schema) memset(schema, 0, sizeof(*schema));
- if (partitions) memset(partitions, 0, sizeof(*partitions));
- return PanicDummyStatementExecutePartitions(statement, schema, partitions,
- rows_affected, error);
+AdbcStatusCode AdbcStatementSetOptionBytes(struct AdbcStatement* statement,
+ const char* key, const uint8_t*
value,
+ size_t length, struct AdbcError*
error) {
+ return PanicDummyStatementSetOptionBytes(statement, key, value, length,
error);
+}
+
+AdbcStatusCode AdbcStatementSetOptionDouble(struct AdbcStatement* statement,
+ const char* key, double value,
+ struct AdbcError* error) {
+ return PanicDummyStatementSetOptionDouble(statement, key, value, error);
+}
+
+AdbcStatusCode AdbcStatementSetOptionInt(struct AdbcStatement* statement,
+ const char* key, int64_t value,
+ struct AdbcError* error) {
+ return PanicDummyStatementSetOptionInt(statement, key, value, error);
}
ADBC_EXPORT
diff --git a/go/adbc/pkg/snowflake/driver.go b/go/adbc/pkg/snowflake/driver.go
index 369a125f..e6bda279 100644
--- a/go/adbc/pkg/snowflake/driver.go
+++ b/go/adbc/pkg/snowflake/driver.go
@@ -1001,6 +1001,7 @@ func SnowflakeConnectionGetObjects(cnxn
*C.struct_AdbcConnection, depth C.int, c
if e != nil {
return C.AdbcStatusCode(conn.errToAdbcErr(err, e))
}
+ defer rdr.Release()
cdata.ExportRecordReader(rdr, toCdataStream(out))
return C.ADBC_STATUS_OK
}
@@ -1028,6 +1029,7 @@ func SnowflakeConnectionGetStatistics(cnxn
*C.struct_AdbcConnection, catalog, db
return C.AdbcStatusCode(conn.errToAdbcErr(err, e))
}
+ defer rdr.Release()
cdata.ExportRecordReader(rdr, toCdataStream(out))
return C.ADBC_STATUS_OK
}
diff --git a/go/adbc/pkg/snowflake/utils.c b/go/adbc/pkg/snowflake/utils.c
index 24d3ca3d..d45c3707 100644
--- a/go/adbc/pkg/snowflake/utils.c
+++ b/go/adbc/pkg/snowflake/utils.c
@@ -35,43 +35,70 @@ void Snowflake_release_error(struct AdbcError* error) {
error->release = NULL;
}
-AdbcStatusCode AdbcDatabaseNew(struct AdbcDatabase* database, struct
AdbcError* error) {
- return SnowflakeDatabaseNew(database, error);
+AdbcStatusCode AdbcDatabaseGetOption(struct AdbcDatabase* database, const
char* key,
+ char* value, size_t* length,
+ struct AdbcError* error) {
+ return SnowflakeDatabaseGetOption(database, key, value, length, error);
}
-AdbcStatusCode AdbcDatabaseSetOption(struct AdbcDatabase* database, const
char* key,
- const char* value, struct AdbcError*
error) {
- return SnowflakeDatabaseSetOption(database, key, value, error);
+AdbcStatusCode AdbcDatabaseGetOptionBytes(struct AdbcDatabase* database, const
char* key,
+ uint8_t* value, size_t* length,
+ struct AdbcError* error) {
+ return SnowflakeDatabaseGetOptionBytes(database, key, value, length, error);
+}
+
+AdbcStatusCode AdbcDatabaseGetOptionDouble(struct AdbcDatabase* database,
const char* key,
+ double* value, struct AdbcError*
error) {
+ return SnowflakeDatabaseGetOptionDouble(database, key, value, error);
+}
+
+AdbcStatusCode AdbcDatabaseGetOptionInt(struct AdbcDatabase* database, const
char* key,
+ int64_t* value, struct AdbcError*
error) {
+ return SnowflakeDatabaseGetOptionInt(database, key, value, error);
}
AdbcStatusCode AdbcDatabaseInit(struct AdbcDatabase* database, struct
AdbcError* error) {
return SnowflakeDatabaseInit(database, error);
}
+AdbcStatusCode AdbcDatabaseNew(struct AdbcDatabase* database, struct
AdbcError* error) {
+ return SnowflakeDatabaseNew(database, error);
+}
+
AdbcStatusCode AdbcDatabaseRelease(struct AdbcDatabase* database,
struct AdbcError* error) {
return SnowflakeDatabaseRelease(database, error);
}
-AdbcStatusCode AdbcConnectionNew(struct AdbcConnection* connection,
- struct AdbcError* error) {
- return SnowflakeConnectionNew(connection, error);
+AdbcStatusCode AdbcDatabaseSetOption(struct AdbcDatabase* database, const
char* key,
+ const char* value, struct AdbcError*
error) {
+ return SnowflakeDatabaseSetOption(database, key, value, error);
}
-AdbcStatusCode AdbcConnectionSetOption(struct AdbcConnection* connection,
const char* key,
- const char* value, struct AdbcError*
error) {
- return SnowflakeConnectionSetOption(connection, key, value, error);
+AdbcStatusCode AdbcDatabaseSetOptionBytes(struct AdbcDatabase* database, const
char* key,
+ const uint8_t* value, size_t length,
+ struct AdbcError* error) {
+ return SnowflakeDatabaseSetOptionBytes(database, key, value, length, error);
}
-AdbcStatusCode AdbcConnectionInit(struct AdbcConnection* connection,
- struct AdbcDatabase* database,
- struct AdbcError* error) {
- return SnowflakeConnectionInit(connection, database, error);
+AdbcStatusCode AdbcDatabaseSetOptionDouble(struct AdbcDatabase* database,
const char* key,
+ double value, struct AdbcError*
error) {
+ return SnowflakeDatabaseSetOptionDouble(database, key, value, error);
}
-AdbcStatusCode AdbcConnectionRelease(struct AdbcConnection* connection,
- struct AdbcError* error) {
- return SnowflakeConnectionRelease(connection, error);
+AdbcStatusCode AdbcDatabaseSetOptionInt(struct AdbcDatabase* database, const
char* key,
+ int64_t value, struct AdbcError*
error) {
+ return SnowflakeDatabaseSetOptionInt(database, key, value, error);
+}
+
+AdbcStatusCode AdbcConnectionCancel(struct AdbcConnection* connection,
+ struct AdbcError* error) {
+ return SnowflakeConnectionCancel(connection, error);
+}
+
+AdbcStatusCode AdbcConnectionCommit(struct AdbcConnection* connection,
+ struct AdbcError* error) {
+ return SnowflakeConnectionCommit(connection, error);
}
AdbcStatusCode AdbcConnectionGetInfo(struct AdbcConnection* connection,
@@ -79,8 +106,8 @@ AdbcStatusCode AdbcConnectionGetInfo(struct AdbcConnection*
connection,
struct ArrowArrayStream* out,
struct AdbcError* error) {
if (out) memset(out, 0, sizeof(*out));
- return SnowflakeConnectionGetInfo(connection, info_codes, info_codes_length,
out,
- error);
+ return SnowflakeConnectionGetInfo(connection, info_codes, info_codes_length,
+ out, error);
}
AdbcStatusCode AdbcConnectionGetObjects(struct AdbcConnection* connection, int
depth,
@@ -91,7 +118,46 @@ AdbcStatusCode AdbcConnectionGetObjects(struct
AdbcConnection* connection, int d
struct AdbcError* error) {
if (out) memset(out, 0, sizeof(*out));
return SnowflakeConnectionGetObjects(connection, depth, catalog, db_schema,
table_name,
- table_type, column_name, out, error);
+ table_type, column_name, out, error);
+}
+
+AdbcStatusCode AdbcConnectionGetOption(struct AdbcConnection* connection,
const char* key,
+ char* value, size_t* length,
+ struct AdbcError* error) {
+ return SnowflakeConnectionGetOption(connection, key, value, length, error);
+}
+
+AdbcStatusCode AdbcConnectionGetOptionBytes(struct AdbcConnection* connection,
+ const char* key, uint8_t* value,
+ size_t* length, struct AdbcError*
error) {
+ return SnowflakeConnectionGetOptionBytes(connection, key, value, length,
error);
+}
+
+AdbcStatusCode AdbcConnectionGetOptionDouble(struct AdbcConnection* connection,
+ const char* key, double* value,
+ struct AdbcError* error) {
+ return SnowflakeConnectionGetOptionDouble(connection, key, value, error);
+}
+
+AdbcStatusCode AdbcConnectionGetOptionInt(struct AdbcConnection* connection,
+ const char* key, int64_t* value,
+ struct AdbcError* error) {
+ return SnowflakeConnectionGetOptionInt(connection, key, value, error);
+}
+
+AdbcStatusCode AdbcConnectionGetStatistics(struct AdbcConnection* connection,
+ const char* catalog, const char*
db_schema,
+ const char* table_name, char
approximate,
+ struct ArrowArrayStream* out,
+ struct AdbcError* error) {
+ return SnowflakeConnectionGetStatistics(connection, catalog, db_schema,
table_name,
+ approximate, out, error);
+}
+
+AdbcStatusCode AdbcConnectionGetStatisticNames(struct AdbcConnection*
connection,
+ struct ArrowArrayStream* out,
+ struct AdbcError* error) {
+ return SnowflakeConnectionGetStatisticNames(connection, out, error);
}
AdbcStatusCode AdbcConnectionGetTableSchema(struct AdbcConnection* connection,
@@ -101,7 +167,7 @@ AdbcStatusCode AdbcConnectionGetTableSchema(struct
AdbcConnection* connection,
struct AdbcError* error) {
if (schema) memset(schema, 0, sizeof(*schema));
return SnowflakeConnectionGetTableSchema(connection, catalog, db_schema,
table_name,
- schema, error);
+ schema, error);
}
AdbcStatusCode AdbcConnectionGetTableTypes(struct AdbcConnection* connection,
@@ -111,6 +177,17 @@ AdbcStatusCode AdbcConnectionGetTableTypes(struct
AdbcConnection* connection,
return SnowflakeConnectionGetTableTypes(connection, out, error);
}
+AdbcStatusCode AdbcConnectionInit(struct AdbcConnection* connection,
+ struct AdbcDatabase* database,
+ struct AdbcError* error) {
+ return SnowflakeConnectionInit(connection, database, error);
+}
+
+AdbcStatusCode AdbcConnectionNew(struct AdbcConnection* connection,
+ struct AdbcError* error) {
+ return SnowflakeConnectionNew(connection, error);
+}
+
AdbcStatusCode AdbcConnectionReadPartition(struct AdbcConnection* connection,
const uint8_t* serialized_partition,
size_t serialized_length,
@@ -118,12 +195,12 @@ AdbcStatusCode AdbcConnectionReadPartition(struct
AdbcConnection* connection,
struct AdbcError* error) {
if (out) memset(out, 0, sizeof(*out));
return SnowflakeConnectionReadPartition(connection, serialized_partition,
- serialized_length, out, error);
+ serialized_length, out, error);
}
-AdbcStatusCode AdbcConnectionCommit(struct AdbcConnection* connection,
- struct AdbcError* error) {
- return SnowflakeConnectionCommit(connection, error);
+AdbcStatusCode AdbcConnectionRelease(struct AdbcConnection* connection,
+ struct AdbcError* error) {
+ return SnowflakeConnectionRelease(connection, error);
}
AdbcStatusCode AdbcConnectionRollback(struct AdbcConnection* connection,
@@ -131,39 +208,32 @@ AdbcStatusCode AdbcConnectionRollback(struct
AdbcConnection* connection,
return SnowflakeConnectionRollback(connection, error);
}
-AdbcStatusCode AdbcStatementNew(struct AdbcConnection* connection,
- struct AdbcStatement* statement,
- struct AdbcError* error) {
- return SnowflakeStatementNew(connection, statement, error);
+AdbcStatusCode AdbcConnectionSetOption(struct AdbcConnection* connection,
const char* key,
+ const char* value, struct AdbcError*
error) {
+ return SnowflakeConnectionSetOption(connection, key, value, error);
}
-AdbcStatusCode AdbcStatementRelease(struct AdbcStatement* statement,
- struct AdbcError* error) {
- return SnowflakeStatementRelease(statement, error);
+AdbcStatusCode AdbcConnectionSetOptionBytes(struct AdbcConnection* connection,
+ const char* key, const uint8_t*
value,
+ size_t length, struct AdbcError*
error) {
+ return SnowflakeConnectionSetOptionBytes(connection, key, value, length,
error);
}
-AdbcStatusCode AdbcStatementExecuteQuery(struct AdbcStatement* statement,
- struct ArrowArrayStream* out,
- int64_t* rows_affected,
- struct AdbcError* error) {
- if (out) memset(out, 0, sizeof(*out));
- return SnowflakeStatementExecuteQuery(statement, out, rows_affected, error);
-}
-
-AdbcStatusCode AdbcStatementPrepare(struct AdbcStatement* statement,
- struct AdbcError* error) {
- return SnowflakeStatementPrepare(statement, error);
+AdbcStatusCode AdbcConnectionSetOptionDouble(struct AdbcConnection* connection,
+ const char* key, double value,
+ struct AdbcError* error) {
+ return SnowflakeConnectionSetOptionDouble(connection, key, value, error);
}
-AdbcStatusCode AdbcStatementSetSqlQuery(struct AdbcStatement* statement,
- const char* query, struct AdbcError*
error) {
- return SnowflakeStatementSetSqlQuery(statement, query, error);
+AdbcStatusCode AdbcConnectionSetOptionInt(struct AdbcConnection* connection,
+ const char* key, int64_t value,
+ struct AdbcError* error) {
+ return SnowflakeConnectionSetOptionInt(connection, key, value, error);
}
-AdbcStatusCode AdbcStatementSetSubstraitPlan(struct AdbcStatement* statement,
- const uint8_t* plan, size_t
length,
- struct AdbcError* error) {
- return SnowflakeStatementSetSubstraitPlan(statement, plan, length, error);
+AdbcStatusCode AdbcStatementCancel(struct AdbcStatement* statement,
+ struct AdbcError* error) {
+ return SnowflakeStatementCancel(statement, error);
}
AdbcStatusCode AdbcStatementBind(struct AdbcStatement* statement,
@@ -178,6 +248,56 @@ AdbcStatusCode AdbcStatementBindStream(struct
AdbcStatement* statement,
return SnowflakeStatementBindStream(statement, stream, error);
}
+AdbcStatusCode AdbcStatementExecutePartitions(struct AdbcStatement* statement,
+ struct ArrowSchema* schema,
+ struct AdbcPartitions*
partitions,
+ int64_t* rows_affected,
+ struct AdbcError* error) {
+ if (schema) memset(schema, 0, sizeof(*schema));
+ if (partitions) memset(partitions, 0, sizeof(*partitions));
+ return SnowflakeStatementExecutePartitions(statement, schema, partitions,
+ rows_affected, error);
+}
+
+AdbcStatusCode AdbcStatementExecuteQuery(struct AdbcStatement* statement,
+ struct ArrowArrayStream* out,
+ int64_t* rows_affected,
+ struct AdbcError* error) {
+ if (out) memset(out, 0, sizeof(*out));
+ return SnowflakeStatementExecuteQuery(statement, out, rows_affected, error);
+}
+
+AdbcStatusCode AdbcStatementExecuteSchema(struct AdbcStatement* statement,
+ struct ArrowSchema* schema,
+ struct AdbcError* error) {
+ if (schema) memset(schema, 0, sizeof(*schema));
+ return SnowflakeStatementExecuteSchema(statement, schema, error);
+}
+
+AdbcStatusCode AdbcStatementGetOption(struct AdbcStatement* statement, const
char* key,
+ char* value, size_t* length,
+ struct AdbcError* error) {
+ return SnowflakeStatementGetOption(statement, key, value, length, error);
+}
+
+AdbcStatusCode AdbcStatementGetOptionBytes(struct AdbcStatement* statement,
+ const char* key, uint8_t* value,
+ size_t* length, struct AdbcError*
error) {
+ return SnowflakeStatementGetOptionBytes(statement, key, value, length,
error);
+}
+
+AdbcStatusCode AdbcStatementGetOptionDouble(struct AdbcStatement* statement,
+ const char* key, double* value,
+ struct AdbcError* error) {
+ return SnowflakeStatementGetOptionDouble(statement, key, value, error);
+}
+
+AdbcStatusCode AdbcStatementGetOptionInt(struct AdbcStatement* statement,
+ const char* key, int64_t* value,
+ struct AdbcError* error) {
+ return SnowflakeStatementGetOptionInt(statement, key, value, error);
+}
+
AdbcStatusCode AdbcStatementGetParameterSchema(struct AdbcStatement* statement,
struct ArrowSchema* schema,
struct AdbcError* error) {
@@ -185,20 +305,54 @@ AdbcStatusCode AdbcStatementGetParameterSchema(struct
AdbcStatement* statement,
return SnowflakeStatementGetParameterSchema(statement, schema, error);
}
+AdbcStatusCode AdbcStatementNew(struct AdbcConnection* connection,
+ struct AdbcStatement* statement,
+ struct AdbcError* error) {
+ return SnowflakeStatementNew(connection, statement, error);
+}
+
+AdbcStatusCode AdbcStatementPrepare(struct AdbcStatement* statement,
+ struct AdbcError* error) {
+ return SnowflakeStatementPrepare(statement, error);
+}
+
+AdbcStatusCode AdbcStatementRelease(struct AdbcStatement* statement,
+ struct AdbcError* error) {
+ return SnowflakeStatementRelease(statement, error);
+}
+
+AdbcStatusCode AdbcStatementSetSqlQuery(struct AdbcStatement* statement,
+ const char* query, struct AdbcError*
error) {
+ return SnowflakeStatementSetSqlQuery(statement, query, error);
+}
+
+AdbcStatusCode AdbcStatementSetSubstraitPlan(struct AdbcStatement* statement,
+ const uint8_t* plan, size_t
length,
+ struct AdbcError* error) {
+ return SnowflakeStatementSetSubstraitPlan(statement, plan, length, error);
+}
+
AdbcStatusCode AdbcStatementSetOption(struct AdbcStatement* statement, const
char* key,
const char* value, struct AdbcError*
error) {
return SnowflakeStatementSetOption(statement, key, value, error);
}
-AdbcStatusCode AdbcStatementExecutePartitions(struct AdbcStatement* statement,
- struct ArrowSchema* schema,
- struct AdbcPartitions*
partitions,
- int64_t* rows_affected,
- struct AdbcError* error) {
- if (schema) memset(schema, 0, sizeof(*schema));
- if (partitions) memset(partitions, 0, sizeof(*partitions));
- return SnowflakeStatementExecutePartitions(statement, schema, partitions,
rows_affected,
- error);
+AdbcStatusCode AdbcStatementSetOptionBytes(struct AdbcStatement* statement,
+ const char* key, const uint8_t*
value,
+ size_t length, struct AdbcError*
error) {
+ return SnowflakeStatementSetOptionBytes(statement, key, value, length,
error);
+}
+
+AdbcStatusCode AdbcStatementSetOptionDouble(struct AdbcStatement* statement,
+ const char* key, double value,
+ struct AdbcError* error) {
+ return SnowflakeStatementSetOptionDouble(statement, key, value, error);
+}
+
+AdbcStatusCode AdbcStatementSetOptionInt(struct AdbcStatement* statement,
+ const char* key, int64_t value,
+ struct AdbcError* error) {
+ return SnowflakeStatementSetOptionInt(statement, key, value, error);
}
ADBC_EXPORT
