开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 查看源码
info.c
资源名称：postgresql-6.5.2.tar.gz　[点击查看]
上传用户：blenddy
上传日期：2007-01-07
资源大小：6495k
文件大小：86k
源码类别：

数据库系统

开发平台：

Unix_Linux

info.c：源码内容
  2. /* Module:          info.c
  3.  *
  4.  * Description:     This module contains routines related to
  5.  *                  ODBC informational functions.
  6.  *
  7.  * Classes:         n/a
  8.  *
  9.  * API functions:   SQLGetInfo, SQLGetTypeInfo, SQLGetFunctions, 
  10.  *                  SQLTables, SQLColumns, SQLStatistics, SQLSpecialColumns,
  11.  *                  SQLPrimaryKeys, SQLForeignKeys, 
  12.  *                  SQLProcedureColumns(NI), SQLProcedures(NI), 
  13.  *                  SQLTablePrivileges(NI), SQLColumnPrivileges(NI)
  14.  *
  15.  * Comments:        See "notice.txt" for copyright and license information.
  16.  *
  17.  */
  19. #ifdef HAVE_CONFIG_H
  20. #include "config.h"
  21. #endif
  23. #include <string.h>
  24. #include <stdio.h>
  25. #include "psqlodbc.h"
  27. #ifndef WIN32
  28. #include "iodbc.h"
  29. #include "isql.h"
  30. #include "isqlext.h"
  31. #include <ctype.h> /* for tolower function */
  32. #else
  33. #include <windows.h>
  34. #include <sql.h> 
  35. #include <sqlext.h>
  36. #endif
  38. #include "tuple.h"
  39. #include "pgtypes.h"
  41. #include "environ.h"
  42. #include "connection.h"
  43. #include "statement.h"
  44. #include "qresult.h"
  45. #include "bind.h"
  46. #include "misc.h"
  47. #include "pgtypes.h"
  50. /* Trigger related stuff for SQLForeign Keys */
  51. #define TRIGGER_SHIFT 3
  52. #define TRIGGER_MASK   0x03
  53. #define TRIGGER_DELETE 0x01
  54. #define TRIGGER_UPDATE 0x02
  57. extern GLOBAL_VALUES globals;
  60. //      -       -       -       -       -       -       -       -       -
  62. RETCODE SQL_API SQLGetInfo(
  63.         HDBC      hdbc,
  64.         UWORD     fInfoType,
  65.         PTR       rgbInfoValue,
  66.         SWORD     cbInfoValueMax,
  67.         SWORD FAR *pcbInfoValue)
  68. {
  69. static char *func = "SQLGetInfo";
  70. ConnectionClass *conn = (ConnectionClass *) hdbc;
  71. ConnInfo *ci;
  72. char *p = NULL;
  73. int len = 0, value = 0;
  74. RETCODE result;
  76. mylog( "%s: entering...fInfoType=%dn", func, fInfoType);
  78. if ( ! conn) {
  79. CC_log_error(func, "", NULL);
  80. return SQL_INVALID_HANDLE;
  81. }
  83. ci = &conn->connInfo;
  85.     switch (fInfoType) {
  86.     case SQL_ACCESSIBLE_PROCEDURES: /* ODBC 1.0 */
  87. p = "N";
  88.         break;
  90.     case SQL_ACCESSIBLE_TABLES: /* ODBC 1.0 */
  91. p = "N";
  92.         break;
  94.     case SQL_ACTIVE_CONNECTIONS: /* ODBC 1.0 */
  95.         len = 2;
  96.         value = MAX_CONNECTIONS;
  97.         break;
  99.     case SQL_ACTIVE_STATEMENTS: /* ODBC 1.0 */
  100.         len = 2;
  101.         value = 0;
  102.         break;
  104.     case SQL_ALTER_TABLE: /* ODBC 2.0 */
  105.         len = 4;
  106.         value = SQL_AT_ADD_COLUMN;
  107.         break;
  109.     case SQL_BOOKMARK_PERSISTENCE: /* ODBC 2.0 */
  110. /* very simple bookmark support */        
  111. len = 4;
  112.         value = globals.use_declarefetch ? 0 : (SQL_BP_SCROLL);
  113.         break;
  115.     case SQL_COLUMN_ALIAS: /* ODBC 2.0 */
  116. p = "N";
  117.         break;
  119.     case SQL_CONCAT_NULL_BEHAVIOR: /* ODBC 1.0 */
  120.         len = 2;
  121.         value = SQL_CB_NON_NULL;
  122.         break;
  124.     case SQL_CONVERT_BIGINT:
  125.     case SQL_CONVERT_BINARY:
  126.     case SQL_CONVERT_BIT:
  127.     case SQL_CONVERT_CHAR:
  128.     case SQL_CONVERT_DATE:
  129.     case SQL_CONVERT_DECIMAL:
  130.     case SQL_CONVERT_DOUBLE:
  131.     case SQL_CONVERT_FLOAT:
  132.     case SQL_CONVERT_INTEGER:
  133.     case SQL_CONVERT_LONGVARBINARY:
  134.     case SQL_CONVERT_LONGVARCHAR:
  135.     case SQL_CONVERT_NUMERIC:
  136.     case SQL_CONVERT_REAL:
  137.     case SQL_CONVERT_SMALLINT:
  138.     case SQL_CONVERT_TIME:
  139.     case SQL_CONVERT_TIMESTAMP:
  140.     case SQL_CONVERT_TINYINT:
  141.     case SQL_CONVERT_VARBINARY:
  142.     case SQL_CONVERT_VARCHAR: /* ODBC 1.0 */
  143. len = 4;
  144.         value = fInfoType;
  145.         break;
  147.     case SQL_CONVERT_FUNCTIONS: /* ODBC 1.0 */
  148. len = 4;
  149.         value = 0;
  150.         break;
  152.     case SQL_CORRELATION_NAME: /* ODBC 1.0 */
  154. /* Saying no correlation name makes Query not work right.
  155. value = SQL_CN_NONE;
  156. */
  157. len = 2;
  158.         value = SQL_CN_ANY;
  159.         break;
  161.     case SQL_CURSOR_COMMIT_BEHAVIOR: /* ODBC 1.0 */
  162.         len = 2;
  163.         value = SQL_CB_CLOSE;
  164.         break;
  166.     case SQL_CURSOR_ROLLBACK_BEHAVIOR: /* ODBC 1.0 */
  167.         len = 2;
  168.         value = SQL_CB_CLOSE;
  169.         break;
  171.     case SQL_DATA_SOURCE_NAME: /* ODBC 1.0 */
  172. p = CC_get_DSN(conn);
  173.         break;
  175.     case SQL_DATA_SOURCE_READ_ONLY: /* ODBC 1.0 */
  176. p = CC_is_readonly(conn) ? "Y" : "N";
  177.         break;
  179.     case SQL_DATABASE_NAME: /* Support for old ODBC 1.0 Apps */
  181. /* Returning the database name causes problems in MS Query.
  182. It generates query like: "SELECT DISTINCT a FROM byronncrap3 crap3"
  184. p = CC_get_database(conn);
  185. */
  186. p = "";    
  187. break;
  189.     case SQL_DBMS_NAME: /* ODBC 1.0 */
  190. p = DBMS_NAME;
  191.         break;
  193.     case SQL_DBMS_VER: /* ODBC 1.0 */
  194. p = DBMS_VERSION;
  195.         break;
  197.     case SQL_DEFAULT_TXN_ISOLATION: /* ODBC 1.0 */
  198. len = 4;
  199.         value = SQL_TXN_READ_COMMITTED; //SQL_TXN_SERIALIZABLE;
  200.         break;
  202.     case SQL_DRIVER_NAME: /* ODBC 1.0 */
  203.         p = DRIVER_FILE_NAME;
  204.         break;
  206.     case SQL_DRIVER_ODBC_VER:
  207. p = DRIVER_ODBC_VER;
  208.         break;
  210.     case SQL_DRIVER_VER: /* ODBC 1.0 */
  211.         p = POSTGRESDRIVERVERSION;
  212.         break;
  214.     case SQL_EXPRESSIONS_IN_ORDERBY: /* ODBC 1.0 */
  215. p = "N";
  216.         break;
  218.     case SQL_FETCH_DIRECTION: /* ODBC 1.0 */
  219. len = 4;
  220.         value = globals.use_declarefetch ? (SQL_FD_FETCH_NEXT) : (SQL_FD_FETCH_NEXT |
  221.                                    SQL_FD_FETCH_FIRST |
  222.                                    SQL_FD_FETCH_LAST |
  223.                                    SQL_FD_FETCH_PRIOR |
  224.                                    SQL_FD_FETCH_ABSOLUTE |
  225.    SQL_FD_FETCH_RELATIVE | 
  226.    SQL_FD_FETCH_BOOKMARK);
  227.         break;
  229.     case SQL_FILE_USAGE: /* ODBC 2.0 */
  230. len = 2;
  231.         value = SQL_FILE_NOT_SUPPORTED;
  232.         break;
  234.     case SQL_GETDATA_EXTENSIONS: /* ODBC 2.0 */
  235. len = 4;
  236.         value = (SQL_GD_ANY_COLUMN | SQL_GD_ANY_ORDER | SQL_GD_BOUND | SQL_GD_BLOCK);
  237.         break;
  239.     case SQL_GROUP_BY: /* ODBC 2.0 */
  240. len = 2;
  241.         value = SQL_GB_GROUP_BY_EQUALS_SELECT;
  242.         break;
  244.     case SQL_IDENTIFIER_CASE: /* ODBC 1.0 */
  245.         /* are identifiers case-sensitive (yes, but only when quoted.  If not quoted, they
  246. default to lowercase)
  247. */
  248. len = 2;
  249.         value = SQL_IC_LOWER;
  250.         break;
  252.     case SQL_IDENTIFIER_QUOTE_CHAR: /* ODBC 1.0 */
  253.         /* the character used to quote "identifiers" */
  254. p = PROTOCOL_62(ci) ? " " : """;
  255.         break;
  257.     case SQL_KEYWORDS: /* ODBC 2.0 */
  258. p = "";
  259.         break;
  261.     case SQL_LIKE_ESCAPE_CLAUSE: /* ODBC 2.0 */
  262. /* is there a character that escapes '%' and '_' in a LIKE clause?
  263. not as far as I can tell
  264. */
  265.         p = "N";
  266.         break;
  268.     case SQL_LOCK_TYPES: /* ODBC 2.0 */
  269. len = 4;
  270.         value = globals.lie ? (SQL_LCK_NO_CHANGE | SQL_LCK_EXCLUSIVE | SQL_LCK_UNLOCK) : SQL_LCK_NO_CHANGE;
  271.         break;
  273.     case SQL_MAX_BINARY_LITERAL_LEN: /* ODBC 2.0 */
  274. len = 4;
  275.         value = 0;
  276.         break;
  278.     case SQL_MAX_CHAR_LITERAL_LEN: /* ODBC 2.0 */
  279. len = 4;
  280.         value = 0;
  281.         break;
  283.     case SQL_MAX_COLUMN_NAME_LEN: /* ODBC 1.0 */
  284. len = 2;
  285.         value = MAX_COLUMN_LEN;
  286.         break;
  288.     case SQL_MAX_COLUMNS_IN_GROUP_BY: /* ODBC 2.0 */
  289. len = 2;
  290.         value = 0;
  291.         break;
  293.     case SQL_MAX_COLUMNS_IN_INDEX: /* ODBC 2.0 */
  294. len = 2;
  295.         value = 0;
  296.         break;
  298.     case SQL_MAX_COLUMNS_IN_ORDER_BY: /* ODBC 2.0 */
  299. len = 2;
  300.         value = 0;
  301.         break;
  303.     case SQL_MAX_COLUMNS_IN_SELECT: /* ODBC 2.0 */
  304. len = 2;
  305.         value = 0;
  306.         break;
  308.     case SQL_MAX_COLUMNS_IN_TABLE: /* ODBC 2.0 */
  309. len = 2;
  310.         value = 0;
  311.         break;
  313.     case SQL_MAX_CURSOR_NAME_LEN: /* ODBC 1.0 */
  314. len = 2;
  315.         value = MAX_CURSOR_LEN;
  316.         break;
  318.     case SQL_MAX_INDEX_SIZE: /* ODBC 2.0 */
  319. len = 4;
  320.         value = 0;
  321.         break;
  323.     case SQL_MAX_OWNER_NAME_LEN: /* ODBC 1.0 */
  324. len = 2;
  325.         value = 0;
  326.         break;
  328.     case SQL_MAX_PROCEDURE_NAME_LEN: /* ODBC 1.0 */
  329. len = 2;
  330.         value = 0;
  331.         break;
  333.     case SQL_MAX_QUALIFIER_NAME_LEN: /* ODBC 1.0 */
  334. len = 2;
  335.         value = 0;
  336.         break;
  338.     case SQL_MAX_ROW_SIZE: /* ODBC 2.0 */
  339. len = 4;
  340.         value = BLCKSZ;
  341.         break;
  343.     case SQL_MAX_ROW_SIZE_INCLUDES_LONG: /* ODBC 2.0 */
  344.         /* does the preceding value include LONGVARCHAR and LONGVARBINARY
  345. fields?   Well, it does include longvarchar, but not longvarbinary.
  346. */
  347. p = "Y";
  348.         break;
  350.     case SQL_MAX_STATEMENT_LEN: /* ODBC 2.0 */
  351.         /* maybe this should be 0? */
  352. len = 4;
  353.         value = MAX_QUERY_SIZE;
  354.         break;
  356.     case SQL_MAX_TABLE_NAME_LEN: /* ODBC 1.0 */
  357. len = 2;
  358.         value = MAX_TABLE_LEN;
  359.         break;
  361.     case SQL_MAX_TABLES_IN_SELECT: /* ODBC 2.0 */
  362. len = 2;
  363.         value = 0;
  364.         break;
  366.     case SQL_MAX_USER_NAME_LEN:
  367. len = 2;
  368.         value = 0;
  369.         break;
  371.     case SQL_MULT_RESULT_SETS: /* ODBC 1.0 */
  372.         /* Don't support multiple result sets but say yes anyway? */
  373. p = "Y";
  374.         break;
  376.     case SQL_MULTIPLE_ACTIVE_TXN: /* ODBC 1.0 */
  377. p = "Y";
  378.         break;
  380.     case SQL_NEED_LONG_DATA_LEN: /* ODBC 2.0 */
  381. /* Dont need the length, SQLPutData can handle any size and multiple calls */
  382. p = "N";
  383.         break;
  385.     case SQL_NON_NULLABLE_COLUMNS: /* ODBC 1.0 */
  386. len = 2;
  387.         value = SQL_NNC_NON_NULL;
  388.         break;
  390.     case SQL_NULL_COLLATION: /* ODBC 2.0 */
  391.         /* where are nulls sorted? */
  392. len = 2;
  393.         value = SQL_NC_END;
  394.         break;
  396.     case SQL_NUMERIC_FUNCTIONS: /* ODBC 1.0 */
  397. len = 4;
  398.         value = 0;
  399.         break;
  401.     case SQL_ODBC_API_CONFORMANCE: /* ODBC 1.0 */
  402. len = 2;
  403.         value = SQL_OAC_LEVEL1;
  404.         break;
  406.     case SQL_ODBC_SAG_CLI_CONFORMANCE: /* ODBC 1.0 */
  407. len = 2;
  408.         value = SQL_OSCC_NOT_COMPLIANT;
  409.         break;
  411.     case SQL_ODBC_SQL_CONFORMANCE: /* ODBC 1.0 */
  412. len = 2;
  413.         value = SQL_OSC_CORE;
  414.         break;
  416.     case SQL_ODBC_SQL_OPT_IEF: /* ODBC 1.0 */
  417. p = "N";
  418.         break;
  420.     case SQL_ORDER_BY_COLUMNS_IN_SELECT: /* ODBC 2.0 */
  421. p = "Y";
  422.         break;
  424.     case SQL_OUTER_JOINS: /* ODBC 1.0 */
  425. p = "N";
  426.         break;
  428.     case SQL_OWNER_TERM: /* ODBC 1.0 */
  429. p = "owner";
  430.         break;
  432.     case SQL_OWNER_USAGE: /* ODBC 2.0 */
  433. len = 4;
  434.         value = 0;
  435.         break;
  437.     case SQL_POS_OPERATIONS: /* ODBC 2.0 */
  438. len = 4;
  439.         value = globals.lie ? (SQL_POS_POSITION | SQL_POS_REFRESH | SQL_POS_UPDATE | SQL_POS_DELETE | SQL_POS_ADD) : (SQL_POS_POSITION | SQL_POS_REFRESH);
  440.         break;
  442.     case SQL_POSITIONED_STATEMENTS: /* ODBC 2.0 */
  443. len = 4;
  444.         value = globals.lie ? (SQL_PS_POSITIONED_DELETE | 
  445. SQL_PS_POSITIONED_UPDATE | 
  446. SQL_PS_SELECT_FOR_UPDATE) : 0;
  447.         break;
  449.     case SQL_PROCEDURE_TERM: /* ODBC 1.0 */
  450.         p = "procedure";
  451.         break;
  453.     case SQL_PROCEDURES: /* ODBC 1.0 */
  454. p = "Y";
  455.         break;
  457.     case SQL_QUALIFIER_LOCATION: /* ODBC 2.0 */
  458. len = 2;
  459.         value = SQL_QL_START;
  460.         break;
  462.     case SQL_QUALIFIER_NAME_SEPARATOR: /* ODBC 1.0 */
  463. p = "";
  464.         break;
  466.     case SQL_QUALIFIER_TERM: /* ODBC 1.0 */
  467. p = "";
  468.         break;
  470.     case SQL_QUALIFIER_USAGE: /* ODBC 2.0 */
  471. len = 4;
  472.         value = 0;
  473.         break;
  475.     case SQL_QUOTED_IDENTIFIER_CASE: /* ODBC 2.0 */
  476.         /* are "quoted" identifiers case-sensitive?  YES! */
  477. len = 2;
  478.         value = SQL_IC_SENSITIVE;
  479.         break;
  481.     case SQL_ROW_UPDATES: /* ODBC 1.0 */
  482.         /*  Driver doesn't support keyset-driven or mixed cursors, so
  483. not much point in saying row updates are supported
  484. */
  485.         p = globals.lie ? "Y" : "N";
  486.         break;
  488.     case SQL_SCROLL_CONCURRENCY: /* ODBC 1.0 */
  489. len = 4;
  490.         value = globals.lie ? (SQL_SCCO_READ_ONLY | 
  491. SQL_SCCO_LOCK | 
  492. SQL_SCCO_OPT_ROWVER | 
  493. SQL_SCCO_OPT_VALUES) : (SQL_SCCO_READ_ONLY);
  494.         break;
  496.     case SQL_SCROLL_OPTIONS: /* ODBC 1.0 */
  497. len = 4;
  498.         value = globals.lie ? (SQL_SO_FORWARD_ONLY | 
  499. SQL_SO_STATIC | 
  500. SQL_SO_KEYSET_DRIVEN | 
  501. SQL_SO_DYNAMIC | 
  502. SQL_SO_MIXED) : (globals.use_declarefetch ? SQL_SO_FORWARD_ONLY : (SQL_SO_FORWARD_ONLY | SQL_SO_STATIC));
  503.         break;
  505.     case SQL_SEARCH_PATTERN_ESCAPE: /* ODBC 1.0 */
  506. p = "";
  507.         break;
  509.     case SQL_SERVER_NAME: /* ODBC 1.0 */
  510. p = CC_get_server(conn);
  511.         break;
  513.     case SQL_SPECIAL_CHARACTERS: /* ODBC 2.0 */
  514.         p = "_";
  515.         break;
  517.     case SQL_STATIC_SENSITIVITY: /* ODBC 2.0 */
  518. len = 4;
  519.         value = globals.lie ? (SQL_SS_ADDITIONS | SQL_SS_DELETIONS | SQL_SS_UPDATES) : 0;
  520.         break;
  522.     case SQL_STRING_FUNCTIONS: /* ODBC 1.0 */
  523. len = 4;
  524.         value = (SQL_FN_STR_CONCAT |
  525. SQL_FN_STR_LCASE | 
  526. SQL_FN_STR_LENGTH | 
  527. SQL_FN_STR_LOCATE | 
  528. SQL_FN_STR_LTRIM | 
  529. SQL_FN_STR_RTRIM |
  530. SQL_FN_STR_SUBSTRING |
  531. SQL_FN_STR_UCASE);
  532.         break;
  534.     case SQL_SUBQUERIES: /* ODBC 2.0 */
  535. /* postgres 6.3 supports subqueries */
  536. len = 4;
  537.         value = (SQL_SQ_QUANTIFIED |
  538. SQL_SQ_IN |
  539. SQL_SQ_EXISTS |
  540. SQL_SQ_COMPARISON);
  541.         break;
  543.     case SQL_SYSTEM_FUNCTIONS: /* ODBC 1.0 */
  544. len = 4;
  545. value = 0;
  546.         break;
  548.     case SQL_TABLE_TERM: /* ODBC 1.0 */
  549. p = "table";
  550.         break;
  552.     case SQL_TIMEDATE_ADD_INTERVALS: /* ODBC 2.0 */
  553. len = 4;
  554.         value = 0;
  555.         break;
  557.     case SQL_TIMEDATE_DIFF_INTERVALS: /* ODBC 2.0 */
  558. len = 4;
  559.         value = 0;
  560.         break;
  562.     case SQL_TIMEDATE_FUNCTIONS: /* ODBC 1.0 */
  563. len = 4;
  564.         value = (SQL_FN_TD_NOW);
  565.         break;
  567.     case SQL_TXN_CAPABLE: /* ODBC 1.0 */
  568.         /* Postgres can deal with create or drop table statements in a transaction */
  569. len = 2;
  570.         value = SQL_TC_ALL;
  571.         break;
  573.     case SQL_TXN_ISOLATION_OPTION: /* ODBC 1.0 */
  574. len = 4;
  575.         value = SQL_TXN_READ_COMMITTED; // SQL_TXN_SERIALIZABLE;
  576.         break;
  578.     case SQL_UNION: /* ODBC 2.0 */
  579. /*  unions with all supported in postgres 6.3 */
  580. len = 4;
  581.         value = (SQL_U_UNION | SQL_U_UNION_ALL);
  582.         break;
  584.     case SQL_USER_NAME: /* ODBC 1.0 */
  585. p = CC_get_username(conn);
  586.         break;
  588.     default:
  589.         /* unrecognized key */
  590.         conn->errormsg = "Unrecognized key passed to SQLGetInfo.";
  591.         conn->errornumber = CONN_NOT_IMPLEMENTED_ERROR;
  592. CC_log_error(func, "", conn);
  593.         return SQL_ERROR;
  594.     }
  596. result = SQL_SUCCESS;
  598. mylog("SQLGetInfo: p='%s', len=%d, value=%d, cbMax=%dn", p?p:"<NULL>", len, value, cbInfoValueMax);
  600. /* NOTE, that if rgbInfoValue is NULL, then no warnings or errors should
  601. result and just pcbInfoValue is returned, which indicates what length 
  602. would be required if a real buffer had been passed in.
  603. */
  604. if (p) {  /* char/binary data */
  605. len = strlen(p);
  607. if (rgbInfoValue) {
  608. strncpy_null((char *)rgbInfoValue, p, (size_t)cbInfoValueMax);
  610. if (len >= cbInfoValueMax)  {
  611. result = SQL_SUCCESS_WITH_INFO;
  612. conn->errornumber = STMT_TRUNCATED;
  613. conn->errormsg = "The buffer was too small for the result.";
  614. }
  615. }
  616. }
  618. else { /* numeric data */
  620. if (rgbInfoValue) {
  622. if (len == 2 ) 
  623. *((WORD *)rgbInfoValue) = (WORD) value;
  624. else if (len == 4)
  625. *((DWORD *)rgbInfoValue) = (DWORD) value;
  626. }
  627. }
  629. if (pcbInfoValue) 
  630. *pcbInfoValue = len;
  632. return result;
  633. }
  635. //      -       -       -       -       -       -       -       -       -
  638. RETCODE SQL_API SQLGetTypeInfo(
  639.         HSTMT   hstmt,
  640.         SWORD   fSqlType)
  641. {
  642. static char *func = "SQLGetTypeInfo";
  643. StatementClass *stmt = (StatementClass *) hstmt;
  644. TupleNode *row;
  645. int i;
  646. // Int4 type;
  647. Int4 pgType; 
  648. Int2 sqlType;
  650. mylog("%s: entering...fSqlType = %dn", func, fSqlType);
  652. if( ! stmt) {
  653. SC_log_error(func, "", NULL);
  654. return SQL_INVALID_HANDLE;
  655. }
  658. stmt->manual_result = TRUE;
  659. stmt->result = QR_Constructor();
  660. if( ! stmt->result) {
  661. SC_log_error(func, "Error creating result.", stmt);
  662. return SQL_ERROR;
  663. }
  665. extend_bindings(stmt, 15);
  667. QR_set_num_fields(stmt->result, 15);
  668. QR_set_field_info(stmt->result, 0, "TYPE_NAME", PG_TYPE_TEXT, MAX_INFO_STRING);
  669. QR_set_field_info(stmt->result, 1, "DATA_TYPE", PG_TYPE_INT2, 2);
  670. QR_set_field_info(stmt->result, 2, "PRECISION", PG_TYPE_INT4, 4);
  671. QR_set_field_info(stmt->result, 3, "LITERAL_PREFIX", PG_TYPE_TEXT, MAX_INFO_STRING);
  672. QR_set_field_info(stmt->result, 4, "LITERAL_SUFFIX", PG_TYPE_TEXT, MAX_INFO_STRING);
  673. QR_set_field_info(stmt->result, 5, "CREATE_PARAMS", PG_TYPE_TEXT, MAX_INFO_STRING);
  674. QR_set_field_info(stmt->result, 6, "NULLABLE", PG_TYPE_INT2, 2);
  675. QR_set_field_info(stmt->result, 7, "CASE_SENSITIVE", PG_TYPE_INT2, 2);
  676. QR_set_field_info(stmt->result, 8, "SEARCHABLE", PG_TYPE_INT2, 2);
  677. QR_set_field_info(stmt->result, 9, "UNSIGNED_ATTRIBUTE", PG_TYPE_INT2, 2);
  678. QR_set_field_info(stmt->result, 10, "MONEY", PG_TYPE_INT2, 2);
  679. QR_set_field_info(stmt->result, 11, "AUTO_INCREMENT", PG_TYPE_INT2, 2);
  680. QR_set_field_info(stmt->result, 12, "LOCAL_TYPE_NAME", PG_TYPE_TEXT, MAX_INFO_STRING);
  681. QR_set_field_info(stmt->result, 13, "MINIMUM_SCALE", PG_TYPE_INT2, 2);
  682. QR_set_field_info(stmt->result, 14, "MAXIMUM_SCALE", PG_TYPE_INT2, 2);
  684. for(i=0, sqlType = sqlTypes[0]; sqlType; sqlType = sqlTypes[++i]) {
  685. pgType = sqltype_to_pgtype(sqlType);
  687. if (fSqlType == SQL_ALL_TYPES || fSqlType == sqlType) {
  688. row = (TupleNode *)malloc(sizeof(TupleNode) + (15 - 1)*sizeof(TupleField));
  690. /* These values can't be NULL */
  691. set_tuplefield_string(&row->tuple[0], pgtype_to_name(stmt, pgType));
  692. set_tuplefield_int2(&row->tuple[1], (Int2) sqlType);
  693. set_tuplefield_int2(&row->tuple[6], pgtype_nullable(stmt, pgType));
  694. set_tuplefield_int2(&row->tuple[7], pgtype_case_sensitive(stmt, pgType));
  695. set_tuplefield_int2(&row->tuple[8], pgtype_searchable(stmt, pgType));
  696. set_tuplefield_int2(&row->tuple[10], pgtype_money(stmt, pgType));
  698. /* Localized data-source dependent data type name (always NULL) */
  699. set_tuplefield_null(&row->tuple[12]);
  701. /* These values can be NULL */
  702. set_nullfield_int4(&row->tuple[2], pgtype_precision(stmt, pgType, PG_STATIC, PG_STATIC));
  703. set_nullfield_string(&row->tuple[3], pgtype_literal_prefix(stmt, pgType));
  704. set_nullfield_string(&row->tuple[4], pgtype_literal_suffix(stmt, pgType));
  705. set_nullfield_string(&row->tuple[5], pgtype_create_params(stmt, pgType));
  706. set_nullfield_int2(&row->tuple[9], pgtype_unsigned(stmt, pgType));
  707. set_nullfield_int2(&row->tuple[11], pgtype_auto_increment(stmt, pgType));
  708. set_nullfield_int2(&row->tuple[13], pgtype_scale(stmt, pgType));
  709. set_nullfield_int2(&row->tuple[14], pgtype_scale(stmt, pgType));
  711. QR_add_tuple(stmt->result, row);
  712. }
  713. }
  716.     stmt->status = STMT_FINISHED;
  717.     stmt->currTuple = -1;
  718. stmt->rowset_start = -1;
  719. stmt->current_col = -1;
  721.     return SQL_SUCCESS;
  722. }
  724. //      -       -       -       -       -       -       -       -       -
  726. RETCODE SQL_API SQLGetFunctions(
  727.         HDBC      hdbc,
  728.         UWORD     fFunction,
  729.         UWORD FAR *pfExists)
  730. {
  731. static char *func="SQLGetFunctions";
  733. mylog( "%s: entering...n", func);
  735.     if (fFunction == SQL_API_ALL_FUNCTIONS) {
  737. if (globals.lie) {
  738. int i;
  739. memset(pfExists, 0, sizeof(UWORD)*100);
  741. pfExists[SQL_API_SQLALLOCENV] = TRUE;
  742. pfExists[SQL_API_SQLFREEENV] = TRUE;
  743. for (i = SQL_API_SQLALLOCCONNECT; i <= SQL_NUM_FUNCTIONS; i++)
  744. pfExists[i] = TRUE;
  745. for (i = SQL_EXT_API_START; i <= SQL_EXT_API_LAST; i++)
  746. pfExists[i] = TRUE;
  747. }
  748. else {
  749. memset(pfExists, 0, sizeof(UWORD)*100);
  751. // ODBC core functions
  752. pfExists[SQL_API_SQLALLOCCONNECT]     = TRUE;
  753. pfExists[SQL_API_SQLALLOCENV]         = TRUE;
  754. pfExists[SQL_API_SQLALLOCSTMT]        = TRUE;
  755. pfExists[SQL_API_SQLBINDCOL]          = TRUE;  
  756. pfExists[SQL_API_SQLCANCEL]           = TRUE;
  757. pfExists[SQL_API_SQLCOLATTRIBUTES]    = TRUE;
  758. pfExists[SQL_API_SQLCONNECT]          = TRUE;
  759. pfExists[SQL_API_SQLDESCRIBECOL]      = TRUE;  // partial
  760. pfExists[SQL_API_SQLDISCONNECT]       = TRUE;
  761. pfExists[SQL_API_SQLERROR]            = TRUE;
  762. pfExists[SQL_API_SQLEXECDIRECT]       = TRUE;
  763. pfExists[SQL_API_SQLEXECUTE]          = TRUE;
  764. pfExists[SQL_API_SQLFETCH]            = TRUE;
  765. pfExists[SQL_API_SQLFREECONNECT]      = TRUE;
  766. pfExists[SQL_API_SQLFREEENV]          = TRUE;
  767. pfExists[SQL_API_SQLFREESTMT]         = TRUE;
  768. pfExists[SQL_API_SQLGETCURSORNAME]    = TRUE;
  769. pfExists[SQL_API_SQLNUMRESULTCOLS]    = TRUE;
  770. pfExists[SQL_API_SQLPREPARE]          = TRUE;  // complete?
  771. pfExists[SQL_API_SQLROWCOUNT]         = TRUE;
  772. pfExists[SQL_API_SQLSETCURSORNAME]    = TRUE;
  773. pfExists[SQL_API_SQLSETPARAM]         = FALSE; // odbc 1.0
  774. pfExists[SQL_API_SQLTRANSACT]         = TRUE;
  776. // ODBC level 1 functions
  777. pfExists[SQL_API_SQLBINDPARAMETER]    = TRUE;
  778. pfExists[SQL_API_SQLCOLUMNS]          = TRUE;
  779. pfExists[SQL_API_SQLDRIVERCONNECT]    = TRUE;
  780. pfExists[SQL_API_SQLGETCONNECTOPTION] = TRUE;  // partial
  781. pfExists[SQL_API_SQLGETDATA]          = TRUE;
  782. pfExists[SQL_API_SQLGETFUNCTIONS]     = TRUE;                                                       
  783. pfExists[SQL_API_SQLGETINFO]          = TRUE;
  784. pfExists[SQL_API_SQLGETSTMTOPTION]    = TRUE;  // partial
  785. pfExists[SQL_API_SQLGETTYPEINFO]      = TRUE;
  786. pfExists[SQL_API_SQLPARAMDATA]        = TRUE;
  787. pfExists[SQL_API_SQLPUTDATA]          = TRUE;
  788. pfExists[SQL_API_SQLSETCONNECTOPTION] = TRUE;  // partial
  789. pfExists[SQL_API_SQLSETSTMTOPTION]    = TRUE;
  790. pfExists[SQL_API_SQLSPECIALCOLUMNS]   = TRUE;
  791. pfExists[SQL_API_SQLSTATISTICS]       = TRUE;
  792. pfExists[SQL_API_SQLTABLES]           = TRUE;
  794. // ODBC level 2 functions
  795. pfExists[SQL_API_SQLBROWSECONNECT]    = FALSE;
  796. pfExists[SQL_API_SQLCOLUMNPRIVILEGES] = FALSE;
  797. pfExists[SQL_API_SQLDATASOURCES]      = FALSE;  // only implemented by DM
  798. pfExists[SQL_API_SQLDESCRIBEPARAM]    = FALSE; // not properly implemented
  799. pfExists[SQL_API_SQLDRIVERS]          = FALSE;  // only implemented by DM
  800. pfExists[SQL_API_SQLEXTENDEDFETCH]    = TRUE;
  801. pfExists[SQL_API_SQLFOREIGNKEYS]      = TRUE;
  802. pfExists[SQL_API_SQLMORERESULTS]      = TRUE;
  803. pfExists[SQL_API_SQLNATIVESQL]        = TRUE;
  804. pfExists[SQL_API_SQLNUMPARAMS]        = TRUE;
  805. pfExists[SQL_API_SQLPARAMOPTIONS]     = FALSE;
  806. pfExists[SQL_API_SQLPRIMARYKEYS]      = TRUE;
  807. pfExists[SQL_API_SQLPROCEDURECOLUMNS] = FALSE;
  808. pfExists[SQL_API_SQLPROCEDURES]       = FALSE;
  809. pfExists[SQL_API_SQLSETPOS]           = TRUE;
  810. pfExists[SQL_API_SQLSETSCROLLOPTIONS] = TRUE; // odbc 1.0
  811. pfExists[SQL_API_SQLTABLEPRIVILEGES]  = FALSE;
  812. }
  813.     } else {
  815. if (globals.lie)
  816. *pfExists = TRUE;
  818. else {
  820. switch(fFunction) {
  821. case SQL_API_SQLALLOCCONNECT:     *pfExists = TRUE; break;
  822. case SQL_API_SQLALLOCENV:         *pfExists = TRUE; break;
  823. case SQL_API_SQLALLOCSTMT:        *pfExists = TRUE; break;
  824. case SQL_API_SQLBINDCOL:          *pfExists = TRUE; break;
  825. case SQL_API_SQLCANCEL:           *pfExists = TRUE; break;
  826. case SQL_API_SQLCOLATTRIBUTES:    *pfExists = TRUE; break;
  827. case SQL_API_SQLCONNECT:          *pfExists = TRUE; break;
  828. case SQL_API_SQLDESCRIBECOL:      *pfExists = TRUE; break;  // partial
  829. case SQL_API_SQLDISCONNECT:       *pfExists = TRUE; break;
  830. case SQL_API_SQLERROR:            *pfExists = TRUE; break;
  831. case SQL_API_SQLEXECDIRECT:       *pfExists = TRUE; break;
  832. case SQL_API_SQLEXECUTE:          *pfExists = TRUE; break;
  833. case SQL_API_SQLFETCH:            *pfExists = TRUE; break;
  834. case SQL_API_SQLFREECONNECT:      *pfExists = TRUE; break;
  835. case SQL_API_SQLFREEENV:          *pfExists = TRUE; break;
  836. case SQL_API_SQLFREESTMT:         *pfExists = TRUE; break;
  837. case SQL_API_SQLGETCURSORNAME:    *pfExists = TRUE; break;
  838. case SQL_API_SQLNUMRESULTCOLS:    *pfExists = TRUE; break;
  839. case SQL_API_SQLPREPARE:          *pfExists = TRUE; break;
  840. case SQL_API_SQLROWCOUNT:         *pfExists = TRUE; break;
  841. case SQL_API_SQLSETCURSORNAME:    *pfExists = TRUE; break;
  842. case SQL_API_SQLSETPARAM:         *pfExists = FALSE; break; // odbc 1.0
  843. case SQL_API_SQLTRANSACT:         *pfExists = TRUE; break;
  845. // ODBC level 1 functions
  846. case SQL_API_SQLBINDPARAMETER:    *pfExists = TRUE; break;
  847. case SQL_API_SQLCOLUMNS:          *pfExists = TRUE; break;
  848. case SQL_API_SQLDRIVERCONNECT:    *pfExists = TRUE; break;
  849. case SQL_API_SQLGETCONNECTOPTION: *pfExists = TRUE; break;  // partial
  850. case SQL_API_SQLGETDATA:          *pfExists = TRUE; break;
  851. case SQL_API_SQLGETFUNCTIONS:     *pfExists = TRUE; break;
  852. case SQL_API_SQLGETINFO:          *pfExists = TRUE; break;
  853. case SQL_API_SQLGETSTMTOPTION:    *pfExists = TRUE; break;  // partial
  854. case SQL_API_SQLGETTYPEINFO:      *pfExists = TRUE; break;
  855. case SQL_API_SQLPARAMDATA:        *pfExists = TRUE; break;
  856. case SQL_API_SQLPUTDATA:          *pfExists = TRUE; break;
  857. case SQL_API_SQLSETCONNECTOPTION: *pfExists = TRUE; break;  // partial
  858. case SQL_API_SQLSETSTMTOPTION:    *pfExists = TRUE; break;
  859. case SQL_API_SQLSPECIALCOLUMNS:   *pfExists = TRUE; break;
  860. case SQL_API_SQLSTATISTICS:       *pfExists = TRUE; break;
  861. case SQL_API_SQLTABLES:           *pfExists = TRUE; break;
  863. // ODBC level 2 functions
  864. case SQL_API_SQLBROWSECONNECT:    *pfExists = FALSE; break;
  865. case SQL_API_SQLCOLUMNPRIVILEGES: *pfExists = FALSE; break;
  866. case SQL_API_SQLDATASOURCES:      *pfExists = FALSE; break;  // only implemented by DM
  867. case SQL_API_SQLDESCRIBEPARAM:    *pfExists = FALSE; break;  // not properly implemented
  868. case SQL_API_SQLDRIVERS:          *pfExists = FALSE; break;  // only implemented by DM
  869. case SQL_API_SQLEXTENDEDFETCH:    *pfExists = TRUE; break;
  870. case SQL_API_SQLFOREIGNKEYS:      *pfExists = TRUE; break;
  871. case SQL_API_SQLMORERESULTS:      *pfExists = TRUE; break;
  872. case SQL_API_SQLNATIVESQL:        *pfExists = TRUE; break;
  873. case SQL_API_SQLNUMPARAMS:        *pfExists = TRUE; break;
  874. case SQL_API_SQLPARAMOPTIONS:     *pfExists = FALSE; break;
  875. case SQL_API_SQLPRIMARYKEYS:      *pfExists = TRUE; break;
  876. case SQL_API_SQLPROCEDURECOLUMNS: *pfExists = FALSE; break;
  877. case SQL_API_SQLPROCEDURES:       *pfExists = FALSE; break;
  878. case SQL_API_SQLSETPOS:           *pfExists = TRUE; break;
  879. case SQL_API_SQLSETSCROLLOPTIONS: *pfExists = TRUE; break; // odbc 1.0
  880. case SQL_API_SQLTABLEPRIVILEGES:  *pfExists = FALSE; break;
  881. }
  882. }
  883.     }
  885.     return SQL_SUCCESS;
  886. }
  890. RETCODE SQL_API SQLTables(
  891.                           HSTMT       hstmt,
  892.                           UCHAR FAR * szTableQualifier,
  893.                           SWORD       cbTableQualifier,
  894.                           UCHAR FAR * szTableOwner,
  895.                           SWORD       cbTableOwner,
  896.                           UCHAR FAR * szTableName,
  897.                           SWORD       cbTableName,
  898.                           UCHAR FAR * szTableType,
  899.                           SWORD       cbTableType)
  900. {
  901. static char *func = "SQLTables";
  902. StatementClass *stmt = (StatementClass *) hstmt;
  903. StatementClass *tbl_stmt;
  904. TupleNode *row;
  905. HSTMT htbl_stmt;
  906. RETCODE result;
  907. char *tableType;
  908. char tables_query[MAX_STATEMENT_LEN];
  909. char table_name[MAX_INFO_STRING], table_owner[MAX_INFO_STRING], relhasrules[MAX_INFO_STRING];
  910. ConnInfo *ci;
  911. char *prefix[32], prefixes[MEDIUM_REGISTRY_LEN];
  912. char *table_type[32], table_types[MAX_INFO_STRING];
  913. char show_system_tables, show_regular_tables, show_views;
  914. char regular_table, view, systable;
  915. int i;
  917. mylog("%s: entering...stmt=%un", func, stmt);
  919. if( ! stmt) {
  920. SC_log_error(func, "", NULL);
  921. return SQL_INVALID_HANDLE;
  922. }
  924. stmt->manual_result = TRUE;
  925. stmt->errormsg_created = TRUE;
  927. ci = &stmt->hdbc->connInfo;
  929. result = SQLAllocStmt( stmt->hdbc, &htbl_stmt);
  930. if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  931. stmt->errornumber = STMT_NO_MEMORY_ERROR;
  932. stmt->errormsg = "Couldn't allocate statement for SQLTables result.";
  933. SC_log_error(func, "", stmt);
  934. return SQL_ERROR;
  935. }
  936. tbl_stmt = (StatementClass *) htbl_stmt;
  938. // **********************************************************************
  939. // Create the query to find out the tables
  940. // **********************************************************************
  942. strcpy(tables_query, "select relname, usename, relhasrules from pg_class, pg_user");
  943. strcat(tables_query, " where relkind = 'r'");
  945. my_strcat(tables_query, " and usename like '%.*s'", szTableOwner, cbTableOwner);
  946. my_strcat(tables_query, " and relname like '%.*s'", szTableName, cbTableName);
  949. // Parse the extra systable prefix 
  950. strcpy(prefixes, globals.extra_systable_prefixes);
  951. i = 0;
  952. prefix[i] = strtok(prefixes, ";");
  953. while (prefix[i] && i<32) {
  954. prefix[++i] = strtok(NULL, ";");
  955. }
  957. /* Parse the desired table types to return */
  958. show_system_tables = FALSE;
  959. show_regular_tables = FALSE;
  960. show_views = FALSE;
  962. /* make_string mallocs memory */
  963. tableType = make_string(szTableType, cbTableType, NULL);
  964. if (tableType) {
  965. strcpy(table_types, tableType);
  966. free(tableType);
  967. i = 0;
  968. table_type[i] = strtok(table_types, ",");
  969. while (table_type[i] && i<32) {
  970. table_type[++i] = strtok(NULL, ",");
  971. }
  973. /* Check for desired table types to return */
  974. i = 0;
  975. while (table_type[i]) {
  976. if ( strstr(table_type[i], "SYSTEM TABLE"))
  977. show_system_tables = TRUE;
  978. else if ( strstr(table_type[i], "TABLE"))
  979. show_regular_tables = TRUE;
  980. else if ( strstr(table_type[i], "VIEW"))
  981. show_views = TRUE;
  983. i++;
  984. }
  985. }
  986. else {
  987. show_regular_tables = TRUE;
  988. show_views = TRUE;
  989. }
  991. /*  If not interested in SYSTEM TABLES then filter them out
  992. to save some time on the query.  If treating system tables
  993. as regular tables, then dont filter either.
  994. */
  995. if ( ! atoi(ci->show_system_tables) && ! show_system_tables) {
  996. strcat(tables_query, " and relname !~ '^" POSTGRES_SYS_PREFIX);
  998. /* Also filter out user-defined system table types */
  999. i = 0;
  1000. while(prefix[i]) {
  1001. strcat(tables_query, "|^");
  1002. strcat(tables_query, prefix[i]);
  1003. i++;
  1004. }
  1006. strcat(tables_query, "'");
  1007. }
  1010. /* filter out large objects unconditionally (they are not system tables) and match users */
  1011. strcat(tables_query, " and relname !~ '^xinv[0-9]+'");
  1012. strcat(tables_query, " and int4out(usesysid) = int4out(relowner)");
  1013. strcat(tables_query, "order by relname");
  1015. // **********************************************************************
  1017. result = SQLExecDirect(htbl_stmt, tables_query, strlen(tables_query));
  1018. if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  1019. stmt->errormsg = SC_create_errormsg(htbl_stmt);
  1020. stmt->errornumber = tbl_stmt->errornumber;
  1021. SC_log_error(func, "", stmt);
  1022. SQLFreeStmt(htbl_stmt, SQL_DROP);
  1023. return SQL_ERROR;
  1024. }
  1026.     result = SQLBindCol(htbl_stmt, 1, SQL_C_CHAR,
  1027.                         table_name, MAX_INFO_STRING, NULL);
  1028.     if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  1029. stmt->errormsg = tbl_stmt->errormsg;
  1030. stmt->errornumber = tbl_stmt->errornumber;
  1031. SC_log_error(func, "", stmt);
  1032. SQLFreeStmt(htbl_stmt, SQL_DROP);
  1033.         return SQL_ERROR;
  1034.     }
  1036.     result = SQLBindCol(htbl_stmt, 2, SQL_C_CHAR,
  1037.                         table_owner, MAX_INFO_STRING, NULL);
  1038.     if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  1039. stmt->errormsg = tbl_stmt->errormsg;
  1040. stmt->errornumber = tbl_stmt->errornumber;
  1041. SC_log_error(func, "", stmt);
  1042. SQLFreeStmt(htbl_stmt, SQL_DROP);
  1043.         return SQL_ERROR;
  1044.     }
  1045.     result = SQLBindCol(htbl_stmt, 3, SQL_C_CHAR,
  1046.                         relhasrules, MAX_INFO_STRING, NULL);
  1047.     if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  1048. stmt->errormsg = tbl_stmt->errormsg;
  1049. stmt->errornumber = tbl_stmt->errornumber;
  1050. SC_log_error(func, "", stmt);
  1051. SQLFreeStmt(htbl_stmt, SQL_DROP);
  1052.         return SQL_ERROR;
  1053.     }
  1055. stmt->result = QR_Constructor();
  1056. if(!stmt->result) {
  1057. stmt->errormsg = "Couldn't allocate memory for SQLTables result.";
  1058. stmt->errornumber = STMT_NO_MEMORY_ERROR;
  1059. SC_log_error(func, "", stmt);
  1060. SQLFreeStmt(htbl_stmt, SQL_DROP);
  1061. return SQL_ERROR;
  1062. }
  1064.     // the binding structure for a statement is not set up until
  1065.     // a statement is actually executed, so we'll have to do this ourselves.
  1066. extend_bindings(stmt, 5);
  1068.     // set the field names
  1069. QR_set_num_fields(stmt->result, 5);
  1070. QR_set_field_info(stmt->result, 0, "TABLE_QUALIFIER", PG_TYPE_TEXT, MAX_INFO_STRING);
  1071. QR_set_field_info(stmt->result, 1, "TABLE_OWNER", PG_TYPE_TEXT, MAX_INFO_STRING);
  1072. QR_set_field_info(stmt->result, 2, "TABLE_NAME", PG_TYPE_TEXT, MAX_INFO_STRING);
  1073. QR_set_field_info(stmt->result, 3, "TABLE_TYPE", PG_TYPE_TEXT, MAX_INFO_STRING);
  1074. QR_set_field_info(stmt->result, 4, "REMARKS", PG_TYPE_TEXT, 254);
  1076.     // add the tuples
  1077. result = SQLFetch(htbl_stmt);
  1078. while((result == SQL_SUCCESS) || (result == SQL_SUCCESS_WITH_INFO)) {
  1080. /* Determine if this table name is a system table.
  1081. If treating system tables as regular tables, then 
  1082. no need to do this test.
  1083. */
  1084. systable = FALSE;
  1085. if( ! atoi(ci->show_system_tables)) {
  1087. if ( strncmp(table_name, POSTGRES_SYS_PREFIX, strlen(POSTGRES_SYS_PREFIX)) == 0)
  1088. systable = TRUE;
  1090. else { /* Check extra system table prefixes */
  1091. i = 0;
  1092. while (prefix[i]) {
  1093. mylog("table_name='%s', prefix[%d]='%s'n", table_name, i, prefix[i]);
  1094. if (strncmp(table_name, prefix[i], strlen(prefix[i])) == 0) {
  1095. systable = TRUE;
  1096. break;
  1097. }
  1098. i++;
  1099. }
  1100. }
  1101. }
  1103. /* Determine if the table name is a view */
  1104. view = (relhasrules[0] == '1');
  1106. /* It must be a regular table */
  1107. regular_table = ( ! systable && ! view);
  1110. /* Include the row in the result set if meets all criteria */
  1111. /* NOTE: Unsupported table types (i.e., LOCAL TEMPORARY, ALIAS, etc)
  1112. will return nothing */
  1113. if ( (systable && show_system_tables) ||
  1114.  (view && show_views) || 
  1115.  (regular_table && show_regular_tables)) {
  1117. row = (TupleNode *)malloc(sizeof(TupleNode) + (5 - 1) * sizeof(TupleField));
  1119. set_tuplefield_string(&row->tuple[0], "");
  1121. // I have to hide the table owner from Access, otherwise it
  1122. // insists on referring to the table as 'owner.table'.
  1123. // (this is valid according to the ODBC SQL grammar, but
  1124. // Postgres won't support it.)
  1125. // set_tuplefield_string(&row->tuple[1], table_owner);
  1127. mylog("SQLTables: table_name = '%s'n", table_name);
  1129. set_tuplefield_string(&row->tuple[1], "");
  1130. set_tuplefield_string(&row->tuple[2], table_name);
  1131. set_tuplefield_string(&row->tuple[3], systable ? "SYSTEM TABLE" : (view ? "VIEW" : "TABLE"));
  1132. set_tuplefield_string(&row->tuple[4], "");
  1134. QR_add_tuple(stmt->result, row);
  1135. }
  1136. result = SQLFetch(htbl_stmt);
  1137.     }
  1138. if(result != SQL_NO_DATA_FOUND) {
  1139. stmt->errormsg = SC_create_errormsg(htbl_stmt);
  1140. stmt->errornumber = tbl_stmt->errornumber;
  1141. SC_log_error(func, "", stmt);
  1142. SQLFreeStmt(htbl_stmt, SQL_DROP);
  1143. return SQL_ERROR;
  1144. }
  1146.     // also, things need to think that this statement is finished so
  1147.     // the results can be retrieved.
  1148. stmt->status = STMT_FINISHED;
  1150.     // set up the current tuple pointer for SQLFetch
  1151. stmt->currTuple = -1;
  1152. stmt->rowset_start = -1;
  1153. stmt->current_col = -1;
  1155. SQLFreeStmt(htbl_stmt, SQL_DROP);
  1156. mylog("SQLTables(): EXIT,  stmt=%un", stmt);
  1157. return SQL_SUCCESS;
  1158. }
  1163. RETCODE SQL_API SQLColumns(
  1164.                            HSTMT        hstmt,
  1165.                            UCHAR FAR *  szTableQualifier,
  1166.                            SWORD        cbTableQualifier,
  1167.                            UCHAR FAR *  szTableOwner,
  1168.                            SWORD        cbTableOwner,
  1169.                            UCHAR FAR *  szTableName,
  1170.                            SWORD        cbTableName,
  1171.                            UCHAR FAR *  szColumnName,
  1172.                            SWORD        cbColumnName)
  1173. {
  1174. static char *func = "SQLColumns";
  1175. StatementClass *stmt = (StatementClass *) hstmt;
  1176. TupleNode *row;
  1177. HSTMT hcol_stmt;
  1178. StatementClass *col_stmt;
  1179. char columns_query[MAX_STATEMENT_LEN];
  1180. RETCODE result;
  1181. char table_owner[MAX_INFO_STRING], table_name[MAX_INFO_STRING], field_name[MAX_INFO_STRING], field_type_name[MAX_INFO_STRING];
  1182. Int2 field_number, result_cols;
  1183. Int4 field_type, the_type, field_length, mod_length;
  1184. char not_null[MAX_INFO_STRING];
  1185. ConnInfo *ci;
  1188. mylog("%s: entering...stmt=%un", func, stmt);
  1190. if( ! stmt) {
  1191. SC_log_error(func, "", NULL);
  1192. return SQL_INVALID_HANDLE;
  1193. }
  1195. stmt->manual_result = TRUE;
  1196. stmt->errormsg_created = TRUE;
  1198. ci = &stmt->hdbc->connInfo;
  1200. // **********************************************************************
  1201. // Create the query to find out the columns (Note: pre 6.3 did not have the atttypmod field)
  1202. // **********************************************************************
  1203. sprintf(columns_query, "select u.usename, c.relname, a.attname, a.atttypid,t.typname, a.attnum, a.attlen, %s, a.attnotnull from pg_user u, pg_class c, pg_attribute a, pg_type t where "
  1204. "int4out(u.usesysid) = int4out(c.relowner) and c.oid= a.attrelid and a.atttypid = t.oid and (a.attnum > 0)",
  1205. PROTOCOL_62(ci) ? "a.attlen" : "a.atttypmod");
  1207. my_strcat(columns_query, " and c.relname like '%.*s'", szTableName, cbTableName);
  1208. my_strcat(columns_query, " and u.usename like '%.*s'", szTableOwner, cbTableOwner);
  1209. my_strcat(columns_query, " and a.attname like '%.*s'", szColumnName, cbColumnName);
  1211.     // give the output in the order the columns were defined
  1212.     // when the table was created
  1213.     strcat(columns_query, " order by attnum");
  1214. // **********************************************************************
  1216.     result = SQLAllocStmt( stmt->hdbc, &hcol_stmt);
  1217.     if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  1218. stmt->errornumber = STMT_NO_MEMORY_ERROR;
  1219. stmt->errormsg = "Couldn't allocate statement for SQLColumns result.";
  1220. SC_log_error(func, "", stmt);
  1221.         return SQL_ERROR;
  1222.     }
  1223. col_stmt = (StatementClass *) hcol_stmt;
  1225. mylog("SQLColumns: hcol_stmt = %u, col_stmt = %un", hcol_stmt, col_stmt);
  1227.     result = SQLExecDirect(hcol_stmt, columns_query,
  1228.                            strlen(columns_query));
  1229.     if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  1230. stmt->errormsg = SC_create_errormsg(hcol_stmt);
  1231. stmt->errornumber = col_stmt->errornumber;
  1232. SC_log_error(func, "", stmt);
  1233. SQLFreeStmt(hcol_stmt, SQL_DROP);
  1234.         return SQL_ERROR;
  1235.     }
  1237.     result = SQLBindCol(hcol_stmt, 1, SQL_C_CHAR,
  1238.                         table_owner, MAX_INFO_STRING, NULL);
  1239.     if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  1240. stmt->errormsg = col_stmt->errormsg;
  1241. stmt->errornumber = col_stmt->errornumber;
  1242. SC_log_error(func, "", stmt);
  1243. SQLFreeStmt(hcol_stmt, SQL_DROP);
  1244.         return SQL_ERROR;
  1245.     }
  1247.     result = SQLBindCol(hcol_stmt, 2, SQL_C_CHAR,
  1248.                         table_name, MAX_INFO_STRING, NULL);
  1249.     if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  1250. stmt->errormsg = col_stmt->errormsg;
  1251. stmt->errornumber = col_stmt->errornumber;
  1252. SC_log_error(func, "", stmt);
  1253. SQLFreeStmt(hcol_stmt, SQL_DROP);
  1254.         return SQL_ERROR;
  1255.     }
  1257.     result = SQLBindCol(hcol_stmt, 3, SQL_C_CHAR,
  1258.                         field_name, MAX_INFO_STRING, NULL);
  1259.     if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  1260. stmt->errormsg = col_stmt->errormsg;
  1261. stmt->errornumber = col_stmt->errornumber;
  1262. SC_log_error(func, "", stmt);
  1263. SQLFreeStmt(hcol_stmt, SQL_DROP);
  1264.         return SQL_ERROR;
  1265.     }
  1267.     result = SQLBindCol(hcol_stmt, 4, SQL_C_LONG,
  1268.                         &field_type, 4, NULL);
  1269.     if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  1270. stmt->errormsg = col_stmt->errormsg;
  1271. stmt->errornumber = col_stmt->errornumber;
  1272. SC_log_error(func, "", stmt);
  1273. SQLFreeStmt(hcol_stmt, SQL_DROP);
  1274.         return SQL_ERROR;
  1275.     }
  1277.     result = SQLBindCol(hcol_stmt, 5, SQL_C_CHAR,
  1278.                         field_type_name, MAX_INFO_STRING, NULL);
  1279.     if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  1280. stmt->errormsg = col_stmt->errormsg;
  1281. stmt->errornumber = col_stmt->errornumber;
  1282. SC_log_error(func, "", stmt);
  1283. SQLFreeStmt(hcol_stmt, SQL_DROP);
  1284.         return SQL_ERROR;
  1285.     }
  1287.     result = SQLBindCol(hcol_stmt, 6, SQL_C_SHORT,
  1288.                         &field_number, MAX_INFO_STRING, NULL);
  1289.     if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  1290. stmt->errormsg = col_stmt->errormsg;
  1291. stmt->errornumber = col_stmt->errornumber;
  1292. SC_log_error(func, "", stmt);
  1293. SQLFreeStmt(hcol_stmt, SQL_DROP);
  1294.         return SQL_ERROR;
  1295.     }
  1297.     result = SQLBindCol(hcol_stmt, 7, SQL_C_LONG,
  1298.                         &field_length, MAX_INFO_STRING, NULL);
  1299.     if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  1300. stmt->errormsg = col_stmt->errormsg;
  1301. stmt->errornumber = col_stmt->errornumber;
  1302. SC_log_error(func, "", stmt);
  1303. SQLFreeStmt(hcol_stmt, SQL_DROP);
  1304.         return SQL_ERROR;
  1305.     }
  1307.     result = SQLBindCol(hcol_stmt, 8, SQL_C_LONG,
  1308.                         &mod_length, MAX_INFO_STRING, NULL);
  1309.     if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  1310. stmt->errormsg = col_stmt->errormsg;
  1311. stmt->errornumber = col_stmt->errornumber;
  1312. SC_log_error(func, "", stmt);
  1313. SQLFreeStmt(hcol_stmt, SQL_DROP);
  1314.         return SQL_ERROR;
  1315.     }
  1317.     result = SQLBindCol(hcol_stmt, 9, SQL_C_CHAR,
  1318.                         not_null, MAX_INFO_STRING, NULL);
  1319.     if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  1320. stmt->errormsg = col_stmt->errormsg;
  1321. stmt->errornumber = col_stmt->errornumber;
  1322. SC_log_error(func, "", stmt);
  1323. SQLFreeStmt(hcol_stmt, SQL_DROP);
  1324.         return SQL_ERROR;
  1325.     }
  1327.     stmt->result = QR_Constructor();
  1328.     if(!stmt->result) {
  1329. stmt->errormsg = "Couldn't allocate memory for SQLColumns result.";
  1330.         stmt->errornumber = STMT_NO_MEMORY_ERROR;
  1331. SC_log_error(func, "", stmt);
  1332. SQLFreeStmt(hcol_stmt, SQL_DROP);
  1333.         return SQL_ERROR;
  1334.     }
  1336.     // the binding structure for a statement is not set up until
  1337.     // a statement is actually executed, so we'll have to do this ourselves.
  1338. result_cols = 14;
  1339.     extend_bindings(stmt, result_cols);
  1341.     // set the field names
  1342.     QR_set_num_fields(stmt->result, result_cols);
  1343.     QR_set_field_info(stmt->result, 0, "TABLE_QUALIFIER", PG_TYPE_TEXT, MAX_INFO_STRING);
  1344.     QR_set_field_info(stmt->result, 1, "TABLE_OWNER", PG_TYPE_TEXT, MAX_INFO_STRING);
  1345.     QR_set_field_info(stmt->result, 2, "TABLE_NAME", PG_TYPE_TEXT, MAX_INFO_STRING);
  1346.     QR_set_field_info(stmt->result, 3, "COLUMN_NAME", PG_TYPE_TEXT, MAX_INFO_STRING);
  1347.     QR_set_field_info(stmt->result, 4, "DATA_TYPE", PG_TYPE_INT2, 2);
  1348.     QR_set_field_info(stmt->result, 5, "TYPE_NAME", PG_TYPE_TEXT, MAX_INFO_STRING);
  1349.     QR_set_field_info(stmt->result, 6, "PRECISION", PG_TYPE_INT4, 4);
  1350.     QR_set_field_info(stmt->result, 7, "LENGTH", PG_TYPE_INT4, 4);
  1351.     QR_set_field_info(stmt->result, 8, "SCALE", PG_TYPE_INT2, 2);
  1352.     QR_set_field_info(stmt->result, 9, "RADIX", PG_TYPE_INT2, 2);
  1353.     QR_set_field_info(stmt->result, 10, "NULLABLE", PG_TYPE_INT2, 2);
  1354.     QR_set_field_info(stmt->result, 11, "REMARKS", PG_TYPE_TEXT, 254);
  1356. // User defined fields
  1357.     QR_set_field_info(stmt->result, 12, "DISPLAY_SIZE", PG_TYPE_INT4, 4);
  1358. QR_set_field_info(stmt->result, 13, "FIELD_TYPE", PG_TYPE_INT4, 4);
  1361. result = SQLFetch(hcol_stmt);
  1364. /* Only show oid if option AND there are other columns AND 
  1365. its not being called by SQLStatistics .
  1366. Always show OID if its a system table
  1367. */
  1369. if (result != SQL_ERROR && ! stmt->internal) {
  1371. if (atoi(ci->show_oid_column) || strncmp(table_name, POSTGRES_SYS_PREFIX, strlen(POSTGRES_SYS_PREFIX)) == 0) {
  1373. /* For OID fields */
  1374. the_type = PG_TYPE_OID;
  1375. row = (TupleNode *)malloc(sizeof(TupleNode) +
  1376.   (result_cols - 1) * sizeof(TupleField));
  1378. set_tuplefield_string(&row->tuple[0], "");
  1379. // see note in SQLTables()
  1380. //      set_tuplefield_string(&row->tuple[1], table_owner);
  1381. set_tuplefield_string(&row->tuple[1], "");
  1382. set_tuplefield_string(&row->tuple[2], table_name);
  1383. set_tuplefield_string(&row->tuple[3], "oid");
  1384. set_tuplefield_int2(&row->tuple[4], pgtype_to_sqltype(stmt, the_type));
  1385. set_tuplefield_string(&row->tuple[5], "OID");
  1387. set_tuplefield_int4(&row->tuple[7], pgtype_length(stmt, the_type, PG_STATIC, PG_STATIC));
  1388. set_tuplefield_int4(&row->tuple[6], pgtype_precision(stmt, the_type, PG_STATIC, PG_STATIC));
  1390. set_nullfield_int2(&row->tuple[8], pgtype_scale(stmt, the_type));
  1391. set_nullfield_int2(&row->tuple[9], pgtype_radix(stmt, the_type));
  1392. set_tuplefield_int2(&row->tuple[10], SQL_NO_NULLS);
  1393. set_tuplefield_string(&row->tuple[11], "");
  1395. set_tuplefield_int4(&row->tuple[12], pgtype_display_size(stmt, the_type, PG_STATIC, PG_STATIC));
  1396. set_tuplefield_int4(&row->tuple[13], the_type);
  1398. QR_add_tuple(stmt->result, row);
  1399. }
  1401. }
  1403.     while((result == SQL_SUCCESS) || (result == SQL_SUCCESS_WITH_INFO)) {
  1404.         row = (TupleNode *)malloc(sizeof(TupleNode) +
  1405.                                   (result_cols - 1) * sizeof(TupleField));
  1408.         set_tuplefield_string(&row->tuple[0], "");
  1409.         // see note in SQLTables()
  1410.         //      set_tuplefield_string(&row->tuple[1], table_owner);
  1411.         set_tuplefield_string(&row->tuple[1], "");
  1412.         set_tuplefield_string(&row->tuple[2], table_name);
  1413.         set_tuplefield_string(&row->tuple[3], field_name);
  1414.         set_tuplefield_int2(&row->tuple[4], pgtype_to_sqltype(stmt, field_type));
  1415.         set_tuplefield_string(&row->tuple[5], field_type_name);
  1418. /* Some Notes about Postgres Data Types:
  1420. VARCHAR - the length is stored in the pg_attribute.atttypmod field
  1421. BPCHAR  - the length is also stored as varchar is
  1423. */
  1424.         if((field_type == PG_TYPE_VARCHAR) ||
  1425.    (field_type == PG_TYPE_BPCHAR)) {
  1427. if (mod_length >= 4)
  1428. mod_length -= 4; // the length is in atttypmod - 4
  1430. if (mod_length > globals.max_varchar_size || mod_length <= 0)
  1431. mod_length = globals.max_varchar_size;
  1433. mylog("SQLColumns: field type is VARCHAR,BPCHAR: field_type = %d, mod_length = %dn", field_type, mod_length);
  1435.             set_tuplefield_int4(&row->tuple[7], mod_length);
  1436. set_tuplefield_int4(&row->tuple[6], mod_length);
  1437. set_tuplefield_int4(&row->tuple[12], mod_length);
  1438.         } else {
  1439. mylog("SQLColumns: field type is OTHER: field_type = %d, pgtype_length = %dn", field_type, pgtype_length(stmt, field_type, PG_STATIC, PG_STATIC));
  1441.             set_tuplefield_int4(&row->tuple[7], pgtype_length(stmt, field_type, PG_STATIC, PG_STATIC));
  1442. set_tuplefield_int4(&row->tuple[6], pgtype_precision(stmt, field_type, PG_STATIC, PG_STATIC));
  1443. set_tuplefield_int4(&row->tuple[12], pgtype_display_size(stmt, field_type, PG_STATIC, PG_STATIC));
  1445.         }
  1447. set_nullfield_int2(&row->tuple[8], pgtype_scale(stmt, field_type));
  1448. set_nullfield_int2(&row->tuple[9], pgtype_radix(stmt, field_type));
  1449. set_tuplefield_int2(&row->tuple[10], (Int2) (not_null[0] == '1' ? SQL_NO_NULLS : pgtype_nullable(stmt, field_type)));
  1450. set_tuplefield_string(&row->tuple[11], "");
  1451. set_tuplefield_int4(&row->tuple[13], field_type);
  1453.         QR_add_tuple(stmt->result, row);
  1456.         result = SQLFetch(hcol_stmt);
  1458.     }
  1459.     if(result != SQL_NO_DATA_FOUND) {
  1460. stmt->errormsg = SC_create_errormsg(hcol_stmt);
  1461. stmt->errornumber = col_stmt->errornumber;
  1462. SC_log_error(func, "", stmt);
  1463. SQLFreeStmt(hcol_stmt, SQL_DROP);
  1464.         return SQL_ERROR;
  1465.     }
  1467. // Put the row version column at the end so it might not be
  1468. // mistaken for a key field.
  1469. if ( ! stmt->internal && atoi(ci->row_versioning)) {
  1470. /* For Row Versioning fields */
  1471. the_type = PG_TYPE_INT4;
  1473. row = (TupleNode *)malloc(sizeof(TupleNode) +
  1474.   (result_cols - 1) * sizeof(TupleField));
  1476. set_tuplefield_string(&row->tuple[0], "");
  1477. set_tuplefield_string(&row->tuple[1], "");
  1478. set_tuplefield_string(&row->tuple[2], table_name);
  1479. set_tuplefield_string(&row->tuple[3], "xmin");
  1480. set_tuplefield_int2(&row->tuple[4], pgtype_to_sqltype(stmt, the_type));
  1481. set_tuplefield_string(&row->tuple[5], pgtype_to_name(stmt, the_type));
  1482. set_tuplefield_int4(&row->tuple[6], pgtype_precision(stmt, the_type, PG_STATIC, PG_STATIC));
  1483. set_tuplefield_int4(&row->tuple[7], pgtype_length(stmt, the_type, PG_STATIC, PG_STATIC));
  1484. set_nullfield_int2(&row->tuple[8], pgtype_scale(stmt, the_type));
  1485. set_nullfield_int2(&row->tuple[9], pgtype_radix(stmt, the_type));
  1486. set_tuplefield_int2(&row->tuple[10], SQL_NO_NULLS);
  1487. set_tuplefield_string(&row->tuple[11], "");
  1488. set_tuplefield_int4(&row->tuple[12], pgtype_display_size(stmt, the_type, PG_STATIC, PG_STATIC));
  1489. set_tuplefield_int4(&row->tuple[13], the_type);
  1491. QR_add_tuple(stmt->result, row);
  1492. }
  1494.     // also, things need to think that this statement is finished so
  1495.     // the results can be retrieved.
  1496.     stmt->status = STMT_FINISHED;
  1498.     // set up the current tuple pointer for SQLFetch
  1499.     stmt->currTuple = -1;
  1500. stmt->rowset_start = -1;
  1501. stmt->current_col = -1;
  1503. SQLFreeStmt(hcol_stmt, SQL_DROP);
  1504. mylog("SQLColumns(): EXIT,  stmt=%un", stmt);
  1505.     return SQL_SUCCESS;
  1506. }
  1508. RETCODE SQL_API SQLSpecialColumns(
  1509.                                   HSTMT        hstmt,
  1510.                                   UWORD        fColType,
  1511.                                   UCHAR FAR *  szTableQualifier,
  1512.                                   SWORD        cbTableQualifier,
  1513.                                   UCHAR FAR *  szTableOwner,
  1514.                                   SWORD        cbTableOwner,
  1515.                                   UCHAR FAR *  szTableName,
  1516.                                   SWORD        cbTableName,
  1517.                                   UWORD        fScope,
  1518.                                   UWORD        fNullable)
  1519. {
  1520. static char *func = "SQLSpecialColumns";
  1521. TupleNode *row;
  1522. StatementClass *stmt = (StatementClass *) hstmt;
  1523. ConnInfo *ci;
  1526. mylog("%s: entering...stmt=%un", func, stmt);
  1528.     if( ! stmt) {
  1529. SC_log_error(func, "", NULL);
  1530.         return SQL_INVALID_HANDLE;
  1531.     }
  1532. ci = &stmt->hdbc->connInfo;
  1534. stmt->manual_result = TRUE;
  1535.     stmt->result = QR_Constructor();
  1536.     extend_bindings(stmt, 8);
  1538.     QR_set_num_fields(stmt->result, 8);
  1539.     QR_set_field_info(stmt->result, 0, "SCOPE", PG_TYPE_INT2, 2);
  1540.     QR_set_field_info(stmt->result, 1, "COLUMN_NAME", PG_TYPE_TEXT, MAX_INFO_STRING);
  1541.     QR_set_field_info(stmt->result, 2, "DATA_TYPE", PG_TYPE_INT2, 2);
  1542.     QR_set_field_info(stmt->result, 3, "TYPE_NAME", PG_TYPE_TEXT, MAX_INFO_STRING);
  1543.     QR_set_field_info(stmt->result, 4, "PRECISION", PG_TYPE_INT4, 4);
  1544.     QR_set_field_info(stmt->result, 5, "LENGTH", PG_TYPE_INT4, 4);
  1545.     QR_set_field_info(stmt->result, 6, "SCALE", PG_TYPE_INT2, 2);
  1546.     QR_set_field_info(stmt->result, 7, "PSEUDO_COLUMN", PG_TYPE_INT2, 2);
  1548.     /* use the oid value for the rowid */
  1549.     if(fColType == SQL_BEST_ROWID) {
  1550.         row = (TupleNode *)malloc(sizeof(TupleNode) + (8 - 1) * sizeof(TupleField));
  1552.         set_tuplefield_int2(&row->tuple[0], SQL_SCOPE_SESSION);
  1553.         set_tuplefield_string(&row->tuple[1], "oid");
  1554.         set_tuplefield_int2(&row->tuple[2], pgtype_to_sqltype(stmt, PG_TYPE_OID));
  1555.         set_tuplefield_string(&row->tuple[3], "OID");
  1556.         set_tuplefield_int4(&row->tuple[4], pgtype_precision(stmt, PG_TYPE_OID, PG_STATIC, PG_STATIC));
  1557.         set_tuplefield_int4(&row->tuple[5], pgtype_length(stmt, PG_TYPE_OID, PG_STATIC, PG_STATIC));
  1558.         set_tuplefield_int2(&row->tuple[6], pgtype_scale(stmt, PG_TYPE_OID));
  1559.         set_tuplefield_int2(&row->tuple[7], SQL_PC_PSEUDO);
  1561.         QR_add_tuple(stmt->result, row);
  1563.     } else if(fColType == SQL_ROWVER) {
  1565. Int2 the_type = PG_TYPE_INT4;
  1567. if (atoi(ci->row_versioning)) {
  1568. row = (TupleNode *)malloc(sizeof(TupleNode) + (8 - 1) * sizeof(TupleField));
  1570. set_tuplefield_null(&row->tuple[0]);
  1571. set_tuplefield_string(&row->tuple[1], "xmin");
  1572. set_tuplefield_int2(&row->tuple[2], pgtype_to_sqltype(stmt, the_type));
  1573. set_tuplefield_string(&row->tuple[3], pgtype_to_name(stmt, the_type));
  1574. set_tuplefield_int4(&row->tuple[4], pgtype_precision(stmt, the_type, PG_STATIC, PG_STATIC));
  1575. set_tuplefield_int4(&row->tuple[5], pgtype_length(stmt, the_type, PG_STATIC, PG_STATIC));
  1576. set_tuplefield_int2(&row->tuple[6], pgtype_scale(stmt, the_type));
  1577. set_tuplefield_int2(&row->tuple[7], SQL_PC_PSEUDO);
  1579. QR_add_tuple(stmt->result, row);
  1580. }
  1581. }
  1582.     stmt->status = STMT_FINISHED;
  1583.     stmt->currTuple = -1;
  1584. stmt->rowset_start = -1;
  1585. stmt->current_col = -1;
  1587. mylog("SQLSpecialColumns(): EXIT,  stmt=%un", stmt);
  1588.     return SQL_SUCCESS;
  1589. }
  1591. RETCODE SQL_API SQLStatistics(
  1592.                               HSTMT         hstmt,
  1593.                               UCHAR FAR *   szTableQualifier,
  1594.                               SWORD         cbTableQualifier,
  1595.                               UCHAR FAR *   szTableOwner,
  1596.                               SWORD         cbTableOwner,
  1597.                               UCHAR FAR *   szTableName,
  1598.                               SWORD         cbTableName,
  1599.                               UWORD         fUnique,
  1600.                               UWORD         fAccuracy)
  1601. {
  1602. static char *func="SQLStatistics";
  1603. StatementClass *stmt = (StatementClass *) hstmt;
  1604. char index_query[MAX_STATEMENT_LEN];
  1605. HSTMT hindx_stmt;
  1606. RETCODE result;
  1607. char *table_name;
  1608. char index_name[MAX_INFO_STRING];
  1609. short fields_vector[8];
  1610. char isunique[10], isclustered[10];
  1611. SDWORD index_name_len, fields_vector_len;
  1612. TupleNode *row;
  1613. int i;
  1614. HSTMT hcol_stmt;
  1615. StatementClass *col_stmt, *indx_stmt;
  1616. char column_name[MAX_INFO_STRING];
  1617. char **column_names = 0;
  1618. Int4 column_name_len;
  1619. int total_columns = 0;
  1620. char error = TRUE;
  1621. ConnInfo *ci;
  1622. char buf[256];
  1624. mylog("%s: entering...stmt=%un", func, stmt);
  1626.     if( ! stmt) {
  1627. SC_log_error(func, "", NULL);
  1628.         return SQL_INVALID_HANDLE;
  1629.     }
  1631. stmt->manual_result = TRUE;
  1632. stmt->errormsg_created = TRUE;
  1634. ci = &stmt->hdbc->connInfo;
  1636.     stmt->result = QR_Constructor();
  1637.     if(!stmt->result) {
  1638.         stmt->errormsg = "Couldn't allocate memory for SQLStatistics result.";
  1639.         stmt->errornumber = STMT_NO_MEMORY_ERROR;
  1640. SC_log_error(func, "", stmt);
  1641.         return SQL_ERROR;
  1642.     }
  1644.     // the binding structure for a statement is not set up until
  1645.     // a statement is actually executed, so we'll have to do this ourselves.
  1646.     extend_bindings(stmt, 13);
  1648.     // set the field names
  1649.     QR_set_num_fields(stmt->result, 13);
  1650.     QR_set_field_info(stmt->result, 0, "TABLE_QUALIFIER", PG_TYPE_TEXT, MAX_INFO_STRING);
  1651.     QR_set_field_info(stmt->result, 1, "TABLE_OWNER", PG_TYPE_TEXT, MAX_INFO_STRING);
  1652.     QR_set_field_info(stmt->result, 2, "TABLE_NAME", PG_TYPE_TEXT, MAX_INFO_STRING);
  1653.     QR_set_field_info(stmt->result, 3, "NON_UNIQUE", PG_TYPE_INT2, 2);
  1654.     QR_set_field_info(stmt->result, 4, "INDEX_QUALIFIER", PG_TYPE_TEXT, MAX_INFO_STRING);
  1655.     QR_set_field_info(stmt->result, 5, "INDEX_NAME", PG_TYPE_TEXT, MAX_INFO_STRING);
  1656.     QR_set_field_info(stmt->result, 6, "TYPE", PG_TYPE_INT2, 2);
  1657.     QR_set_field_info(stmt->result, 7, "SEQ_IN_INDEX", PG_TYPE_INT2, 2);
  1658.     QR_set_field_info(stmt->result, 8, "COLUMN_NAME", PG_TYPE_TEXT, MAX_INFO_STRING);
  1659.     QR_set_field_info(stmt->result, 9, "COLLATION", PG_TYPE_CHAR, 1);
  1660.     QR_set_field_info(stmt->result, 10, "CARDINALITY", PG_TYPE_INT4, 4);
  1661.     QR_set_field_info(stmt->result, 11, "PAGES", PG_TYPE_INT4, 4);
  1662.     QR_set_field_info(stmt->result, 12, "FILTER_CONDITION", PG_TYPE_TEXT, MAX_INFO_STRING);
  1665.     // only use the table name... the owner should be redundant, and
  1666.     // we never use qualifiers.
  1667. table_name = make_string(szTableName, cbTableName, NULL);
  1668. if ( ! table_name) {
  1669.         stmt->errormsg = "No table name passed to SQLStatistics.";
  1670.         stmt->errornumber = STMT_INTERNAL_ERROR;
  1671. SC_log_error(func, "", stmt);
  1672.         return SQL_ERROR;
  1673.     }
  1675. // we need to get a list of the field names first,
  1676. // so we can return them later.
  1677. result = SQLAllocStmt( stmt->hdbc, &hcol_stmt);
  1678. if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  1679. stmt->errormsg = "SQLAllocStmt failed in SQLStatistics for columns.";
  1680. stmt->errornumber = STMT_NO_MEMORY_ERROR;
  1681. goto SEEYA;
  1682. }
  1684. col_stmt = (StatementClass *) hcol_stmt;
  1686. /* "internal" prevents SQLColumns from returning the oid if it is being shown.
  1687. This would throw everything off.
  1688. */
  1689. col_stmt->internal = TRUE;
  1690. result = SQLColumns(hcol_stmt, "", 0, "", 0, 
  1691. table_name, (SWORD) strlen(table_name), "", 0);
  1692. col_stmt->internal = FALSE;
  1694. if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  1695. stmt->errormsg = col_stmt->errormsg;        // "SQLColumns failed in SQLStatistics.";
  1696. stmt->errornumber = col_stmt->errornumber;  // STMT_EXEC_ERROR;
  1697. SQLFreeStmt(hcol_stmt, SQL_DROP);
  1698. goto SEEYA;
  1699. }
  1700. result = SQLBindCol(hcol_stmt, 4, SQL_C_CHAR,
  1701. column_name, MAX_INFO_STRING, &column_name_len);
  1702. if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  1703. stmt->errormsg = col_stmt->errormsg;
  1704. stmt->errornumber = col_stmt->errornumber;
  1705. SQLFreeStmt(hcol_stmt, SQL_DROP);
  1706. goto SEEYA;
  1708. }
  1710. result = SQLFetch(hcol_stmt);
  1711. while((result == SQL_SUCCESS) || (result == SQL_SUCCESS_WITH_INFO)) {
  1712. total_columns++;
  1714. column_names = 
  1715. (char **)realloc(column_names, 
  1716.  total_columns * sizeof(char *));
  1717. column_names[total_columns-1] = 
  1718. (char *)malloc(strlen(column_name)+1);
  1719. strcpy(column_names[total_columns-1], column_name);
  1721. mylog("SQLStatistics: column_name = '%s'n", column_name);
  1723. result = SQLFetch(hcol_stmt);
  1724. }
  1725. if(result != SQL_NO_DATA_FOUND || total_columns == 0) {
  1726. stmt->errormsg = SC_create_errormsg(hcol_stmt); // "Couldn't get column names in SQLStatistics.";
  1727. stmt->errornumber = col_stmt->errornumber;
  1728. SQLFreeStmt(hcol_stmt, SQL_DROP);
  1729.     goto SEEYA;
  1731. }
  1733. SQLFreeStmt(hcol_stmt, SQL_DROP);
  1735.     // get a list of indexes on this table
  1736.     result = SQLAllocStmt( stmt->hdbc, &hindx_stmt);
  1737.     if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  1738. stmt->errormsg = "SQLAllocStmt failed in SQLStatistics for indices.";
  1739. stmt->errornumber = STMT_NO_MEMORY_ERROR;
  1740. goto SEEYA;
  1742.     }
  1743. indx_stmt = (StatementClass *) hindx_stmt;
  1745. sprintf(index_query, "select c.relname, i.indkey, i.indisunique, i.indisclustered from pg_index i, pg_class c, pg_class d where c.oid = i.indexrelid and d.relname = '%s' and d.oid = i.indrelid", 
  1746. table_name);
  1748.     result = SQLExecDirect(hindx_stmt, index_query, strlen(index_query));
  1749.     if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  1750. stmt->errormsg = SC_create_errormsg(hindx_stmt); // "Couldn't execute index query (w/SQLExecDirect) in SQLStatistics.";
  1751. stmt->errornumber = indx_stmt->errornumber;
  1752. SQLFreeStmt(hindx_stmt, SQL_DROP);
  1753.    goto SEEYA;
  1755.     }
  1757.     // bind the index name column
  1758.     result = SQLBindCol(hindx_stmt, 1, SQL_C_CHAR,
  1759.                         index_name, MAX_INFO_STRING, &index_name_len);
  1760.     if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  1761. stmt->errormsg = indx_stmt->errormsg; // "Couldn't bind column in SQLStatistics.";
  1762. stmt->errornumber = indx_stmt->errornumber;
  1763. SQLFreeStmt(hindx_stmt, SQL_DROP);
  1764.     goto SEEYA;
  1766.     }
  1767.     // bind the vector column
  1768.     result = SQLBindCol(hindx_stmt, 2, SQL_C_DEFAULT,
  1769.                         fields_vector, 16, &fields_vector_len);
  1770.     if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  1771. stmt->errormsg = indx_stmt->errormsg;  // "Couldn't bind column in SQLStatistics.";
  1772. stmt->errornumber = indx_stmt->errornumber;
  1773. SQLFreeStmt(hindx_stmt, SQL_DROP);
  1774. goto SEEYA;
  1776.     }
  1777.     // bind the "is unique" column
  1778.     result = SQLBindCol(hindx_stmt, 3, SQL_C_CHAR,
  1779.                         isunique, sizeof(isunique), NULL);
  1780.     if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  1781. stmt->errormsg = indx_stmt->errormsg;  // "Couldn't bind column in SQLStatistics.";
  1782. stmt->errornumber = indx_stmt->errornumber;
  1783. SQLFreeStmt(hindx_stmt, SQL_DROP);
  1784. goto SEEYA;
  1785.     }
  1787.     // bind the "is clustered" column
  1788.     result = SQLBindCol(hindx_stmt, 4, SQL_C_CHAR,
  1789.                         isclustered, sizeof(isclustered), NULL);
  1790.     if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  1791. stmt->errormsg = indx_stmt->errormsg;  // "Couldn't bind column in SQLStatistics.";
  1792. stmt->errornumber = indx_stmt->errornumber;
  1793. SQLFreeStmt(hindx_stmt, SQL_DROP);
  1794. goto SEEYA;
  1796.     }
  1798. /* fake index of OID */
  1799. if (atoi(ci->show_oid_column) && atoi(ci->fake_oid_index)) {
  1800. row = (TupleNode *)malloc(sizeof(TupleNode) + 
  1801.   (13 - 1) * sizeof(TupleField));
  1803. // no table qualifier
  1804. set_tuplefield_string(&row->tuple[0], "");
  1805. // don't set the table owner, else Access tries to use it
  1806. set_tuplefield_string(&row->tuple[1], "");
  1807. set_tuplefield_string(&row->tuple[2], table_name);
  1809. // non-unique index?
  1810. set_tuplefield_int2(&row->tuple[3], (Int2) (globals.unique_index ? FALSE : TRUE));
  1812. // no index qualifier
  1813. set_tuplefield_string(&row->tuple[4], "");
  1815. sprintf(buf, "%s_idx_fake_oid", table_name);
  1816. set_tuplefield_string(&row->tuple[5], buf);
  1818. // Clustered index?  I think non-clustered should be type OTHER not HASHED
  1819. set_tuplefield_int2(&row->tuple[6], (Int2) SQL_INDEX_OTHER);
  1820. set_tuplefield_int2(&row->tuple[7], (Int2) 1);
  1822. set_tuplefield_string(&row->tuple[8], "oid");
  1823. set_tuplefield_string(&row->tuple[9], "A");
  1824. set_tuplefield_null(&row->tuple[10]);
  1825. set_tuplefield_null(&row->tuple[11]);
  1826. set_tuplefield_null(&row->tuple[12]);
  1828. QR_add_tuple(stmt->result, row);
  1829. }
  1831.     result = SQLFetch(hindx_stmt);
  1832.     while((result == SQL_SUCCESS) || (result == SQL_SUCCESS_WITH_INFO)) {
  1834. // If only requesting unique indexs, then just return those.
  1835. if (fUnique == SQL_INDEX_ALL || 
  1836. (fUnique == SQL_INDEX_UNIQUE && atoi(isunique))) {
  1837. i = 0;
  1838. // add a row in this table for each field in the index
  1839. while(i < 8 && fields_vector[i] != 0) {
  1841. row = (TupleNode *)malloc(sizeof(TupleNode) + 
  1842.   (13 - 1) * sizeof(TupleField));
  1844. // no table qualifier
  1845. set_tuplefield_string(&row->tuple[0], "");
  1846. // don't set the table owner, else Access tries to use it
  1847. set_tuplefield_string(&row->tuple[1], "");
  1848. set_tuplefield_string(&row->tuple[2], table_name);
  1850. // non-unique index?
  1851. if (globals.unique_index)
  1852. set_tuplefield_int2(&row->tuple[3], (Int2) (atoi(isunique) ? FALSE : TRUE));
  1853. else
  1854. set_tuplefield_int2(&row->tuple[3], TRUE);
  1856. // no index qualifier
  1857. set_tuplefield_string(&row->tuple[4], "");
  1858. set_tuplefield_string(&row->tuple[5], index_name);
  1860. // Clustered index?  I think non-clustered should be type OTHER not HASHED
  1861. set_tuplefield_int2(&row->tuple[6], (Int2) (atoi(isclustered) ? SQL_INDEX_CLUSTERED : SQL_INDEX_OTHER));
  1862. set_tuplefield_int2(&row->tuple[7], (Int2) (i+1));
  1864. if(fields_vector[i] == OID_ATTNUM) {
  1865. set_tuplefield_string(&row->tuple[8], "oid");
  1866. mylog("SQLStatistics: column name = oidn");
  1867. }
  1868. else if(fields_vector[i] < 0 || fields_vector[i] > total_columns) {
  1869. set_tuplefield_string(&row->tuple[8], "UNKNOWN");
  1870. mylog("SQLStatistics: column name = UNKNOWNn");
  1871. }
  1872. else {
  1873. set_tuplefield_string(&row->tuple[8], column_names[fields_vector[i]-1]);
  1874. mylog("SQLStatistics: column name = '%s'n", column_names[fields_vector[i]-1]);
  1875. }
  1877. set_tuplefield_string(&row->tuple[9], "A");
  1878. set_tuplefield_null(&row->tuple[10]);
  1879. set_tuplefield_null(&row->tuple[11]);
  1880. set_tuplefield_null(&row->tuple[12]);
  1882. QR_add_tuple(stmt->result, row);
  1883. i++;
  1884. }
  1885. }
  1887.         result = SQLFetch(hindx_stmt);
  1888.     }
  1889.     if(result != SQL_NO_DATA_FOUND) {
  1890. stmt->errormsg = SC_create_errormsg(hindx_stmt); // "SQLFetch failed in SQLStatistics.";
  1891. stmt->errornumber = indx_stmt->errornumber;
  1892. SQLFreeStmt(hindx_stmt, SQL_DROP);
  1893. goto SEEYA;
  1894.     }
  1896. SQLFreeStmt(hindx_stmt, SQL_DROP);
  1898.     // also, things need to think that this statement is finished so
  1899.     // the results can be retrieved.
  1900.     stmt->status = STMT_FINISHED;
  1902.     // set up the current tuple pointer for SQLFetch
  1903.     stmt->currTuple = -1;
  1904. stmt->rowset_start = -1;
  1905. stmt->current_col = -1;
  1907. error = FALSE;
  1909. SEEYA:
  1910. /* These things should be freed on any error ALSO! */
  1911. free(table_name);
  1912.     for(i = 0; i < total_columns; i++) {
  1913. free(column_names[i]);
  1914.     }
  1915.     free(column_names);
  1917. mylog("SQLStatistics(): EXIT, %s, stmt=%un", error ? "error" : "success", stmt);
  1919. if (error) {
  1920. SC_log_error(func, "", stmt);
  1921. return SQL_ERROR;
  1922. }
  1923. else
  1924. return SQL_SUCCESS;
  1925. }
  1927. RETCODE SQL_API SQLColumnPrivileges(
  1928.                                     HSTMT        hstmt,
  1929.                                     UCHAR FAR *  szTableQualifier,
  1930.                                     SWORD        cbTableQualifier,
  1931.                                     UCHAR FAR *  szTableOwner,
  1932.                                     SWORD        cbTableOwner,
  1933.                                     UCHAR FAR *  szTableName,
  1934.                                     SWORD        cbTableName,
  1935.                                     UCHAR FAR *  szColumnName,
  1936.                                     SWORD        cbColumnName)
  1937. {
  1938. static char *func="SQLColumnPrivileges";
  1940. mylog("%s: entering...n", func);
  1942. /* Neither Access or Borland care about this. */
  1944. SC_log_error(func, "Function not implemented", (StatementClass *) hstmt);
  1945.     return SQL_ERROR;
  1946. }
  1950. RETCODE SQL_API SQLPrimaryKeys(
  1951.                                HSTMT         hstmt,
  1952.                                UCHAR FAR *   szTableQualifier,
  1953.                                SWORD         cbTableQualifier,
  1954.                                UCHAR FAR *   szTableOwner,
  1955.                                SWORD         cbTableOwner,
  1956.                                UCHAR FAR *   szTableName,
  1957.                                SWORD         cbTableName)
  1958. {
  1959. static char *func = "SQLPrimaryKeys";
  1960. StatementClass *stmt = (StatementClass *) hstmt;
  1961. TupleNode *row;
  1962. RETCODE result;
  1963. int seq = 0;
  1964. HSTMT htbl_stmt;
  1965. StatementClass *tbl_stmt;
  1966. char tables_query[MAX_STATEMENT_LEN];
  1967. char attname[MAX_INFO_STRING];
  1968. SDWORD attname_len;
  1969. char pktab[MAX_TABLE_LEN + 1];
  1970. Int2 result_cols;
  1972. mylog("%s: entering...stmt=%un", func, stmt);
  1974.     if( ! stmt) {
  1975. SC_log_error(func, "", NULL);
  1976.         return SQL_INVALID_HANDLE;
  1977.     }
  1978. stmt->manual_result = TRUE;
  1979. stmt->errormsg_created = TRUE;
  1981.     stmt->result = QR_Constructor();
  1982.     if(!stmt->result) {
  1983.         stmt->errormsg = "Couldn't allocate memory for SQLPrimaryKeys result.";
  1984.         stmt->errornumber = STMT_NO_MEMORY_ERROR;
  1985. SC_log_error(func, "", stmt);
  1986.         return SQL_ERROR;
  1987.     }
  1989.     // the binding structure for a statement is not set up until
  1990.     // a statement is actually executed, so we'll have to do this ourselves.
  1991. result_cols = 6;
  1992.     extend_bindings(stmt, result_cols);
  1994.     // set the field names
  1995.     QR_set_num_fields(stmt->result, result_cols);
  1996.     QR_set_field_info(stmt->result, 0, "TABLE_QUALIFIER", PG_TYPE_TEXT, MAX_INFO_STRING);
  1997.     QR_set_field_info(stmt->result, 1, "TABLE_OWNER", PG_TYPE_TEXT, MAX_INFO_STRING);
  1998.     QR_set_field_info(stmt->result, 2, "TABLE_NAME", PG_TYPE_TEXT, MAX_INFO_STRING);
  1999.     QR_set_field_info(stmt->result, 3, "COLUMN_NAME", PG_TYPE_TEXT, MAX_INFO_STRING);
  2000.     QR_set_field_info(stmt->result, 4, "KEY_SEQ", PG_TYPE_INT2, 2);
  2001.     QR_set_field_info(stmt->result, 5, "PK_NAME", PG_TYPE_TEXT, MAX_INFO_STRING);
  2004.     result = SQLAllocStmt( stmt->hdbc, &htbl_stmt);
  2005.     if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  2006. stmt->errornumber = STMT_NO_MEMORY_ERROR;
  2007. stmt->errormsg = "Couldn't allocate statement for Primary Key result.";
  2008. SC_log_error(func, "", stmt);
  2009.         return SQL_ERROR;
  2010.     }
  2011. tbl_stmt = (StatementClass *) htbl_stmt;
  2013. pktab[0] = '';
  2014. make_string(szTableName, cbTableName, pktab);
  2015. if ( pktab[0] == '') {
  2016. stmt->errormsg = "No Table specified to SQLPrimaryKeys.";
  2017.     stmt->errornumber = STMT_INTERNAL_ERROR;
  2018. SC_log_error(func, "", stmt);
  2019. SQLFreeStmt(htbl_stmt, SQL_DROP);
  2020. return SQL_ERROR;
  2021. }
  2023. 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);
  2025. mylog("SQLPrimaryKeys: tables_query='%s'n", tables_query);
  2027.     result = SQLExecDirect(htbl_stmt, tables_query, strlen(tables_query));
  2028.     if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  2029. stmt->errormsg = SC_create_errormsg(htbl_stmt);
  2030. stmt->errornumber = tbl_stmt->errornumber;
  2031. SC_log_error(func, "", stmt);
  2032. SQLFreeStmt(htbl_stmt, SQL_DROP);
  2033.         return SQL_ERROR;
  2034.     }
  2036.     result = SQLBindCol(htbl_stmt, 1, SQL_C_CHAR,
  2037.                         attname, MAX_INFO_STRING, &attname_len);
  2038.     if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  2039. stmt->errormsg = tbl_stmt->errormsg;
  2040. stmt->errornumber = tbl_stmt->errornumber;
  2041. SC_log_error(func, "", stmt);
  2042. SQLFreeStmt(htbl_stmt, SQL_DROP);
  2043.         return SQL_ERROR;
  2044.     }
  2046.     result = SQLFetch(htbl_stmt);
  2048.     while((result == SQL_SUCCESS) || (result == SQL_SUCCESS_WITH_INFO)) {
  2050.         row = (TupleNode *)malloc(sizeof(TupleNode) + (result_cols - 1) * sizeof(TupleField));
  2052.         set_tuplefield_null(&row->tuple[0]);
  2054.         // I have to hide the table owner from Access, otherwise it
  2055.         // insists on referring to the table as 'owner.table'.
  2056.         // (this is valid according to the ODBC SQL grammar, but
  2057.         // Postgres won't support it.)
  2059.         set_tuplefield_string(&row->tuple[1], "");
  2060.         set_tuplefield_string(&row->tuple[2], pktab);
  2061.         set_tuplefield_string(&row->tuple[3], attname);
  2062. set_tuplefield_int2(&row->tuple[4], (Int2) (++seq));
  2063. set_tuplefield_null(&row->tuple[5]);
  2065.         QR_add_tuple(stmt->result, row);
  2067. mylog(">> primaryKeys: pktab = '%s', attname = '%s', seq = %dn", pktab, attname, seq);
  2069.         result = SQLFetch(htbl_stmt);
  2070.     }
  2072.     if(result != SQL_NO_DATA_FOUND) {
  2073. stmt->errormsg = SC_create_errormsg(htbl_stmt);
  2074. stmt->errornumber = tbl_stmt->errornumber;
  2075. SC_log_error(func, "", stmt);
  2076. SQLFreeStmt(htbl_stmt, SQL_DROP);
  2077.         return SQL_ERROR;
  2078.     }
  2080. SQLFreeStmt(htbl_stmt, SQL_DROP);
  2083.     // also, things need to think that this statement is finished so
  2084.     // the results can be retrieved.
  2085.     stmt->status = STMT_FINISHED;
  2087.     // set up the current tuple pointer for SQLFetch
  2088.     stmt->currTuple = -1;
  2089. stmt->rowset_start = -1;
  2090. stmt->current_col = -1;
  2092. mylog("SQLPrimaryKeys(): EXIT, stmt=%un", stmt);
  2093.     return SQL_SUCCESS;
  2094. }
  2096. RETCODE SQL_API SQLForeignKeys(
  2097.                                HSTMT         hstmt,
  2098.                                UCHAR FAR *   szPkTableQualifier,
  2099.                                SWORD         cbPkTableQualifier,
  2100.                                UCHAR FAR *   szPkTableOwner,
  2101.                                SWORD         cbPkTableOwner,
  2102.                                UCHAR FAR *   szPkTableName,
  2103.                                SWORD         cbPkTableName,
  2104.                                UCHAR FAR *   szFkTableQualifier,
  2105.                                SWORD         cbFkTableQualifier,
  2106.                                UCHAR FAR *   szFkTableOwner,
  2107.                                SWORD         cbFkTableOwner,
  2108.                                UCHAR FAR *   szFkTableName,
  2109.                                SWORD         cbFkTableName)
  2110. {
  2111. static char *func = "SQLForeignKeys";
  2112. StatementClass *stmt = (StatementClass *) hstmt;
  2113. TupleNode *row;
  2114. HSTMT htbl_stmt, hpkey_stmt;
  2115. StatementClass *tbl_stmt;
  2116. RETCODE result, keyresult;
  2117. char tables_query[MAX_STATEMENT_LEN];
  2118. char args[1024], tgname[MAX_INFO_STRING];
  2119. char pktab[MAX_TABLE_LEN + 1], fktab[MAX_TABLE_LEN + 1];
  2120. char *ptr, *pkey_ptr, *pkptr, *fkptr, *frel, *prel;
  2121. int i, k, pkeys, seq, ntabs;
  2122. SWORD nargs, rule_type, action;
  2123. char pkey[MAX_INFO_STRING];
  2124. Int2 result_cols;
  2127. mylog("%s: entering...stmt=%un", func, stmt);
  2130.     if( ! stmt) {
  2131. SC_log_error(func, "", NULL);
  2132.         return SQL_INVALID_HANDLE;
  2133.     }
  2134. stmt->manual_result = TRUE;
  2135. stmt->errormsg_created = TRUE;
  2137.     stmt->result = QR_Constructor();
  2138.     if(!stmt->result) {
  2139. stmt->errormsg = "Couldn't allocate memory for SQLForeignKeys result.";
  2140.         stmt->errornumber = STMT_NO_MEMORY_ERROR;
  2141. SC_log_error(func, "", stmt);
  2142. SQLFreeStmt(htbl_stmt, SQL_DROP);
  2143.         return SQL_ERROR;
  2144.     }
  2146.     // the binding structure for a statement is not set up until
  2147.     // a statement is actually executed, so we'll have to do this ourselves.
  2148. result_cols = 14;
  2149.     extend_bindings(stmt, result_cols);
  2151.     // set the field names
  2152.     QR_set_num_fields(stmt->result, result_cols);
  2153.     QR_set_field_info(stmt->result, 0, "PKTABLE_QUALIFIER", PG_TYPE_TEXT, MAX_INFO_STRING);
  2154.     QR_set_field_info(stmt->result, 1, "PKTABLE_OWNER", PG_TYPE_TEXT, MAX_INFO_STRING);
  2155.     QR_set_field_info(stmt->result, 2, "PKTABLE_NAME", PG_TYPE_TEXT, MAX_INFO_STRING);
  2156.     QR_set_field_info(stmt->result, 3, "PKCOLUMN_NAME", PG_TYPE_TEXT, MAX_INFO_STRING);
  2157.     QR_set_field_info(stmt->result, 4, "FKTABLE_QUALIFIER", PG_TYPE_TEXT, MAX_INFO_STRING);
  2158.     QR_set_field_info(stmt->result, 5, "FKTABLE_OWNER", PG_TYPE_TEXT, MAX_INFO_STRING);
  2159.     QR_set_field_info(stmt->result, 6, "FKTABLE_NAME", PG_TYPE_TEXT, MAX_INFO_STRING);
  2160.     QR_set_field_info(stmt->result, 7, "FKCOLUMN_NAME", PG_TYPE_TEXT, MAX_INFO_STRING);
  2161.     QR_set_field_info(stmt->result, 8, "KEY_SEQ", PG_TYPE_INT2, 2);
  2162.     QR_set_field_info(stmt->result, 9, "UPDATE_RULE", PG_TYPE_INT2, 2);
  2163.     QR_set_field_info(stmt->result, 10, "DELETE_RULE", PG_TYPE_INT2, 2);
  2164.     QR_set_field_info(stmt->result, 11, "FK_NAME", PG_TYPE_TEXT, MAX_INFO_STRING);
  2165.     QR_set_field_info(stmt->result, 12, "PK_NAME", PG_TYPE_TEXT, MAX_INFO_STRING);
  2166.     QR_set_field_info(stmt->result, 13, "TRIGGER_NAME", PG_TYPE_TEXT, MAX_INFO_STRING);
  2168.     // also, things need to think that this statement is finished so
  2169.     // the results can be retrieved.
  2170.     stmt->status = STMT_FINISHED;
  2172.     // set up the current tuple pointer for SQLFetch
  2173.     stmt->currTuple = -1;
  2174. stmt->rowset_start = -1;
  2175. stmt->current_col = -1;
  2178.     result = SQLAllocStmt( stmt->hdbc, &htbl_stmt);
  2179.     if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  2180. stmt->errornumber = STMT_NO_MEMORY_ERROR;
  2181. stmt->errormsg = "Couldn't allocate statement for SQLForeignKeys result.";
  2182. SC_log_error(func, "", stmt);
  2183.         return SQL_ERROR;
  2184.     }
  2186. tbl_stmt = (StatementClass *) htbl_stmt;
  2188. pktab[0] = '';
  2189. fktab[0] = '';
  2191. make_string(szPkTableName, cbPkTableName, pktab);
  2192. make_string(szFkTableName, cbFkTableName, fktab);
  2195. /* Case #2 -- Get the foreign keys in the specified table (fktab) that 
  2196. refer to the primary keys of other table(s).
  2197. */
  2198. if (fktab[0] != '') {
  2200. sprintf(tables_query, "select pg_trigger.tgargs, pg_trigger.tgnargs, pg_trigger.tgname from pg_proc, pg_trigger, pg_class where pg_proc.oid = pg_trigger.tgfoid and pg_trigger.tgrelid = pg_class.oid AND pg_proc.proname = 'check_primary_key' AND pg_class.relname = '%s'",
  2201. fktab);
  2203. result = SQLExecDirect(htbl_stmt, tables_query, strlen(tables_query));
  2204. if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  2205. stmt->errormsg = SC_create_errormsg(htbl_stmt);
  2206. stmt->errornumber = tbl_stmt->errornumber;
  2207. SC_log_error(func, "", stmt);
  2208.      SQLFreeStmt(htbl_stmt, SQL_DROP);
  2209. return SQL_ERROR;
  2210. }
  2212. result = SQLBindCol(htbl_stmt, 1, SQL_C_BINARY,
  2213. args, MAX_INFO_STRING, NULL);
  2214. if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  2215. stmt->errormsg = tbl_stmt->errormsg;
  2216. stmt->errornumber = tbl_stmt->errornumber;
  2217. SC_log_error(func, "", stmt);
  2218. SQLFreeStmt(htbl_stmt, SQL_DROP);
  2219. return SQL_ERROR;
  2220. }
  2222. result = SQLBindCol(htbl_stmt, 2, SQL_C_SHORT,
  2223. &nargs, 0, NULL);
  2224. if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  2225. stmt->errormsg = tbl_stmt->errormsg;
  2226. stmt->errornumber = tbl_stmt->errornumber;
  2227. SC_log_error(func, "", stmt);
  2228. SQLFreeStmt(htbl_stmt, SQL_DROP);
  2229. return SQL_ERROR;
  2230. }
  2232. result = SQLBindCol(htbl_stmt, 3, SQL_C_CHAR,
  2233. tgname, sizeof(tgname), NULL);
  2234. if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  2235. stmt->errormsg = tbl_stmt->errormsg;
  2236. stmt->errornumber = tbl_stmt->errornumber;
  2237. SC_log_error(func, "", stmt);
  2238. SQLFreeStmt(htbl_stmt, SQL_DROP);
  2239. return SQL_ERROR;
  2240. }
  2242. result = SQLFetch(htbl_stmt);
  2243. if (result == SQL_NO_DATA_FOUND)
  2244. return SQL_SUCCESS;
  2246. if(result != SQL_SUCCESS) {
  2247. stmt->errormsg = SC_create_errormsg(htbl_stmt);
  2248. stmt->errornumber = tbl_stmt->errornumber;
  2249. SC_log_error(func, "", stmt);
  2250. SQLFreeStmt(htbl_stmt, SQL_DROP);
  2251. return SQL_ERROR;
  2252. }
  2254. keyresult = SQLAllocStmt( stmt->hdbc, &hpkey_stmt);
  2255. if((keyresult != SQL_SUCCESS) && (keyresult != SQL_SUCCESS_WITH_INFO)) {
  2256. stmt->errornumber = STMT_NO_MEMORY_ERROR;
  2257. stmt->errormsg = "Couldn't allocate statement for SQLForeignKeys (pkeys) result.";
  2258. SC_log_error(func, "", stmt);
  2259. return SQL_ERROR;
  2260. }
  2262. keyresult = SQLBindCol(hpkey_stmt, 4, SQL_C_CHAR,
  2263. pkey, sizeof(pkey), NULL);
  2264. if (keyresult != SQL_SUCCESS) {
  2265. stmt->errornumber = STMT_NO_MEMORY_ERROR;
  2266. stmt->errormsg = "Couldn't bindcol for primary keys for SQLForeignKeys result.";
  2267. SC_log_error(func, "", stmt);
  2268. SQLFreeStmt(hpkey_stmt, SQL_DROP);
  2269. return SQL_ERROR;
  2270. }
  2272. while (result == SQL_SUCCESS) {
  2274. /* Compute the number of keyparts. */
  2275. pkeys = nargs / 2;
  2277. mylog("Foreign Key Case#2: nargs = %d, pkeys = %dn", nargs, pkeys);
  2279. ptr = args;
  2281. /* Get to the PK Table Name */
  2282. for (k = 0; k < pkeys; k++)
  2283. ptr += strlen(ptr) + 1;
  2285. prel = ptr;
  2287. mylog("prel = '%s'n", prel);
  2289. /* If there is a pk table specified, then check it. */
  2290. if (pktab[0] != '') {
  2292. /* If it doesn't match, then continue */
  2293. if ( strcmp(prel, pktab)) {
  2294. result = SQLFetch(htbl_stmt);
  2295. continue;
  2296. }
  2297. }
  2299. keyresult = SQLPrimaryKeys(hpkey_stmt, NULL, 0, NULL, 0, prel, SQL_NTS);
  2300. if (keyresult != SQL_SUCCESS) {
  2301. stmt->errornumber = STMT_NO_MEMORY_ERROR;
  2302. stmt->errormsg = "Couldn't get primary keys for SQLForeignKeys result.";
  2303. SC_log_error(func, "", stmt);
  2304. SQLFreeStmt(hpkey_stmt, SQL_DROP);
  2305. return SQL_ERROR;
  2306. }
  2309. /* Check that the key listed is the primary key */
  2310. keyresult = SQLFetch(hpkey_stmt);
  2311. for (k = 0; k < pkeys; k++) {
  2313. ptr += strlen(ptr) + 1;
  2314. if ( keyresult != SQL_SUCCESS || strcmp(ptr, pkey)) {
  2315. pkeys = 0;
  2316. break;
  2317. }
  2318. keyresult = SQLFetch(hpkey_stmt);
  2319. }
  2320. ptr = prel;
  2324. /* Set to first fk column */
  2325. fkptr = args;
  2326. seq = 0;
  2328. for (k = 0; k < pkeys; k++) {
  2330. row = (TupleNode *)malloc(sizeof(TupleNode) + (result_cols - 1) * sizeof(TupleField));
  2332. set_tuplefield_null(&row->tuple[0]);
  2333. set_tuplefield_string(&row->tuple[1], "");
  2335. set_tuplefield_string(&row->tuple[2], prel);
  2337. // Get to the primary key
  2338. ptr += strlen(ptr) + 1;
  2340. mylog("prel = '%s', ptr = '%s'n", prel, ptr);
  2342. set_tuplefield_string(&row->tuple[3], ptr);
  2343. set_tuplefield_null(&row->tuple[4]);
  2344. set_tuplefield_string(&row->tuple[5], "");
  2346. set_tuplefield_string(&row->tuple[6], fktab);
  2347. set_tuplefield_string(&row->tuple[7], fkptr);
  2349. mylog("fktab = '%s', fkptr = '%s'n", fktab, fkptr);
  2351. set_tuplefield_int2(&row->tuple[8], (Int2) (++seq));
  2352. set_tuplefield_null(&row->tuple[9]);
  2353. set_tuplefield_null(&row->tuple[10]);
  2354. set_tuplefield_null(&row->tuple[11]);
  2355. set_tuplefield_null(&row->tuple[12]);
  2357. set_tuplefield_string(&row->tuple[13], tgname);
  2359. QR_add_tuple(stmt->result, row);
  2361. // next foreign key
  2362. fkptr += strlen(fkptr) + 1;
  2364. }
  2366. result = SQLFetch(htbl_stmt);
  2367. }
  2368. }
  2370. /* Case #1 -- Get the foreign keys in other tables that refer to the primary key
  2371. in the specified table (pktab).  i.e., Who points to me?
  2372. */
  2373.     else if (pktab[0] != '') {
  2375. sprintf(tables_query, "select pg_trigger.tgargs, pg_trigger.tgnargs, pg_trigger.tgtype, pg_trigger.tgname from pg_proc, pg_trigger, pg_class where pg_proc.oid = pg_trigger.tgfoid and pg_trigger.tgrelid = pg_class.oid AND pg_proc.proname = 'check_foreign_key' AND pg_class.relname = '%s'",
  2376. pktab);
  2378. result = SQLExecDirect(htbl_stmt, tables_query, strlen(tables_query));
  2379. if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  2380. stmt->errormsg = SC_create_errormsg(htbl_stmt);
  2381. stmt->errornumber = tbl_stmt->errornumber;
  2382. SC_log_error(func, "", stmt);
  2383.      SQLFreeStmt(htbl_stmt, SQL_DROP);
  2384. return SQL_ERROR;
  2385. }
  2387. result = SQLBindCol(htbl_stmt, 1, SQL_C_BINARY,
  2388. args, sizeof(args), NULL);
  2389. if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  2390. stmt->errormsg = tbl_stmt->errormsg;
  2391. stmt->errornumber = tbl_stmt->errornumber;
  2392. SC_log_error(func, "", stmt);
  2393. SQLFreeStmt(htbl_stmt, SQL_DROP);
  2394. return SQL_ERROR;
  2395. }
  2397. result = SQLBindCol(htbl_stmt, 2, SQL_C_SHORT,
  2398. &nargs, 0, NULL);
  2399. if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  2400. stmt->errormsg = tbl_stmt->errormsg;
  2401. stmt->errornumber = tbl_stmt->errornumber;
  2402. SC_log_error(func, "", stmt);
  2403. SQLFreeStmt(htbl_stmt, SQL_DROP);
  2404. return SQL_ERROR;
  2405. }
  2407. result = SQLBindCol(htbl_stmt, 3, SQL_C_SHORT,
  2408. &rule_type, 0, NULL);
  2409. if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  2410. stmt->errormsg = tbl_stmt->errormsg;
  2411. stmt->errornumber = tbl_stmt->errornumber;
  2412. SC_log_error(func, "", stmt);
  2413. SQLFreeStmt(htbl_stmt, SQL_DROP);
  2414. return SQL_ERROR;
  2415. }
  2417. result = SQLBindCol(htbl_stmt, 4, SQL_C_CHAR,
  2418. tgname, sizeof(tgname), NULL);
  2419. if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  2420. stmt->errormsg = tbl_stmt->errormsg;
  2421. stmt->errornumber = tbl_stmt->errornumber;
  2422. SC_log_error(func, "", stmt);
  2423. SQLFreeStmt(htbl_stmt, SQL_DROP);
  2424. return SQL_ERROR;
  2425. }
  2427. result = SQLFetch(htbl_stmt);
  2428. if (result == SQL_NO_DATA_FOUND)
  2429. return SQL_SUCCESS;
  2431. if(result != SQL_SUCCESS) {
  2432. stmt->errormsg = SC_create_errormsg(htbl_stmt);
  2433. stmt->errornumber = tbl_stmt->errornumber;
  2434. SC_log_error(func, "", stmt);
  2435. SQLFreeStmt(htbl_stmt, SQL_DROP);
  2436. return SQL_ERROR;
  2437. }
  2439. keyresult = SQLAllocStmt( stmt->hdbc, &hpkey_stmt);
  2440. if((keyresult != SQL_SUCCESS) && (keyresult != SQL_SUCCESS_WITH_INFO)) {
  2441. stmt->errornumber = STMT_NO_MEMORY_ERROR;
  2442. stmt->errormsg = "Couldn't allocate statement for SQLForeignKeys (pkeys) result.";
  2443. SC_log_error(func, "", stmt);
  2444. return SQL_ERROR;
  2445. }
  2447. keyresult = SQLPrimaryKeys(hpkey_stmt, NULL, 0, NULL, 0, pktab, SQL_NTS);
  2448. if (keyresult != SQL_SUCCESS) {
  2449. stmt->errornumber = STMT_NO_MEMORY_ERROR;
  2450. stmt->errormsg = "Couldn't get primary keys for SQLForeignKeys result.";
  2451. SC_log_error(func, "", stmt);
  2452. SQLFreeStmt(hpkey_stmt, SQL_DROP);
  2453. return SQL_ERROR;
  2454. }
  2456. keyresult = SQLBindCol(hpkey_stmt, 4, SQL_C_CHAR,
  2457. pkey, sizeof(pkey), NULL);
  2458. if (keyresult != SQL_SUCCESS) {
  2459. stmt->errornumber = STMT_NO_MEMORY_ERROR;
  2460. stmt->errormsg = "Couldn't bindcol for primary keys for SQLForeignKeys result.";
  2461. SC_log_error(func, "", stmt);
  2462. SQLFreeStmt(hpkey_stmt, SQL_DROP);
  2463. return SQL_ERROR;
  2464. }
  2466. while (result == SQL_SUCCESS) {
  2467. // Get the number of tables
  2468. ptr = args;
  2469. ntabs = atoi(args);
  2470. ptr += strlen(ptr) + 1;
  2473. // Handle action (i.e., 'cascade', 'restrict', 'setnull')
  2474. switch(tolower(ptr[0])) {
  2475. case 'c':
  2476. action = SQL_CASCADE;
  2477. break;
  2478. case 'r':
  2479. action = SQL_RESTRICT;
  2480. break;
  2481. case 's':
  2482. action = SQL_SET_NULL;
  2483. break;
  2484. default:
  2485. action = -1;
  2486. break;
  2487. }
  2489. rule_type >>= TRIGGER_SHIFT;
  2490. ptr += strlen(ptr) + 1;
  2492. // Calculate the number of key parts
  2493. pkeys = (nargs - ( 2 + ntabs)) / (ntabs + 1);
  2494. pkey_ptr = ptr;
  2497. keyresult = SQLExtendedFetch(hpkey_stmt, SQL_FETCH_FIRST, -1, NULL, NULL);
  2498. if ( keyresult != SQL_SUCCESS || strcmp(pkey, ptr)) {
  2499. ntabs = 0;
  2500. }
  2502. // Get to the last primary keypart
  2503. for (i = 1; i < pkeys; i++) {
  2505. // If keypart doesnt match, skip this entry
  2506. if ( keyresult != SQL_SUCCESS || strcmp(pkey, ptr)) {
  2507. ntabs = 0;
  2508. break;
  2509. }
  2510. ptr += strlen(ptr) + 1;
  2512. keyresult = SQLExtendedFetch(hpkey_stmt, SQL_FETCH_NEXT, -1, NULL, NULL);
  2513. }
  2515. mylog("Foreign Key Case#1: nargs = %d, ntabs = %d, pkeys = %dn", nargs, ntabs, pkeys);
  2518. // Get Foreign Key Tables
  2519. for (i = 0; i < ntabs; i++) {
  2521. seq = 0;
  2522. pkptr = pkey_ptr;
  2524. ptr += strlen(ptr) + 1;
  2525. frel = ptr;
  2527. for (k = 0; k < pkeys; k++) {
  2529. row = (TupleNode *)malloc(sizeof(TupleNode) + (result_cols - 1) * sizeof(TupleField));
  2531. set_tuplefield_null(&row->tuple[0]);
  2532. set_tuplefield_string(&row->tuple[1], "");
  2534. set_tuplefield_string(&row->tuple[2], pktab);
  2535. set_tuplefield_string(&row->tuple[3], pkptr);
  2537. mylog("pktab = '%s', pkptr = '%s'n", pktab, pkptr);
  2539. set_tuplefield_null(&row->tuple[4]);
  2540. set_tuplefield_string(&row->tuple[5], "");
  2541. set_tuplefield_string(&row->tuple[6], frel);
  2543. // Get to the foreign key
  2544. ptr += strlen(ptr) + 1;
  2546. set_tuplefield_string(&row->tuple[7], ptr);
  2548. mylog("frel = '%s', ptr = '%s'n", frel, ptr);
  2549. mylog("rule_type = %d, action = %dn", rule_type, action);
  2551. set_tuplefield_int2(&row->tuple[8], (Int2) (++seq));
  2553. set_nullfield_int2(&row->tuple[9], (Int2) ((rule_type & TRIGGER_UPDATE) ? action : -1));
  2554. set_nullfield_int2(&row->tuple[10], (Int2) ((rule_type & TRIGGER_DELETE) ? action : -1));
  2556. set_tuplefield_null(&row->tuple[11]);
  2557. set_tuplefield_null(&row->tuple[12]);
  2559. set_tuplefield_string(&row->tuple[13], tgname);
  2561. QR_add_tuple(stmt->result, row);
  2563. // next primary key
  2564. pkptr += strlen(pkptr) + 1;
  2566. }
  2568. }
  2570. result = SQLFetch(htbl_stmt);
  2571. }
  2572.     }
  2573. else {
  2574. stmt->errormsg = "No tables specified to SQLForeignKeys.";
  2575. stmt->errornumber = STMT_INTERNAL_ERROR;
  2576. SC_log_error(func, "", stmt);
  2577. SQLFreeStmt(htbl_stmt, SQL_DROP);
  2578. return SQL_ERROR;
  2579. }
  2581. SQLFreeStmt(htbl_stmt, SQL_DROP);
  2582. SQLFreeStmt(hpkey_stmt, SQL_DROP);
  2584. mylog("SQLForeignKeys(): EXIT, stmt=%un", stmt);
  2585.     return SQL_SUCCESS;
  2586. }
  2590. RETCODE SQL_API SQLProcedureColumns(
  2591.                                     HSTMT         hstmt,
  2592.                                     UCHAR FAR *   szProcQualifier,
  2593.                                     SWORD         cbProcQualifier,
  2594.                                     UCHAR FAR *   szProcOwner,
  2595.                                     SWORD         cbProcOwner,
  2596.                                     UCHAR FAR *   szProcName,
  2597.                                     SWORD         cbProcName,
  2598.                                     UCHAR FAR *   szColumnName,
  2599.                                     SWORD         cbColumnName)
  2600. {
  2601. static char *func="SQLProcedureColumns";
  2603. mylog("%s: entering...n", func);
  2605. SC_log_error(func, "Function not implemented", (StatementClass *) hstmt);
  2606.     return SQL_ERROR;
  2607. }
  2609. RETCODE SQL_API SQLProcedures(
  2610.                               HSTMT          hstmt,
  2611.                               UCHAR FAR *    szProcQualifier,
  2612.                               SWORD          cbProcQualifier,
  2613.                               UCHAR FAR *    szProcOwner,
  2614.                               SWORD          cbProcOwner,
  2615.                               UCHAR FAR *    szProcName,
  2616.                               SWORD          cbProcName)
  2617. {
  2618. static char *func="SQLProcedures";
  2620. mylog("%s: entering...n", func);
  2622. SC_log_error(func, "Function not implemented", (StatementClass *) hstmt);
  2623.     return SQL_ERROR;
  2624. }
  2626. RETCODE SQL_API SQLTablePrivileges(
  2627.                                    HSTMT           hstmt,
  2628.                                    UCHAR FAR *     szTableQualifier,
  2629.                                    SWORD           cbTableQualifier,
  2630.                                    UCHAR FAR *     szTableOwner,
  2631.                                    SWORD           cbTableOwner,
  2632.                                    UCHAR FAR *     szTableName,
  2633.                                    SWORD           cbTableName)
  2634. {
  2635. static char *func="SQLTablePrivileges";
  2637. mylog("%s: entering...n", func);
  2639. SC_log_error(func, "Function not implemented", (StatementClass *) hstmt);
  2640.     return SQL_ERROR;
  2641. }