info.c

关系型数据库 Postgresql 6.5.2

/* Module:          info.c
 *
 * Description:     This module contains routines related to
 *                  ODBC informational functions.
 *
 * Classes:         n/a
 *
 * API functions:   SQLGetInfo, SQLGetTypeInfo, SQLGetFunctions, 
 *                  SQLTables, SQLColumns, SQLStatistics, SQLSpecialColumns,
 *                  SQLPrimaryKeys, SQLForeignKeys, 
 *                  SQLProcedureColumns(NI), SQLProcedures(NI), 
 *                  SQLTablePrivileges(NI), SQLColumnPrivileges(NI)
 *
 * Comments:        See "notice.txt" for copyright and license information.
 *
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <string.h>
#include <stdio.h>
#include "psqlodbc.h"

#ifndef WIN32
#include "iodbc.h"
#include "isql.h"
#include "isqlext.h"
#include <ctype.h>	/* for tolower function */
#else
#include <windows.h>
#include <sql.h> 
#include <sqlext.h>
#endif

#include "tuple.h"
#include "pgtypes.h"

#include "environ.h"
#include "connection.h"
#include "statement.h"
#include "qresult.h"
#include "bind.h"
#include "misc.h"
#include "pgtypes.h"


/*	Trigger related stuff for SQLForeign Keys */
#define TRIGGER_SHIFT 3
#define TRIGGER_MASK   0x03
#define TRIGGER_DELETE 0x01
#define TRIGGER_UPDATE 0x02


extern GLOBAL_VALUES globals;


//      -       -       -       -       -       -       -       -       -

