Skip to content

Commit 614140b

Browse files
rustyconoverrustyconover
committed
fix: add function descriptions
1 parent de633ce commit 614140b

File tree

3 files changed

+189
-49
lines changed

3 files changed

+189
-49
lines changed

‎src/adbc_catalog.cpp‎

Lines changed: 85 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,7 @@
66
#include "duckdb/function/table/arrow.hpp"
77
#include "duckdb/function/table/arrow/arrow_duck_schema.hpp"
88
#include "duckdb/common/insertion_order_preserving_map.hpp"
9+
#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
910
#include <nanoarrow/nanoarrow.h>
1011

1112
namespace duckdb {
@@ -1232,43 +1233,98 @@ void RegisterAdbcCatalogFunctions(DatabaseInstance &db) {
12321233
ExtensionLoader loader(db, "adbc");
12331234

12341235
// adbc_info(connection_id) - Get driver/database information
1235-
TableFunction adbc_info_function("adbc_info", {LogicalType::BIGINT}, AdbcInfoFunction,
1236-
AdbcInfoBind, AdbcInfoInitGlobal, AdbcInfoInitLocal);
1237-
adbc_info_function.projection_pushdown = false;
1238-
loader.RegisterFunction(adbc_info_function);
1236+
{
1237+
TableFunction adbc_info_function("adbc_info", {LogicalType::BIGINT}, AdbcInfoFunction,
1238+
AdbcInfoBind, AdbcInfoInitGlobal, AdbcInfoInitLocal);
1239+
adbc_info_function.projection_pushdown = false;
1240+
CreateTableFunctionInfo info(adbc_info_function);
1241+
FunctionDescription desc;
1242+
desc.description = "Get driver and database information from an ADBC connection";
1243+
desc.parameter_names = {"connection_handle"};
1244+
desc.parameter_types = {LogicalType::BIGINT};
1245+
desc.examples = {"SELECT * FROM adbc_info(connection_handle)"};
1246+
desc.categories = {"adbc"};
1247+
info.descriptions.push_back(std::move(desc));
1248+
loader.RegisterFunction(info);
1249+
}
12391250

12401251
// adbc_tables(connection_id, catalog, schema, table_name) - Get tables
1241-
TableFunction adbc_tables_function("adbc_tables", {LogicalType::BIGINT}, AdbcTablesFunction,
1242-
AdbcTablesBind, AdbcTablesInitGlobal, AdbcTablesInitLocal);
1243-
adbc_tables_function.named_parameters["catalog"] = LogicalType::VARCHAR;
1244-
adbc_tables_function.named_parameters["schema"] = LogicalType::VARCHAR;
1245-
adbc_tables_function.named_parameters["table_name"] = LogicalType::VARCHAR;
1246-
adbc_tables_function.projection_pushdown = false;
1247-
loader.RegisterFunction(adbc_tables_function);
1252+
{
1253+
TableFunction adbc_tables_function("adbc_tables", {LogicalType::BIGINT}, AdbcTablesFunction,
1254+
AdbcTablesBind, AdbcTablesInitGlobal, AdbcTablesInitLocal);
1255+
adbc_tables_function.named_parameters["catalog"] = LogicalType::VARCHAR;
1256+
adbc_tables_function.named_parameters["schema"] = LogicalType::VARCHAR;
1257+
adbc_tables_function.named_parameters["table_name"] = LogicalType::VARCHAR;
1258+
adbc_tables_function.projection_pushdown = false;
1259+
CreateTableFunctionInfo info(adbc_tables_function);
1260+
FunctionDescription desc;
1261+
desc.description = "Get list of tables from an ADBC data source";
1262+
desc.parameter_names = {"connection_handle", "catalog", "schema", "table_name"};
1263+
desc.parameter_types = {LogicalType::BIGINT, LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR};
1264+
desc.examples = {"SELECT * FROM adbc_tables(conn)",
1265+
"SELECT * FROM adbc_tables(conn, catalog := 'main')",
1266+
"SELECT * FROM adbc_tables(conn, table_name := 'users')"};
1267+
desc.categories = {"adbc"};
1268+
info.descriptions.push_back(std::move(desc));
1269+
loader.RegisterFunction(info);
1270+
}
12481271

12491272
// adbc_table_types(connection_id) - Get supported table types
1250-
TableFunction adbc_table_types_function("adbc_table_types", {LogicalType::BIGINT}, AdbcTableTypesFunction,
1251-
AdbcTableTypesBind, AdbcTableTypesInitGlobal, AdbcTableTypesInitLocal);
1252-
adbc_table_types_function.projection_pushdown = false;
1253-
loader.RegisterFunction(adbc_table_types_function);
1273+
{
1274+
TableFunction adbc_table_types_function("adbc_table_types", {LogicalType::BIGINT}, AdbcTableTypesFunction,
1275+
AdbcTableTypesBind, AdbcTableTypesInitGlobal, AdbcTableTypesInitLocal);
1276+
adbc_table_types_function.projection_pushdown = false;
1277+
CreateTableFunctionInfo info(adbc_table_types_function);
1278+
FunctionDescription desc;
1279+
desc.description = "Get supported table types from an ADBC data source (e.g., 'table', 'view')";
1280+
desc.parameter_names = {"connection_handle"};
1281+
desc.parameter_types = {LogicalType::BIGINT};
1282+
desc.examples = {"SELECT * FROM adbc_table_types(conn)"};
1283+
desc.categories = {"adbc"};
1284+
info.descriptions.push_back(std::move(desc));
1285+
loader.RegisterFunction(info);
1286+
}
12541287

12551288
// adbc_columns(connection_id, ...) - Get column metadata
1256-
TableFunction adbc_columns_function("adbc_columns", {LogicalType::BIGINT}, AdbcColumnsFunction,
1257-
AdbcColumnsBind, AdbcColumnsInitGlobal, AdbcColumnsInitLocal);
1258-
adbc_columns_function.named_parameters["catalog"] = LogicalType::VARCHAR;
1259-
adbc_columns_function.named_parameters["schema"] = LogicalType::VARCHAR;
1260-
adbc_columns_function.named_parameters["table_name"] = LogicalType::VARCHAR;
1261-
adbc_columns_function.named_parameters["column_name"] = LogicalType::VARCHAR;
1262-
adbc_columns_function.projection_pushdown = false;
1263-
loader.RegisterFunction(adbc_columns_function);
1289+
{
1290+
TableFunction adbc_columns_function("adbc_columns", {LogicalType::BIGINT}, AdbcColumnsFunction,
1291+
AdbcColumnsBind, AdbcColumnsInitGlobal, AdbcColumnsInitLocal);
1292+
adbc_columns_function.named_parameters["catalog"] = LogicalType::VARCHAR;
1293+
adbc_columns_function.named_parameters["schema"] = LogicalType::VARCHAR;
1294+
adbc_columns_function.named_parameters["table_name"] = LogicalType::VARCHAR;
1295+
adbc_columns_function.named_parameters["column_name"] = LogicalType::VARCHAR;
1296+
adbc_columns_function.projection_pushdown = false;
1297+
CreateTableFunctionInfo info(adbc_columns_function);
1298+
FunctionDescription desc;
1299+
desc.description = "Get column metadata for tables in an ADBC data source";
1300+
desc.parameter_names = {"connection_handle", "catalog", "schema", "table_name", "column_name"};
1301+
desc.parameter_types = {LogicalType::BIGINT, LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR};
1302+
desc.examples = {"SELECT * FROM adbc_columns(conn)",
1303+
"SELECT * FROM adbc_columns(conn, table_name := 'users')",
1304+
"SELECT * FROM adbc_columns(conn, table_name := 'users', column_name := 'id')"};
1305+
desc.categories = {"adbc"};
1306+
info.descriptions.push_back(std::move(desc));
1307+
loader.RegisterFunction(info);
1308+
}
12641309

12651310
// adbc_schema(connection_id, table_name, ...) - Get Arrow schema for a table
1266-
TableFunction adbc_schema_function("adbc_schema", {LogicalType::BIGINT, LogicalType::VARCHAR}, AdbcSchemaFunction,
1267-
AdbcSchemaBind, AdbcSchemaInitGlobal, AdbcSchemaInitLocal);
1268-
adbc_schema_function.named_parameters["catalog"] = LogicalType::VARCHAR;
1269-
adbc_schema_function.named_parameters["schema"] = LogicalType::VARCHAR;
1270-
adbc_schema_function.projection_pushdown = false;
1271-
loader.RegisterFunction(adbc_schema_function);
1311+
{
1312+
TableFunction adbc_schema_function("adbc_schema", {LogicalType::BIGINT, LogicalType::VARCHAR}, AdbcSchemaFunction,
1313+
AdbcSchemaBind, AdbcSchemaInitGlobal, AdbcSchemaInitLocal);
1314+
adbc_schema_function.named_parameters["catalog"] = LogicalType::VARCHAR;
1315+
adbc_schema_function.named_parameters["schema"] = LogicalType::VARCHAR;
1316+
adbc_schema_function.projection_pushdown = false;
1317+
CreateTableFunctionInfo info(adbc_schema_function);
1318+
FunctionDescription desc;
1319+
desc.description = "Get the Arrow schema for a specific table in an ADBC data source";
1320+
desc.parameter_names = {"connection_handle", "table_name", "catalog", "schema"};
1321+
desc.parameter_types = {LogicalType::BIGINT, LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR};
1322+
desc.examples = {"SELECT * FROM adbc_schema(conn, 'users')",
1323+
"SELECT * FROM adbc_schema(conn, 'users', catalog := 'main')"};
1324+
desc.categories = {"adbc"};
1325+
info.descriptions.push_back(std::move(desc));
1326+
loader.RegisterFunction(info);
1327+
}
12721328
}
12731329

12741330
} // namespace adbc

