diff options
Diffstat (limited to 'src/interfaces/odbc/info.c')
| -rw-r--r-- | src/interfaces/odbc/info.c | 3630 |
1 files changed, 2013 insertions, 1617 deletions
diff --git a/src/interfaces/odbc/info.c b/src/interfaces/odbc/info.c index 685248eeb7c..764cb3a5889 100644 --- a/src/interfaces/odbc/info.c +++ b/src/interfaces/odbc/info.c @@ -1,18 +1,18 @@ -/* Module: info.c +/* Module: info.c * - * Description: This module contains routines related to - * ODBC informational functions. + * Description: This module contains routines related to + * ODBC informational functions. * - * Classes: n/a + * Classes: n/a * - * API functions: SQLGetInfo, SQLGetTypeInfo, SQLGetFunctions, - * SQLTables, SQLColumns, SQLStatistics, SQLSpecialColumns, - * SQLPrimaryKeys, SQLForeignKeys, - * SQLProcedureColumns(NI), SQLProcedures(NI), - * SQLTablePrivileges(NI), SQLColumnPrivileges(NI) + * API functions: SQLGetInfo, SQLGetTypeInfo, SQLGetFunctions, + * SQLTables, SQLColumns, SQLStatistics, SQLSpecialColumns, + * SQLPrimaryKeys, SQLForeignKeys, + * SQLProcedureColumns(NI), SQLProcedures(NI), + * SQLTablePrivileges(NI), SQLColumnPrivileges(NI) * - * Comments: See "notice.txt" for copyright and license information. + * Comments: See "notice.txt" for copyright and license information. * */ @@ -31,7 +31,7 @@ #include <ctype.h> #else #include <windows.h> -#include <sql.h> +#include <sql.h> #include <sqlext.h> #endif @@ -57,589 +57,636 @@ extern GLOBAL_VALUES globals; -/* - - - - - - - - - */ +/* - - - - - - - - - */ -RETCODE SQL_API SQLGetInfo( - HDBC hdbc, - UWORD fInfoType, - PTR rgbInfoValue, - SWORD cbInfoValueMax, - SWORD FAR *pcbInfoValue) +RETCODE SQL_API +SQLGetInfo( + HDBC hdbc, + UWORD fInfoType, + PTR rgbInfoValue, + SWORD cbInfoValueMax, + SWORD FAR *pcbInfoValue) { -static char *func = "SQLGetInfo"; -ConnectionClass *conn = (ConnectionClass *) hdbc; -ConnInfo *ci; -char *p = NULL, tmp[MAX_INFO_STRING]; -int len = 0, value = 0; -RETCODE result; - - mylog( "%s: entering...fInfoType=%d\n", func, fInfoType); - - if ( ! conn) { + static char *func = "SQLGetInfo"; + ConnectionClass *conn = (ConnectionClass *) hdbc; + ConnInfo *ci; + char *p = NULL, + tmp[MAX_INFO_STRING]; + int len = 0, + value = 0; + RETCODE result; + + mylog("%s: entering...fInfoType=%d\n", func, fInfoType); + + if (!conn) + { CC_log_error(func, "", NULL); return SQL_INVALID_HANDLE; } ci = &conn->connInfo; - switch (fInfoType) { - case SQL_ACCESSIBLE_PROCEDURES: /* ODBC 1.0 */ - p = "N"; - break; - - case SQL_ACCESSIBLE_TABLES: /* ODBC 1.0 */ - p = "N"; - break; - - case SQL_ACTIVE_CONNECTIONS: /* ODBC 1.0 */ - len = 2; - value = MAX_CONNECTIONS; - break; - - case SQL_ACTIVE_STATEMENTS: /* ODBC 1.0 */ - len = 2; - value = 0; - break; - - case SQL_ALTER_TABLE: /* ODBC 2.0 */ - len = 4; - value = SQL_AT_ADD_COLUMN; - break; - - case SQL_BOOKMARK_PERSISTENCE: /* ODBC 2.0 */ - /* very simple bookmark support */ - len = 4; - value = globals.use_declarefetch ? 0 : (SQL_BP_SCROLL); - break; - - case SQL_COLUMN_ALIAS: /* ODBC 2.0 */ - p = "N"; - break; - - case SQL_CONCAT_NULL_BEHAVIOR: /* ODBC 1.0 */ - len = 2; - value = SQL_CB_NON_NULL; - break; - - case SQL_CONVERT_BIGINT: - case SQL_CONVERT_BINARY: - case SQL_CONVERT_BIT: - case SQL_CONVERT_CHAR: - case SQL_CONVERT_DATE: - case SQL_CONVERT_DECIMAL: - case SQL_CONVERT_DOUBLE: - case SQL_CONVERT_FLOAT: - case SQL_CONVERT_INTEGER: - case SQL_CONVERT_LONGVARBINARY: - case SQL_CONVERT_LONGVARCHAR: - case SQL_CONVERT_NUMERIC: - case SQL_CONVERT_REAL: - case SQL_CONVERT_SMALLINT: - case SQL_CONVERT_TIME: - case SQL_CONVERT_TIMESTAMP: - case SQL_CONVERT_TINYINT: - case SQL_CONVERT_VARBINARY: - case SQL_CONVERT_VARCHAR: /* ODBC 1.0 */ - len = 4; - value = fInfoType; - break; - - case SQL_CONVERT_FUNCTIONS: /* ODBC 1.0 */ - len = 4; - value = 0; - break; - - case SQL_CORRELATION_NAME: /* ODBC 1.0 */ - - /* Saying no correlation name makes Query not work right. - value = SQL_CN_NONE; - */ - len = 2; - value = SQL_CN_ANY; - break; - - case SQL_CURSOR_COMMIT_BEHAVIOR: /* ODBC 1.0 */ - len = 2; - value = SQL_CB_CLOSE; - break; - - case SQL_CURSOR_ROLLBACK_BEHAVIOR: /* ODBC 1.0 */ - len = 2; - value = SQL_CB_CLOSE; - break; - - case SQL_DATA_SOURCE_NAME: /* ODBC 1.0 */ - p = CC_get_DSN(conn); - break; - - case SQL_DATA_SOURCE_READ_ONLY: /* ODBC 1.0 */ - p = CC_is_onlyread(conn) ? "Y" : "N"; - break; - - case SQL_DATABASE_NAME: /* Support for old ODBC 1.0 Apps */ - - /* Returning the database name causes problems in MS Query. - It generates query like: "SELECT DISTINCT a FROM byronncrap3 crap3" - - p = CC_get_database(conn); - */ - p = ""; - break; - - case SQL_DBMS_NAME: /* ODBC 1.0 */ - p = DBMS_NAME; - break; - - case SQL_DBMS_VER: /* ODBC 1.0 */ - /* The ODBC spec wants ##.##.#### ...whatever... so prepend the driver */ - /* version number to the dbms version string */ - sprintf(tmp, "%s %s", POSTGRESDRIVERVERSION, conn->pg_version); - p = tmp; - break; - - case SQL_DEFAULT_TXN_ISOLATION: /* ODBC 1.0 */ - len = 4; - value = SQL_TXN_READ_COMMITTED; /*SQL_TXN_SERIALIZABLE; */ - break; - - case SQL_DRIVER_NAME: /* ODBC 1.0 */ - p = DRIVER_FILE_NAME; - break; - - case SQL_DRIVER_ODBC_VER: - p = DRIVER_ODBC_VER; - break; - - case SQL_DRIVER_VER: /* ODBC 1.0 */ - p = POSTGRESDRIVERVERSION; - break; - - case SQL_EXPRESSIONS_IN_ORDERBY: /* ODBC 1.0 */ - p = "N"; - break; - - case SQL_FETCH_DIRECTION: /* ODBC 1.0 */ - len = 4; - value = globals.use_declarefetch ? (SQL_FD_FETCH_NEXT) : (SQL_FD_FETCH_NEXT | - SQL_FD_FETCH_FIRST | - SQL_FD_FETCH_LAST | - SQL_FD_FETCH_PRIOR | - SQL_FD_FETCH_ABSOLUTE | - SQL_FD_FETCH_RELATIVE | - SQL_FD_FETCH_BOOKMARK); - break; - - case SQL_FILE_USAGE: /* ODBC 2.0 */ - len = 2; - value = SQL_FILE_NOT_SUPPORTED; - break; - - case SQL_GETDATA_EXTENSIONS: /* ODBC 2.0 */ - len = 4; - value = (SQL_GD_ANY_COLUMN | SQL_GD_ANY_ORDER | SQL_GD_BOUND | SQL_GD_BLOCK); - break; - - case SQL_GROUP_BY: /* ODBC 2.0 */ - len = 2; - value = SQL_GB_GROUP_BY_EQUALS_SELECT; - break; - - case SQL_IDENTIFIER_CASE: /* ODBC 1.0 */ - /* are identifiers case-sensitive (yes, but only when quoted. If not quoted, they - default to lowercase) - */ - len = 2; - value = SQL_IC_LOWER; - break; - - case SQL_IDENTIFIER_QUOTE_CHAR: /* ODBC 1.0 */ - /* the character used to quote "identifiers" */ - p = PG_VERSION_LE(conn, 6.2) ? " " : "\""; - break; - - case SQL_KEYWORDS: /* ODBC 2.0 */ - p = ""; - break; - - case SQL_LIKE_ESCAPE_CLAUSE: /* ODBC 2.0 */ - /* is there a character that escapes '%' and '_' in a LIKE clause? - not as far as I can tell - */ - p = "N"; - break; - - case SQL_LOCK_TYPES: /* ODBC 2.0 */ - len = 4; - value = globals.lie ? (SQL_LCK_NO_CHANGE | SQL_LCK_EXCLUSIVE | SQL_LCK_UNLOCK) : SQL_LCK_NO_CHANGE; - break; - - case SQL_MAX_BINARY_LITERAL_LEN: /* ODBC 2.0 */ - len = 4; - value = 0; - break; - - case SQL_MAX_CHAR_LITERAL_LEN: /* ODBC 2.0 */ - len = 4; - value = 0; - break; - - case SQL_MAX_COLUMN_NAME_LEN: /* ODBC 1.0 */ - len = 2; - value = MAX_COLUMN_LEN; - break; - - case SQL_MAX_COLUMNS_IN_GROUP_BY: /* ODBC 2.0 */ - len = 2; - value = 0; - break; - - case SQL_MAX_COLUMNS_IN_INDEX: /* ODBC 2.0 */ - len = 2; - value = 0; - break; - - case SQL_MAX_COLUMNS_IN_ORDER_BY: /* ODBC 2.0 */ - len = 2; - value = 0; - break; - - case SQL_MAX_COLUMNS_IN_SELECT: /* ODBC 2.0 */ - len = 2; - value = 0; - break; - - case SQL_MAX_COLUMNS_IN_TABLE: /* ODBC 2.0 */ - len = 2; - value = 0; - break; - - case SQL_MAX_CURSOR_NAME_LEN: /* ODBC 1.0 */ - len = 2; - value = MAX_CURSOR_LEN; - break; - - case SQL_MAX_INDEX_SIZE: /* ODBC 2.0 */ - len = 4; - value = 0; - break; - - case SQL_MAX_OWNER_NAME_LEN: /* ODBC 1.0 */ - len = 2; - value = 0; - break; - - case SQL_MAX_PROCEDURE_NAME_LEN: /* ODBC 1.0 */ - len = 2; - value = 0; - break; - - case SQL_MAX_QUALIFIER_NAME_LEN: /* ODBC 1.0 */ - len = 2; - value = 0; - break; - - case SQL_MAX_ROW_SIZE: /* ODBC 2.0 */ - len = 4; - if (PG_VERSION_GE(conn, 7.1)) { /* Large Rowa in 7.1+ */ - value = MAX_ROW_SIZE; - } else { /* Without the Toaster we're limited to the blocksize */ - value = BLCKSZ; - } - break; - - case SQL_MAX_ROW_SIZE_INCLUDES_LONG: /* ODBC 2.0 */ - /* does the preceding value include LONGVARCHAR and LONGVARBINARY - fields? Well, it does include longvarchar, but not longvarbinary. - */ - p = "Y"; - break; - - case SQL_MAX_STATEMENT_LEN: /* ODBC 2.0 */ - /* maybe this should be 0? */ - len = 4; - if (PG_VERSION_GE(conn, 7.0)) { /* Long Queries in 7.0+ */ - value = MAX_STATEMENT_LEN; - } else if (PG_VERSION_GE(conn, 6.5)) /* Prior to 7.0 we used 2*BLCKSZ */ - value = (2*BLCKSZ); - else /* Prior to 6.5 we used BLCKSZ */ - value = BLCKSZ; - - break; - - case SQL_MAX_TABLE_NAME_LEN: /* ODBC 1.0 */ - len = 2; - value = MAX_TABLE_LEN; - break; - - case SQL_MAX_TABLES_IN_SELECT: /* ODBC 2.0 */ - len = 2; - value = 0; - break; - - case SQL_MAX_USER_NAME_LEN: - len = 2; - value = 0; - break; - - case SQL_MULT_RESULT_SETS: /* ODBC 1.0 */ - /* Don't support multiple result sets but say yes anyway? */ - p = "Y"; - break; - - case SQL_MULTIPLE_ACTIVE_TXN: /* ODBC 1.0 */ - p = "Y"; - break; - - case SQL_NEED_LONG_DATA_LEN: /* ODBC 2.0 */ - /* Dont need the length, SQLPutData can handle any size and multiple calls */ - p = "N"; - break; - - case SQL_NON_NULLABLE_COLUMNS: /* ODBC 1.0 */ - len = 2; - value = SQL_NNC_NON_NULL; - break; - - case SQL_NULL_COLLATION: /* ODBC 2.0 */ - /* where are nulls sorted? */ - len = 2; - value = SQL_NC_END; - break; - - case SQL_NUMERIC_FUNCTIONS: /* ODBC 1.0 */ - len = 4; - value = 0; - break; - - case SQL_ODBC_API_CONFORMANCE: /* ODBC 1.0 */ - len = 2; - value = SQL_OAC_LEVEL1; - break; - - case SQL_ODBC_SAG_CLI_CONFORMANCE: /* ODBC 1.0 */ - len = 2; - value = SQL_OSCC_NOT_COMPLIANT; - break; - - case SQL_ODBC_SQL_CONFORMANCE: /* ODBC 1.0 */ - len = 2; - value = SQL_OSC_CORE; - break; - - case SQL_ODBC_SQL_OPT_IEF: /* ODBC 1.0 */ - p = "N"; - break; - - case SQL_OJ_CAPABILITIES: /* ODBC 2.01 */ - len = 4; - if (PG_VERSION_GE(conn, 7.1)) { /* OJs in 7.1+ */ - value = (SQL_OJ_LEFT | - SQL_OJ_RIGHT | - SQL_OJ_FULL | - SQL_OJ_NESTED | - SQL_OJ_NOT_ORDERED | - SQL_OJ_INNER | - SQL_OJ_ALL_COMPARISON_OPS); - } else { /* OJs not in <7.1 */ + switch (fInfoType) + { + case SQL_ACCESSIBLE_PROCEDURES: /* ODBC 1.0 */ + p = "N"; + break; + + case SQL_ACCESSIBLE_TABLES: /* ODBC 1.0 */ + p = "N"; + break; + + case SQL_ACTIVE_CONNECTIONS: /* ODBC 1.0 */ + len = 2; + value = MAX_CONNECTIONS; + break; + + case SQL_ACTIVE_STATEMENTS: /* ODBC 1.0 */ + len = 2; value = 0; - } - break; + break; + + case SQL_ALTER_TABLE: /* ODBC 2.0 */ + len = 4; + value = SQL_AT_ADD_COLUMN; + break; - case SQL_ORDER_BY_COLUMNS_IN_SELECT: /* ODBC 2.0 */ - p = (PG_VERSION_LE(conn, 6.3)) ? "Y" : "N"; - break; + case SQL_BOOKMARK_PERSISTENCE: /* ODBC 2.0 */ + /* very simple bookmark support */ + len = 4; + value = globals.use_declarefetch ? 0 : (SQL_BP_SCROLL); + break; + + case SQL_COLUMN_ALIAS: /* ODBC 2.0 */ + p = "N"; + break; + + case SQL_CONCAT_NULL_BEHAVIOR: /* ODBC 1.0 */ + len = 2; + value = SQL_CB_NON_NULL; + break; + + case SQL_CONVERT_BIGINT: + case SQL_CONVERT_BINARY: + case SQL_CONVERT_BIT: + case SQL_CONVERT_CHAR: + case SQL_CONVERT_DATE: + case SQL_CONVERT_DECIMAL: + case SQL_CONVERT_DOUBLE: + case SQL_CONVERT_FLOAT: + case SQL_CONVERT_INTEGER: + case SQL_CONVERT_LONGVARBINARY: + case SQL_CONVERT_LONGVARCHAR: + case SQL_CONVERT_NUMERIC: + case SQL_CONVERT_REAL: + case SQL_CONVERT_SMALLINT: + case SQL_CONVERT_TIME: + case SQL_CONVERT_TIMESTAMP: + case SQL_CONVERT_TINYINT: + case SQL_CONVERT_VARBINARY: + case SQL_CONVERT_VARCHAR: /* ODBC 1.0 */ + len = 4; + value = fInfoType; + break; + + case SQL_CONVERT_FUNCTIONS: /* ODBC 1.0 */ + len = 4; + value = 0; + break; + + case SQL_CORRELATION_NAME: /* ODBC 1.0 */ + + /* + * Saying no correlation name makes Query not work right. + * value = SQL_CN_NONE; + */ + len = 2; + value = SQL_CN_ANY; + break; + + case SQL_CURSOR_COMMIT_BEHAVIOR: /* ODBC 1.0 */ + len = 2; + value = SQL_CB_CLOSE; + break; + + case SQL_CURSOR_ROLLBACK_BEHAVIOR: /* ODBC 1.0 */ + len = 2; + value = SQL_CB_CLOSE; + break; + + case SQL_DATA_SOURCE_NAME: /* ODBC 1.0 */ + p = CC_get_DSN(conn); + break; + + case SQL_DATA_SOURCE_READ_ONLY: /* ODBC 1.0 */ + p = CC_is_onlyread(conn) ? "Y" : "N"; + break; + + case SQL_DATABASE_NAME:/* Support for old ODBC 1.0 Apps */ + + /* + * Returning the database name causes problems in MS Query. It + * generates query like: "SELECT DISTINCT a FROM byronncrap3 + * crap3" + * + * p = CC_get_database(conn); + */ + p = ""; + break; + + case SQL_DBMS_NAME: /* ODBC 1.0 */ + p = DBMS_NAME; + break; + + case SQL_DBMS_VER: /* ODBC 1.0 */ + + /* + * The ODBC spec wants ##.##.#### ...whatever... so prepend + * the driver + */ + /* version number to the dbms version string */ + sprintf(tmp, "%s %s", POSTGRESDRIVERVERSION, conn->pg_version); + p = tmp; + break; + + case SQL_DEFAULT_TXN_ISOLATION: /* ODBC 1.0 */ + len = 4; + value = SQL_TXN_READ_COMMITTED; /* SQL_TXN_SERIALIZABLE; */ + break; + + case SQL_DRIVER_NAME: /* ODBC 1.0 */ + p = DRIVER_FILE_NAME; + break; + + case SQL_DRIVER_ODBC_VER: + p = DRIVER_ODBC_VER; + break; + + case SQL_DRIVER_VER: /* ODBC 1.0 */ + p = POSTGRESDRIVERVERSION; + break; + + case SQL_EXPRESSIONS_IN_ORDERBY: /* ODBC 1.0 */ + p = "N"; + break; + + case SQL_FETCH_DIRECTION: /* ODBC 1.0 */ + len = 4; + value = globals.use_declarefetch ? (SQL_FD_FETCH_NEXT) : (SQL_FD_FETCH_NEXT | + SQL_FD_FETCH_FIRST | + SQL_FD_FETCH_LAST | + SQL_FD_FETCH_PRIOR | + SQL_FD_FETCH_ABSOLUTE | + SQL_FD_FETCH_RELATIVE | + SQL_FD_FETCH_BOOKMARK); + break; + + case SQL_FILE_USAGE: /* ODBC 2.0 */ + len = 2; + value = SQL_FILE_NOT_SUPPORTED; + break; + + case SQL_GETDATA_EXTENSIONS: /* ODBC 2.0 */ + len = 4; + value = (SQL_GD_ANY_COLUMN | SQL_GD_ANY_ORDER | SQL_GD_BOUND | SQL_GD_BLOCK); + break; + + case SQL_GROUP_BY: /* ODBC 2.0 */ + len = 2; + value = SQL_GB_GROUP_BY_EQUALS_SELECT; + break; + + case SQL_IDENTIFIER_CASE: /* ODBC 1.0 */ + + /* + * are identifiers case-sensitive (yes, but only when quoted. + * If not quoted, they default to lowercase) + */ + len = 2; + value = SQL_IC_LOWER; + break; + + case SQL_IDENTIFIER_QUOTE_CHAR: /* ODBC 1.0 */ + /* the character used to quote "identifiers" */ + p = PG_VERSION_LE(conn, 6.2) ? " " : "\""; + break; + + case SQL_KEYWORDS: /* ODBC 2.0 */ + p = ""; + break; + + case SQL_LIKE_ESCAPE_CLAUSE: /* ODBC 2.0 */ + + /* + * is there a character that escapes '%' and '_' in a LIKE + * clause? not as far as I can tell + */ + p = "N"; + break; + + case SQL_LOCK_TYPES: /* ODBC 2.0 */ + len = 4; + value = globals.lie ? (SQL_LCK_NO_CHANGE | SQL_LCK_EXCLUSIVE | SQL_LCK_UNLOCK) : SQL_LCK_NO_CHANGE; + break; + + case SQL_MAX_BINARY_LITERAL_LEN: /* ODBC 2.0 */ + len = 4; + value = 0; + break; + + case SQL_MAX_CHAR_LITERAL_LEN: /* ODBC 2.0 */ + len = 4; + value = 0; + break; + + case SQL_MAX_COLUMN_NAME_LEN: /* ODBC 1.0 */ + len = 2; + value = MAX_COLUMN_LEN; + break; + + case SQL_MAX_COLUMNS_IN_GROUP_BY: /* ODBC 2.0 */ + len = 2; + value = 0; + break; + + case SQL_MAX_COLUMNS_IN_INDEX: /* ODBC 2.0 */ + len = 2; + value = 0; + break; - case SQL_OUTER_JOINS: /* ODBC 1.0 */ - if (PG_VERSION_GE(conn, 7.1)) { /* OJs in 7.1+ */ + case SQL_MAX_COLUMNS_IN_ORDER_BY: /* ODBC 2.0 */ + len = 2; + value = 0; + break; + + case SQL_MAX_COLUMNS_IN_SELECT: /* ODBC 2.0 */ + len = 2; + value = 0; + break; + + case SQL_MAX_COLUMNS_IN_TABLE: /* ODBC 2.0 */ + len = 2; + value = 0; + break; + + case SQL_MAX_CURSOR_NAME_LEN: /* ODBC 1.0 */ + len = 2; + value = MAX_CURSOR_LEN; + break; + + case SQL_MAX_INDEX_SIZE: /* ODBC 2.0 */ + len = 4; + value = 0; + break; + + case SQL_MAX_OWNER_NAME_LEN: /* ODBC 1.0 */ + len = 2; + value = 0; + break; + + case SQL_MAX_PROCEDURE_NAME_LEN: /* ODBC 1.0 */ + len = 2; + value = 0; + break; + + case SQL_MAX_QUALIFIER_NAME_LEN: /* ODBC 1.0 */ + len = 2; + value = 0; + break; + + case SQL_MAX_ROW_SIZE: /* ODBC 2.0 */ + len = 4; + if (PG_VERSION_GE(conn, 7.1)) + { /* Large Rowa in 7.1+ */ + value = MAX_ROW_SIZE; + } + else + { /* Without the Toaster we're limited to + * the blocksize */ + value = BLCKSZ; + } + break; + + case SQL_MAX_ROW_SIZE_INCLUDES_LONG: /* ODBC 2.0 */ + + /* + * does the preceding value include LONGVARCHAR and + * LONGVARBINARY fields? Well, it does include longvarchar, + * but not longvarbinary. + */ p = "Y"; - } else { /* OJs not in <7.1 */ + break; + + case SQL_MAX_STATEMENT_LEN: /* ODBC 2.0 */ + /* maybe this should be 0? */ + len = 4; + if (PG_VERSION_GE(conn, 7.0)) + { /* Long Queries in 7.0+ */ + value = MAX_STATEMENT_LEN; + } + else if (PG_VERSION_GE(conn, 6.5)) /* Prior to 7.0 we used + * 2*BLCKSZ */ + value = (2 * BLCKSZ); + else +/* Prior to 6.5 we used BLCKSZ */ + value = BLCKSZ; + + break; + + case SQL_MAX_TABLE_NAME_LEN: /* ODBC 1.0 */ + len = 2; + value = MAX_TABLE_LEN; + break; + + case SQL_MAX_TABLES_IN_SELECT: /* ODBC 2.0 */ + len = 2; + value = 0; + break; + + case SQL_MAX_USER_NAME_LEN: + len = 2; + value = 0; + break; + + case SQL_MULT_RESULT_SETS: /* ODBC 1.0 */ + /* Don't support multiple result sets but say yes anyway? */ + p = "Y"; + break; + + case SQL_MULTIPLE_ACTIVE_TXN: /* ODBC 1.0 */ + p = "Y"; + break; + + case SQL_NEED_LONG_DATA_LEN: /* ODBC 2.0 */ + + /* + * Dont need the length, SQLPutData can handle any size and + * multiple calls + */ p = "N"; - } - break; - - case SQL_OWNER_TERM: /* ODBC 1.0 */ - p = "owner"; - break; - - case SQL_OWNER_USAGE: /* ODBC 2.0 */ - len = 4; - value = 0; - break; - - case SQL_POS_OPERATIONS: /* ODBC 2.0 */ - len = 4; - value = globals.lie ? (SQL_POS_POSITION | SQL_POS_REFRESH | SQL_POS_UPDATE | SQL_POS_DELETE | SQL_POS_ADD) : (SQL_POS_POSITION | SQL_POS_REFRESH); - break; - - case SQL_POSITIONED_STATEMENTS: /* ODBC 2.0 */ - len = 4; - value = globals.lie ? (SQL_PS_POSITIONED_DELETE | - SQL_PS_POSITIONED_UPDATE | - SQL_PS_SELECT_FOR_UPDATE) : 0; - break; - - case SQL_PROCEDURE_TERM: /* ODBC 1.0 */ - p = "procedure"; - break; - - case SQL_PROCEDURES: /* ODBC 1.0 */ - p = "Y"; - break; - - case SQL_QUALIFIER_LOCATION: /* ODBC 2.0 */ - len = 2; - value = SQL_QL_START; - break; - - case SQL_QUALIFIER_NAME_SEPARATOR: /* ODBC 1.0 */ - p = ""; - break; - - case SQL_QUALIFIER_TERM: /* ODBC 1.0 */ - p = ""; - break; - - case SQL_QUALIFIER_USAGE: /* ODBC 2.0 */ - len = 4; - value = 0; - break; - - case SQL_QUOTED_IDENTIFIER_CASE: /* ODBC 2.0 */ - /* are "quoted" identifiers case-sensitive? YES! */ - len = 2; - value = SQL_IC_SENSITIVE; - break; - - case SQL_ROW_UPDATES: /* ODBC 1.0 */ - /* Driver doesn't support keyset-driven or mixed cursors, so - not much point in saying row updates are supported - */ - p = globals.lie ? "Y" : "N"; - break; - - case SQL_SCROLL_CONCURRENCY: /* ODBC 1.0 */ - len = 4; - value = globals.lie ? (SQL_SCCO_READ_ONLY | - SQL_SCCO_LOCK | - SQL_SCCO_OPT_ROWVER | - SQL_SCCO_OPT_VALUES) : (SQL_SCCO_READ_ONLY); - break; - - case SQL_SCROLL_OPTIONS: /* ODBC 1.0 */ - len = 4; - value = globals.lie ? (SQL_SO_FORWARD_ONLY | - SQL_SO_STATIC | - SQL_SO_KEYSET_DRIVEN | - SQL_SO_DYNAMIC | - SQL_SO_MIXED) : (globals.use_declarefetch ? SQL_SO_FORWARD_ONLY : (SQL_SO_FORWARD_ONLY | SQL_SO_STATIC)); - break; - - case SQL_SEARCH_PATTERN_ESCAPE: /* ODBC 1.0 */ - p = ""; - break; - - case SQL_SERVER_NAME: /* ODBC 1.0 */ - p = CC_get_server(conn); - break; - - case SQL_SPECIAL_CHARACTERS: /* ODBC 2.0 */ - p = "_"; - break; - - case SQL_STATIC_SENSITIVITY: /* ODBC 2.0 */ - len = 4; - value = globals.lie ? (SQL_SS_ADDITIONS | SQL_SS_DELETIONS | SQL_SS_UPDATES) : 0; - break; - - case SQL_STRING_FUNCTIONS: /* ODBC 1.0 */ - len = 4; - value = (SQL_FN_STR_CONCAT | - SQL_FN_STR_LCASE | - SQL_FN_STR_LENGTH | - SQL_FN_STR_LOCATE | - SQL_FN_STR_LTRIM | - SQL_FN_STR_RTRIM | - SQL_FN_STR_SUBSTRING | - SQL_FN_STR_UCASE); - break; - - case SQL_SUBQUERIES: /* ODBC 2.0 */ - /* postgres 6.3 supports subqueries */ - len = 4; - value = (SQL_SQ_QUANTIFIED | - SQL_SQ_IN | - SQL_SQ_EXISTS | - SQL_SQ_COMPARISON); - break; - - case SQL_SYSTEM_FUNCTIONS: /* ODBC 1.0 */ - len = 4; - value = 0; - break; - - case SQL_TABLE_TERM: /* ODBC 1.0 */ - p = "table"; - break; - - case SQL_TIMEDATE_ADD_INTERVALS: /* ODBC 2.0 */ - len = 4; - value = 0; - break; - - case SQL_TIMEDATE_DIFF_INTERVALS: /* ODBC 2.0 */ - len = 4; - value = 0; - break; - - case SQL_TIMEDATE_FUNCTIONS: /* ODBC 1.0 */ - len = 4; - value = (SQL_FN_TD_NOW); - break; - - case SQL_TXN_CAPABLE: /* ODBC 1.0 */ - /* Postgres can deal with create or drop table statements in a transaction */ - len = 2; - value = SQL_TC_ALL; - break; - - case SQL_TXN_ISOLATION_OPTION: /* ODBC 1.0 */ - len = 4; - value = SQL_TXN_READ_COMMITTED; /* SQL_TXN_SERIALIZABLE; */ - break; - - case SQL_UNION: /* ODBC 2.0 */ - /* unions with all supported in postgres 6.3 */ - len = 4; - value = (SQL_U_UNION | SQL_U_UNION_ALL); - break; - - case SQL_USER_NAME: /* ODBC 1.0 */ - p = CC_get_username(conn); - break; - - default: - /* unrecognized key */ - conn->errormsg = "Unrecognized key passed to SQLGetInfo."; - conn->errornumber = CONN_NOT_IMPLEMENTED_ERROR; - CC_log_error(func, "", conn); - return SQL_ERROR; - } + break; + + case SQL_NON_NULLABLE_COLUMNS: /* ODBC 1.0 */ + len = 2; + value = SQL_NNC_NON_NULL; + break; + + case SQL_NULL_COLLATION: /* ODBC 2.0 */ + /* where are nulls sorted? */ + len = 2; + value = SQL_NC_END; + break; + + case SQL_NUMERIC_FUNCTIONS: /* ODBC 1.0 */ + len = 4; + value = 0; + break; + + case SQL_ODBC_API_CONFORMANCE: /* ODBC 1.0 */ + len = 2; + value = SQL_OAC_LEVEL1; + break; + + case SQL_ODBC_SAG_CLI_CONFORMANCE: /* ODBC 1.0 */ + len = 2; + value = SQL_OSCC_NOT_COMPLIANT; + break; + + case SQL_ODBC_SQL_CONFORMANCE: /* ODBC 1.0 */ + len = 2; + value = SQL_OSC_CORE; + break; + + case SQL_ODBC_SQL_OPT_IEF: /* ODBC 1.0 */ + p = "N"; + break; + + case SQL_OJ_CAPABILITIES: /* ODBC 2.01 */ + len = 4; + if (PG_VERSION_GE(conn, 7.1)) + { /* OJs in 7.1+ */ + value = (SQL_OJ_LEFT | + SQL_OJ_RIGHT | + SQL_OJ_FULL | + SQL_OJ_NESTED | + SQL_OJ_NOT_ORDERED | + SQL_OJ_INNER | + SQL_OJ_ALL_COMPARISON_OPS); + } + else + { /* OJs not in <7.1 */ + value = 0; + } + break; + + case SQL_ORDER_BY_COLUMNS_IN_SELECT: /* ODBC 2.0 */ + p = (PG_VERSION_LE(conn, 6.3)) ? "Y" : "N"; + break; + + case SQL_OUTER_JOINS: /* ODBC 1.0 */ + if (PG_VERSION_GE(conn, 7.1)) + { /* OJs in 7.1+ */ + p = "Y"; + } + else + { /* OJs not in <7.1 */ + p = "N"; + } + break; + + case SQL_OWNER_TERM: /* ODBC 1.0 */ + p = "owner"; + break; + + case SQL_OWNER_USAGE: /* ODBC 2.0 */ + len = 4; + value = 0; + break; + + case SQL_POS_OPERATIONS: /* ODBC 2.0 */ + len = 4; + value = globals.lie ? (SQL_POS_POSITION | SQL_POS_REFRESH | SQL_POS_UPDATE | SQL_POS_DELETE | SQL_POS_ADD) : (SQL_POS_POSITION | SQL_POS_REFRESH); + break; + + case SQL_POSITIONED_STATEMENTS: /* ODBC 2.0 */ + len = 4; + value = globals.lie ? (SQL_PS_POSITIONED_DELETE | + SQL_PS_POSITIONED_UPDATE | + SQL_PS_SELECT_FOR_UPDATE) : 0; + break; + + case SQL_PROCEDURE_TERM: /* ODBC 1.0 */ + p = "procedure"; + break; + + case SQL_PROCEDURES: /* ODBC 1.0 */ + p = "Y"; + break; + + case SQL_QUALIFIER_LOCATION: /* ODBC 2.0 */ + len = 2; + value = SQL_QL_START; + break; + + case SQL_QUALIFIER_NAME_SEPARATOR: /* ODBC 1.0 */ + p = ""; + break; + + case SQL_QUALIFIER_TERM: /* ODBC 1.0 */ + p = ""; + break; + + case SQL_QUALIFIER_USAGE: /* ODBC 2.0 */ + len = 4; + value = 0; + break; + + case SQL_QUOTED_IDENTIFIER_CASE: /* ODBC 2.0 */ + /* are "quoted" identifiers case-sensitive? YES! */ + len = 2; + value = SQL_IC_SENSITIVE; + break; + + case SQL_ROW_UPDATES: /* ODBC 1.0 */ + + /* + * Driver doesn't support keyset-driven or mixed cursors, so + * not much point in saying row updates are supported + */ + p = globals.lie ? "Y" : "N"; + break; + + case SQL_SCROLL_CONCURRENCY: /* ODBC 1.0 */ + len = 4; + value = globals.lie ? (SQL_SCCO_READ_ONLY | + SQL_SCCO_LOCK | + SQL_SCCO_OPT_ROWVER | + SQL_SCCO_OPT_VALUES) : (SQL_SCCO_READ_ONLY); + break; + + case SQL_SCROLL_OPTIONS: /* ODBC 1.0 */ + len = 4; + value = globals.lie ? (SQL_SO_FORWARD_ONLY | + SQL_SO_STATIC | + SQL_SO_KEYSET_DRIVEN | + SQL_SO_DYNAMIC | + SQL_SO_MIXED) : (globals.use_declarefetch ? SQL_SO_FORWARD_ONLY : (SQL_SO_FORWARD_ONLY | SQL_SO_STATIC)); + break; + + case SQL_SEARCH_PATTERN_ESCAPE: /* ODBC 1.0 */ + p = ""; + break; + + case SQL_SERVER_NAME: /* ODBC 1.0 */ + p = CC_get_server(conn); + break; + + case SQL_SPECIAL_CHARACTERS: /* ODBC 2.0 */ + p = "_"; + break; + + case SQL_STATIC_SENSITIVITY: /* ODBC 2.0 */ + len = 4; + value = globals.lie ? (SQL_SS_ADDITIONS | SQL_SS_DELETIONS | SQL_SS_UPDATES) : 0; + break; + + case SQL_STRING_FUNCTIONS: /* ODBC 1.0 */ + len = 4; + value = (SQL_FN_STR_CONCAT | + SQL_FN_STR_LCASE | + SQL_FN_STR_LENGTH | + SQL_FN_STR_LOCATE | + SQL_FN_STR_LTRIM | + SQL_FN_STR_RTRIM | + SQL_FN_STR_SUBSTRING | + SQL_FN_STR_UCASE); + break; + + case SQL_SUBQUERIES: /* ODBC 2.0 */ + /* postgres 6.3 supports subqueries */ + len = 4; + value = (SQL_SQ_QUANTIFIED | + SQL_SQ_IN | + SQL_SQ_EXISTS | + SQL_SQ_COMPARISON); + break; + + case SQL_SYSTEM_FUNCTIONS: /* ODBC 1.0 */ + len = 4; + value = 0; + break; + + case SQL_TABLE_TERM: /* ODBC 1.0 */ + p = "table"; + break; + + case SQL_TIMEDATE_ADD_INTERVALS: /* ODBC 2.0 */ + len = 4; + value = 0; + break; + + case SQL_TIMEDATE_DIFF_INTERVALS: /* ODBC 2.0 */ + len = 4; + value = 0; + break; + + case SQL_TIMEDATE_FUNCTIONS: /* ODBC 1.0 */ + len = 4; + value = (SQL_FN_TD_NOW); + break; + + case SQL_TXN_CAPABLE: /* ODBC 1.0 */ + + /* + * Postgres can deal with create or drop table statements in a + * transaction + */ + len = 2; + value = SQL_TC_ALL; + break; + + case SQL_TXN_ISOLATION_OPTION: /* ODBC 1.0 */ + len = 4; + value = SQL_TXN_READ_COMMITTED; /* SQL_TXN_SERIALIZABLE; */ + break; + + case SQL_UNION: /* ODBC 2.0 */ + /* unions with all supported in postgres 6.3 */ + len = 4; + value = (SQL_U_UNION | SQL_U_UNION_ALL); + break; + + case SQL_USER_NAME: /* ODBC 1.0 */ + p = CC_get_username(conn); + break; + + default: + /* unrecognized key */ + conn->errormsg = "Unrecognized key passed to SQLGetInfo."; + conn->errornumber = CONN_NOT_IMPLEMENTED_ERROR; + CC_log_error(func, "", conn); + return SQL_ERROR; + } result = SQL_SUCCESS; - mylog("SQLGetInfo: p='%s', len=%d, value=%d, cbMax=%d\n", p?p:"<NULL>", len, value, cbInfoValueMax); + mylog("SQLGetInfo: p='%s', len=%d, value=%d, cbMax=%d\n", p ? p : "<NULL>", len, value, cbInfoValueMax); - /* NOTE, that if rgbInfoValue is NULL, then no warnings or errors should - result and just pcbInfoValue is returned, which indicates what length - would be required if a real buffer had been passed in. - */ - if (p) { /* char/binary data */ + /* + * NOTE, that if rgbInfoValue is NULL, then no warnings or errors + * should result and just pcbInfoValue is returned, which indicates + * what length would be required if a real buffer had been passed in. + */ + if (p) + { /* char/binary data */ len = strlen(p); - if (rgbInfoValue) { - strncpy_null((char *)rgbInfoValue, p, (size_t)cbInfoValueMax); + if (rgbInfoValue) + { + strncpy_null((char *) rgbInfoValue, p, (size_t) cbInfoValueMax); - if (len >= cbInfoValueMax) { + if (len >= cbInfoValueMax) + { result = SQL_SUCCESS_WITH_INFO; conn->errornumber = STMT_TRUNCATED; conn->errormsg = "The buffer was too small for the result."; @@ -647,41 +694,46 @@ RETCODE result; } } - else { /* numeric data */ - - if (rgbInfoValue) { - - if (len == 2 ) - *((WORD *)rgbInfoValue) = (WORD) value; + else + { /* numeric data */ + + if (rgbInfoValue) + { + + if (len == 2) + *((WORD *) rgbInfoValue) = (WORD) value; else if (len == 4) - *((DWORD *)rgbInfoValue) = (DWORD) value; + *((DWORD *) rgbInfoValue) = (DWORD) value; } } - if (pcbInfoValue) + if (pcbInfoValue) *pcbInfoValue = len; return result; } -/* - - - - - - - - - */ +/* - - - - - - - - - */ -RETCODE SQL_API SQLGetTypeInfo( - HSTMT hstmt, - SWORD fSqlType) +RETCODE SQL_API +SQLGetTypeInfo( + HSTMT hstmt, + SWORD fSqlType) { -static char *func = "SQLGetTypeInfo"; -StatementClass *stmt = (StatementClass *) hstmt; -TupleNode *row; -int i; + static char *func = "SQLGetTypeInfo"; + StatementClass *stmt = (StatementClass *) hstmt; + TupleNode *row; + int i; + /* Int4 type; */ -Int4 pgType; -Int2 sqlType; + Int4 pgType; + Int2 sqlType; mylog("%s: entering...fSqlType = %d\n", func, fSqlType); - if( ! stmt) { + if (!stmt) + { SC_log_error(func, "", NULL); return SQL_INVALID_HANDLE; } @@ -689,7 +741,8 @@ Int2 sqlType; stmt->manual_result = TRUE; stmt->result = QR_Constructor(); - if( ! stmt->result) { + if (!stmt->result) + { SC_log_error(func, "Error creating result.", stmt); return SQL_ERROR; } @@ -713,13 +766,15 @@ Int2 sqlType; QR_set_field_info(stmt->result, 13, "MINIMUM_SCALE", PG_TYPE_INT2, 2); QR_set_field_info(stmt->result, 14, "MAXIMUM_SCALE", PG_TYPE_INT2, 2); - for(i=0, sqlType = sqlTypes[0]; sqlType; sqlType = sqlTypes[++i]) { + for (i = 0, sqlType = sqlTypes[0]; sqlType; sqlType = sqlTypes[++i]) + { pgType = sqltype_to_pgtype(sqlType); - if (fSqlType == SQL_ALL_TYPES || fSqlType == sqlType) { - row = (TupleNode *)malloc(sizeof(TupleNode) + (15 - 1)*sizeof(TupleField)); + if (fSqlType == SQL_ALL_TYPES || fSqlType == sqlType) + { + row = (TupleNode *) malloc(sizeof(TupleNode) + (15 - 1) *sizeof(TupleField)); - /* These values can't be NULL */ + /* These values can't be NULL */ set_tuplefield_string(&row->tuple[0], pgtype_to_name(stmt, pgType)); set_tuplefield_int2(&row->tuple[1], (Int2) sqlType); set_tuplefield_int2(&row->tuple[6], pgtype_nullable(stmt, pgType)); @@ -727,10 +782,13 @@ Int2 sqlType; set_tuplefield_int2(&row->tuple[8], pgtype_searchable(stmt, pgType)); set_tuplefield_int2(&row->tuple[10], pgtype_money(stmt, pgType)); - /* Localized data-source dependent data type name (always NULL) */ - set_tuplefield_null(&row->tuple[12]); + /* + * Localized data-source dependent data type name (always + * NULL) + */ + set_tuplefield_null(&row->tuple[12]); - /* These values can be NULL */ + /* These values can be NULL */ set_nullfield_int4(&row->tuple[2], pgtype_precision(stmt, pgType, PG_STATIC, PG_STATIC)); set_nullfield_string(&row->tuple[3], pgtype_literal_prefix(stmt, pgType)); set_nullfield_string(&row->tuple[4], pgtype_literal_suffix(stmt, pgType)); @@ -745,30 +803,34 @@ Int2 sqlType; } - stmt->status = STMT_FINISHED; - stmt->currTuple = -1; + stmt->status = STMT_FINISHED; + stmt->currTuple = -1; stmt->rowset_start = -1; stmt->current_col = -1; - return SQL_SUCCESS; + return SQL_SUCCESS; } -/* - - - - - - - - - */ +/* - - - - - - - - - */ -RETCODE SQL_API SQLGetFunctions( - HDBC hdbc, - UWORD fFunction, - UWORD FAR *pfExists) +RETCODE SQL_API +SQLGetFunctions( + HDBC hdbc, + UWORD fFunction, + UWORD FAR *pfExists) { -static char *func="SQLGetFunctions"; + static char *func = "SQLGetFunctions"; - mylog( "%s: entering...\n", func); + mylog("%s: entering...\n", func); - if (fFunction == SQL_API_ALL_FUNCTIONS) { + if (fFunction == SQL_API_ALL_FUNCTIONS) + { - if (globals.lie) { - int i; - memset(pfExists, 0, sizeof(UWORD)*100); + if (globals.lie) + { + int i; + + memset(pfExists, 0, sizeof(UWORD) * 100); pfExists[SQL_API_SQLALLOCENV] = TRUE; pfExists[SQL_API_SQLFREEENV] = TRUE; @@ -777,179 +839,309 @@ static char *func="SQLGetFunctions"; for (i = SQL_EXT_API_START; i <= SQL_EXT_API_LAST; i++) pfExists[i] = TRUE; } - else { - memset(pfExists, 0, sizeof(UWORD)*100); + else + { + memset(pfExists, 0, sizeof(UWORD) * 100); /* ODBC core functions */ - pfExists[SQL_API_SQLALLOCCONNECT] = TRUE; - pfExists[SQL_API_SQLALLOCENV] = TRUE; - pfExists[SQL_API_SQLALLOCSTMT] = TRUE; - pfExists[SQL_API_SQLBINDCOL] = TRUE; - pfExists[SQL_API_SQLCANCEL] = TRUE; - pfExists[SQL_API_SQLCOLATTRIBUTES] = TRUE; - pfExists[SQL_API_SQLCONNECT] = TRUE; - pfExists[SQL_API_SQLDESCRIBECOL] = TRUE; /* partial */ - pfExists[SQL_API_SQLDISCONNECT] = TRUE; - pfExists[SQL_API_SQLERROR] = TRUE; - pfExists[SQL_API_SQLEXECDIRECT] = TRUE; - pfExists[SQL_API_SQLEXECUTE] = TRUE; - pfExists[SQL_API_SQLFETCH] = TRUE; - pfExists[SQL_API_SQLFREECONNECT] = TRUE; - pfExists[SQL_API_SQLFREEENV] = TRUE; - pfExists[SQL_API_SQLFREESTMT] = TRUE; - pfExists[SQL_API_SQLGETCURSORNAME] = TRUE; - pfExists[SQL_API_SQLNUMRESULTCOLS] = TRUE; - pfExists[SQL_API_SQLPREPARE] = TRUE; /* complete? */ - pfExists[SQL_API_SQLROWCOUNT] = TRUE; - pfExists[SQL_API_SQLSETCURSORNAME] = TRUE; - pfExists[SQL_API_SQLSETPARAM] = FALSE; /* odbc 1.0 */ - pfExists[SQL_API_SQLTRANSACT] = TRUE; + pfExists[SQL_API_SQLALLOCCONNECT] = TRUE; + pfExists[SQL_API_SQLALLOCENV] = TRUE; + pfExists[SQL_API_SQLALLOCSTMT] = TRUE; + pfExists[SQL_API_SQLBINDCOL] = TRUE; + pfExists[SQL_API_SQLCANCEL] = TRUE; + pfExists[SQL_API_SQLCOLATTRIBUTES] = TRUE; + pfExists[SQL_API_SQLCONNECT] = TRUE; + pfExists[SQL_API_SQLDESCRIBECOL] = TRUE; /* partial */ + pfExists[SQL_API_SQLDISCONNECT] = TRUE; + pfExists[SQL_API_SQLERROR] = TRUE; + pfExists[SQL_API_SQLEXECDIRECT] = TRUE; + pfExists[SQL_API_SQLEXECUTE] = TRUE; + pfExists[SQL_API_SQLFETCH] = TRUE; + pfExists[SQL_API_SQLFREECONNECT] = TRUE; + pfExists[SQL_API_SQLFREEENV] = TRUE; + pfExists[SQL_API_SQLFREESTMT] = TRUE; + pfExists[SQL_API_SQLGETCURSORNAME] = TRUE; + pfExists[SQL_API_SQLNUMRESULTCOLS] = TRUE; + pfExists[SQL_API_SQLPREPARE] = TRUE; /* complete? */ + pfExists[SQL_API_SQLROWCOUNT] = TRUE; + pfExists[SQL_API_SQLSETCURSORNAME] = TRUE; + pfExists[SQL_API_SQLSETPARAM] = FALSE; /* odbc 1.0 */ + pfExists[SQL_API_SQLTRANSACT] = TRUE; /* ODBC level 1 functions */ - pfExists[SQL_API_SQLBINDPARAMETER] = TRUE; - pfExists[SQL_API_SQLCOLUMNS] = TRUE; - pfExists[SQL_API_SQLDRIVERCONNECT] = TRUE; - pfExists[SQL_API_SQLGETCONNECTOPTION] = TRUE; /* partial */ - pfExists[SQL_API_SQLGETDATA] = TRUE; - pfExists[SQL_API_SQLGETFUNCTIONS] = TRUE; - pfExists[SQL_API_SQLGETINFO] = TRUE; - pfExists[SQL_API_SQLGETSTMTOPTION] = TRUE; /* partial */ - pfExists[SQL_API_SQLGETTYPEINFO] = TRUE; - pfExists[SQL_API_SQLPARAMDATA] = TRUE; - pfExists[SQL_API_SQLPUTDATA] = TRUE; - pfExists[SQL_API_SQLSETCONNECTOPTION] = TRUE; /* partial */ - pfExists[SQL_API_SQLSETSTMTOPTION] = TRUE; - pfExists[SQL_API_SQLSPECIALCOLUMNS] = TRUE; - pfExists[SQL_API_SQLSTATISTICS] = TRUE; - pfExists[SQL_API_SQLTABLES] = TRUE; + pfExists[SQL_API_SQLBINDPARAMETER] = TRUE; + pfExists[SQL_API_SQLCOLUMNS] = TRUE; + pfExists[SQL_API_SQLDRIVERCONNECT] = TRUE; + pfExists[SQL_API_SQLGETCONNECTOPTION] = TRUE; /* partial */ + pfExists[SQL_API_SQLGETDATA] = TRUE; + pfExists[SQL_API_SQLGETFUNCTIONS] = TRUE; + pfExists[SQL_API_SQLGETINFO] = TRUE; + pfExists[SQL_API_SQLGETSTMTOPTION] = TRUE; /* partial */ + pfExists[SQL_API_SQLGETTYPEINFO] = TRUE; + pfExists[SQL_API_SQLPARAMDATA] = TRUE; + pfExists[SQL_API_SQLPUTDATA] = TRUE; + pfExists[SQL_API_SQLSETCONNECTOPTION] = TRUE; /* partial */ + pfExists[SQL_API_SQLSETSTMTOPTION] = TRUE; + pfExists[SQL_API_SQLSPECIALCOLUMNS] = TRUE; + pfExists[SQL_API_SQLSTATISTICS] = TRUE; + pfExists[SQL_API_SQLTABLES] = TRUE; /* ODBC level 2 functions */ - pfExists[SQL_API_SQLBROWSECONNECT] = FALSE; + pfExists[SQL_API_SQLBROWSECONNECT] = FALSE; pfExists[SQL_API_SQLCOLUMNPRIVILEGES] = FALSE; - pfExists[SQL_API_SQLDATASOURCES] = FALSE; /* only implemented by DM */ - pfExists[SQL_API_SQLDESCRIBEPARAM] = FALSE; /* not properly implemented */ - pfExists[SQL_API_SQLDRIVERS] = FALSE; /* only implemented by DM */ - pfExists[SQL_API_SQLEXTENDEDFETCH] = TRUE; - pfExists[SQL_API_SQLFOREIGNKEYS] = TRUE; - pfExists[SQL_API_SQLMORERESULTS] = TRUE; - pfExists[SQL_API_SQLNATIVESQL] = TRUE; - pfExists[SQL_API_SQLNUMPARAMS] = TRUE; - pfExists[SQL_API_SQLPARAMOPTIONS] = FALSE; - pfExists[SQL_API_SQLPRIMARYKEYS] = TRUE; + pfExists[SQL_API_SQLDATASOURCES] = FALSE; /* only implemented by + * DM */ + pfExists[SQL_API_SQLDESCRIBEPARAM] = FALSE; /* not properly + * implemented */ + pfExists[SQL_API_SQLDRIVERS] = FALSE; /* only implemented by + * DM */ + pfExists[SQL_API_SQLEXTENDEDFETCH] = TRUE; + pfExists[SQL_API_SQLFOREIGNKEYS] = TRUE; + pfExists[SQL_API_SQLMORERESULTS] = TRUE; + pfExists[SQL_API_SQLNATIVESQL] = TRUE; + pfExists[SQL_API_SQLNUMPARAMS] = TRUE; + pfExists[SQL_API_SQLPARAMOPTIONS] = FALSE; + pfExists[SQL_API_SQLPRIMARYKEYS] = TRUE; pfExists[SQL_API_SQLPROCEDURECOLUMNS] = FALSE; - pfExists[SQL_API_SQLPROCEDURES] = FALSE; - pfExists[SQL_API_SQLSETPOS] = TRUE; - pfExists[SQL_API_SQLSETSCROLLOPTIONS] = TRUE; /* odbc 1.0 */ - pfExists[SQL_API_SQLTABLEPRIVILEGES] = FALSE; + pfExists[SQL_API_SQLPROCEDURES] = FALSE; + pfExists[SQL_API_SQLSETPOS] = TRUE; + pfExists[SQL_API_SQLSETSCROLLOPTIONS] = TRUE; /* odbc 1.0 */ + pfExists[SQL_API_SQLTABLEPRIVILEGES] = FALSE; } - } else { + } + else + { if (globals.lie) *pfExists = TRUE; - else { - - switch(fFunction) { - case SQL_API_SQLALLOCCONNECT: *pfExists = TRUE; break; - case SQL_API_SQLALLOCENV: *pfExists = TRUE; break; - case SQL_API_SQLALLOCSTMT: *pfExists = TRUE; break; - case SQL_API_SQLBINDCOL: *pfExists = TRUE; break; - case SQL_API_SQLCANCEL: *pfExists = TRUE; break; - case SQL_API_SQLCOLATTRIBUTES: *pfExists = TRUE; break; - case SQL_API_SQLCONNECT: *pfExists = TRUE; break; - case SQL_API_SQLDESCRIBECOL: *pfExists = TRUE; break; /* partial */ - case SQL_API_SQLDISCONNECT: *pfExists = TRUE; break; - case SQL_API_SQLERROR: *pfExists = TRUE; break; - case SQL_API_SQLEXECDIRECT: *pfExists = TRUE; break; - case SQL_API_SQLEXECUTE: *pfExists = TRUE; break; - case SQL_API_SQLFETCH: *pfExists = TRUE; break; - case SQL_API_SQLFREECONNECT: *pfExists = TRUE; break; - case SQL_API_SQLFREEENV: *pfExists = TRUE; break; - case SQL_API_SQLFREESTMT: *pfExists = TRUE; break; - case SQL_API_SQLGETCURSORNAME: *pfExists = TRUE; break; - case SQL_API_SQLNUMRESULTCOLS: *pfExists = TRUE; break; - case SQL_API_SQLPREPARE: *pfExists = TRUE; break; - case SQL_API_SQLROWCOUNT: *pfExists = TRUE; break; - case SQL_API_SQLSETCURSORNAME: *pfExists = TRUE; break; - case SQL_API_SQLSETPARAM: *pfExists = FALSE; break; /* odbc 1.0 */ - case SQL_API_SQLTRANSACT: *pfExists = TRUE; break; - - /* ODBC level 1 functions */ - case SQL_API_SQLBINDPARAMETER: *pfExists = TRUE; break; - case SQL_API_SQLCOLUMNS: *pfExists = TRUE; break; - case SQL_API_SQLDRIVERCONNECT: *pfExists = TRUE; break; - case SQL_API_SQLGETCONNECTOPTION: *pfExists = TRUE; break; /* partial */ - case SQL_API_SQLGETDATA: *pfExists = TRUE; break; - case SQL_API_SQLGETFUNCTIONS: *pfExists = TRUE; break; - case SQL_API_SQLGETINFO: *pfExists = TRUE; break; - case SQL_API_SQLGETSTMTOPTION: *pfExists = TRUE; break; /* partial */ - case SQL_API_SQLGETTYPEINFO: *pfExists = TRUE; break; - case SQL_API_SQLPARAMDATA: *pfExists = TRUE; break; - case SQL_API_SQLPUTDATA: *pfExists = TRUE; break; - case SQL_API_SQLSETCONNECTOPTION: *pfExists = TRUE; break; /* partial */ - case SQL_API_SQLSETSTMTOPTION: *pfExists = TRUE; break; - case SQL_API_SQLSPECIALCOLUMNS: *pfExists = TRUE; break; - case SQL_API_SQLSTATISTICS: *pfExists = TRUE; break; - case SQL_API_SQLTABLES: *pfExists = TRUE; break; - - /* ODBC level 2 functions */ - case SQL_API_SQLBROWSECONNECT: *pfExists = FALSE; break; - case SQL_API_SQLCOLUMNPRIVILEGES: *pfExists = FALSE; break; - case SQL_API_SQLDATASOURCES: *pfExists = FALSE; break; /* only implemented by DM */ - case SQL_API_SQLDESCRIBEPARAM: *pfExists = FALSE; break; /* not properly implemented */ - case SQL_API_SQLDRIVERS: *pfExists = FALSE; break; /* only implemented by DM */ - case SQL_API_SQLEXTENDEDFETCH: *pfExists = TRUE; break; - case SQL_API_SQLFOREIGNKEYS: *pfExists = TRUE; break; - case SQL_API_SQLMORERESULTS: *pfExists = TRUE; break; - case SQL_API_SQLNATIVESQL: *pfExists = TRUE; break; - case SQL_API_SQLNUMPARAMS: *pfExists = TRUE; break; - case SQL_API_SQLPARAMOPTIONS: *pfExists = FALSE; break; - case SQL_API_SQLPRIMARYKEYS: *pfExists = TRUE; break; - case SQL_API_SQLPROCEDURECOLUMNS: *pfExists = FALSE; break; - case SQL_API_SQLPROCEDURES: *pfExists = FALSE; break; - case SQL_API_SQLSETPOS: *pfExists = TRUE; break; - case SQL_API_SQLSETSCROLLOPTIONS: *pfExists = TRUE; break; /* odbc 1.0 */ - case SQL_API_SQLTABLEPRIVILEGES: *pfExists = FALSE; break; + else + { + + switch (fFunction) + { + case SQL_API_SQLALLOCCONNECT: + *pfExists = TRUE; + break; + case SQL_API_SQLALLOCENV: + *pfExists = TRUE; + break; + case SQL_API_SQLALLOCSTMT: + *pfExists = TRUE; + break; + case SQL_API_SQLBINDCOL: + *pfExists = TRUE; + break; + case SQL_API_SQLCANCEL: + *pfExists = TRUE; + break; + case SQL_API_SQLCOLATTRIBUTES: + *pfExists = TRUE; + break; + case SQL_API_SQLCONNECT: + *pfExists = TRUE; + break; + case SQL_API_SQLDESCRIBECOL: + *pfExists = TRUE; + break; /* partial */ + case SQL_API_SQLDISCONNECT: + *pfExists = TRUE; + break; + case SQL_API_SQLERROR: + *pfExists = TRUE; + break; + case SQL_API_SQLEXECDIRECT: + *pfExists = TRUE; + break; + case SQL_API_SQLEXECUTE: + *pfExists = TRUE; + break; + case SQL_API_SQLFETCH: + *pfExists = TRUE; + break; + case SQL_API_SQLFREECONNECT: + *pfExists = TRUE; + break; + case SQL_API_SQLFREEENV: + *pfExists = TRUE; + break; + case SQL_API_SQLFREESTMT: + *pfExists = TRUE; + break; + case SQL_API_SQLGETCURSORNAME: + *pfExists = TRUE; + break; + case SQL_API_SQLNUMRESULTCOLS: + *pfExists = TRUE; + break; + case SQL_API_SQLPREPARE: + *pfExists = TRUE; + break; + case SQL_API_SQLROWCOUNT: + *pfExists = TRUE; + break; + case SQL_API_SQLSETCURSORNAME: + *pfExists = TRUE; + break; + case SQL_API_SQLSETPARAM: + *pfExists = FALSE; + break; /* odbc 1.0 */ + case SQL_API_SQLTRANSACT: + *pfExists = TRUE; + break; + + /* ODBC level 1 functions */ + case SQL_API_SQLBINDPARAMETER: + *pfExists = TRUE; + break; + case SQL_API_SQLCOLUMNS: + *pfExists = TRUE; + break; + case SQL_API_SQLDRIVERCONNECT: + *pfExists = TRUE; + break; + case SQL_API_SQLGETCONNECTOPTION: + *pfExists = TRUE; + break; /* partial */ + case SQL_API_SQLGETDATA: + *pfExists = TRUE; + break; + case SQL_API_SQLGETFUNCTIONS: + *pfExists = TRUE; + break; + case SQL_API_SQLGETINFO: + *pfExists = TRUE; + break; + case SQL_API_SQLGETSTMTOPTION: + *pfExists = TRUE; + break; /* partial */ + case SQL_API_SQLGETTYPEINFO: + *pfExists = TRUE; + break; + case SQL_API_SQLPARAMDATA: + *pfExists = TRUE; + break; + case SQL_API_SQLPUTDATA: + *pfExists = TRUE; + break; + case SQL_API_SQLSETCONNECTOPTION: + *pfExists = TRUE; + break; /* partial */ + case SQL_API_SQLSETSTMTOPTION: + *pfExists = TRUE; + break; + case SQL_API_SQLSPECIALCOLUMNS: + *pfExists = TRUE; + break; + case SQL_API_SQLSTATISTICS: + *pfExists = TRUE; + break; + case SQL_API_SQLTABLES: + *pfExists = TRUE; + break; + + /* ODBC level 2 functions */ + case SQL_API_SQLBROWSECONNECT: + *pfExists = FALSE; + break; + case SQL_API_SQLCOLUMNPRIVILEGES: + *pfExists = FALSE; + break; + case SQL_API_SQLDATASOURCES: + *pfExists = FALSE; + break; /* only implemented by DM */ + case SQL_API_SQLDESCRIBEPARAM: + *pfExists = FALSE; + break; /* not properly implemented */ + case SQL_API_SQLDRIVERS: + *pfExists = FALSE; + break; /* only implemented by DM */ + case SQL_API_SQLEXTENDEDFETCH: + *pfExists = TRUE; + break; + case SQL_API_SQLFOREIGNKEYS: + *pfExists = TRUE; + break; + case SQL_API_SQLMORERESULTS: + *pfExists = TRUE; + break; + case SQL_API_SQLNATIVESQL: + *pfExists = TRUE; + break; + case SQL_API_SQLNUMPARAMS: + *pfExists = TRUE; + break; + case SQL_API_SQLPARAMOPTIONS: + *pfExists = FALSE; + break; + case SQL_API_SQLPRIMARYKEYS: + *pfExists = TRUE; + break; + case SQL_API_SQLPROCEDURECOLUMNS: + *pfExists = FALSE; + break; + case SQL_API_SQLPROCEDURES: + *pfExists = FALSE; + break; + case SQL_API_SQLSETPOS: + *pfExists = TRUE; + break; + case SQL_API_SQLSETSCROLLOPTIONS: + *pfExists = TRUE; + break; /* odbc 1.0 */ + case SQL_API_SQLTABLEPRIVILEGES: + *pfExists = FALSE; + break; } } - } + } - return SQL_SUCCESS; + return SQL_SUCCESS; } -RETCODE SQL_API SQLTables( - HSTMT hstmt, - UCHAR FAR * szTableQualifier, - SWORD cbTableQualifier, - UCHAR FAR * szTableOwner, - SWORD cbTableOwner, - UCHAR FAR * szTableName, - SWORD cbTableName, - UCHAR FAR * szTableType, - SWORD cbTableType) +RETCODE SQL_API +SQLTables( + HSTMT hstmt, + UCHAR FAR *szTableQualifier, + SWORD cbTableQualifier, + UCHAR FAR *szTableOwner, + SWORD cbTableOwner, + UCHAR FAR *szTableName, + SWORD cbTableName, + UCHAR FAR *szTableType, + SWORD cbTableType) { -static char *func = "SQLTables"; -StatementClass *stmt = (StatementClass *) hstmt; -StatementClass *tbl_stmt; -TupleNode *row; -HSTMT htbl_stmt; -RETCODE result; -char *tableType; -char tables_query[STD_STATEMENT_LEN]; -char table_name[MAX_INFO_STRING], table_owner[MAX_INFO_STRING], relkind_or_hasrules[MAX_INFO_STRING]; -ConnectionClass *conn; -ConnInfo *ci; -char *prefix[32], prefixes[MEDIUM_REGISTRY_LEN]; -char *table_type[32], table_types[MAX_INFO_STRING]; -char show_system_tables, show_regular_tables, show_views; -char regular_table, view, systable; -int i; - -mylog("%s: entering...stmt=%u\n", func, stmt); - - if( ! stmt) { + static char *func = "SQLTables"; + StatementClass *stmt = (StatementClass *) hstmt; + StatementClass *tbl_stmt; + TupleNode *row; + HSTMT htbl_stmt; + RETCODE result; + char *tableType; + char tables_query[STD_STATEMENT_LEN]; + char table_name[MAX_INFO_STRING], + table_owner[MAX_INFO_STRING], + relkind_or_hasrules[MAX_INFO_STRING]; + ConnectionClass *conn; + ConnInfo *ci; + char *prefix[32], + prefixes[MEDIUM_REGISTRY_LEN]; + char *table_type[32], + table_types[MAX_INFO_STRING]; + char show_system_tables, + show_regular_tables, + show_views; + char regular_table, + view, + systable; + int i; + + mylog("%s: entering...stmt=%u\n", func, stmt); + + if (!stmt) + { SC_log_error(func, "", NULL); return SQL_INVALID_HANDLE; } @@ -960,8 +1152,9 @@ mylog("%s: entering...stmt=%u\n", func, stmt); conn = (ConnectionClass *) (stmt->hdbc); ci = &stmt->hdbc->connInfo; - result = SQLAllocStmt( stmt->hdbc, &htbl_stmt); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + result = SQLAllocStmt(stmt->hdbc, &htbl_stmt); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errornumber = STMT_NO_MEMORY_ERROR; stmt->errormsg = "Couldn't allocate statement for SQLTables result."; SC_log_error(func, "", stmt); @@ -970,14 +1163,17 @@ mylog("%s: entering...stmt=%u\n", func, stmt); tbl_stmt = (StatementClass *) htbl_stmt; /* ********************************************************************** */ - /* Create the query to find out the tables */ + /* Create the query to find out the tables */ /* ********************************************************************** */ - if (PG_VERSION_GE(conn, 7.1)) { /* view is represented by its relkind since 7.1 */ + if (PG_VERSION_GE(conn, 7.1)) + { /* view is represented by its relkind + * since 7.1 */ strcpy(tables_query, "select relname, usename, relkind from pg_class, pg_user"); strcat(tables_query, " where relkind in ('r', 'v')"); } - else { + else + { strcpy(tables_query, "select relname, usename, relhasrules from pg_class, pg_user"); strcat(tables_query, " where relkind = 'r'"); } @@ -986,58 +1182,64 @@ mylog("%s: entering...stmt=%u\n", func, stmt); my_strcat(tables_query, " and relname like '%.*s'", szTableName, cbTableName); - /* Parse the extra systable prefix */ + /* Parse the extra systable prefix */ strcpy(prefixes, globals.extra_systable_prefixes); i = 0; prefix[i] = strtok(prefixes, ";"); - while (prefix[i] && i<32) { + while (prefix[i] && i < 32) + { prefix[++i] = strtok(NULL, ";"); } - /* Parse the desired table types to return */ + /* Parse the desired table types to return */ show_system_tables = FALSE; show_regular_tables = FALSE; show_views = FALSE; - /* make_string mallocs memory */ + /* make_string mallocs memory */ tableType = make_string(szTableType, cbTableType, NULL); - if (tableType) { + if (tableType) + { strcpy(table_types, tableType); free(tableType); i = 0; table_type[i] = strtok(table_types, ","); - while (table_type[i] && i<32) { + while (table_type[i] && i < 32) table_type[++i] = strtok(NULL, ","); - } - /* Check for desired table types to return */ + /* Check for desired table types to return */ i = 0; - while (table_type[i]) { - if ( strstr(table_type[i], "SYSTEM TABLE")) + while (table_type[i]) + { + if (strstr(table_type[i], "SYSTEM TABLE")) show_system_tables = TRUE; - else if ( strstr(table_type[i], "TABLE")) + else if (strstr(table_type[i], "TABLE")) show_regular_tables = TRUE; - else if ( strstr(table_type[i], "VIEW")) + else if (strstr(table_type[i], "VIEW")) show_views = TRUE; i++; } } - else { + else + { show_regular_tables = TRUE; show_views = TRUE; } - /* If not interested in SYSTEM TABLES then filter them out - to save some time on the query. If treating system tables - as regular tables, then dont filter either. - */ - if ( ! atoi(ci->show_system_tables) && ! show_system_tables) { + /* + * If not interested in SYSTEM TABLES then filter them out to save + * some time on the query. If treating system tables as regular + * tables, then dont filter either. + */ + if (!atoi(ci->show_system_tables) && !show_system_tables) + { strcat(tables_query, " and relname !~ '^" POSTGRES_SYS_PREFIX); - /* Also filter out user-defined system table types */ + /* Also filter out user-defined system table types */ i = 0; - while(prefix[i]) { + while (prefix[i]) + { strcat(tables_query, "|^"); strcat(tables_query, prefix[i]); i++; @@ -1048,8 +1250,9 @@ mylog("%s: entering...stmt=%u\n", func, stmt); /* match users */ - if (PG_VERSION_LT(conn, 7.1)) /* filter out large objects in older versions */ - strcat(tables_query, " and relname !~ '^xinv[0-9]+'"); + if (PG_VERSION_LT(conn, 7.1)) /* filter out large objects in + * older versions */ + strcat(tables_query, " and relname !~ '^xinv[0-9]+'"); strcat(tables_query, " and usesysid = relowner"); strcat(tables_query, " order by relname"); @@ -1057,7 +1260,8 @@ mylog("%s: entering...stmt=%u\n", func, stmt); /* ********************************************************************** */ result = SQLExecDirect(htbl_stmt, tables_query, strlen(tables_query)); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = SC_create_errormsg(htbl_stmt); stmt->errornumber = tbl_stmt->errornumber; SC_log_error(func, "", stmt); @@ -1065,37 +1269,41 @@ mylog("%s: entering...stmt=%u\n", func, stmt); return SQL_ERROR; } - result = SQLBindCol(htbl_stmt, 1, SQL_C_CHAR, - table_name, MAX_INFO_STRING, NULL); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + result = SQLBindCol(htbl_stmt, 1, SQL_C_CHAR, + table_name, MAX_INFO_STRING, NULL); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = tbl_stmt->errormsg; stmt->errornumber = tbl_stmt->errornumber; SC_log_error(func, "", stmt); SQLFreeStmt(htbl_stmt, SQL_DROP); - return SQL_ERROR; - } + return SQL_ERROR; + } - result = SQLBindCol(htbl_stmt, 2, SQL_C_CHAR, - table_owner, MAX_INFO_STRING, NULL); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + result = SQLBindCol(htbl_stmt, 2, SQL_C_CHAR, + table_owner, MAX_INFO_STRING, NULL); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = tbl_stmt->errormsg; stmt->errornumber = tbl_stmt->errornumber; SC_log_error(func, "", stmt); SQLFreeStmt(htbl_stmt, SQL_DROP); - return SQL_ERROR; - } - result = SQLBindCol(htbl_stmt, 3, SQL_C_CHAR, - relkind_or_hasrules, MAX_INFO_STRING, NULL); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + return SQL_ERROR; + } + result = SQLBindCol(htbl_stmt, 3, SQL_C_CHAR, + relkind_or_hasrules, MAX_INFO_STRING, NULL); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = tbl_stmt->errormsg; stmt->errornumber = tbl_stmt->errornumber; SC_log_error(func, "", stmt); SQLFreeStmt(htbl_stmt, SQL_DROP); - return SQL_ERROR; - } + return SQL_ERROR; + } stmt->result = QR_Constructor(); - if(!stmt->result) { + if (!stmt->result) + { stmt->errormsg = "Couldn't allocate memory for SQLTables result."; stmt->errornumber = STMT_NO_MEMORY_ERROR; SC_log_error(func, "", stmt); @@ -1104,9 +1312,13 @@ mylog("%s: entering...stmt=%u\n", func, stmt); } /* the binding structure for a statement is not set up until */ - /* a statement is actually executed, so we'll have to do this ourselves. */ + + /* + * a statement is actually executed, so we'll have to do this + * ourselves. + */ extend_bindings(stmt, 5); - + /* set the field names */ QR_set_num_fields(stmt->result, 5); QR_set_field_info(stmt->result, 0, "TABLE_QUALIFIER", PG_TYPE_TEXT, MAX_INFO_STRING); @@ -1117,23 +1329,28 @@ mylog("%s: entering...stmt=%u\n", func, stmt); /* add the tuples */ result = SQLFetch(htbl_stmt); - while((result == SQL_SUCCESS) || (result == SQL_SUCCESS_WITH_INFO)) { + while ((result == SQL_SUCCESS) || (result == SQL_SUCCESS_WITH_INFO)) + { - /* Determine if this table name is a system table. - If treating system tables as regular tables, then - no need to do this test. - */ + /* + * Determine if this table name is a system table. If treating + * system tables as regular tables, then no need to do this test. + */ systable = FALSE; - if( ! atoi(ci->show_system_tables)) { + if (!atoi(ci->show_system_tables)) + { - if ( strncmp(table_name, POSTGRES_SYS_PREFIX, strlen(POSTGRES_SYS_PREFIX)) == 0) + if (strncmp(table_name, POSTGRES_SYS_PREFIX, strlen(POSTGRES_SYS_PREFIX)) == 0) systable = TRUE; - else { /* Check extra system table prefixes */ + else + { /* Check extra system table prefixes */ i = 0; - while (prefix[i]) { + while (prefix[i]) + { mylog("table_name='%s', prefix[%d]='%s'\n", table_name, i, prefix[i]); - if (strncmp(table_name, prefix[i], strlen(prefix[i])) == 0) { + if (strncmp(table_name, prefix[i], strlen(prefix[i])) == 0) + { systable = TRUE; break; } @@ -1142,24 +1359,29 @@ mylog("%s: entering...stmt=%u\n", func, stmt); } } - /* Determine if the table name is a view */ - if (PG_VERSION_GE(conn, 7.1)) /* view is represented by its relkind since 7.1 */ + /* Determine if the table name is a view */ + if (PG_VERSION_GE(conn, 7.1)) /* view is represented by its + * relkind since 7.1 */ view = (relkind_or_hasrules[0] == 'v'); else view = (relkind_or_hasrules[0] == '1'); - /* It must be a regular table */ - regular_table = ( ! systable && ! view); + /* It must be a regular table */ + regular_table = (!systable && !view); + + /* Include the row in the result set if meets all criteria */ - /* Include the row in the result set if meets all criteria */ - /* NOTE: Unsupported table types (i.e., LOCAL TEMPORARY, ALIAS, etc) - will return nothing */ - if ( (systable && show_system_tables) || - (view && show_views) || - (regular_table && show_regular_tables)) { + /* + * NOTE: Unsupported table types (i.e., LOCAL TEMPORARY, ALIAS, + * etc) will return nothing + */ + if ((systable && show_system_tables) || + (view && show_views) || + (regular_table && show_regular_tables)) + { - row = (TupleNode *)malloc(sizeof(TupleNode) + (5 - 1) * sizeof(TupleField)); + row = (TupleNode *) malloc(sizeof(TupleNode) + (5 - 1) *sizeof(TupleField)); set_tuplefield_string(&row->tuple[0], ""); @@ -1179,8 +1401,9 @@ mylog("%s: entering...stmt=%u\n", func, stmt); QR_add_tuple(stmt->result, row); } result = SQLFetch(htbl_stmt); - } - if(result != SQL_NO_DATA_FOUND) { + } + if (result != SQL_NO_DATA_FOUND) + { stmt->errormsg = SC_create_errormsg(htbl_stmt); stmt->errornumber = tbl_stmt->errornumber; SC_log_error(func, "", stmt); @@ -1205,36 +1428,48 @@ mylog("%s: entering...stmt=%u\n", func, stmt); -RETCODE SQL_API SQLColumns( - HSTMT hstmt, - UCHAR FAR * szTableQualifier, - SWORD cbTableQualifier, - UCHAR FAR * szTableOwner, - SWORD cbTableOwner, - UCHAR FAR * szTableName, - SWORD cbTableName, - UCHAR FAR * szColumnName, - SWORD cbColumnName) +RETCODE SQL_API +SQLColumns( + HSTMT hstmt, + UCHAR FAR *szTableQualifier, + SWORD cbTableQualifier, + UCHAR FAR *szTableOwner, + SWORD cbTableOwner, + UCHAR FAR *szTableName, + SWORD cbTableName, + UCHAR FAR *szColumnName, + SWORD cbColumnName) { -static char *func = "SQLColumns"; -StatementClass *stmt = (StatementClass *) hstmt; -TupleNode *row; -HSTMT hcol_stmt; -StatementClass *col_stmt; -char columns_query[STD_STATEMENT_LEN]; -RETCODE result; -char table_owner[MAX_INFO_STRING], table_name[MAX_INFO_STRING], field_name[MAX_INFO_STRING], field_type_name[MAX_INFO_STRING]; -Int2 field_number, result_cols, scale; -Int4 field_type, the_type, field_length, mod_length, precision; -char useStaticPrecision; -char not_null[MAX_INFO_STRING], relhasrules[MAX_INFO_STRING]; -ConnInfo *ci; -ConnectionClass *conn; + static char *func = "SQLColumns"; + StatementClass *stmt = (StatementClass *) hstmt; + TupleNode *row; + HSTMT hcol_stmt; + StatementClass *col_stmt; + char columns_query[STD_STATEMENT_LEN]; + RETCODE result; + char table_owner[MAX_INFO_STRING], + table_name[MAX_INFO_STRING], + field_name[MAX_INFO_STRING], + field_type_name[MAX_INFO_STRING]; + Int2 field_number, + result_cols, + scale; + Int4 field_type, + the_type, + field_length, + mod_length, + precision; + char useStaticPrecision; + char not_null[MAX_INFO_STRING], + relhasrules[MAX_INFO_STRING]; + ConnInfo *ci; + ConnectionClass *conn; mylog("%s: entering...stmt=%u\n", func, stmt); - if( ! stmt) { + if (!stmt) + { SC_log_error(func, "", NULL); return SQL_INVALID_HANDLE; } @@ -1246,13 +1481,17 @@ ConnectionClass *conn; ci = &stmt->hdbc->connInfo; /* ********************************************************************** */ - /* Create the query to find out the columns (Note: pre 6.3 did not have the atttypmod field) */ + + /* + * Create the query to find out the columns (Note: pre 6.3 did not + * have the atttypmod field) + */ /* ********************************************************************** */ sprintf(columns_query, "select u.usename, c.relname, a.attname, a.atttypid" - ", t.typname, a.attnum, a.attlen, %s, a.attnotnull, c.relhasrules" + ", t.typname, a.attnum, a.attlen, %s, a.attnotnull, c.relhasrules" " from pg_user u, pg_class c, pg_attribute a, pg_type t" " where u.usesysid = c.relowner" - " and c.oid= a.attrelid and a.atttypid = t.oid and (a.attnum > 0)", + " and c.oid= a.attrelid and a.atttypid = t.oid and (a.attnum > 0)", PG_VERSION_LE(conn, 6.2) ? "a.attlen" : "a.atttypmod"); my_strcat(columns_query, " and c.relname like '%.*s'", szTableName, cbTableName); @@ -1261,186 +1500,206 @@ ConnectionClass *conn; /* give the output in the order the columns were defined */ /* when the table was created */ - strcat(columns_query, " order by attnum"); - /* ********************************************************************** */ + strcat(columns_query, " order by attnum"); + /* ********************************************************************** */ - result = SQLAllocStmt( stmt->hdbc, &hcol_stmt); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + result = SQLAllocStmt(stmt->hdbc, &hcol_stmt); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errornumber = STMT_NO_MEMORY_ERROR; stmt->errormsg = "Couldn't allocate statement for SQLColumns result."; SC_log_error(func, "", stmt); - return SQL_ERROR; - } + return SQL_ERROR; + } col_stmt = (StatementClass *) hcol_stmt; mylog("SQLColumns: hcol_stmt = %u, col_stmt = %u\n", hcol_stmt, col_stmt); - result = SQLExecDirect(hcol_stmt, columns_query, - strlen(columns_query)); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + result = SQLExecDirect(hcol_stmt, columns_query, + strlen(columns_query)); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = SC_create_errormsg(hcol_stmt); stmt->errornumber = col_stmt->errornumber; SC_log_error(func, "", stmt); SQLFreeStmt(hcol_stmt, SQL_DROP); - return SQL_ERROR; - } + return SQL_ERROR; + } - result = SQLBindCol(hcol_stmt, 1, SQL_C_CHAR, - table_owner, MAX_INFO_STRING, NULL); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + result = SQLBindCol(hcol_stmt, 1, SQL_C_CHAR, + table_owner, MAX_INFO_STRING, NULL); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = col_stmt->errormsg; stmt->errornumber = col_stmt->errornumber; SC_log_error(func, "", stmt); SQLFreeStmt(hcol_stmt, SQL_DROP); - return SQL_ERROR; - } + return SQL_ERROR; + } - result = SQLBindCol(hcol_stmt, 2, SQL_C_CHAR, - table_name, MAX_INFO_STRING, NULL); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + result = SQLBindCol(hcol_stmt, 2, SQL_C_CHAR, + table_name, MAX_INFO_STRING, NULL); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = col_stmt->errormsg; stmt->errornumber = col_stmt->errornumber; SC_log_error(func, "", stmt); SQLFreeStmt(hcol_stmt, SQL_DROP); - return SQL_ERROR; - } + return SQL_ERROR; + } - result = SQLBindCol(hcol_stmt, 3, SQL_C_CHAR, - field_name, MAX_INFO_STRING, NULL); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + result = SQLBindCol(hcol_stmt, 3, SQL_C_CHAR, + field_name, MAX_INFO_STRING, NULL); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = col_stmt->errormsg; stmt->errornumber = col_stmt->errornumber; SC_log_error(func, "", stmt); SQLFreeStmt(hcol_stmt, SQL_DROP); - return SQL_ERROR; - } + return SQL_ERROR; + } - result = SQLBindCol(hcol_stmt, 4, SQL_C_LONG, - &field_type, 4, NULL); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + result = SQLBindCol(hcol_stmt, 4, SQL_C_LONG, + &field_type, 4, NULL); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = col_stmt->errormsg; stmt->errornumber = col_stmt->errornumber; SC_log_error(func, "", stmt); SQLFreeStmt(hcol_stmt, SQL_DROP); - return SQL_ERROR; - } + return SQL_ERROR; + } - result = SQLBindCol(hcol_stmt, 5, SQL_C_CHAR, - field_type_name, MAX_INFO_STRING, NULL); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + result = SQLBindCol(hcol_stmt, 5, SQL_C_CHAR, + field_type_name, MAX_INFO_STRING, NULL); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = col_stmt->errormsg; stmt->errornumber = col_stmt->errornumber; SC_log_error(func, "", stmt); SQLFreeStmt(hcol_stmt, SQL_DROP); - return SQL_ERROR; - } + return SQL_ERROR; + } - result = SQLBindCol(hcol_stmt, 6, SQL_C_SHORT, - &field_number, MAX_INFO_STRING, NULL); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + result = SQLBindCol(hcol_stmt, 6, SQL_C_SHORT, + &field_number, MAX_INFO_STRING, NULL); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = col_stmt->errormsg; stmt->errornumber = col_stmt->errornumber; SC_log_error(func, "", stmt); SQLFreeStmt(hcol_stmt, SQL_DROP); - return SQL_ERROR; - } + return SQL_ERROR; + } - result = SQLBindCol(hcol_stmt, 7, SQL_C_LONG, - &field_length, MAX_INFO_STRING, NULL); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + result = SQLBindCol(hcol_stmt, 7, SQL_C_LONG, + &field_length, MAX_INFO_STRING, NULL); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = col_stmt->errormsg; stmt->errornumber = col_stmt->errornumber; SC_log_error(func, "", stmt); SQLFreeStmt(hcol_stmt, SQL_DROP); - return SQL_ERROR; - } + return SQL_ERROR; + } - result = SQLBindCol(hcol_stmt, 8, SQL_C_LONG, - &mod_length, MAX_INFO_STRING, NULL); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + result = SQLBindCol(hcol_stmt, 8, SQL_C_LONG, + &mod_length, MAX_INFO_STRING, NULL); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = col_stmt->errormsg; stmt->errornumber = col_stmt->errornumber; SC_log_error(func, "", stmt); SQLFreeStmt(hcol_stmt, SQL_DROP); - return SQL_ERROR; - } + return SQL_ERROR; + } - result = SQLBindCol(hcol_stmt, 9, SQL_C_CHAR, - not_null, MAX_INFO_STRING, NULL); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + result = SQLBindCol(hcol_stmt, 9, SQL_C_CHAR, + not_null, MAX_INFO_STRING, NULL); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = col_stmt->errormsg; stmt->errornumber = col_stmt->errornumber; SC_log_error(func, "", stmt); SQLFreeStmt(hcol_stmt, SQL_DROP); - return SQL_ERROR; - } + return SQL_ERROR; + } - result = SQLBindCol(hcol_stmt, 10, SQL_C_CHAR, - relhasrules, MAX_INFO_STRING, NULL); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + result = SQLBindCol(hcol_stmt, 10, SQL_C_CHAR, + relhasrules, MAX_INFO_STRING, NULL); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = col_stmt->errormsg; stmt->errornumber = col_stmt->errornumber; SC_log_error(func, "", stmt); SQLFreeStmt(hcol_stmt, SQL_DROP); - return SQL_ERROR; - } + return SQL_ERROR; + } - stmt->result = QR_Constructor(); - if(!stmt->result) { + stmt->result = QR_Constructor(); + if (!stmt->result) + { stmt->errormsg = "Couldn't allocate memory for SQLColumns result."; - stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errornumber = STMT_NO_MEMORY_ERROR; SC_log_error(func, "", stmt); SQLFreeStmt(hcol_stmt, SQL_DROP); - return SQL_ERROR; - } + return SQL_ERROR; + } + + /* the binding structure for a statement is not set up until */ - /* the binding structure for a statement is not set up until */ - /* a statement is actually executed, so we'll have to do this ourselves. */ + /* + * a statement is actually executed, so we'll have to do this + * ourselves. + */ result_cols = 14; - extend_bindings(stmt, result_cols); - - /* set the field names */ - QR_set_num_fields(stmt->result, result_cols); - QR_set_field_info(stmt->result, 0, "TABLE_QUALIFIER", PG_TYPE_TEXT, MAX_INFO_STRING); - QR_set_field_info(stmt->result, 1, "TABLE_OWNER", PG_TYPE_TEXT, MAX_INFO_STRING); - QR_set_field_info(stmt->result, 2, "TABLE_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); - QR_set_field_info(stmt->result, 3, "COLUMN_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); - QR_set_field_info(stmt->result, 4, "DATA_TYPE", PG_TYPE_INT2, 2); - QR_set_field_info(stmt->result, 5, "TYPE_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); - QR_set_field_info(stmt->result, 6, "PRECISION", PG_TYPE_INT4, 4); - QR_set_field_info(stmt->result, 7, "LENGTH", PG_TYPE_INT4, 4); - QR_set_field_info(stmt->result, 8, "SCALE", PG_TYPE_INT2, 2); - QR_set_field_info(stmt->result, 9, "RADIX", PG_TYPE_INT2, 2); - QR_set_field_info(stmt->result, 10, "NULLABLE", PG_TYPE_INT2, 2); - QR_set_field_info(stmt->result, 11, "REMARKS", PG_TYPE_TEXT, 254); - - /* User defined fields */ - QR_set_field_info(stmt->result, 12, "DISPLAY_SIZE", PG_TYPE_INT4, 4); + extend_bindings(stmt, result_cols); + + /* set the field names */ + QR_set_num_fields(stmt->result, result_cols); + QR_set_field_info(stmt->result, 0, "TABLE_QUALIFIER", PG_TYPE_TEXT, MAX_INFO_STRING); + QR_set_field_info(stmt->result, 1, "TABLE_OWNER", PG_TYPE_TEXT, MAX_INFO_STRING); + QR_set_field_info(stmt->result, 2, "TABLE_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); + QR_set_field_info(stmt->result, 3, "COLUMN_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); + QR_set_field_info(stmt->result, 4, "DATA_TYPE", PG_TYPE_INT2, 2); + QR_set_field_info(stmt->result, 5, "TYPE_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); + QR_set_field_info(stmt->result, 6, "PRECISION", PG_TYPE_INT4, 4); + QR_set_field_info(stmt->result, 7, "LENGTH", PG_TYPE_INT4, 4); + QR_set_field_info(stmt->result, 8, "SCALE", PG_TYPE_INT2, 2); + QR_set_field_info(stmt->result, 9, "RADIX", PG_TYPE_INT2, 2); + QR_set_field_info(stmt->result, 10, "NULLABLE", PG_TYPE_INT2, 2); + QR_set_field_info(stmt->result, 11, "REMARKS", PG_TYPE_TEXT, 254); + + /* User defined fields */ + QR_set_field_info(stmt->result, 12, "DISPLAY_SIZE", PG_TYPE_INT4, 4); QR_set_field_info(stmt->result, 13, "FIELD_TYPE", PG_TYPE_INT4, 4); - + result = SQLFetch(hcol_stmt); - /* Only show oid if option AND there are other columns AND - it's not being called by SQLStatistics . - Always show OID if it's a system table - */ + /* + * Only show oid if option AND there are other columns AND it's not + * being called by SQLStatistics . Always show OID if it's a system + * table + */ - if (result != SQL_ERROR && ! stmt->internal) { + if (result != SQL_ERROR && !stmt->internal) + { - if (relhasrules[0] != '1' && - (atoi(ci->show_oid_column) || - strncmp(table_name, POSTGRES_SYS_PREFIX, strlen(POSTGRES_SYS_PREFIX)) == 0)) { + if (relhasrules[0] != '1' && + (atoi(ci->show_oid_column) || + strncmp(table_name, POSTGRES_SYS_PREFIX, strlen(POSTGRES_SYS_PREFIX)) == 0)) + { - /* For OID fields */ + /* For OID fields */ the_type = PG_TYPE_OID; - row = (TupleNode *)malloc(sizeof(TupleNode) + - (result_cols - 1) * sizeof(TupleField)); + row = (TupleNode *) malloc(sizeof(TupleNode) + + (result_cols - 1) *sizeof(TupleField)); set_tuplefield_string(&row->tuple[0], ""); /* see note in SQLTables() */ - /* set_tuplefield_string(&row->tuple[1], table_owner); */ + /* set_tuplefield_string(&row->tuple[1], table_owner); */ set_tuplefield_string(&row->tuple[1], ""); set_tuplefield_string(&row->tuple[2], table_name); set_tuplefield_string(&row->tuple[3], "oid"); @@ -1463,64 +1722,69 @@ ConnectionClass *conn; } - while((result == SQL_SUCCESS) || (result == SQL_SUCCESS_WITH_INFO)) { - row = (TupleNode *)malloc(sizeof(TupleNode) + - (result_cols - 1) * sizeof(TupleField)); - - - set_tuplefield_string(&row->tuple[0], ""); - /* see note in SQLTables() */ - /* set_tuplefield_string(&row->tuple[1], table_owner); */ - set_tuplefield_string(&row->tuple[1], ""); - set_tuplefield_string(&row->tuple[2], table_name); - set_tuplefield_string(&row->tuple[3], field_name); - set_tuplefield_int2(&row->tuple[4], pgtype_to_sqltype(stmt, field_type)); - set_tuplefield_string(&row->tuple[5], field_type_name); - + while ((result == SQL_SUCCESS) || (result == SQL_SUCCESS_WITH_INFO)) + { + row = (TupleNode *) malloc(sizeof(TupleNode) + + (result_cols - 1) *sizeof(TupleField)); - /* Some Notes about Postgres Data Types: - VARCHAR - the length is stored in the pg_attribute.atttypmod field - BPCHAR - the length is also stored as varchar is - - NUMERIC - the scale is stored in atttypmod as follows: - precision = ((atttypmod - VARHDRSZ) >> 16) & 0xffff - scale = (atttypmod - VARHDRSZ) & 0xffff - - - */ + set_tuplefield_string(&row->tuple[0], ""); + /* see note in SQLTables() */ + /* set_tuplefield_string(&row->tuple[1], table_owner); */ + set_tuplefield_string(&row->tuple[1], ""); + set_tuplefield_string(&row->tuple[2], table_name); + set_tuplefield_string(&row->tuple[3], field_name); + set_tuplefield_int2(&row->tuple[4], pgtype_to_sqltype(stmt, field_type)); + set_tuplefield_string(&row->tuple[5], field_type_name); + + + /* + * Some Notes about Postgres Data Types: + * + * VARCHAR - the length is stored in the pg_attribute.atttypmod field + * BPCHAR - the length is also stored as varchar is + * + * NUMERIC - the scale is stored in atttypmod as follows: precision = + * ((atttypmod - VARHDRSZ) >> 16) & 0xffff scale = (atttypmod + * - VARHDRSZ) & 0xffff + * + * + */ qlog("SQLColumns: table='%s',field_name='%s',type=%d,sqltype=%d,name='%s'\n", - table_name,field_name,field_type,pgtype_to_sqltype,field_type_name); + table_name, field_name, field_type, pgtype_to_sqltype, field_type_name); useStaticPrecision = TRUE; - if (field_type == PG_TYPE_NUMERIC) { + if (field_type == PG_TYPE_NUMERIC) + { if (mod_length >= 4) - mod_length -= 4; /* the length is in atttypmod - 4 */ + mod_length -= 4;/* the length is in atttypmod - 4 */ - if (mod_length >= 0) { + if (mod_length >= 0) + { useStaticPrecision = FALSE; precision = (mod_length >> 16) & 0xffff; scale = mod_length & 0xffff; - mylog("SQLColumns: field type is NUMERIC: field_type = %d, mod_length=%d, precision=%d, scale=%d\n", field_type, mod_length, precision, scale ); + mylog("SQLColumns: field type is NUMERIC: field_type = %d, mod_length=%d, precision=%d, scale=%d\n", field_type, mod_length, precision, scale); - set_tuplefield_int4(&row->tuple[7], precision + 2); /* sign+dec.point */ + set_tuplefield_int4(&row->tuple[7], precision + 2); /* sign+dec.point */ set_tuplefield_int4(&row->tuple[6], precision); - set_tuplefield_int4(&row->tuple[12], precision + 2); /* sign+dec.point */ + set_tuplefield_int4(&row->tuple[12], precision + 2); /* sign+dec.point */ set_nullfield_int2(&row->tuple[8], scale); } } - if((field_type == PG_TYPE_VARCHAR) || - (field_type == PG_TYPE_BPCHAR)) { + if ((field_type == PG_TYPE_VARCHAR) || + (field_type == PG_TYPE_BPCHAR)) + { useStaticPrecision = FALSE; if (mod_length >= 4) - mod_length -= 4; /* the length is in atttypmod - 4 */ + mod_length -= 4;/* the length is in atttypmod - 4 */ if (mod_length > globals.max_varchar_size || mod_length <= 0) mod_length = globals.max_varchar_size; @@ -1531,44 +1795,47 @@ ConnectionClass *conn; set_tuplefield_int4(&row->tuple[6], mod_length); set_tuplefield_int4(&row->tuple[12], mod_length); set_nullfield_int2(&row->tuple[8], pgtype_scale(stmt, field_type, PG_STATIC)); - } - - if (useStaticPrecision) { + } + + if (useStaticPrecision) + { mylog("SQLColumns: field type is OTHER: field_type = %d, pgtype_length = %d\n", field_type, pgtype_length(stmt, field_type, PG_STATIC, PG_STATIC)); - set_tuplefield_int4(&row->tuple[7], pgtype_length(stmt, field_type, PG_STATIC, PG_STATIC)); + set_tuplefield_int4(&row->tuple[7], pgtype_length(stmt, field_type, PG_STATIC, PG_STATIC)); set_tuplefield_int4(&row->tuple[6], pgtype_precision(stmt, field_type, PG_STATIC, PG_STATIC)); set_tuplefield_int4(&row->tuple[12], pgtype_display_size(stmt, field_type, PG_STATIC, PG_STATIC)); set_nullfield_int2(&row->tuple[8], pgtype_scale(stmt, field_type, PG_STATIC)); - } + } set_nullfield_int2(&row->tuple[9], pgtype_radix(stmt, field_type)); set_tuplefield_int2(&row->tuple[10], (Int2) (not_null[0] == '1' ? SQL_NO_NULLS : pgtype_nullable(stmt, field_type))); set_tuplefield_string(&row->tuple[11], ""); set_tuplefield_int4(&row->tuple[13], field_type); - QR_add_tuple(stmt->result, row); + QR_add_tuple(stmt->result, row); - result = SQLFetch(hcol_stmt); + result = SQLFetch(hcol_stmt); - } - if(result != SQL_NO_DATA_FOUND) { + } + if (result != SQL_NO_DATA_FOUND) + { stmt->errormsg = SC_create_errormsg(hcol_stmt); stmt->errornumber = col_stmt->errornumber; SC_log_error(func, "", stmt); SQLFreeStmt(hcol_stmt, SQL_DROP); - return SQL_ERROR; - } + return SQL_ERROR; + } - /* Put the row version column at the end so it might not be */ - /* mistaken for a key field. */ - if ( relhasrules[0] != '1' && ! stmt->internal && atoi(ci->row_versioning)) { - /* For Row Versioning fields */ + /* Put the row version column at the end so it might not be */ + /* mistaken for a key field. */ + if (relhasrules[0] != '1' && !stmt->internal && atoi(ci->row_versioning)) + { + /* For Row Versioning fields */ the_type = PG_TYPE_INT4; - row = (TupleNode *)malloc(sizeof(TupleNode) + - (result_cols - 1) * sizeof(TupleField)); + row = (TupleNode *) malloc(sizeof(TupleNode) + + (result_cols - 1) *sizeof(TupleField)); set_tuplefield_string(&row->tuple[0], ""); set_tuplefield_string(&row->tuple[1], ""); @@ -1590,115 +1857,122 @@ ConnectionClass *conn; /* also, things need to think that this statement is finished so */ /* the results can be retrieved. */ - stmt->status = STMT_FINISHED; + stmt->status = STMT_FINISHED; - /* set up the current tuple pointer for SQLFetch */ - stmt->currTuple = -1; + /* set up the current tuple pointer for SQLFetch */ + stmt->currTuple = -1; stmt->rowset_start = -1; stmt->current_col = -1; SQLFreeStmt(hcol_stmt, SQL_DROP); mylog("SQLColumns(): EXIT, stmt=%u\n", stmt); - return SQL_SUCCESS; + return SQL_SUCCESS; } -RETCODE SQL_API SQLSpecialColumns( - HSTMT hstmt, - UWORD fColType, - UCHAR FAR * szTableQualifier, - SWORD cbTableQualifier, - UCHAR FAR * szTableOwner, - SWORD cbTableOwner, - UCHAR FAR * szTableName, - SWORD cbTableName, - UWORD fScope, - UWORD fNullable) +RETCODE SQL_API +SQLSpecialColumns( + HSTMT hstmt, + UWORD fColType, + UCHAR FAR *szTableQualifier, + SWORD cbTableQualifier, + UCHAR FAR *szTableOwner, + SWORD cbTableOwner, + UCHAR FAR *szTableName, + SWORD cbTableName, + UWORD fScope, + UWORD fNullable) { -static char *func = "SQLSpecialColumns"; -TupleNode *row; -StatementClass *stmt = (StatementClass *) hstmt; -ConnInfo *ci; -HSTMT hcol_stmt; -StatementClass *col_stmt; -char columns_query[STD_STATEMENT_LEN]; -RETCODE result; -char relhasrules[MAX_INFO_STRING]; + static char *func = "SQLSpecialColumns"; + TupleNode *row; + StatementClass *stmt = (StatementClass *) hstmt; + ConnInfo *ci; + HSTMT hcol_stmt; + StatementClass *col_stmt; + char columns_query[STD_STATEMENT_LEN]; + RETCODE result; + char relhasrules[MAX_INFO_STRING]; -mylog("%s: entering...stmt=%u\n", func, stmt); + mylog("%s: entering...stmt=%u\n", func, stmt); - if( ! stmt) { + if (!stmt) + { SC_log_error(func, "", NULL); - return SQL_INVALID_HANDLE; - } + return SQL_INVALID_HANDLE; + } ci = &stmt->hdbc->connInfo; stmt->manual_result = TRUE; /* ********************************************************************** */ - /* Create the query to find out if this is a view or not... */ + /* Create the query to find out if this is a view or not... */ /* ********************************************************************** */ sprintf(columns_query, "select c.relhasrules " - "from pg_user u, pg_class c where " - "u.usesysid = c.relowner"); + "from pg_user u, pg_class c where " + "u.usesysid = c.relowner"); my_strcat(columns_query, " and c.relname like '%.*s'", szTableName, cbTableName); my_strcat(columns_query, " and u.usename like '%.*s'", szTableOwner, cbTableOwner); - result = SQLAllocStmt( stmt->hdbc, &hcol_stmt); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + result = SQLAllocStmt(stmt->hdbc, &hcol_stmt); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errornumber = STMT_NO_MEMORY_ERROR; stmt->errormsg = "Couldn't allocate statement for SQLSpecialColumns result."; SC_log_error(func, "", stmt); - return SQL_ERROR; - } + return SQL_ERROR; + } col_stmt = (StatementClass *) hcol_stmt; mylog("SQLSpecialColumns: hcol_stmt = %u, col_stmt = %u\n", hcol_stmt, col_stmt); - result = SQLExecDirect(hcol_stmt, columns_query, - strlen(columns_query)); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + result = SQLExecDirect(hcol_stmt, columns_query, + strlen(columns_query)); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = SC_create_errormsg(hcol_stmt); stmt->errornumber = col_stmt->errornumber; SC_log_error(func, "", stmt); SQLFreeStmt(hcol_stmt, SQL_DROP); - return SQL_ERROR; - } + return SQL_ERROR; + } - result = SQLBindCol(hcol_stmt, 1, SQL_C_CHAR, - relhasrules, MAX_INFO_STRING, NULL); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + result = SQLBindCol(hcol_stmt, 1, SQL_C_CHAR, + relhasrules, MAX_INFO_STRING, NULL); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = col_stmt->errormsg; stmt->errornumber = col_stmt->errornumber; SC_log_error(func, "", stmt); SQLFreeStmt(hcol_stmt, SQL_DROP); - return SQL_ERROR; - } + return SQL_ERROR; + } result = SQLFetch(hcol_stmt); SQLFreeStmt(hcol_stmt, SQL_DROP); - stmt->result = QR_Constructor(); - extend_bindings(stmt, 8); - - QR_set_num_fields(stmt->result, 8); - QR_set_field_info(stmt->result, 0, "SCOPE", PG_TYPE_INT2, 2); - QR_set_field_info(stmt->result, 1, "COLUMN_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); - QR_set_field_info(stmt->result, 2, "DATA_TYPE", PG_TYPE_INT2, 2); - QR_set_field_info(stmt->result, 3, "TYPE_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); - QR_set_field_info(stmt->result, 4, "PRECISION", PG_TYPE_INT4, 4); - QR_set_field_info(stmt->result, 5, "LENGTH", PG_TYPE_INT4, 4); - QR_set_field_info(stmt->result, 6, "SCALE", PG_TYPE_INT2, 2); - QR_set_field_info(stmt->result, 7, "PSEUDO_COLUMN", PG_TYPE_INT2, 2); - - if ( relhasrules[0] != '1' ) { + stmt->result = QR_Constructor(); + extend_bindings(stmt, 8); + + QR_set_num_fields(stmt->result, 8); + QR_set_field_info(stmt->result, 0, "SCOPE", PG_TYPE_INT2, 2); + QR_set_field_info(stmt->result, 1, "COLUMN_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); + QR_set_field_info(stmt->result, 2, "DATA_TYPE", PG_TYPE_INT2, 2); + QR_set_field_info(stmt->result, 3, "TYPE_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); + QR_set_field_info(stmt->result, 4, "PRECISION", PG_TYPE_INT4, 4); + QR_set_field_info(stmt->result, 5, "LENGTH", PG_TYPE_INT4, 4); + QR_set_field_info(stmt->result, 6, "SCALE", PG_TYPE_INT2, 2); + QR_set_field_info(stmt->result, 7, "PSEUDO_COLUMN", PG_TYPE_INT2, 2); + + if (relhasrules[0] != '1') + { /* use the oid value for the rowid */ - if(fColType == SQL_BEST_ROWID) { - row = (TupleNode *)malloc(sizeof(TupleNode) + (8 - 1) * sizeof(TupleField)); + if (fColType == SQL_BEST_ROWID) + { + row = (TupleNode *) malloc(sizeof(TupleNode) + (8 - 1) *sizeof(TupleField)); set_tuplefield_int2(&row->tuple[0], SQL_SCOPE_SESSION); set_tuplefield_string(&row->tuple[1], "oid"); @@ -1711,12 +1985,15 @@ mylog("%s: entering...stmt=%u\n", func, stmt); QR_add_tuple(stmt->result, row); - } else if(fColType == SQL_ROWVER) { + } + else if (fColType == SQL_ROWVER) + { - Int2 the_type = PG_TYPE_INT4; + Int2 the_type = PG_TYPE_INT4; - if (atoi(ci->row_versioning)) { - row = (TupleNode *)malloc(sizeof(TupleNode) + (8 - 1) * sizeof(TupleField)); + if (atoi(ci->row_versioning)) + { + row = (TupleNode *) malloc(sizeof(TupleNode) + (8 - 1) *sizeof(TupleField)); set_tuplefield_null(&row->tuple[0]); set_tuplefield_string(&row->tuple[1], "xmin"); @@ -1734,103 +2011,116 @@ mylog("%s: entering...stmt=%u\n", func, stmt); - stmt->status = STMT_FINISHED; - stmt->currTuple = -1; + stmt->status = STMT_FINISHED; + stmt->currTuple = -1; stmt->rowset_start = -1; stmt->current_col = -1; mylog("SQLSpecialColumns(): EXIT, stmt=%u\n", stmt); - return SQL_SUCCESS; + return SQL_SUCCESS; } -RETCODE SQL_API SQLStatistics( - HSTMT hstmt, - UCHAR FAR * szTableQualifier, - SWORD cbTableQualifier, - UCHAR FAR * szTableOwner, - SWORD cbTableOwner, - UCHAR FAR * szTableName, - SWORD cbTableName, - UWORD fUnique, - UWORD fAccuracy) +RETCODE SQL_API +SQLStatistics( + HSTMT hstmt, + UCHAR FAR *szTableQualifier, + SWORD cbTableQualifier, + UCHAR FAR *szTableOwner, + SWORD cbTableOwner, + UCHAR FAR *szTableName, + SWORD cbTableName, + UWORD fUnique, + UWORD fAccuracy) { -static char *func="SQLStatistics"; -StatementClass *stmt = (StatementClass *) hstmt; -char index_query[STD_STATEMENT_LEN]; -HSTMT hindx_stmt; -RETCODE result; -char *table_name; -char index_name[MAX_INFO_STRING]; -short fields_vector[16]; -char isunique[10], isclustered[10]; -SDWORD index_name_len, fields_vector_len; -TupleNode *row; -int i; -HSTMT hcol_stmt; -StatementClass *col_stmt, *indx_stmt; -char column_name[MAX_INFO_STRING], relhasrules[MAX_INFO_STRING]; -char **column_names = 0; -Int4 column_name_len; -int total_columns = 0; -char error = TRUE; -ConnInfo *ci; -char buf[256]; - -mylog("%s: entering...stmt=%u\n", func, stmt); - - if( ! stmt) { + static char *func = "SQLStatistics"; + StatementClass *stmt = (StatementClass *) hstmt; + char index_query[STD_STATEMENT_LEN]; + HSTMT hindx_stmt; + RETCODE result; + char *table_name; + char index_name[MAX_INFO_STRING]; + short fields_vector[16]; + char isunique[10], + isclustered[10]; + SDWORD index_name_len, + fields_vector_len; + TupleNode *row; + int i; + HSTMT hcol_stmt; + StatementClass *col_stmt, + *indx_stmt; + char column_name[MAX_INFO_STRING], + relhasrules[MAX_INFO_STRING]; + char **column_names = 0; + Int4 column_name_len; + int total_columns = 0; + char error = TRUE; + ConnInfo *ci; + char buf[256]; + + mylog("%s: entering...stmt=%u\n", func, stmt); + + if (!stmt) + { SC_log_error(func, "", NULL); - return SQL_INVALID_HANDLE; - } + return SQL_INVALID_HANDLE; + } stmt->manual_result = TRUE; stmt->errormsg_created = TRUE; ci = &stmt->hdbc->connInfo; - stmt->result = QR_Constructor(); - if(!stmt->result) { - stmt->errormsg = "Couldn't allocate memory for SQLStatistics result."; - stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->result = QR_Constructor(); + if (!stmt->result) + { + stmt->errormsg = "Couldn't allocate memory for SQLStatistics result."; + stmt->errornumber = STMT_NO_MEMORY_ERROR; SC_log_error(func, "", stmt); - return SQL_ERROR; - } - - /* the binding structure for a statement is not set up until */ - /* a statement is actually executed, so we'll have to do this ourselves. */ - extend_bindings(stmt, 13); - - /* set the field names */ - QR_set_num_fields(stmt->result, 13); - QR_set_field_info(stmt->result, 0, "TABLE_QUALIFIER", PG_TYPE_TEXT, MAX_INFO_STRING); - QR_set_field_info(stmt->result, 1, "TABLE_OWNER", PG_TYPE_TEXT, MAX_INFO_STRING); - QR_set_field_info(stmt->result, 2, "TABLE_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); - QR_set_field_info(stmt->result, 3, "NON_UNIQUE", PG_TYPE_INT2, 2); - QR_set_field_info(stmt->result, 4, "INDEX_QUALIFIER", PG_TYPE_TEXT, MAX_INFO_STRING); - QR_set_field_info(stmt->result, 5, "INDEX_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); - QR_set_field_info(stmt->result, 6, "TYPE", PG_TYPE_INT2, 2); - QR_set_field_info(stmt->result, 7, "SEQ_IN_INDEX", PG_TYPE_INT2, 2); - QR_set_field_info(stmt->result, 8, "COLUMN_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); - QR_set_field_info(stmt->result, 9, "COLLATION", PG_TYPE_CHAR, 1); - QR_set_field_info(stmt->result, 10, "CARDINALITY", PG_TYPE_INT4, 4); - QR_set_field_info(stmt->result, 11, "PAGES", PG_TYPE_INT4, 4); - QR_set_field_info(stmt->result, 12, "FILTER_CONDITION", PG_TYPE_TEXT, MAX_INFO_STRING); - - - /* only use the table name... the owner should be redundant, and */ - /* we never use qualifiers. */ + return SQL_ERROR; + } + + /* the binding structure for a statement is not set up until */ + + /* + * a statement is actually executed, so we'll have to do this + * ourselves. + */ + extend_bindings(stmt, 13); + + /* set the field names */ + QR_set_num_fields(stmt->result, 13); + QR_set_field_info(stmt->result, 0, "TABLE_QUALIFIER", PG_TYPE_TEXT, MAX_INFO_STRING); + QR_set_field_info(stmt->result, 1, "TABLE_OWNER", PG_TYPE_TEXT, MAX_INFO_STRING); + QR_set_field_info(stmt->result, 2, "TABLE_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); + QR_set_field_info(stmt->result, 3, "NON_UNIQUE", PG_TYPE_INT2, 2); + QR_set_field_info(stmt->result, 4, "INDEX_QUALIFIER", PG_TYPE_TEXT, MAX_INFO_STRING); + QR_set_field_info(stmt->result, 5, "INDEX_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); + QR_set_field_info(stmt->result, 6, "TYPE", PG_TYPE_INT2, 2); + QR_set_field_info(stmt->result, 7, "SEQ_IN_INDEX", PG_TYPE_INT2, 2); + QR_set_field_info(stmt->result, 8, "COLUMN_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); + QR_set_field_info(stmt->result, 9, "COLLATION", PG_TYPE_CHAR, 1); + QR_set_field_info(stmt->result, 10, "CARDINALITY", PG_TYPE_INT4, 4); + QR_set_field_info(stmt->result, 11, "PAGES", PG_TYPE_INT4, 4); + QR_set_field_info(stmt->result, 12, "FILTER_CONDITION", PG_TYPE_TEXT, MAX_INFO_STRING); + + + /* only use the table name... the owner should be redundant, and */ + /* we never use qualifiers. */ table_name = make_string(szTableName, cbTableName, NULL); - if ( ! table_name) { - stmt->errormsg = "No table name passed to SQLStatistics."; - stmt->errornumber = STMT_INTERNAL_ERROR; + if (!table_name) + { + stmt->errormsg = "No table name passed to SQLStatistics."; + stmt->errornumber = STMT_INTERNAL_ERROR; SC_log_error(func, "", stmt); - return SQL_ERROR; - } + return SQL_ERROR; + } /* we need to get a list of the field names first, */ /* so we can return them later. */ - result = SQLAllocStmt( stmt->hdbc, &hcol_stmt); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + result = SQLAllocStmt(stmt->hdbc, &hcol_stmt); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = "SQLAllocStmt failed in SQLStatistics for columns."; stmt->errornumber = STMT_NO_MEMORY_ERROR; goto SEEYA; @@ -1838,23 +2128,27 @@ mylog("%s: entering...stmt=%u\n", func, stmt); col_stmt = (StatementClass *) hcol_stmt; - /* "internal" prevents SQLColumns from returning the oid if it is being shown. - This would throw everything off. - */ + /* + * "internal" prevents SQLColumns from returning the oid if it is + * being shown. This would throw everything off. + */ col_stmt->internal = TRUE; - result = SQLColumns(hcol_stmt, "", 0, "", 0, - table_name, (SWORD) strlen(table_name), "", 0); + result = SQLColumns(hcol_stmt, "", 0, "", 0, + table_name, (SWORD) strlen(table_name), "", 0); col_stmt->internal = FALSE; - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { - stmt->errormsg = col_stmt->errormsg; /* "SQLColumns failed in SQLStatistics."; */ - stmt->errornumber = col_stmt->errornumber; /* STMT_EXEC_ERROR; */ - SQLFreeStmt(hcol_stmt, SQL_DROP); - goto SEEYA; + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { + stmt->errormsg = col_stmt->errormsg; /* "SQLColumns failed in + * SQLStatistics."; */ + stmt->errornumber = col_stmt->errornumber; /* STMT_EXEC_ERROR; */ + SQLFreeStmt(hcol_stmt, SQL_DROP); + goto SEEYA; } result = SQLBindCol(hcol_stmt, 4, SQL_C_CHAR, - column_name, MAX_INFO_STRING, &column_name_len); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + column_name, MAX_INFO_STRING, &column_name_len); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = col_stmt->errormsg; stmt->errornumber = col_stmt->errornumber; SQLFreeStmt(hcol_stmt, SQL_DROP); @@ -1863,38 +2157,43 @@ mylog("%s: entering...stmt=%u\n", func, stmt); } result = SQLFetch(hcol_stmt); - while((result == SQL_SUCCESS) || (result == SQL_SUCCESS_WITH_INFO)) { + while ((result == SQL_SUCCESS) || (result == SQL_SUCCESS_WITH_INFO)) + { total_columns++; - column_names = - (char **)realloc(column_names, - total_columns * sizeof(char *)); - column_names[total_columns-1] = - (char *)malloc(strlen(column_name)+1); - strcpy(column_names[total_columns-1], column_name); + column_names = + (char **) realloc(column_names, + total_columns * sizeof(char *)); + column_names[total_columns - 1] = + (char *) malloc(strlen(column_name) + 1); + strcpy(column_names[total_columns - 1], column_name); mylog("SQLStatistics: column_name = '%s'\n", column_name); result = SQLFetch(hcol_stmt); } - if(result != SQL_NO_DATA_FOUND || total_columns == 0) { - stmt->errormsg = SC_create_errormsg(hcol_stmt); /* "Couldn't get column names in SQLStatistics."; */ - stmt->errornumber = col_stmt->errornumber; - SQLFreeStmt(hcol_stmt, SQL_DROP); - goto SEEYA; + if (result != SQL_NO_DATA_FOUND || total_columns == 0) + { + stmt->errormsg = SC_create_errormsg(hcol_stmt); /* "Couldn't get column + * names in + * SQLStatistics."; */ + stmt->errornumber = col_stmt->errornumber; + SQLFreeStmt(hcol_stmt, SQL_DROP); + goto SEEYA; } - + SQLFreeStmt(hcol_stmt, SQL_DROP); /* get a list of indexes on this table */ - result = SQLAllocStmt( stmt->hdbc, &hindx_stmt); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + result = SQLAllocStmt(stmt->hdbc, &hindx_stmt); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = "SQLAllocStmt failed in SQLStatistics for indices."; stmt->errornumber = STMT_NO_MEMORY_ERROR; goto SEEYA; - } + } indx_stmt = (StatementClass *) hindx_stmt; sprintf(index_query, "select c.relname, i.indkey, i.indisunique" @@ -1903,69 +2202,83 @@ mylog("%s: entering...stmt=%u\n", func, stmt); " where c.oid = i.indexrelid and d.relname = '%s'" " and d.oid = i.indrelid", table_name); - result = SQLExecDirect(hindx_stmt, index_query, strlen(index_query)); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { - stmt->errormsg = SC_create_errormsg(hindx_stmt); /* "Couldn't execute index query (w/SQLExecDirect) in SQLStatistics."; */ + result = SQLExecDirect(hindx_stmt, index_query, strlen(index_query)); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { + stmt->errormsg = SC_create_errormsg(hindx_stmt); /* "Couldn't execute + * index query + * (w/SQLExecDirect) in + * SQLStatistics."; */ stmt->errornumber = indx_stmt->errornumber; SQLFreeStmt(hindx_stmt, SQL_DROP); - goto SEEYA; + goto SEEYA; - } + } - /* bind the index name column */ - result = SQLBindCol(hindx_stmt, 1, SQL_C_CHAR, - index_name, MAX_INFO_STRING, &index_name_len); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { - stmt->errormsg = indx_stmt->errormsg; /* "Couldn't bind column in SQLStatistics."; */ + /* bind the index name column */ + result = SQLBindCol(hindx_stmt, 1, SQL_C_CHAR, + index_name, MAX_INFO_STRING, &index_name_len); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { + stmt->errormsg = indx_stmt->errormsg; /* "Couldn't bind column + * in SQLStatistics."; */ stmt->errornumber = indx_stmt->errornumber; SQLFreeStmt(hindx_stmt, SQL_DROP); - goto SEEYA; - - } - /* bind the vector column */ - result = SQLBindCol(hindx_stmt, 2, SQL_C_DEFAULT, - fields_vector, 32, &fields_vector_len); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { - stmt->errormsg = indx_stmt->errormsg; /* "Couldn't bind column in SQLStatistics."; */ + goto SEEYA; + + } + /* bind the vector column */ + result = SQLBindCol(hindx_stmt, 2, SQL_C_DEFAULT, + fields_vector, 32, &fields_vector_len); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { + stmt->errormsg = indx_stmt->errormsg; /* "Couldn't bind column + * in SQLStatistics."; */ stmt->errornumber = indx_stmt->errornumber; SQLFreeStmt(hindx_stmt, SQL_DROP); goto SEEYA; - } - /* bind the "is unique" column */ - result = SQLBindCol(hindx_stmt, 3, SQL_C_CHAR, - isunique, sizeof(isunique), NULL); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { - stmt->errormsg = indx_stmt->errormsg; /* "Couldn't bind column in SQLStatistics."; */ + } + /* bind the "is unique" column */ + result = SQLBindCol(hindx_stmt, 3, SQL_C_CHAR, + isunique, sizeof(isunique), NULL); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { + stmt->errormsg = indx_stmt->errormsg; /* "Couldn't bind column + * in SQLStatistics."; */ stmt->errornumber = indx_stmt->errornumber; SQLFreeStmt(hindx_stmt, SQL_DROP); goto SEEYA; - } + } - /* bind the "is clustered" column */ - result = SQLBindCol(hindx_stmt, 4, SQL_C_CHAR, - isclustered, sizeof(isclustered), NULL); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { - stmt->errormsg = indx_stmt->errormsg; /* "Couldn't bind column in SQLStatistics."; */ + /* bind the "is clustered" column */ + result = SQLBindCol(hindx_stmt, 4, SQL_C_CHAR, + isclustered, sizeof(isclustered), NULL); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { + stmt->errormsg = indx_stmt->errormsg; /* "Couldn't bind column + * in SQLStatistics."; */ stmt->errornumber = indx_stmt->errornumber; SQLFreeStmt(hindx_stmt, SQL_DROP); goto SEEYA; - } + } - result = SQLBindCol(hindx_stmt, 5, SQL_C_CHAR, - relhasrules, MAX_INFO_STRING, NULL); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + result = SQLBindCol(hindx_stmt, 5, SQL_C_CHAR, + relhasrules, MAX_INFO_STRING, NULL); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = indx_stmt->errormsg; stmt->errornumber = indx_stmt->errornumber; SQLFreeStmt(hindx_stmt, SQL_DROP); - goto SEEYA; - } + goto SEEYA; + } - /* fake index of OID */ - if ( relhasrules[0] != '1' && atoi(ci->show_oid_column) && atoi(ci->fake_oid_index)) { - row = (TupleNode *)malloc(sizeof(TupleNode) + - (13 - 1) * sizeof(TupleField)); + /* fake index of OID */ + if (relhasrules[0] != '1' && atoi(ci->show_oid_column) && atoi(ci->fake_oid_index)) + { + row = (TupleNode *) malloc(sizeof(TupleNode) + + (13 - 1) *sizeof(TupleField)); /* no table qualifier */ set_tuplefield_string(&row->tuple[0], ""); @@ -1975,14 +2288,17 @@ mylog("%s: entering...stmt=%u\n", func, stmt); /* non-unique index? */ set_tuplefield_int2(&row->tuple[3], (Int2) (globals.unique_index ? FALSE : TRUE)); - + /* no index qualifier */ set_tuplefield_string(&row->tuple[4], ""); sprintf(buf, "%s_idx_fake_oid", table_name); set_tuplefield_string(&row->tuple[5], buf); - /* Clustered index? I think non-clustered should be type OTHER not HASHED */ + /* + * Clustered index? I think non-clustered should be type OTHER + * not HASHED + */ set_tuplefield_int2(&row->tuple[6], (Int2) SQL_INDEX_OTHER); set_tuplefield_int2(&row->tuple[7], (Int2) 1); @@ -1995,18 +2311,21 @@ mylog("%s: entering...stmt=%u\n", func, stmt); QR_add_tuple(stmt->result, row); } - result = SQLFetch(hindx_stmt); - while((result == SQL_SUCCESS) || (result == SQL_SUCCESS_WITH_INFO)) { + result = SQLFetch(hindx_stmt); + while ((result == SQL_SUCCESS) || (result == SQL_SUCCESS_WITH_INFO)) + { - /* If only requesting unique indexs, then just return those. */ - if (fUnique == SQL_INDEX_ALL || - (fUnique == SQL_INDEX_UNIQUE && atoi(isunique))) { + /* If only requesting unique indexs, then just return those. */ + if (fUnique == SQL_INDEX_ALL || + (fUnique == SQL_INDEX_UNIQUE && atoi(isunique))) + { i = 0; /* add a row in this table for each field in the index */ - while(i < 16 && fields_vector[i] != 0) { + while (i < 16 && fields_vector[i] != 0) + { - row = (TupleNode *)malloc(sizeof(TupleNode) + - (13 - 1) * sizeof(TupleField)); + row = (TupleNode *) malloc(sizeof(TupleNode) + + (13 - 1) *sizeof(TupleField)); /* no table qualifier */ set_tuplefield_string(&row->tuple[0], ""); @@ -2019,26 +2338,32 @@ mylog("%s: entering...stmt=%u\n", func, stmt); set_tuplefield_int2(&row->tuple[3], (Int2) (atoi(isunique) ? FALSE : TRUE)); else set_tuplefield_int2(&row->tuple[3], TRUE); - + /* no index qualifier */ set_tuplefield_string(&row->tuple[4], ""); set_tuplefield_string(&row->tuple[5], index_name); - /* Clustered index? I think non-clustered should be type OTHER not HASHED */ + /* + * Clustered index? I think non-clustered should be type + * OTHER not HASHED + */ set_tuplefield_int2(&row->tuple[6], (Int2) (atoi(isclustered) ? SQL_INDEX_CLUSTERED : SQL_INDEX_OTHER)); - set_tuplefield_int2(&row->tuple[7], (Int2) (i+1)); + set_tuplefield_int2(&row->tuple[7], (Int2) (i + 1)); - if(fields_vector[i] == OID_ATTNUM) { + if (fields_vector[i] == OID_ATTNUM) + { set_tuplefield_string(&row->tuple[8], "oid"); mylog("SQLStatistics: column name = oid\n"); } - else if(fields_vector[i] < 0 || fields_vector[i] > total_columns) { + else if (fields_vector[i] < 0 || fields_vector[i] > total_columns) + { set_tuplefield_string(&row->tuple[8], "UNKNOWN"); mylog("SQLStatistics: column name = UNKNOWN\n"); } - else { - set_tuplefield_string(&row->tuple[8], column_names[fields_vector[i]-1]); - mylog("SQLStatistics: column name = '%s'\n", column_names[fields_vector[i]-1]); + else + { + set_tuplefield_string(&row->tuple[8], column_names[fields_vector[i] - 1]); + mylog("SQLStatistics: column name = '%s'\n", column_names[fields_vector[i] - 1]); } set_tuplefield_string(&row->tuple[9], "A"); @@ -2051,23 +2376,25 @@ mylog("%s: entering...stmt=%u\n", func, stmt); } } - result = SQLFetch(hindx_stmt); - } - if(result != SQL_NO_DATA_FOUND) { - stmt->errormsg = SC_create_errormsg(hindx_stmt); /* "SQLFetch failed in SQLStatistics."; */ + result = SQLFetch(hindx_stmt); + } + if (result != SQL_NO_DATA_FOUND) + { + stmt->errormsg = SC_create_errormsg(hindx_stmt); /* "SQLFetch failed in + * SQLStatistics."; */ stmt->errornumber = indx_stmt->errornumber; SQLFreeStmt(hindx_stmt, SQL_DROP); goto SEEYA; - } + } SQLFreeStmt(hindx_stmt, SQL_DROP); /* also, things need to think that this statement is finished so */ /* the results can be retrieved. */ - stmt->status = STMT_FINISHED; + stmt->status = STMT_FINISHED; - /* set up the current tuple pointer for SQLFetch */ - stmt->currTuple = -1; + /* set up the current tuple pointer for SQLFetch */ + stmt->currTuple = -1; stmt->rowset_start = -1; stmt->current_col = -1; @@ -2076,14 +2403,14 @@ mylog("%s: entering...stmt=%u\n", func, stmt); SEEYA: /* These things should be freed on any error ALSO! */ free(table_name); - for(i = 0; i < total_columns; i++) { + for (i = 0; i < total_columns; i++) free(column_names[i]); - } - free(column_names); + free(column_names); mylog("SQLStatistics(): EXIT, %s, stmt=%u\n", error ? "error" : "success", stmt); - if (error) { + if (error) + { SC_log_error(func, "", stmt); return SQL_ERROR; } @@ -2091,99 +2418,109 @@ SEEYA: return SQL_SUCCESS; } -RETCODE SQL_API SQLColumnPrivileges( - HSTMT hstmt, - UCHAR FAR * szTableQualifier, - SWORD cbTableQualifier, - UCHAR FAR * szTableOwner, - SWORD cbTableOwner, - UCHAR FAR * szTableName, - SWORD cbTableName, - UCHAR FAR * szColumnName, - SWORD cbColumnName) +RETCODE SQL_API +SQLColumnPrivileges( + HSTMT hstmt, + UCHAR FAR *szTableQualifier, + SWORD cbTableQualifier, + UCHAR FAR *szTableOwner, + SWORD cbTableOwner, + UCHAR FAR *szTableName, + SWORD cbTableName, + UCHAR FAR *szColumnName, + SWORD cbColumnName) { -static char *func="SQLColumnPrivileges"; + static char *func = "SQLColumnPrivileges"; mylog("%s: entering...\n", func); /* Neither Access or Borland care about this. */ SC_log_error(func, "Function not implemented", (StatementClass *) hstmt); - return SQL_ERROR; + return SQL_ERROR; } /* SQLPrimaryKeys() * Retrieve the primary key columns for the specified table. */ -RETCODE SQL_API SQLPrimaryKeys( - HSTMT hstmt, - UCHAR FAR * szTableQualifier, - SWORD cbTableQualifier, - UCHAR FAR * szTableOwner, - SWORD cbTableOwner, - UCHAR FAR * szTableName, - SWORD cbTableName) +RETCODE SQL_API +SQLPrimaryKeys( + HSTMT hstmt, + UCHAR FAR *szTableQualifier, + SWORD cbTableQualifier, + UCHAR FAR *szTableOwner, + SWORD cbTableOwner, + UCHAR FAR *szTableName, + SWORD cbTableName) { -static char *func = "SQLPrimaryKeys"; -StatementClass *stmt = (StatementClass *) hstmt; -TupleNode *row; -RETCODE result; -int seq = 0; -HSTMT htbl_stmt; -StatementClass *tbl_stmt; -char tables_query[STD_STATEMENT_LEN]; -char attname[MAX_INFO_STRING]; -SDWORD attname_len; -char pktab[MAX_TABLE_LEN + 1]; -Int2 result_cols; + static char *func = "SQLPrimaryKeys"; + StatementClass *stmt = (StatementClass *) hstmt; + TupleNode *row; + RETCODE result; + int seq = 0; + HSTMT htbl_stmt; + StatementClass *tbl_stmt; + char tables_query[STD_STATEMENT_LEN]; + char attname[MAX_INFO_STRING]; + SDWORD attname_len; + char pktab[MAX_TABLE_LEN + 1]; + Int2 result_cols; mylog("%s: entering...stmt=%u\n", func, stmt); - if( ! stmt) { + if (!stmt) + { SC_log_error(func, "", NULL); - return SQL_INVALID_HANDLE; - } + return SQL_INVALID_HANDLE; + } stmt->manual_result = TRUE; stmt->errormsg_created = TRUE; - stmt->result = QR_Constructor(); - if(!stmt->result) { - stmt->errormsg = "Couldn't allocate memory for SQLPrimaryKeys result."; - stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->result = QR_Constructor(); + if (!stmt->result) + { + stmt->errormsg = "Couldn't allocate memory for SQLPrimaryKeys result."; + stmt->errornumber = STMT_NO_MEMORY_ERROR; SC_log_error(func, "", stmt); - return SQL_ERROR; - } + return SQL_ERROR; + } + + /* the binding structure for a statement is not set up until */ - /* the binding structure for a statement is not set up until */ - /* a statement is actually executed, so we'll have to do this ourselves. */ + /* + * a statement is actually executed, so we'll have to do this + * ourselves. + */ result_cols = 6; - extend_bindings(stmt, result_cols); - - /* set the field names */ - QR_set_num_fields(stmt->result, result_cols); - QR_set_field_info(stmt->result, 0, "TABLE_QUALIFIER", PG_TYPE_TEXT, MAX_INFO_STRING); - QR_set_field_info(stmt->result, 1, "TABLE_OWNER", PG_TYPE_TEXT, MAX_INFO_STRING); - QR_set_field_info(stmt->result, 2, "TABLE_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); - QR_set_field_info(stmt->result, 3, "COLUMN_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); - QR_set_field_info(stmt->result, 4, "KEY_SEQ", PG_TYPE_INT2, 2); - QR_set_field_info(stmt->result, 5, "PK_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); - - - result = SQLAllocStmt( stmt->hdbc, &htbl_stmt); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + extend_bindings(stmt, result_cols); + + /* set the field names */ + QR_set_num_fields(stmt->result, result_cols); + QR_set_field_info(stmt->result, 0, "TABLE_QUALIFIER", PG_TYPE_TEXT, MAX_INFO_STRING); + QR_set_field_info(stmt->result, 1, "TABLE_OWNER", PG_TYPE_TEXT, MAX_INFO_STRING); + QR_set_field_info(stmt->result, 2, "TABLE_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); + QR_set_field_info(stmt->result, 3, "COLUMN_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); + QR_set_field_info(stmt->result, 4, "KEY_SEQ", PG_TYPE_INT2, 2); + QR_set_field_info(stmt->result, 5, "PK_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); + + + result = SQLAllocStmt(stmt->hdbc, &htbl_stmt); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errornumber = STMT_NO_MEMORY_ERROR; stmt->errormsg = "Couldn't allocate statement for Primary Key result."; SC_log_error(func, "", stmt); - return SQL_ERROR; - } + return SQL_ERROR; + } tbl_stmt = (StatementClass *) htbl_stmt; pktab[0] = '\0'; make_string(szTableName, cbTableName, pktab); - if ( pktab[0] == '\0') { + if (pktab[0] == '\0') + { stmt->errormsg = "No Table specified to SQLPrimaryKeys."; - stmt->errornumber = STMT_INTERNAL_ERROR; + stmt->errornumber = STMT_INTERNAL_ERROR; SC_log_error(func, "", stmt); SQLFreeStmt(htbl_stmt, SQL_DROP); return SQL_ERROR; @@ -2192,12 +2529,13 @@ Int2 result_cols; #if 0 sprintf(tables_query, "select distinct on (attnum) a2.attname, a2.attnum from pg_attribute a1, pg_attribute a2, pg_class c, pg_index i where c.relname = '%s_pkey' AND c.oid = i.indexrelid AND a1.attrelid = c.oid AND a2.attrelid = c.oid AND (i.indkey[0] = a1.attnum OR i.indkey[1] = a1.attnum OR i.indkey[2] = a1.attnum OR i.indkey[3] = a1.attnum OR i.indkey[4] = a1.attnum OR i.indkey[5] = a1.attnum OR i.indkey[6] = a1.attnum OR i.indkey[7] = a1.attnum) order by a2.attnum", pktab); #else - /* Simplified query to remove assumptions about - * number of possible index columns. - * Courtesy of Tom Lane - thomas 2000-03-21 + + /* + * Simplified query to remove assumptions about number of possible + * index columns. Courtesy of Tom Lane - thomas 2000-03-21 */ sprintf(tables_query, "select ta.attname, ia.attnum" - " from pg_attribute ta, pg_attribute ia, pg_class c, pg_index i" + " from pg_attribute ta, pg_attribute ia, pg_class c, pg_index i" " where c.relname = '%s_pkey'" " AND c.oid = i.indexrelid" " AND ia.attrelid = i.indexrelid" @@ -2209,174 +2547,200 @@ Int2 result_cols; mylog("SQLPrimaryKeys: tables_query='%s'\n", tables_query); - result = SQLExecDirect(htbl_stmt, tables_query, strlen(tables_query)); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + result = SQLExecDirect(htbl_stmt, tables_query, strlen(tables_query)); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = SC_create_errormsg(htbl_stmt); stmt->errornumber = tbl_stmt->errornumber; SC_log_error(func, "", stmt); SQLFreeStmt(htbl_stmt, SQL_DROP); - return SQL_ERROR; - } + return SQL_ERROR; + } - result = SQLBindCol(htbl_stmt, 1, SQL_C_CHAR, - attname, MAX_INFO_STRING, &attname_len); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + result = SQLBindCol(htbl_stmt, 1, SQL_C_CHAR, + attname, MAX_INFO_STRING, &attname_len); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = tbl_stmt->errormsg; stmt->errornumber = tbl_stmt->errornumber; SC_log_error(func, "", stmt); SQLFreeStmt(htbl_stmt, SQL_DROP); - return SQL_ERROR; - } + return SQL_ERROR; + } - result = SQLFetch(htbl_stmt); + result = SQLFetch(htbl_stmt); - while((result == SQL_SUCCESS) || (result == SQL_SUCCESS_WITH_INFO)) { + while ((result == SQL_SUCCESS) || (result == SQL_SUCCESS_WITH_INFO)) + { - row = (TupleNode *)malloc(sizeof(TupleNode) + (result_cols - 1) * sizeof(TupleField)); + row = (TupleNode *) malloc(sizeof(TupleNode) + (result_cols - 1) *sizeof(TupleField)); - set_tuplefield_null(&row->tuple[0]); + set_tuplefield_null(&row->tuple[0]); - /* I have to hide the table owner from Access, otherwise it - * insists on referring to the table as 'owner.table'. - * (this is valid according to the ODBC SQL grammar, but - * Postgres won't support it.) + /* + * I have to hide the table owner from Access, otherwise it + * insists on referring to the table as 'owner.table'. (this is + * valid according to the ODBC SQL grammar, but Postgres won't + * support it.) */ - set_tuplefield_string(&row->tuple[1], ""); - set_tuplefield_string(&row->tuple[2], pktab); - set_tuplefield_string(&row->tuple[3], attname); + set_tuplefield_string(&row->tuple[1], ""); + set_tuplefield_string(&row->tuple[2], pktab); + set_tuplefield_string(&row->tuple[3], attname); set_tuplefield_int2(&row->tuple[4], (Int2) (++seq)); set_tuplefield_null(&row->tuple[5]); - QR_add_tuple(stmt->result, row); + QR_add_tuple(stmt->result, row); mylog(">> primaryKeys: pktab = '%s', attname = '%s', seq = %d\n", pktab, attname, seq); - result = SQLFetch(htbl_stmt); - } + result = SQLFetch(htbl_stmt); + } - if(result != SQL_NO_DATA_FOUND) { + if (result != SQL_NO_DATA_FOUND) + { stmt->errormsg = SC_create_errormsg(htbl_stmt); stmt->errornumber = tbl_stmt->errornumber; SC_log_error(func, "", stmt); SQLFreeStmt(htbl_stmt, SQL_DROP); - return SQL_ERROR; - } + return SQL_ERROR; + } SQLFreeStmt(htbl_stmt, SQL_DROP); /* also, things need to think that this statement is finished so */ /* the results can be retrieved. */ - stmt->status = STMT_FINISHED; + stmt->status = STMT_FINISHED; - /* set up the current tuple pointer for SQLFetch */ - stmt->currTuple = -1; + /* set up the current tuple pointer for SQLFetch */ + stmt->currTuple = -1; stmt->rowset_start = -1; stmt->current_col = -1; mylog("SQLPrimaryKeys(): EXIT, stmt=%u\n", stmt); - return SQL_SUCCESS; + return SQL_SUCCESS; } -RETCODE SQL_API SQLForeignKeys( - HSTMT hstmt, - UCHAR FAR * szPkTableQualifier, - SWORD cbPkTableQualifier, - UCHAR FAR * szPkTableOwner, - SWORD cbPkTableOwner, - UCHAR FAR * szPkTableName, - SWORD cbPkTableName, - UCHAR FAR * szFkTableQualifier, - SWORD cbFkTableQualifier, - UCHAR FAR * szFkTableOwner, - SWORD cbFkTableOwner, - UCHAR FAR * szFkTableName, - SWORD cbFkTableName) +RETCODE SQL_API +SQLForeignKeys( + HSTMT hstmt, + UCHAR FAR *szPkTableQualifier, + SWORD cbPkTableQualifier, + UCHAR FAR *szPkTableOwner, + SWORD cbPkTableOwner, + UCHAR FAR *szPkTableName, + SWORD cbPkTableName, + UCHAR FAR *szFkTableQualifier, + SWORD cbFkTableQualifier, + UCHAR FAR *szFkTableOwner, + SWORD cbFkTableOwner, + UCHAR FAR *szFkTableName, + SWORD cbFkTableName) { -static char *func = "SQLForeignKeys"; -StatementClass *stmt = (StatementClass *) hstmt; -TupleNode *row; -HSTMT htbl_stmt, hpkey_stmt; -StatementClass *tbl_stmt; -RETCODE result, keyresult; -char tables_query[STD_STATEMENT_LEN]; -char trig_deferrable[2]; -char trig_initdeferred[2]; -char trig_args[1024]; -char upd_rule[MAX_TABLE_LEN], del_rule[MAX_TABLE_LEN]; -char pk_table_needed[MAX_TABLE_LEN + 1]; -char fk_table_needed[MAX_TABLE_LEN + 1]; -char *pkey_ptr, *fkey_ptr, *pk_table, *fk_table; -int i, j, k, num_keys; -SWORD trig_nargs, upd_rule_type=0, del_rule_type=0; + static char *func = "SQLForeignKeys"; + StatementClass *stmt = (StatementClass *) hstmt; + TupleNode *row; + HSTMT htbl_stmt, + hpkey_stmt; + StatementClass *tbl_stmt; + RETCODE result, + keyresult; + char tables_query[STD_STATEMENT_LEN]; + char trig_deferrable[2]; + char trig_initdeferred[2]; + char trig_args[1024]; + char upd_rule[MAX_TABLE_LEN], + del_rule[MAX_TABLE_LEN]; + char pk_table_needed[MAX_TABLE_LEN + 1]; + char fk_table_needed[MAX_TABLE_LEN + 1]; + char *pkey_ptr, + *fkey_ptr, + *pk_table, + *fk_table; + int i, + j, + k, + num_keys; + SWORD trig_nargs, + upd_rule_type = 0, + del_rule_type = 0; + #if (ODBCVER >= 0x0300) -SWORD defer_type; + SWORD defer_type; + #endif -char pkey[MAX_INFO_STRING]; -Int2 result_cols; + char pkey[MAX_INFO_STRING]; + Int2 result_cols; mylog("%s: entering...stmt=%u\n", func, stmt); - if( ! stmt) { + if (!stmt) + { SC_log_error(func, "", NULL); - return SQL_INVALID_HANDLE; - } - + return SQL_INVALID_HANDLE; + } + stmt->manual_result = TRUE; stmt->errormsg_created = TRUE; - stmt->result = QR_Constructor(); - if(!stmt->result) { + stmt->result = QR_Constructor(); + if (!stmt->result) + { stmt->errormsg = "Couldn't allocate memory for SQLForeignKeys result."; - stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errornumber = STMT_NO_MEMORY_ERROR; SC_log_error(func, "", stmt); - return SQL_ERROR; - } + return SQL_ERROR; + } + + /* the binding structure for a statement is not set up until */ - /* the binding structure for a statement is not set up until */ - /* a statement is actually executed, so we'll have to do this ourselves. */ + /* + * a statement is actually executed, so we'll have to do this + * ourselves. + */ result_cols = 14; - extend_bindings(stmt, result_cols); - - /* set the field names */ - QR_set_num_fields(stmt->result, result_cols); - QR_set_field_info(stmt->result, 0, "PKTABLE_QUALIFIER", PG_TYPE_TEXT, MAX_INFO_STRING); - QR_set_field_info(stmt->result, 1, "PKTABLE_OWNER", PG_TYPE_TEXT, MAX_INFO_STRING); - QR_set_field_info(stmt->result, 2, "PKTABLE_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); - QR_set_field_info(stmt->result, 3, "PKCOLUMN_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); - QR_set_field_info(stmt->result, 4, "FKTABLE_QUALIFIER", PG_TYPE_TEXT, MAX_INFO_STRING); - QR_set_field_info(stmt->result, 5, "FKTABLE_OWNER", PG_TYPE_TEXT, MAX_INFO_STRING); - QR_set_field_info(stmt->result, 6, "FKTABLE_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); - QR_set_field_info(stmt->result, 7, "FKCOLUMN_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); - QR_set_field_info(stmt->result, 8, "KEY_SEQ", PG_TYPE_INT2, 2); - QR_set_field_info(stmt->result, 9, "UPDATE_RULE", PG_TYPE_INT2, 2); - QR_set_field_info(stmt->result, 10, "DELETE_RULE", PG_TYPE_INT2, 2); - QR_set_field_info(stmt->result, 11, "FK_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); - QR_set_field_info(stmt->result, 12, "PK_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); - QR_set_field_info(stmt->result, 13, "TRIGGER_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); + extend_bindings(stmt, result_cols); + + /* set the field names */ + QR_set_num_fields(stmt->result, result_cols); + QR_set_field_info(stmt->result, 0, "PKTABLE_QUALIFIER", PG_TYPE_TEXT, MAX_INFO_STRING); + QR_set_field_info(stmt->result, 1, "PKTABLE_OWNER", PG_TYPE_TEXT, MAX_INFO_STRING); + QR_set_field_info(stmt->result, 2, "PKTABLE_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); + QR_set_field_info(stmt->result, 3, "PKCOLUMN_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); + QR_set_field_info(stmt->result, 4, "FKTABLE_QUALIFIER", PG_TYPE_TEXT, MAX_INFO_STRING); + QR_set_field_info(stmt->result, 5, "FKTABLE_OWNER", PG_TYPE_TEXT, MAX_INFO_STRING); + QR_set_field_info(stmt->result, 6, "FKTABLE_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); + QR_set_field_info(stmt->result, 7, "FKCOLUMN_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); + QR_set_field_info(stmt->result, 8, "KEY_SEQ", PG_TYPE_INT2, 2); + QR_set_field_info(stmt->result, 9, "UPDATE_RULE", PG_TYPE_INT2, 2); + QR_set_field_info(stmt->result, 10, "DELETE_RULE", PG_TYPE_INT2, 2); + QR_set_field_info(stmt->result, 11, "FK_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); + QR_set_field_info(stmt->result, 12, "PK_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); + QR_set_field_info(stmt->result, 13, "TRIGGER_NAME", PG_TYPE_TEXT, MAX_INFO_STRING); #if (ODBCVER >= 0x0300) QR_set_field_info(stmt->result, 14, "DEFERRABILITY", PG_TYPE_INT2, 2); -#endif /* ODBCVER >= 0x0300 */ +#endif /* ODBCVER >= 0x0300 */ - /* also, things need to think that this statement is finished so */ - /* the results can be retrieved. */ - stmt->status = STMT_FINISHED; + /* also, things need to think that this statement is finished so */ + /* the results can be retrieved. */ + stmt->status = STMT_FINISHED; - /* set up the current tuple pointer for SQLFetch */ - stmt->currTuple = -1; + /* set up the current tuple pointer for SQLFetch */ + stmt->currTuple = -1; stmt->rowset_start = -1; stmt->current_col = -1; - result = SQLAllocStmt( stmt->hdbc, &htbl_stmt); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + result = SQLAllocStmt(stmt->hdbc, &htbl_stmt); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errornumber = STMT_NO_MEMORY_ERROR; stmt->errormsg = "Couldn't allocate statement for SQLForeignKeys result."; SC_log_error(func, "", stmt); - return SQL_ERROR; - } + return SQL_ERROR; + } tbl_stmt = (StatementClass *) htbl_stmt; @@ -2386,53 +2750,57 @@ Int2 result_cols; make_string(szPkTableName, cbPkTableName, pk_table_needed); make_string(szFkTableName, cbFkTableName, fk_table_needed); - /* Case #2 -- Get the foreign keys in the specified table (fktab) that - refer to the primary keys of other table(s). - */ - if (fk_table_needed[0] != '\0') { + /* + * Case #2 -- Get the foreign keys in the specified table (fktab) that + * refer to the primary keys of other table(s). + */ + if (fk_table_needed[0] != '\0') + { mylog("%s: entering Foreign Key Case #2", func); sprintf(tables_query, "SELECT pt.tgargs, " - " pt.tgnargs, " - " pt.tgdeferrable, " - " pt.tginitdeferred, " - " pg_proc.proname, " - " pg_proc_1.proname " - "FROM pg_class pc, " - " pg_proc pg_proc, " - " pg_proc pg_proc_1, " - " pg_trigger pg_trigger, " - " pg_trigger pg_trigger_1, " - " pg_proc pp, " - " pg_trigger pt " - "WHERE pt.tgrelid = pc.oid " - "AND pp.oid = pt.tgfoid " - "AND pg_trigger.tgconstrrelid = pc.oid " - "AND pg_proc.oid = pg_trigger.tgfoid " - "AND pg_trigger_1.tgfoid = pg_proc_1.oid " - "AND pg_trigger_1.tgconstrrelid = pc.oid " - "AND ((pc.relname='%s') " - "AND (pp.proname LIKE '%%ins') " - "AND (pg_proc.proname LIKE '%%upd') " - "AND (pg_proc_1.proname LIKE '%%del') " - "AND (pg_trigger.tgrelid=pt.tgconstrrelid) " - "AND (pg_trigger.tgconstrname=pt.tgconstrname) " - "AND (pg_trigger_1.tgrelid=pt.tgconstrrelid) " - "AND (pg_trigger_1.tgconstrname=pt.tgconstrname))", - fk_table_needed); + " pt.tgnargs, " + " pt.tgdeferrable, " + " pt.tginitdeferred, " + " pg_proc.proname, " + " pg_proc_1.proname " + "FROM pg_class pc, " + " pg_proc pg_proc, " + " pg_proc pg_proc_1, " + " pg_trigger pg_trigger, " + " pg_trigger pg_trigger_1, " + " pg_proc pp, " + " pg_trigger pt " + "WHERE pt.tgrelid = pc.oid " + "AND pp.oid = pt.tgfoid " + "AND pg_trigger.tgconstrrelid = pc.oid " + "AND pg_proc.oid = pg_trigger.tgfoid " + "AND pg_trigger_1.tgfoid = pg_proc_1.oid " + "AND pg_trigger_1.tgconstrrelid = pc.oid " + "AND ((pc.relname='%s') " + "AND (pp.proname LIKE '%%ins') " + "AND (pg_proc.proname LIKE '%%upd') " + "AND (pg_proc_1.proname LIKE '%%del') " + "AND (pg_trigger.tgrelid=pt.tgconstrrelid) " + "AND (pg_trigger.tgconstrname=pt.tgconstrname) " + "AND (pg_trigger_1.tgrelid=pt.tgconstrrelid) " + "AND (pg_trigger_1.tgconstrname=pt.tgconstrname))", + fk_table_needed); result = SQLExecDirect(htbl_stmt, tables_query, strlen(tables_query)); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = SC_create_errormsg(htbl_stmt); stmt->errornumber = tbl_stmt->errornumber; SC_log_error(func, "", stmt); - SQLFreeStmt(htbl_stmt, SQL_DROP); + SQLFreeStmt(htbl_stmt, SQL_DROP); return SQL_ERROR; } result = SQLBindCol(htbl_stmt, 1, SQL_C_BINARY, trig_args, sizeof(trig_args), NULL); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = tbl_stmt->errormsg; stmt->errornumber = tbl_stmt->errornumber; SC_log_error(func, "", stmt); @@ -2442,7 +2810,8 @@ Int2 result_cols; result = SQLBindCol(htbl_stmt, 2, SQL_C_SHORT, &trig_nargs, 0, NULL); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = tbl_stmt->errormsg; stmt->errornumber = tbl_stmt->errornumber; SC_log_error(func, "", stmt); @@ -2451,8 +2820,9 @@ Int2 result_cols; } result = SQLBindCol(htbl_stmt, 3, SQL_C_CHAR, - trig_deferrable, sizeof(trig_deferrable), NULL); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + trig_deferrable, sizeof(trig_deferrable), NULL); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = tbl_stmt->errormsg; stmt->errornumber = tbl_stmt->errornumber; SC_log_error(func, "", stmt); @@ -2461,8 +2831,9 @@ Int2 result_cols; } result = SQLBindCol(htbl_stmt, 4, SQL_C_CHAR, - trig_initdeferred, sizeof(trig_initdeferred), NULL); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + trig_initdeferred, sizeof(trig_initdeferred), NULL); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = tbl_stmt->errormsg; stmt->errornumber = tbl_stmt->errornumber; SC_log_error(func, "", stmt); @@ -2472,7 +2843,8 @@ Int2 result_cols; result = SQLBindCol(htbl_stmt, 5, SQL_C_CHAR, upd_rule, sizeof(upd_rule), NULL); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = tbl_stmt->errormsg; stmt->errornumber = tbl_stmt->errornumber; SC_log_error(func, "", stmt); @@ -2482,7 +2854,8 @@ Int2 result_cols; result = SQLBindCol(htbl_stmt, 6, SQL_C_CHAR, del_rule, sizeof(del_rule), NULL); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = tbl_stmt->errormsg; stmt->errornumber = tbl_stmt->errornumber; SC_log_error(func, "", stmt); @@ -2494,7 +2867,8 @@ Int2 result_cols; if (result == SQL_NO_DATA_FOUND) return SQL_SUCCESS; - if(result != SQL_SUCCESS) { + if (result != SQL_SUCCESS) + { stmt->errormsg = SC_create_errormsg(htbl_stmt); stmt->errornumber = tbl_stmt->errornumber; SC_log_error(func, "", stmt); @@ -2502,8 +2876,9 @@ Int2 result_cols; return SQL_ERROR; } - keyresult = SQLAllocStmt( stmt->hdbc, &hpkey_stmt); - if((keyresult != SQL_SUCCESS) && (keyresult != SQL_SUCCESS_WITH_INFO)) { + keyresult = SQLAllocStmt(stmt->hdbc, &hpkey_stmt); + if ((keyresult != SQL_SUCCESS) && (keyresult != SQL_SUCCESS_WITH_INFO)) + { stmt->errornumber = STMT_NO_MEMORY_ERROR; stmt->errormsg = "Couldn't allocate statement for SQLForeignKeys (pkeys) result."; SC_log_error(func, "", stmt); @@ -2511,8 +2886,9 @@ Int2 result_cols; } keyresult = SQLBindCol(hpkey_stmt, 4, SQL_C_CHAR, - pkey, sizeof(pkey), NULL); - if (keyresult != SQL_SUCCESS) { + pkey, sizeof(pkey), NULL); + if (keyresult != SQL_SUCCESS) + { stmt->errornumber = STMT_NO_MEMORY_ERROR; stmt->errormsg = "Couldn't bindcol for primary keys for SQLForeignKeys result."; SC_log_error(func, "", stmt); @@ -2520,31 +2896,35 @@ Int2 result_cols; return SQL_ERROR; } - while (result == SQL_SUCCESS) { + while (result == SQL_SUCCESS) + { - /* Compute the number of keyparts. */ + /* Compute the number of keyparts. */ num_keys = (trig_nargs - 4) / 2; mylog("Foreign Key Case#2: trig_nargs = %d, num_keys = %d\n", trig_nargs, num_keys); pk_table = trig_args; - /* Get to the PK Table Name */ + /* Get to the PK Table Name */ for (k = 0; k < 2; k++) pk_table += strlen(pk_table) + 1; - /* If there is a pk table specified, then check it. */ - if (pk_table_needed[0] != '\0') { + /* If there is a pk table specified, then check it. */ + if (pk_table_needed[0] != '\0') + { - /* If it doesn't match, then continue */ - if ( strcmp(pk_table, pk_table_needed)) { + /* If it doesn't match, then continue */ + if (strcmp(pk_table, pk_table_needed)) + { result = SQLFetch(htbl_stmt); continue; } } keyresult = SQLPrimaryKeys(hpkey_stmt, NULL, 0, NULL, 0, pk_table, SQL_NTS); - if (keyresult != SQL_SUCCESS) { + if (keyresult != SQL_SUCCESS) + { stmt->errornumber = STMT_NO_MEMORY_ERROR; stmt->errormsg = "Couldn't get primary keys for SQLForeignKeys result."; SC_log_error(func, "", stmt); @@ -2553,77 +2933,77 @@ Int2 result_cols; } - /* Check that the key listed is the primary key */ + /* Check that the key listed is the primary key */ keyresult = SQLFetch(hpkey_stmt); - /* Get to first primary key */ + /* Get to first primary key */ pkey_ptr = trig_args; for (i = 0; i < 5; i++) pkey_ptr += strlen(pkey_ptr) + 1; - for (k = 0; k < num_keys; k++) { + for (k = 0; k < num_keys; k++) + { mylog("%s: pkey_ptr='%s', pkey='%s'\n", func, pkey_ptr, pkey); - if ( keyresult != SQL_SUCCESS || strcmp(pkey_ptr, pkey)) { + if (keyresult != SQL_SUCCESS || strcmp(pkey_ptr, pkey)) + { num_keys = 0; break; } - /* Get to next primary key */ + /* Get to next primary key */ for (k = 0; k < 2; k++) pkey_ptr += strlen(pkey_ptr) + 1; keyresult = SQLFetch(hpkey_stmt); } - /* Set to first fk column */ + /* Set to first fk column */ fkey_ptr = trig_args; for (k = 0; k < 4; k++) fkey_ptr += strlen(fkey_ptr) + 1; /* Set update and delete actions for foreign keys */ - if (!strcmp(upd_rule, "RI_FKey_cascade_upd")) { + if (!strcmp(upd_rule, "RI_FKey_cascade_upd")) upd_rule_type = SQL_CASCADE; - } else if (!strcmp(upd_rule, "RI_FKey_noaction_upd")) { + else if (!strcmp(upd_rule, "RI_FKey_noaction_upd")) upd_rule_type = SQL_NO_ACTION; - } else if (!strcmp(upd_rule, "RI_FKey_restrict_upd")) { + else if (!strcmp(upd_rule, "RI_FKey_restrict_upd")) upd_rule_type = SQL_NO_ACTION; - } else if (!strcmp(upd_rule, "RI_FKey_setdefault_upd")) { + else if (!strcmp(upd_rule, "RI_FKey_setdefault_upd")) upd_rule_type = SQL_SET_DEFAULT; - } else if (!strcmp(upd_rule, "RI_FKey_setnull_upd")) { + else if (!strcmp(upd_rule, "RI_FKey_setnull_upd")) upd_rule_type = SQL_SET_NULL; - } - - if (!strcmp(upd_rule, "RI_FKey_cascade_del")) { + + if (!strcmp(upd_rule, "RI_FKey_cascade_del")) del_rule_type = SQL_CASCADE; - } else if (!strcmp(upd_rule, "RI_FKey_noaction_del")) { + else if (!strcmp(upd_rule, "RI_FKey_noaction_del")) del_rule_type = SQL_NO_ACTION; - } else if (!strcmp(upd_rule, "RI_FKey_restrict_del")) { + else if (!strcmp(upd_rule, "RI_FKey_restrict_del")) del_rule_type = SQL_NO_ACTION; - } else if (!strcmp(upd_rule, "RI_FKey_setdefault_del")) { + else if (!strcmp(upd_rule, "RI_FKey_setdefault_del")) del_rule_type = SQL_SET_DEFAULT; - } else if (!strcmp(upd_rule, "RI_FKey_setnull_del")) { + else if (!strcmp(upd_rule, "RI_FKey_setnull_del")) del_rule_type = SQL_SET_NULL; - } #if (ODBCVER >= 0x0300) /* Set deferrability type */ - if (!strcmp(trig_initdeferred, "y")) { + if (!strcmp(trig_initdeferred, "y")) defer_type = SQL_INITIALLY_DEFERRED; - } else if (!strcmp(trig_deferrable, "y")) { + else if (!strcmp(trig_deferrable, "y")) defer_type = SQL_INITIALLY_IMMEDIATE; - } else { + else defer_type = SQL_NOT_DEFERRABLE; - } -#endif /* ODBCVER >= 0x0300 */ +#endif /* ODBCVER >= 0x0300 */ - /* Get to first primary key */ + /* Get to first primary key */ pkey_ptr = trig_args; for (i = 0; i < 5; i++) pkey_ptr += strlen(pkey_ptr) + 1; - for (k = 0; k < num_keys; k++) { + for (k = 0; k < num_keys; k++) + { - row = (TupleNode *)malloc(sizeof(TupleNode) + (result_cols - 1) * sizeof(TupleField)); + row = (TupleNode *) malloc(sizeof(TupleNode) + (result_cols - 1) *sizeof(TupleField)); mylog("%s: pk_table = '%s', pkey_ptr = '%s'\n", func, pk_table, pkey_ptr); set_tuplefield_null(&row->tuple[0]); @@ -2646,12 +3026,13 @@ Int2 result_cols; set_tuplefield_string(&row->tuple[13], trig_args); #if (ODBCVER >= 0x0300) set_tuplefield_int2(&row->tuple[14], defer_type); -#endif /* ODBCVER >= 0x0300 */ +#endif /* ODBCVER >= 0x0300 */ QR_add_tuple(stmt->result, row); /* next primary/foreign key */ - for (i = 0; i < 2; i++) { + for (i = 0; i < 2; i++) + { fkey_ptr += strlen(fkey_ptr) + 1; pkey_ptr += strlen(pkey_ptr) + 1; } @@ -2662,53 +3043,58 @@ Int2 result_cols; SQLFreeStmt(hpkey_stmt, SQL_DROP); } - /* Case #1 -- Get the foreign keys in other tables that refer to the primary key - in the specified table (pktab). i.e., Who points to me? - */ - else if (pk_table_needed[0] != '\0') { + /* + * Case #1 -- Get the foreign keys in other tables that refer to the + * primary key in the specified table (pktab). i.e., Who points to + * me? + */ + else if (pk_table_needed[0] != '\0') + { sprintf(tables_query, "SELECT pg_trigger.tgargs, " - " pg_trigger.tgnargs, " - " pg_trigger.tgdeferrable, " - " pg_trigger.tginitdeferred, " - " pg_proc.proname, " - " pg_proc_1.proname " - "FROM pg_class pg_class, " - " pg_class pg_class_1, " - " pg_class pg_class_2, " - " pg_proc pg_proc, " - " pg_proc pg_proc_1, " - " pg_trigger pg_trigger, " - " pg_trigger pg_trigger_1, " - " pg_trigger pg_trigger_2 " - "WHERE pg_trigger.tgconstrrelid = pg_class.oid " - " AND pg_trigger.tgrelid = pg_class_1.oid " - " AND pg_trigger_1.tgfoid = pg_proc_1.oid " - " AND pg_trigger_1.tgconstrrelid = pg_class_1.oid " - " AND pg_trigger_2.tgconstrrelid = pg_class_2.oid " - " AND pg_trigger_2.tgfoid = pg_proc.oid " - " AND pg_class_2.oid = pg_trigger.tgrelid " - " AND (" - " (pg_class.relname='%s') " - " AND (pg_proc.proname Like '%%upd') " - " AND (pg_proc_1.proname Like '%%del')" - " AND (pg_trigger_1.tgrelid = pg_trigger.tgconstrrelid) " - " AND (pg_trigger_2.tgrelid = pg_trigger.tgconstrrelid) " - " )", + " pg_trigger.tgnargs, " + " pg_trigger.tgdeferrable, " + " pg_trigger.tginitdeferred, " + " pg_proc.proname, " + " pg_proc_1.proname " + "FROM pg_class pg_class, " + " pg_class pg_class_1, " + " pg_class pg_class_2, " + " pg_proc pg_proc, " + " pg_proc pg_proc_1, " + " pg_trigger pg_trigger, " + " pg_trigger pg_trigger_1, " + " pg_trigger pg_trigger_2 " + "WHERE pg_trigger.tgconstrrelid = pg_class.oid " + " AND pg_trigger.tgrelid = pg_class_1.oid " + " AND pg_trigger_1.tgfoid = pg_proc_1.oid " + " AND pg_trigger_1.tgconstrrelid = pg_class_1.oid " + " AND pg_trigger_2.tgconstrrelid = pg_class_2.oid " + " AND pg_trigger_2.tgfoid = pg_proc.oid " + " AND pg_class_2.oid = pg_trigger.tgrelid " + " AND (" + " (pg_class.relname='%s') " + " AND (pg_proc.proname Like '%%upd') " + " AND (pg_proc_1.proname Like '%%del')" + " AND (pg_trigger_1.tgrelid = pg_trigger.tgconstrrelid) " + " AND (pg_trigger_2.tgrelid = pg_trigger.tgconstrrelid) " + " )", pk_table_needed); result = SQLExecDirect(htbl_stmt, tables_query, strlen(tables_query)); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = SC_create_errormsg(htbl_stmt); stmt->errornumber = tbl_stmt->errornumber; SC_log_error(func, "", stmt); - SQLFreeStmt(htbl_stmt, SQL_DROP); + SQLFreeStmt(htbl_stmt, SQL_DROP); return SQL_ERROR; } result = SQLBindCol(htbl_stmt, 1, SQL_C_BINARY, trig_args, sizeof(trig_args), NULL); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = tbl_stmt->errormsg; stmt->errornumber = tbl_stmt->errornumber; SC_log_error(func, "", stmt); @@ -2718,7 +3104,8 @@ Int2 result_cols; result = SQLBindCol(htbl_stmt, 2, SQL_C_SHORT, &trig_nargs, 0, NULL); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = tbl_stmt->errormsg; stmt->errornumber = tbl_stmt->errornumber; SC_log_error(func, "", stmt); @@ -2727,8 +3114,9 @@ Int2 result_cols; } result = SQLBindCol(htbl_stmt, 3, SQL_C_CHAR, - trig_deferrable, sizeof(trig_deferrable), NULL); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + trig_deferrable, sizeof(trig_deferrable), NULL); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = tbl_stmt->errormsg; stmt->errornumber = tbl_stmt->errornumber; SC_log_error(func, "", stmt); @@ -2737,8 +3125,9 @@ Int2 result_cols; } result = SQLBindCol(htbl_stmt, 4, SQL_C_CHAR, - trig_initdeferred, sizeof(trig_initdeferred), NULL); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + trig_initdeferred, sizeof(trig_initdeferred), NULL); + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = tbl_stmt->errormsg; stmt->errornumber = tbl_stmt->errornumber; SC_log_error(func, "", stmt); @@ -2748,7 +3137,8 @@ Int2 result_cols; result = SQLBindCol(htbl_stmt, 5, SQL_C_CHAR, upd_rule, sizeof(upd_rule), NULL); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = tbl_stmt->errormsg; stmt->errornumber = tbl_stmt->errornumber; SC_log_error(func, "", stmt); @@ -2758,7 +3148,8 @@ Int2 result_cols; result = SQLBindCol(htbl_stmt, 6, SQL_C_CHAR, del_rule, sizeof(del_rule), NULL); - if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { + if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) + { stmt->errormsg = tbl_stmt->errormsg; stmt->errornumber = tbl_stmt->errornumber; SC_log_error(func, "", stmt); @@ -2770,7 +3161,8 @@ Int2 result_cols; if (result == SQL_NO_DATA_FOUND) return SQL_SUCCESS; - if(result != SQL_SUCCESS) { + if (result != SQL_SUCCESS) + { stmt->errormsg = SC_create_errormsg(htbl_stmt); stmt->errornumber = tbl_stmt->errornumber; SC_log_error(func, "", stmt); @@ -2778,79 +3170,78 @@ Int2 result_cols; return SQL_ERROR; } - while (result == SQL_SUCCESS) { + while (result == SQL_SUCCESS) + { - /* Calculate the number of key parts */ + /* Calculate the number of key parts */ num_keys = (trig_nargs - 4) / 2;; - /* Handle action (i.e., 'cascade', 'restrict', 'setnull') */ - if (!strcmp(upd_rule, "RI_FKey_cascade_upd")) { + /* Handle action (i.e., 'cascade', 'restrict', 'setnull') */ + if (!strcmp(upd_rule, "RI_FKey_cascade_upd")) upd_rule_type = SQL_CASCADE; - } else if (!strcmp(upd_rule, "RI_FKey_noaction_upd")) { + else if (!strcmp(upd_rule, "RI_FKey_noaction_upd")) upd_rule_type = SQL_NO_ACTION; - } else if (!strcmp(upd_rule, "RI_FKey_restrict_upd")) { + else if (!strcmp(upd_rule, "RI_FKey_restrict_upd")) upd_rule_type = SQL_NO_ACTION; - } else if (!strcmp(upd_rule, "RI_FKey_setdefault_upd")) { + else if (!strcmp(upd_rule, "RI_FKey_setdefault_upd")) upd_rule_type = SQL_SET_DEFAULT; - } else if (!strcmp(upd_rule, "RI_FKey_setnull_upd")) { + else if (!strcmp(upd_rule, "RI_FKey_setnull_upd")) upd_rule_type = SQL_SET_NULL; - } - - if (!strcmp(upd_rule, "RI_FKey_cascade_del")) { + + if (!strcmp(upd_rule, "RI_FKey_cascade_del")) del_rule_type = SQL_CASCADE; - } else if (!strcmp(upd_rule, "RI_FKey_noaction_del")) { + else if (!strcmp(upd_rule, "RI_FKey_noaction_del")) del_rule_type = SQL_NO_ACTION; - } else if (!strcmp(upd_rule, "RI_FKey_restrict_del")) { + else if (!strcmp(upd_rule, "RI_FKey_restrict_del")) del_rule_type = SQL_NO_ACTION; - } else if (!strcmp(upd_rule, "RI_FKey_setdefault_del")) { + else if (!strcmp(upd_rule, "RI_FKey_setdefault_del")) del_rule_type = SQL_SET_DEFAULT; - } else if (!strcmp(upd_rule, "RI_FKey_setnull_del")) { + else if (!strcmp(upd_rule, "RI_FKey_setnull_del")) del_rule_type = SQL_SET_NULL; - } #if (ODBCVER >= 0x0300) /* Set deferrability type */ - if (!strcmp(trig_initdeferred, "y")) { + if (!strcmp(trig_initdeferred, "y")) defer_type = SQL_INITIALLY_DEFERRED; - } else if (!strcmp(trig_deferrable, "y")) { + else if (!strcmp(trig_deferrable, "y")) defer_type = SQL_INITIALLY_IMMEDIATE; - } else { + else defer_type = SQL_NOT_DEFERRABLE; - } -#endif /* ODBCVER >= 0x0300 */ +#endif /* ODBCVER >= 0x0300 */ mylog("Foreign Key Case#1: trig_nargs = %d, num_keys = %d\n", trig_nargs, num_keys); - /* Get to first primary key */ + /* Get to first primary key */ pkey_ptr = trig_args; for (i = 0; i < 5; i++) pkey_ptr += strlen(pkey_ptr) + 1; - /* Get to first foreign table */ + /* Get to first foreign table */ fk_table = trig_args; fk_table += strlen(fk_table) + 1; /* Get to first foreign key */ fkey_ptr = trig_args; - for (k = 0; k < 4; k++) + for (k = 0; k < 4; k++) fkey_ptr += strlen(fkey_ptr) + 1; - for (k = 0; k < num_keys; k++) { + for (k = 0; k < num_keys; k++) + { mylog("pkey_ptr = '%s', fk_table = '%s', fkey_ptr = '%s'\n", pkey_ptr, fk_table, fkey_ptr); - row = (TupleNode *)malloc(sizeof(TupleNode) + (result_cols - 1) * sizeof(TupleField)); + row = (TupleNode *) malloc(sizeof(TupleNode) + (result_cols - 1) *sizeof(TupleField)); mylog("pk_table_needed = '%s', pkey_ptr = '%s'\n", pk_table_needed, pkey_ptr); - set_tuplefield_null(&row->tuple[0]); - set_tuplefield_string(&row->tuple[1], ""); + set_tuplefield_null(&row->tuple[0]); + set_tuplefield_string(&row->tuple[1], ""); set_tuplefield_string(&row->tuple[2], pk_table_needed); set_tuplefield_string(&row->tuple[3], pkey_ptr); mylog("fk_table = '%s', fkey_ptr = '%s'\n", fk_table, fkey_ptr); - set_tuplefield_null(&row->tuple[4]); - set_tuplefield_string(&row->tuple[5], ""); + set_tuplefield_null(&row->tuple[4]); + set_tuplefield_string(&row->tuple[5], ""); set_tuplefield_string(&row->tuple[6], fk_table); set_tuplefield_string(&row->tuple[7], fkey_ptr); @@ -2860,20 +3251,21 @@ Int2 result_cols; set_nullfield_int2(&row->tuple[9], (Int2) upd_rule_type); set_nullfield_int2(&row->tuple[10], (Int2) del_rule_type); - set_tuplefield_null(&row->tuple[11]); - set_tuplefield_null(&row->tuple[12]); + set_tuplefield_null(&row->tuple[11]); + set_tuplefield_null(&row->tuple[12]); set_tuplefield_string(&row->tuple[13], trig_args); #if (ODBCVER >= 0x0300) mylog("defer_type = '%s'", defer_type); set_tuplefield_int2(&row->tuple[14], defer_type); -#endif /* ODBCVER >= 0x0300 */ +#endif /* ODBCVER >= 0x0300 */ QR_add_tuple(stmt->result, row); - /* next primary/foreign key */ - for (j = 0; j < 2; j++) { + /* next primary/foreign key */ + for (j = 0; j < 2; j++) + { pkey_ptr += strlen(pkey_ptr) + 1; fkey_ptr += strlen(fkey_ptr) + 1; } @@ -2881,8 +3273,9 @@ Int2 result_cols; result = SQLFetch(htbl_stmt); } - } - else { + } + else + { stmt->errormsg = "No tables specified to SQLForeignKeys."; stmt->errornumber = STMT_INTERNAL_ERROR; SC_log_error(func, "", stmt); @@ -2893,60 +3286,63 @@ Int2 result_cols; SQLFreeStmt(htbl_stmt, SQL_DROP); mylog("SQLForeignKeys(): EXIT, stmt=%u\n", stmt); - return SQL_SUCCESS; + return SQL_SUCCESS; } -RETCODE SQL_API SQLProcedureColumns( - HSTMT hstmt, - UCHAR FAR * szProcQualifier, - SWORD cbProcQualifier, - UCHAR FAR * szProcOwner, - SWORD cbProcOwner, - UCHAR FAR * szProcName, - SWORD cbProcName, - UCHAR FAR * szColumnName, - SWORD cbColumnName) +RETCODE SQL_API +SQLProcedureColumns( + HSTMT hstmt, + UCHAR FAR *szProcQualifier, + SWORD cbProcQualifier, + UCHAR FAR *szProcOwner, + SWORD cbProcOwner, + UCHAR FAR *szProcName, + SWORD cbProcName, + UCHAR FAR *szColumnName, + SWORD cbColumnName) { -static char *func="SQLProcedureColumns"; + static char *func = "SQLProcedureColumns"; mylog("%s: entering...\n", func); SC_log_error(func, "Function not implemented", (StatementClass *) hstmt); - return SQL_ERROR; + return SQL_ERROR; } -RETCODE SQL_API SQLProcedures( - HSTMT hstmt, - UCHAR FAR * szProcQualifier, - SWORD cbProcQualifier, - UCHAR FAR * szProcOwner, - SWORD cbProcOwner, - UCHAR FAR * szProcName, - SWORD cbProcName) +RETCODE SQL_API +SQLProcedures( + HSTMT hstmt, + UCHAR FAR *szProcQualifier, + SWORD cbProcQualifier, + UCHAR FAR *szProcOwner, + SWORD cbProcOwner, + UCHAR FAR *szProcName, + SWORD cbProcName) { -static char *func="SQLProcedures"; + static char *func = "SQLProcedures"; mylog("%s: entering...\n", func); SC_log_error(func, "Function not implemented", (StatementClass *) hstmt); - return SQL_ERROR; + return SQL_ERROR; } -RETCODE SQL_API SQLTablePrivileges( - HSTMT hstmt, - UCHAR FAR * szTableQualifier, - SWORD cbTableQualifier, - UCHAR FAR * szTableOwner, - SWORD cbTableOwner, - UCHAR FAR * szTableName, - SWORD cbTableName) +RETCODE SQL_API +SQLTablePrivileges( + HSTMT hstmt, + UCHAR FAR *szTableQualifier, + SWORD cbTableQualifier, + UCHAR FAR *szTableOwner, + SWORD cbTableOwner, + UCHAR FAR *szTableName, + SWORD cbTableName) { -static char *func="SQLTablePrivileges"; + static char *func = "SQLTablePrivileges"; mylog("%s: entering...\n", func); SC_log_error(func, "Function not implemented", (StatementClass *) hstmt); - return SQL_ERROR; + return SQL_ERROR; } |