RETCODE SQL_API SQLGetInfo(
        HDBC      hdbc,
        UWORD     fInfoType,
        PTR       rgbInfoValue,
        SWORD     cbInfoValueMax,
        SWORD FAR *pcbInfoValue)
{
static char *func = "SQLGetInfo";
ConnectionClass *conn = (ConnectionClass *) hdbc;
ConnInfo *ci;
char *p = NULL;
int len = 0, value = 0;
RETCODE result;

	mylog( "%s: entering...fInfoType=%d\n", func, fInfoType);

	if ( ! conn) {
		CC_log_error(func, "", NULL);
		return SQL_INVALID_HANDLE;
	}

	ci = &conn->connInfo;

    switch (fInfoType) {
    case SQL_ACCESSIBLE_PROCEDURES: /* ODBC 1.0 */
		p = "N";
        break;

    case SQL_ACCESSIBLE_TABLES: /* ODBC 1.0 */
		p = "N";
        break;

    case SQL_ACTIVE_CONNECTIONS: /* ODBC 1.0 */
        len = 2;
        value = MAX_CONNECTIONS;
        break;

    case SQL_ACTIVE_STATEMENTS: /* ODBC 1.0 */
        len = 2;
        value = 0;
        break;

    case SQL_ALTER_TABLE: /* ODBC 2.0 */
        len = 4;
        value = SQL_AT_ADD_COLUMN;
        break;

    case SQL_BOOKMARK_PERSISTENCE: /* ODBC 2.0 */
		/* very simple bookmark support */        
		len = 4;
        value = globals.use_declarefetch ? 0 : (SQL_BP_SCROLL);		
        break;

    case SQL_COLUMN_ALIAS: /* ODBC 2.0 */
		p = "N";
        break;

    case SQL_CONCAT_NULL_BEHAVIOR: /* ODBC 1.0 */
        len = 2;
        value = SQL_CB_NON_NULL;
        break;

    case SQL_CONVERT_BIGINT:
    case SQL_CONVERT_BINARY:
    case SQL_CONVERT_BIT:
    case SQL_CONVERT_CHAR:
    case SQL_CONVERT_DATE:
    case SQL_CONVERT_DECIMAL:
    case SQL_CONVERT_DOUBLE:
    case SQL_CONVERT_FLOAT:
    case SQL_CONVERT_INTEGER:
    case SQL_CONVERT_LONGVARBINARY:
    case SQL_CONVERT_LONGVARCHAR:
    case SQL_CONVERT_NUMERIC:
    case SQL_CONVERT_REAL:
    case SQL_CONVERT_SMALLINT:
    case SQL_CONVERT_TIME:
    case SQL_CONVERT_TIMESTAMP:
    case SQL_CONVERT_TINYINT:
    case SQL_CONVERT_VARBINARY:
    case SQL_CONVERT_VARCHAR: /* ODBC 1.0 */
		len = 4;
        value = fInfoType;
        break;

    case SQL_CONVERT_FUNCTIONS: /* ODBC 1.0 */
		len = 4;
        value = 0;
        break;

    case SQL_CORRELATION_NAME: /* ODBC 1.0 */

		/*	Saying no correlation name makes Query not work right.
			value = SQL_CN_NONE;
		*/
		len = 2;
        value = SQL_CN_ANY;
        break;

    case SQL_CURSOR_COMMIT_BEHAVIOR: /* ODBC 1.0 */
        len = 2;
        value = SQL_CB_CLOSE;
        break;

    case SQL_CURSOR_ROLLBACK_BEHAVIOR: /* ODBC 1.0 */
        len = 2;
        value = SQL_CB_CLOSE;
        break;

    case SQL_DATA_SOURCE_NAME: /* ODBC 1.0 */
		p = CC_get_DSN(conn);
        break;

    case SQL_DATA_SOURCE_READ_ONLY: /* ODBC 1.0 */
		p = CC_is_readonly(conn) ? "Y" : "N";
        break;

    case SQL_DATABASE_NAME: /* Support for old ODBC 1.0 Apps */

		/*	Returning the database name causes problems in MS Query.
			It generates query like: "SELECT DISTINCT a FROM byronncrap3 crap3"

			p = CC_get_database(conn);
		*/
		p = "";    
		break;

    case SQL_DBMS_NAME: /* ODBC 1.0 */
		p = DBMS_NAME;
        break;

    case SQL_DBMS_VER: /* ODBC 1.0 */
		p = DBMS_VERSION;
        break;

    case SQL_DEFAULT_TXN_ISOLATION: /* ODBC 1.0 */
		len = 4;
        value = SQL_TXN_READ_COMMITTED; //SQL_TXN_SERIALIZABLE;
        break;

    case SQL_DRIVER_NAME: /* ODBC 1.0 */
        p = DRIVER_FILE_NAME;
        break;

    case SQL_DRIVER_ODBC_VER:
		p = DRIVER_ODBC_VER;
        break;

    case SQL_DRIVER_VER: /* ODBC 1.0 */
        p = POSTGRESDRIVERVERSION;
        break;

    case SQL_EXPRESSIONS_IN_ORDERBY: /* ODBC 1.0 */
		p = "N";
        break;

    case SQL_FETCH_DIRECTION: /* ODBC 1.0 */
		len = 4;
        value = globals.use_declarefetch ? (SQL_FD_FETCH_NEXT) : (SQL_FD_FETCH_NEXT |
                                   SQL_FD_FETCH_FIRST |
                                   SQL_FD_FETCH_LAST |
                                   SQL_FD_FETCH_PRIOR |
                                   SQL_FD_FETCH_ABSOLUTE |
								   SQL_FD_FETCH_RELATIVE | 
								   SQL_FD_FETCH_BOOKMARK);
        break;

    case SQL_FILE_USAGE: /* ODBC 2.0 */
		len = 2;
        value = SQL_FILE_NOT_SUPPORTED;
        break;

    case SQL_GETDATA_EXTENSIONS: /* ODBC 2.0 */
		len = 4;
        value = (SQL_GD_ANY_COLUMN | SQL_GD_ANY_ORDER | SQL_GD_BOUND | SQL_GD_BLOCK);
        break;

    case SQL_GROUP_BY: /* ODBC 2.0 */
		len = 2;
        value = SQL_GB_GROUP_BY_EQUALS_SELECT;
        break;

    case SQL_IDENTIFIER_CASE: /* ODBC 1.0 */
        /*	are identifiers case-sensitive (yes, but only when quoted.  If not quoted, they
			default to lowercase)
		*/
		len = 2;
        value = SQL_IC_LOWER;
        break;

    case SQL_IDENTIFIER_QUOTE_CHAR: /* ODBC 1.0 */
        /* the character used to quote "identifiers" */
		p = PROTOCOL_62(ci) ? " " : "\"";
        break;

    case SQL_KEYWORDS: /* ODBC 2.0 */
		p = "";
        break;

    case SQL_LIKE_ESCAPE_CLAUSE: /* ODBC 2.0 */
		/*	is there a character that escapes '%' and '_' in a LIKE clause?
			not as far as I can tell
		*/
        p = "N";
        break;

    case SQL_LOCK_TYPES: /* ODBC 2.0 */
		len = 4;
        value = globals.lie ? (SQL_LCK_NO_CHANGE | SQL_LCK_EXCLUSIVE | SQL_LCK_UNLOCK) : SQL_LCK_NO_CHANGE;
        break;

    case SQL_MAX_BINARY_LITERAL_LEN: /* ODBC 2.0 */
		len = 4;
        value = 0;
        break;

    case SQL_MAX_CHAR_LITERAL_LEN: /* ODBC 2.0 */
		len = 4;
        value = 0;
        break;

    case SQL_MAX_COLUMN_NAME_LEN: /* ODBC 1.0 */
		len = 2;
        value = MAX_COLUMN_LEN;
        break;

    case SQL_MAX_COLUMNS_IN_GROUP_BY: /* ODBC 2.0 */
		len = 2;
        value = 0;
        break;

    case SQL_MAX_COLUMNS_IN_INDEX: /* ODBC 2.0 */
		len = 2;
        value = 0;
        break;

    case SQL_MAX_COLUMNS_IN_ORDER_BY: /* ODBC 2.0 */
		len = 2;
        value = 0;
        break;

    case SQL_MAX_COLUMNS_IN_SELECT: /* ODBC 2.0 */
		len = 2;
        value = 0;
        break;

    case SQL_MAX_COLUMNS_IN_TABLE: /* ODBC 2.0 */
		len = 2;
        value = 0;
        break;

    case SQL_MAX_CURSOR_NAME_LEN: /* ODBC 1.0 */
		len = 2;
        value = MAX_CURSOR_LEN;
        break;

    case SQL_MAX_INDEX_SIZE: /* ODBC 2.0 */
		len = 4;
        value = 0;
        break;

    case SQL_MAX_OWNER_NAME_LEN: /* ODBC 1.0 */
		len = 2;
        value = 0;
        break;

    case SQL_MAX_PROCEDURE_NAME_LEN: /* ODBC 1.0 */
		len = 2;
        value = 0;
        break;

    case SQL_MAX_QUALIFIER_NAME_LEN: /* ODBC 1.0 */
		len = 2;
        value = 0;
        break;

    case SQL_MAX_ROW_SIZE: /* ODBC 2.0 */
		len = 4;
        value = BLCKSZ;
        break;

    case SQL_MAX_ROW_SIZE_INCLUDES_LONG: /* ODBC 2.0 */
        /*	does the preceding value include LONGVARCHAR and LONGVARBINARY
			fields?   Well, it does include longvarchar, but not longvarbinary.
		*/
		p = "Y";
        break;

    case SQL_MAX_STATEMENT_LEN: /* ODBC 2.0 */
        /* maybe this should be 0? */
		len = 4;
        value = MAX_QUERY_SIZE;
        break;

    case SQL_MAX_TABLE_NAME_LEN: /* ODBC 1.0 */
		len = 2;
        value = MAX_TABLE_LEN;
        break;

    case SQL_MAX_TABLES_IN_SELECT: /* ODBC 2.0 */
		len = 2;
        value = 0;
        break;

    case SQL_MAX_USER_NAME_LEN:
		len = 2;
        value = 0;
        break;

    case SQL_MULT_RESULT_SETS: /* ODBC 1.0 */
        /* Don't support multiple result sets but say yes anyway? */
		p = "Y";
        break;

    case SQL_MULTIPLE_ACTIVE_TXN: /* ODBC 1.0 */
		p = "Y";
        break;

    case SQL_NEED_LONG_DATA_LEN: /* ODBC 2.0 */
		/*	Dont need the length, SQLPutData can handle any size and multiple calls */
		p = "N";
        break;

    case SQL_NON_NULLABLE_COLUMNS: /* ODBC 1.0 */
		len = 2;
        value = SQL_NNC_NON_NULL;
        break;

    case SQL_NULL_COLLATION: /* ODBC 2.0 */
        /* where are nulls sorted? */
		len = 2;
        value = SQL_NC_END;
        break;