‎src/adbc_functions.cpp‎

Lines changed: 69 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,7 @@
22
#include "duckdb/function/scalar_function.hpp"
33
#include "duckdb/common/types/value.hpp"
44
#include "duckdb/main/extension/extension_loader.hpp"
5+
#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
56

67
namespace duckdb {
78
namespace adbc {
@@ -226,31 +227,82 @@ void RegisterAdbcScalarFunctions(DatabaseInstance &db) {
226227
ExtensionLoader loader(db, "adbc");
227228

228229
// adbc_connect: Create a new ADBC connection
229-
// Accepts either STRUCT or MAP with string keys/values
230-
auto adbc_connect_function =
231-
ScalarFunction("adbc_connect", {LogicalType::ANY}, LogicalType::BIGINT, AdbcConnectFunction);
232-
loader.RegisterFunction(adbc_connect_function);
230+
{
231+
auto adbc_connect_function =
232+
ScalarFunction("adbc_connect", {LogicalType::ANY}, LogicalType::BIGINT, AdbcConnectFunction);
233+
CreateScalarFunctionInfo info(adbc_connect_function);
234+
FunctionDescription desc;
235+
desc.description = "Connect to an ADBC data source and return a connection handle";
236+
desc.parameter_names = {"options"};
237+
desc.parameter_types = {LogicalType::ANY};
238+
desc.examples = {"SELECT adbc_connect({'driver': 'sqlite', 'uri': ':memory:'})",
239+
"SELECT adbc_connect({'driver': '/path/to/driver.so', 'uri': 'connection_string'})"};
240+
desc.categories = {"adbc"};
241+
info.descriptions.push_back(std::move(desc));
242+
loader.RegisterFunction(info);
243+
}
233244

234245
// adbc_disconnect: Close an ADBC connection
235-
auto adbc_disconnect_function =
236-
ScalarFunction("adbc_disconnect", {LogicalType::BIGINT}, LogicalType::BOOLEAN, AdbcDisconnectFunction);
237-
loader.RegisterFunction(adbc_disconnect_function);
246+
{
247+
auto adbc_disconnect_function =
248+
ScalarFunction("adbc_disconnect", {LogicalType::BIGINT}, LogicalType::BOOLEAN, AdbcDisconnectFunction);
249+
CreateScalarFunctionInfo info(adbc_disconnect_function);
250+
FunctionDescription desc;
251+
desc.description = "Disconnect and close an ADBC connection";
252+
desc.parameter_names = {"connection_handle"};
253+
desc.parameter_types = {LogicalType::BIGINT};
254+
desc.examples = {"SELECT adbc_disconnect(connection_handle)"};
255+
desc.categories = {"adbc"};
256+
info.descriptions.push_back(std::move(desc));
257+
loader.RegisterFunction(info);
258+
}
238259

239260
// adbc_commit: Commit the current transaction
240-
auto adbc_commit_function =
241-
ScalarFunction("adbc_commit", {LogicalType::BIGINT}, LogicalType::BOOLEAN, AdbcCommitFunction);
242-
loader.RegisterFunction(adbc_commit_function);
261+
{
262+
auto adbc_commit_function =
263+
ScalarFunction("adbc_commit", {LogicalType::BIGINT}, LogicalType::BOOLEAN, AdbcCommitFunction);
264+
CreateScalarFunctionInfo info(adbc_commit_function);
265+
FunctionDescription desc;
266+
desc.description = "Commit the current transaction on an ADBC connection";
267+
desc.parameter_names = {"connection_handle"};
268+
desc.parameter_types = {LogicalType::BIGINT};
269+
desc.examples = {"SELECT adbc_commit(connection_handle)"};
270+
desc.categories = {"adbc"};
271+
info.descriptions.push_back(std::move(desc));
272+
loader.RegisterFunction(info);
273+
}
243274

244275
// adbc_rollback: Rollback the current transaction
245-
auto adbc_rollback_function =
246-
ScalarFunction("adbc_rollback", {LogicalType::BIGINT}, LogicalType::BOOLEAN, AdbcRollbackFunction);
247-
loader.RegisterFunction(adbc_rollback_function);
276+
{
277+
auto adbc_rollback_function =
278+
ScalarFunction("adbc_rollback", {LogicalType::BIGINT}, LogicalType::BOOLEAN, AdbcRollbackFunction);
279+
CreateScalarFunctionInfo info(adbc_rollback_function);
280+
FunctionDescription desc;
281+
desc.description = "Rollback the current transaction on an ADBC connection";
282+
desc.parameter_names = {"connection_handle"};
283+
desc.parameter_types = {LogicalType::BIGINT};
284+
desc.examples = {"SELECT adbc_rollback(connection_handle)"};
285+
desc.categories = {"adbc"};
286+
info.descriptions.push_back(std::move(desc));
287+
loader.RegisterFunction(info);
288+
}
248289

249290
// adbc_set_autocommit: Set autocommit mode
250-
auto adbc_set_autocommit_function =
251-
ScalarFunction("adbc_set_autocommit", {LogicalType::BIGINT, LogicalType::BOOLEAN}, LogicalType::BOOLEAN,
252-
AdbcSetAutocommitFunction);
253-
loader.RegisterFunction(adbc_set_autocommit_function);
291+
{
292+
auto adbc_set_autocommit_function =
293+
ScalarFunction("adbc_set_autocommit", {LogicalType::BIGINT, LogicalType::BOOLEAN}, LogicalType::BOOLEAN,
294+
AdbcSetAutocommitFunction);
295+
CreateScalarFunctionInfo info(adbc_set_autocommit_function);
296+
FunctionDescription desc;
297+
desc.description = "Enable or disable autocommit mode on an ADBC connection";
298+
desc.parameter_names = {"connection_handle", "enabled"};
299+
desc.parameter_types = {LogicalType::BIGINT, LogicalType::BOOLEAN};
300+
desc.examples = {"SELECT adbc_set_autocommit(connection_handle, false)",
301+
"SELECT adbc_set_autocommit(connection_handle, true)"};
302+
desc.categories = {"adbc"};
303+
info.descriptions.push_back(std::move(desc));
304+
loader.RegisterFunction(info);
305+
}
254306
}
255307

256308
} // namespace adbc

‎src/adbc_scan.cpp‎

Lines changed: 35 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,8 @@
99
#include "duckdb/storage/statistics/node_statistics.hpp"
1010
#include "duckdb/common/insertion_order_preserving_map.hpp"
1111
#include "duckdb/main/client_context.hpp"
12+
#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
13+
#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
1214
#include <nanoarrow/nanoarrow.h>
1315
#include <queue>
1416

@@ -490,7 +492,17 @@ void RegisterAdbcTableFunctions(DatabaseInstance &db) {
490492
adbc_scan_function.cardinality = AdbcScanCardinality;
491493
adbc_scan_function.to_string = AdbcScanToString;
492494

493-
loader.RegisterFunction(adbc_scan_function);
495+
CreateTableFunctionInfo info(adbc_scan_function);
496+
FunctionDescription desc;
497+
desc.description = "Execute a SELECT query on an ADBC connection and return the results as a table";
498+
desc.parameter_names = {"connection_handle", "query", "params", "batch_size"};
499+
desc.parameter_types = {LogicalType::BIGINT, LogicalType::VARCHAR, LogicalType::ANY, LogicalType::BIGINT};
500+
desc.examples = {"SELECT * FROM adbc_scan(conn, 'SELECT * FROM users')",
501+
"SELECT * FROM adbc_scan(conn, 'SELECT * FROM users WHERE id = ?', params := row(42))",
502+
"SELECT * FROM adbc_scan(conn, 'SELECT * FROM large_table', batch_size := 65536)"};
503+
desc.categories = {"adbc"};
504+
info.descriptions.push_back(std::move(desc));
505+
loader.RegisterFunction(info);
494506
}
495507

496508
// ============================================================================
@@ -620,7 +632,17 @@ void RegisterAdbcExecuteFunction(DatabaseInstance &db) {
620632
AdbcExecuteBind
621633
);
622634

623-
loader.RegisterFunction(adbc_execute_function);
635+
CreateScalarFunctionInfo info(adbc_execute_function);
636+
FunctionDescription desc;
637+
desc.description = "Execute DDL/DML statements (CREATE, INSERT, UPDATE, DELETE) on an ADBC connection";
638+
desc.parameter_names = {"connection_handle", "query"};
639+
desc.parameter_types = {LogicalType::BIGINT, LogicalType::VARCHAR};
640+
desc.examples = {"SELECT adbc_execute(conn, 'CREATE TABLE test (id INTEGER)')",
641+
"SELECT adbc_execute(conn, 'INSERT INTO test VALUES (1)')",
642+
"SELECT adbc_execute(conn, 'DELETE FROM test WHERE id = 1')"};
643+
desc.categories = {"adbc"};
644+
info.descriptions.push_back(std::move(desc));
645+
loader.RegisterFunction(info);
624646
}
625647

