diff --git a/scsh/odbc/odbc.c b/scsh/odbc/odbc.c index 511db5c..10870e1 100644 --- a/scsh/odbc/odbc.c +++ b/scsh/odbc/odbc.c @@ -1683,6 +1683,529 @@ s48_value odbc_sql_describe_col(s48_value stmt_handle, s48_value column_number) * */ +/* Returns a list of columns and associated privileges for one or more tables */ +void odbc_sql_column_privileges(s48_value stmt_handle, s48_value catalog_name, + s48_value schema_name, s48_value table_name, + s48_value column_name) +{ + SQLHSTMT sh; + SQLCHAR *catalog, *schema, *table, *column; + SQLRETURN retval; + + ODBC_DEBUG_PRINTF("odbc_sql_column_privileges\n"); + + sh = (SQLHSTMT) s48_extract_integer(stmt_handle); + catalog = (SQLCHAR *) s48_extract_string(catalog_name); + schema = (SQLCHAR *) s48_extract_string(schema_name); + table = (SQLCHAR *) s48_extract_string(table_name); + column = (SQLCHAR *) s48_extract_string(column_name); + + retval = SQLColumnPrivileges(sh, + catalog, S48_STRING_LENGTH(catalog_name), + schema, S48_STRING_LENGTH(schema_name), + table, S48_STRING_LENGTH(table_name), + column, S48_STRING_LENGTH(column_name)); + + switch (retval) + { + case SQL_SUCCESS: case SQL_SUCCESS_WITH_INFO: + { + return; + } + case SQL_STILL_EXECUTING: + { + ODBC_RAISE_EXCEPTION("SQLColumnPrivileges returned SQL_STILL_EXECUTING. Not implemented yet"); + break; + } + case SQL_ERROR: + { + ODBC_RAISE_EXCEPTION("SQLColumnPrivileges returned SQL_ERROR"); + break; + } + case SQL_INVALID_HANDLE: + { + ODBC_RAISE_EXCEPTION("SQLColumnPrivileges got invalid handle"); + break; + } + default: + { + ODBC_RAISE_EXCEPTION("SQLColumnPrivileges returned unknown error code"); + break; + } + } +} + +/* Returns the list of column names in a specified table */ +void odbc_sql_columns(s48_value stmt_handle, s48_value catalog_name, + s48_value schema_name, s48_value table_name, + s48_value column_name) +{ + SQLHSTMT sh; + SQLCHAR *catalog, *schema, *table, *column; + SQLRETURN retval; + + ODBC_DEBUG_PRINTF("odbc_sql_columns\n"); + + sh = (SQLHSTMT) s48_extract_integer(stmt_handle); + catalog = (SQLCHAR *) s48_extract_string(catalog_name); + schema = (SQLCHAR *) s48_extract_string(schema_name); + table = (SQLCHAR *) s48_extract_string(table_name); + column = (SQLCHAR *) s48_extract_string(column_name); + + retval = SQLColumns(sh, + catalog, S48_STRING_LENGTH(catalog_name), + schema, S48_STRING_LENGTH(schema_name), + table, S48_STRING_LENGTH(table_name), + column, S48_STRING_LENGTH(column_name)); + + switch (retval) + { + case SQL_SUCCESS: case SQL_SUCCESS_WITH_INFO: + { + return; + } + case SQL_STILL_EXECUTING: + { + ODBC_RAISE_EXCEPTION("SQLColumns returned SQL_STILL_EXECUTING. Not implemented yet"); + break; + } + case SQL_ERROR: + { + ODBC_RAISE_EXCEPTION("SQLColumns returned SQL_ERROR"); + break; + } + case SQL_INVALID_HANDLE: + { + ODBC_RAISE_EXCEPTION("SQLColumns got invalid handle"); + break; + } + default: + { + ODBC_RAISE_EXCEPTION("SQLColumns returned unknown error code"); + break; + } + } +} + +/* Returns a list of columns names that make up foreign keys, + if the exist for a specified table */ +void odbc_sql_foreign_keys(s48_value stmt_handle, s48_value pk_catalog_name, + s48_value pk_schema_name, s48_value pk_table_name, + s48_value fk_catalog_name, s48_value fk_schema_name, + s48_value fk_table_name) +{ + SQLHSTMT sh; + SQLCHAR *pk_catalog, *pk_schema, *pk_table; + SQLCHAR *fk_catalog, *fk_schema, *fk_table; + SQLRETURN retval; + + ODBC_DEBUG_PRINTF("odbc_sql_foreign_keys\n"); + + sh = (SQLHSTMT) s48_extract_integer(stmt_handle); + pk_catalog = (SQLCHAR *) s48_extract_string(pk_catalog_name); + pk_schema = (SQLCHAR *) s48_extract_string(pk_schema_name); + pk_table = (SQLCHAR *) s48_extract_string(pk_table_name); + fk_catalog = (SQLCHAR *) s48_extract_string(fk_catalog_name); + fk_schema = (SQLCHAR *) s48_extract_string(fk_schema_name); + fk_table = (SQLCHAR *) s48_extract_string(fk_table_name); + + retval = SQLForeignKeys(sh, + pk_catalog, S48_STRING_LENGTH(pk_catalog_name), + pk_schema, S48_STRING_LENGTH(pk_schema_name), + pk_table, S48_STRING_LENGTH(pk_table_name), + fk_catalog, S48_STRING_LENGTH(fk_catalog_name), + fk_schema, S48_STRING_LENGTH(fk_schema_name), + fk_table, S48_STRING_LENGTH(fk_table_name)); + + switch (retval) + { + case SQL_SUCCESS: case SQL_SUCCESS_WITH_INFO: + { + return; + } + case SQL_STILL_EXECUTING: + { + ODBC_RAISE_EXCEPTION("SQLForeignKeys returned SQL_STILL_EXECUTING. Not implemented"); + break; + } + case SQL_ERROR: + { + ODBC_RAISE_EXCEPTION("SQLForeignKeys returned SQL_ERROR"); + break; + } + case SQL_INVALID_HANDLE: + { + ODBC_RAISE_EXCEPTION("SQLForeignKeys got invalid handle"); + break; + } + default: + { + ODBC_RAISE_EXCEPTION("SQLForeignKeys returned unknwon error code"); + break; + } + } +} + +/* Returns the list of column names that make up the primary key for a table */ +void odbc_sql_primary_keys(s48_value stmt_handle, s48_value catalog_name, + s48_value schema_name, s48_value table_name) +{ + SQLHSTMT sh; + SQLCHAR *catalog, *schema, *table; + SQLRETURN retval; + + ODBC_DEBUG_PRINTF("odbc_sql_primary_keys\n"); + + sh = (SQLHSTMT) s48_extract_integer(stmt_handle); + catalog = (SQLCHAR *) s48_extract_string(catalog_name); + schema = (SQLCHAR *) s48_extract_string(schema_name); + table = (SQLCHAR *) s48_extract_string(table_name); + + retval = SQLPrimaryKeys(sh, + catalog, S48_STRING_LENGTH(catalog_name), + schema, S48_STRING_LENGTH(schema_name), + table, S48_STRING_LENGTH(table_name)); + + switch (retval) + { + case SQL_SUCCESS: case SQL_SUCCESS_WITH_INFO: + { + return; + } + case SQL_STILL_EXECUTING: + { + ODBC_RAISE_EXCEPTION("SQLPrimaryKeys returned SQL_STILL_EXECUTING. Not implemented"); + break; + } + case SQL_ERROR: + { + ODBC_RAISE_EXCEPTION("SQLPrimaryKeys returned SQL_ERROR"); + break; + } + case SQL_INVALID_HANDLE: + { + ODBC_RAISE_EXCEPTION("SQLPrimaryKeys got invalid handle"); + break; + } + default: + { + ODBC_RAISE_EXCEPTION("SQLPrimaryKeys returned unknown error code"); + break; + } + } +} + +/* Returns the list of input and output parameters, as well as the columns + that make up the result set for the specified procedures */ +void odbc_sql_procedure_columns(s48_value stmt_handle, s48_value catalog_name, + s48_value schema_name, s48_value proc_name, + s48_value column_name) +{ + SQLHSTMT sh; + SQLCHAR *catalog, *schema, *proc, *column; + SQLRETURN retval; + + ODBC_DEBUG_PRINTF("odbc_sql_procedure_columns\n"); + + sh = (SQLHSTMT) s48_extract_integer(stmt_handle); + catalog = (SQLCHAR *) s48_extract_string(catalog_name); + schema = (SQLCHAR *) s48_extract_string(schema_name); + proc = (SQLCHAR *) s48_extract_string(proc_name); + column = (SQLCHAR *) s48_extract_string(column_name); + + retval = SQLProcedureColumns(sh, + catalog, S48_STRING_LENGTH(catalog_name), + schema, S48_STRING_LENGTH(schema_name), + proc, S48_STRING_LENGTH(proc_name), + column, S48_STRING_LENGTH(column_name)); + + switch (retval) + { + case SQL_SUCCESS: case SQL_SUCCESS_WITH_INFO: + { + return; + } + case SQL_STILL_EXECUTING: + { + ODBC_RAISE_EXCEPTION("SQLProcedureColumns returned SQL_STILL_EXECUTING. Not implemented"); + break; + } + case SQL_ERROR: + { + ODBC_RAISE_EXCEPTION("SQLProcedureColumns returned SQL_ERROR"); + break; + } + case SQL_INVALID_HANDLE: + { + ODBC_RAISE_EXCEPTION("SQLProcedureColumns got invalid handle"); + break; + } + default: + { + ODBC_RAISE_EXCEPTION("SQLProcedureColumns return unknown error code"); + break; + } + } +} + +/* Returns the list of procedure names stored in a specific data source. */ +void odbc_sql_procedures(s48_value stmt_handle, s48_value catalog_name, + s48_value schema_name, s48_value proc_name) +{ + SQLHSTMT sh; + SQLCHAR *catalog, *schema, *proc; + SQLRETURN retval; + + ODBC_DEBUG_PRINTF("odbc_sql_procedures\n"); + + sh = (SQLHSTMT) s48_extract_integer(stmt_handle); + catalog = (SQLCHAR *) s48_extract_string(catalog_name); + schema = (SQLCHAR *) s48_extract_string(schema_name); + proc = (SQLCHAR *) s48_extract_string(proc_name); + + retval = SQLProcedures(sh, + catalog, S48_STRING_LENGTH(catalog_name), + schema, S48_STRING_LENGTH(schema_name), + proc, S48_STRING_LENGTH(proc_name)); + + switch (retval) + { + case SQL_SUCCESS: case SQL_SUCCESS_WITH_INFO: + { + return; + } + case SQL_STILL_EXECUTING: + { + ODBC_RAISE_EXCEPTION("SQLProcedures returned SQL_STILL_EXECUTING. Not implemented"); + break; + } + case SQL_ERROR: + { + ODBC_RAISE_EXCEPTION("SQLProcedures returned SQL_ERROR"); + break; + } + case SQL_INVALID_HANDLE: + { + ODBC_RAISE_EXCEPTION("SQLProcedures got invalid handle"); + break; + } + default: + { + ODBC_RAISE_EXCEPTION("SQLProcedures returned unknown error code"); + break; + } + } +} + +/* Returns information about the optimal set of columns that uniquely identifies + a row in a specified table, or the columns that are automatically updated + when any value in the row is updated by a transaction */ +void odbc_sql_special_columns(s48_value stmt_handle, s48_value identifier_type, + s48_value catalog_name, s48_value schema_name, + s48_value table_name, s48_value scope, + s48_value nullable) +{ + SQLHSTMT sh; + SQLCHAR *catalog, *schema, *table; + SQLSMALLINT s, n, it; + SQLRETURN retval; + + ODBC_DEBUG_PRINTF("odbc_sql_special_columns\n"); + + sh = (SQLHSTMT) s48_extract_integer(stmt_handle); + it = (SQLSMALLINT) s48_extract_integer(identifier_type); + catalog = (SQLCHAR *) s48_extract_string(catalog_name); + schema = (SQLCHAR *) s48_extract_string(schema_name); + table = (SQLCHAR *) s48_extract_string(table_name); + s = (SQLSMALLINT) s48_extract_integer(scope); + n = (SQLSMALLINT) s48_extract_integer(nullable); + + retval = SQLSpecialColumns(sh, it, + catalog, S48_STRING_LENGTH(catalog_name), + schema, S48_STRING_LENGTH(schema_name), + table, S48_STRING_LENGTH(table_name), + s, n); + + switch (retval) + { + case SQL_SUCCESS: case SQL_SUCCESS_WITH_INFO: + { + return; + } + case SQL_STILL_EXECUTING: + { + ODBC_RAISE_EXCEPTION("SQLSpecialColumns returned SQL_STILL_EXECUTING. Not implemented"); + break; + } + case SQL_ERROR: + { + ODBC_RAISE_EXCEPTION("SQLSpecialColumns returned SQL_ERROR"); + break; + } + case SQL_INVALID_HANDLE: + { + ODBC_RAISE_EXCEPTION("SQLSpecialColumns got invalid handle"); + break; + } + default: + { + ODBC_RAISE_EXCEPTION("SQLSpecialColumns returned unknown error code"); + break; + } + } +} + +/* Returns statistics about a single table and the list of indexes associated + with the table */ +void odbc_sql_statistics(s48_value stmt_handle, s48_value catalog_name, + s48_value schema_name, s48_value table_name, + s48_value unique, s48_value reserved) +{ + SQLHSTMT sh; + SQLCHAR *catalog, *schema, *table; + SQLSMALLINT u, r; + SQLRETURN retval; + + ODBC_DEBUG_PRINTF("odbc_sql_statistics\n"); + + sh = (SQLHSTMT) s48_extract_integer(stmt_handle); + catalog = (SQLCHAR *) s48_extract_string(catalog_name); + schema = (SQLCHAR *) s48_extract_string(schema_name); + table = (SQLCHAR *) s48_extract_string(table_name); + u = (SQLSMALLINT) s48_extract_integer(unique); + r = (SQLSMALLINT) s48_extract_integer(reserved); + + retval = SQLStatistics(sh, + catalog, S48_STRING_LENGTH(catalog_name), + schema, S48_STRING_LENGTH(schema_name), + table, S48_STRING_LENGTH(table_name), + u, r); + + switch (retval) + { + case SQL_SUCCESS: case SQL_SUCCESS_WITH_INFO: + { + return; + } + case SQL_STILL_EXECUTING: + { + ODBC_RAISE_EXCEPTION("SQLStatistics returned SQL_STILL_EXECUTING. Not implemented"); + break; + } + case SQL_ERROR: + { + ODBC_RAISE_EXCEPTION("SQLStatistics returned SQL_ERROR"); + break; + } + case SQL_INVALID_HANDLE: + { + ODBC_RAISE_EXCEPTION("SQLStatistics got invalid handle"); + break; + } + default: + { + ODBC_RAISE_EXCEPTION("SQLStatistics returned unknown error code"); + break; + } + } +} + +/* Returns a list of tables and the privileges associated with each table */ +void odbc_sql_table_privileges(s48_value stmt_handle, s48_value catalog_name, + s48_value schema_name, s48_value table_name) +{ + SQLHSTMT sh; + SQLCHAR *catalog, *schema, *table; + SQLRETURN retval; + + ODBC_DEBUG_PRINTF("odbc_sql_table_privileges\n"); + + sh = (SQLHSTMT) s48_extract_integer(stmt_handle); + catalog = (SQLCHAR *) s48_extract_string(catalog_name); + schema = (SQLCHAR *) s48_extract_string(schema_name); + table = (SQLCHAR *) s48_extract_string(table_name); + + retval = SQLTablePrivileges(sh, + catalog, S48_STRING_LENGTH(catalog_name), + schema, S48_STRING_LENGTH(schema_name), + table, S48_STRING_LENGTH(table_name)); + + switch (retval) + { + case SQL_SUCCESS: case SQL_SUCCESS_WITH_INFO: + { + return; + } + case SQL_STILL_EXECUTING: + { + ODBC_RAISE_EXCEPTION("SQLTablePrivileges returned SQL_STILL_EXECUTING. Not implemented"); + break; + } + case SQL_ERROR: + { + ODBC_RAISE_EXCEPTION("SQLTablePrivileges returned SQL_ERROR"); + break; + } + case SQL_INVALID_HANDLE: + { + ODBC_RAISE_EXCEPTION("SQLTablePrivileges got invalid handle"); + break; + } + default: + { + ODBC_RAISE_EXCEPTION("SQLTablePrivileges returned unknown error code"); + break; + } + } +} + +/* Returns the list of table names stored in a specific data source */ +void odbc_sql_tables(s48_value stmt_handle, s48_value catalog_name, + s48_value schema_name, s48_value table_name, + s48_value table_type) +{ + SQLHSTMT sh; + SQLCHAR *catalog, *schema, *tablen, *tablet; + SQLRETURN retval; + + ODBC_DEBUG_PRINTF("odbc_sql_tables\n"); + + retval = SQLTables(sh, + catalog, S48_STRING_LENGTH(catalog_name), + schema, S48_STRING_LENGTH(schema_name), + tablen, S48_STRING_LENGTH(table_name), + tablet, S48_STRING_LENGTH(table_type)); + + switch (retval) + { + case SQL_SUCCESS: case SQL_SUCCESS_WITH_INFO: + { + return; + } + case SQL_STILL_EXECUTING: + { + ODBC_RAISE_EXCEPTION("SQLTables returned SQL_STILL_EXECUTING. Not implemented"); + break; + } + case SQL_ERROR: + { + ODBC_RAISE_EXCEPTION("SQLTables returned SQL_ERROR"); + break; + } + case SQL_INVALID_HANDLE: + { + ODBC_RAISE_EXCEPTION("SQLTables got invalid handle"); + break; + } + default: + { + ODBC_RAISE_EXCEPTION("SQLTables returned unknown error code"); + break; + } + } +} + + /* * * PART 9 @@ -2225,6 +2748,16 @@ void s48_init_odbc(void) S48_EXPORT_FUNCTION(odbc_sql_describe_col); /* PART 8 */ + S48_EXPORT_FUNCTION(odbc_sql_column_privileges); + S48_EXPORT_FUNCTION(odbc_sql_columns); + S48_EXPORT_FUNCTION(odbc_sql_foreign_keys); + S48_EXPORT_FUNCTION(odbc_sql_primary_keys); + S48_EXPORT_FUNCTION(odbc_sql_procedure_columns); + S48_EXPORT_FUNCTION(odbc_sql_procedures); + S48_EXPORT_FUNCTION(odbc_sql_special_columns); + S48_EXPORT_FUNCTION(odbc_sql_statistics); + S48_EXPORT_FUNCTION(odbc_sql_table_privileges); + S48_EXPORT_FUNCTION(odbc_sql_tables); /* PART 9 */ S48_EXPORT_FUNCTION(odbc_sql_free_statement); diff --git a/scsh/odbc/odbc.h b/scsh/odbc/odbc.h index 778cf57..762a84c 100644 --- a/scsh/odbc/odbc.h +++ b/scsh/odbc/odbc.h @@ -150,40 +150,40 @@ s48_value odbc_sql_get_type_info(s48_value stmt_handle, s48_value data_type); */ s48_value odbc_sql_set_connect_attr_int(s48_value conn_handle, - s48_value attribute, - s48_value value); + s48_value attribute, + s48_value value); s48_value odbc_sql_set_connect_attr_string(s48_value conn_handle, - s48_value attribute, - s48_value value); + s48_value attribute, + s48_value value); s48_value odbc_sql_get_connect_attr_string(s48_value conn_handle, - s48_value attribute); + s48_value attribute); s48_value odbc_sql_get_connect_attr_int(s48_value conn_handle, - s48_value attribute); + s48_value attribute); s48_value odbc_sql_set_env_attr_int(s48_value env_handle, - s48_value attribute, - s48_value value); + s48_value attribute, + s48_value value); s48_value odbc_sql_get_env_attr_int(s48_value env_handle, - s48_value attribute, - s48_value value); + s48_value attribute, + s48_value value); s48_value odbc_sql_set_stmt_attr_int(s48_value stmt_handle, - s48_value attribute, - s48_value value); + s48_value attribute, + s48_value value); s48_value odbc_sql_set_stmt_attr_string(s48_value stmt_handle, - s48_value attribute, - s48_value value); + s48_value attribute, + s48_value value); s48_value odbc_sql_get_stmt_attr_int(s48_value stmt_handle, - s48_value attribute); + s48_value attribute); s48_value odbc_sql_get_stmt_attr_string(s48_value stmt_handle, - s48_value attribute); + s48_value attribute); /* * @@ -254,6 +254,60 @@ s48_value odbc_sql_describe_col(s48_value stmt_handle, s48_value column_number); * */ +/* Returns a list of columns and associated privileges for one or more tables */ +void odbc_sql_column_privileges(s48_value stmt_handle, s48_value catalog_name, + s48_value schema_name, s48_value table_name, + s48_value column_name); + +/* Returns the list of column names in a specified table */ +void odbc_sql_columns(s48_value stmt_handle, s48_value catalog_name, + s48_value schema_name, s48_value table_name, + s48_value column_name); + +/* Returns a list of columns names that make up foreign keys, + if the exist for a specified table */ +void odbc_sql_foreign_keys(s48_value stmt_handle, s48_value pk_catalog_name, + s48_value pk_schema_name, s48_value pk_table_name, + s48_value fk_catalog_name, s48_value fk_schema_name, + s48_value fk_table_name); + +/* Returns the list of column names that make up the primary key for a table */ +void odbc_sql_primary_keys(s48_value stmt_handle, s48_value catalog_name, + s48_value schema_name, s48_value table_name); + +/* Returns the list of input and output parameters, as well as the columns + that make up the result set for the specified procedures */ +void odbc_sql_procedure_columns(s48_value stmt_handle, s48_value catalog_name, + s48_value schema_name, s48_value proc_name, + s48_value column_name); + +/* Returns the list of procedure names stored in a specific data source. */ +void odbc_sql_procedures(s48_value stmt_handle, s48_value catalog_name, + s48_value schema_name, s48_value proc_name); + +/* Returns information about the optimal set of columns that uniquely identifies + a row in a specified table, or the columns that are automatically updated + when any value in the row is updated by a transaction */ +void odbc_sql_special_columns(s48_value stmt_handle, s48_value identifier_type, + s48_value catalog_name, s48_value schema_name, + s48_value table_name, s48_value scope, + s48_value nullable); + +/* Returns statistics about a single table and the list of indexes associated + with the table */ +void odbc_sql_statistics(s48_value stmt_handle, s48_value catalog_name, + s48_value schema_name, s48_value table_name, + s48_value unique, s48_value reserved); + +/* Returns a list of tables and the privileges associated with each table */ +void odbc_sql_table_privileges(s48_value stmt_handle, s48_value catalog_name, + s48_value schema_name, s48_value table_name); + +/* Returns the list of table names stored in a specific data source */ +void odbc_sql_tables(s48_value stmt_handle, s48_value catalog_name, + s48_value schema_name, s48_value table_name, + s48_value table_type); + /* * * PART 9 diff --git a/scsh/odbc/odbc.scm b/scsh/odbc/odbc.scm index b40bb9e..84fc18a 100644 --- a/scsh/odbc/odbc.scm +++ b/scsh/odbc/odbc.scm @@ -367,6 +367,27 @@ (define sql-datatype-time 92) (define sql-datatype-timestamp 93) +; possible identifier-type arguments for SQLSpecialColumns() (odbc-sql-special-columns) +(define sql-best-rowid 1) +(define sql-rowver 2) + +; possible scope arguments for SQLSpecialColumns() (odbc-sql-special-columns) +(define sql-scope-currow 0) +(define sql-scope-transaction 1) +(define sql-scope-session 2) + +; possible nullable arguments for SQLSpecialColumns() (odbc-sql-special-columns) +(define sql-no-nulls 0) +(define sql-nullable 1) + +; possible unique arguments for SQLStatistics() (odbc-sql-statistics) +(define sql-index-unique 0) +(define sql-index-all 1) + +; possible reserved arguments for SQLStatistics() (odbc-sql-statistics) +(define sql-ensure 1) +(define sql-quick 0) + ;;; ODBC return values (define sql-error -1) (define sql-success 0) @@ -649,7 +670,111 @@ ;;; PART 8 -;;; PART 9 +(define (odbc-sql-column-privileges stmt-handle catalog-name schema-name + table-name column-name) + (check-arg statement-handle? stmt-handle odbc-sql-column-privileges) + (odbc-sql-column-privileges-internal (statement-handle-handle stmt-handle) + catalog-name schema-name + table-name column-name)) + +(import-lambda-definition odbc-sql-column-privileges-internal + (stmt-handle catalog-name schema-name table-name column-name) + "odbc_sql_column_privileges") + +(define (odbc-sql-columns stmt-handle catalog-name schema-name + table-name column-name) + (check-arg statement-handle? stmt-handle odbc-sql-columns) + (odbc-sql-columns-internal (statement-handle-handle stmt-handle) + catalog-name schema-name table-name column-name)) + +(import-lambda-definition odbc-sql-columns-internal + (stmt-handle catalog-name schema-name table-name column-name) + "odbc_sql_columns") + +(define (odbc-sql-foreign-keys stmt-handle + pk-catalog-name pk-schema-name pk-table-name + fk-catalog-name fk-schema-name fk-table-name) + (check-arg statement-handle? stmt-handle odbc-sql-foreign-keys) + (odbc-sql-foreign-keys-internal (statement-handle-handle stmt-handle) + pk-catalog-name pk-schema-name pk-table-name + fk-catalog-name fk-schema-name fk-table-name)) + +(import-lambda-definition odbc-sql-foreign-keys-internal + (stmt-handle + pk-catalog-name pk-schema-name pk-table-name + fk-catalog-name fk-schema-name fk-table-name) + "odbc_sql_foreign_keys") + +(define (odbc-sql-primary-keys stmt-handle catalog-name schema-name table-name) + (check-arg statement-handle? stmt-handle odbc-sql-primary-keys) + (odbc-sql-primary-keys-internal (statement-handle-handle stmt-handle) + catalog-name schema-name table-name)) + +(import-lambda-definition odbc-sql-primary-keys-internal + (stmt-handle catalog-name schema-name table-name) + "odbc_sql_primary_keys") + +(define (odbc-sql-procedure-columns stmt-handle catalog-name schema-name + proc-name column-name) + (check-arg statement-handle? stmt-handle odbc-sql-procedure-columns) + (odbc-sql-procedure-columns-internal (statement-handle-handle stmt-handle) + catalog-name schema-name proc-name column-name)) + +(import-lambda-definition odbc-sql-procedure-columns-internal + (stmt-handle catalog-name schema-name proc-name column-name) + "odbc_sql_procedure_columns") + +(define (odbc-sql-procedures stmt-handle catalog-name schema-name proc-name) + (check-arg statement-handle? stmt-handle odbc-sql-procedures) + (odbc-sql-procedures-internal (statement-handle-handle stmt-handle) + catalog-name schema-name proc-name)) + +(import-lambda-definition odbc-sql-procedures-internal + (stmt-handle catalog-name schema-name proc-name) + "odbc_sql_procedures") + +(define (odbc-sql-special-columns stmt-handle identifier-type catalog-name + schema-name table-name scope nullable) + (check-arg statement-handle? stmt-handle odbc-sql-special-columns) + (odbc-sql-special-columns-internal (statement-handle-handle stmt-handle) + identifier-type catalog-name + schema-name table-name schema-name nullable)) + +(import-lambda-definition odbc-sql-special-columns-internal + (stmt-handle identifier-type catalog-name + schema-name table-name scope nullable?) + "odbc_sql_special_columns") + +(define (odbc-sql-statistics stmt-handle catalog-name schema-name table-name + unique reserved) + (check-arg statement-handle? stmt-handle odbc-sql-statistics) + (odbc-sql-statistics-internal (statement-handle-handle stmt-handle) + catalog-name schema-name table-name unique reserved)) + +(import-lambda-definition odbc-sql-statistics-internal + (stmt-handle catalog-name schema-name table-name + unique reserved) + "odbc_sql_statistics") + +(define (odbc-sql-table-privileges stmt-handle catalog-name schema-name table-name) + (check-arg statement-handle? stmt-handle odbc-sql-table-privileges) + (odbc-sql-table-privileges-internal (statement-handle-handle stmt-handle) + catalog-name schema-name table-name)) + +(import-lambda-definition odbc-sql-table-privileges-internal + (stmt-handle catalog-name schema-name table-name) + "odbc_sql_table_privileges") + +(define (odbc-sql-tables stmt-handle catalog-name schema-name table-name table-type) + (check-arg statement-handle? stmt-handle odbc-sql-tables) + (odbc-sql-tables-internal (statement-handle-handle stmt-handle) + catalog-name schema-name table-name table-type)) + +(import-lambda-definition odbc-sql-tables-internal + (stmt-handle catalog-name schema-name table-type table-type) + "odbc_sql_tables") + +;;; part 9 (define (odbc-sql-free-statement stmt-handle option) (check-arg statement-handle? stmt-handle odbc-sql-free-statement)