626648
//===--------------------------------------------------------------------===//
@@ -906,7 +928,17 @@ void RegisterAdbcInsertFunction(DatabaseInstance &db) {
906928
adbc_insert_function.in_out_function_final = AdbcInsertFinalize;
907929
adbc_insert_function.named_parameters["mode"] = LogicalType::VARCHAR;
908930

909-
loader.RegisterFunction(adbc_insert_function);
931+
CreateTableFunctionInfo info(adbc_insert_function);
932+
FunctionDescription desc;
933+
desc.description = "Bulk insert data from a query into an ADBC table";
934+
desc.parameter_names = {"connection_handle", "table_name", "data", "mode"};
935+
desc.parameter_types = {LogicalType::BIGINT, LogicalType::VARCHAR, LogicalType::TABLE, LogicalType::VARCHAR};
936+
desc.examples = {"SELECT * FROM adbc_insert(conn, 'target_table', (SELECT * FROM source_table))",
937+
"SELECT * FROM adbc_insert(conn, 'target', (SELECT * FROM source), mode := 'create')",
938+
"SELECT * FROM adbc_insert(conn, 'target', (SELECT * FROM source), mode := 'append')"};
939+
desc.categories = {"adbc"};
940+
info.descriptions.push_back(std::move(desc));
941+
loader.RegisterFunction(info);
910942
}
911943

912944
} // namespace adbc

0 commit comments

Comments
 (0)