info.c

关系型数据库 Postgresql 6.5.2

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

    case SQL_ODBC_API_CONFORMANCE: /* ODBC 1.0 */
		len = 2;
        value = SQL_OAC_LEVEL1;
        break;

    case SQL_ODBC_SAG_CLI_CONFORMANCE: /* ODBC 1.0 */
		len = 2;
        value = SQL_OSCC_NOT_COMPLIANT;
        break;

    case SQL_ODBC_SQL_CONFORMANCE: /* ODBC 1.0 */
		len = 2;
        value = SQL_OSC_CORE;
        break;

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

    case SQL_ORDER_BY_COLUMNS_IN_SELECT: /* ODBC 2.0 */
		p = "Y";
        break;

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

    case SQL_OWNER_TERM: /* ODBC 1.0 */
		p = "owner";
        break;

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

    case SQL_POS_OPERATIONS: /* ODBC 2.0 */
		len = 4;
        value = globals.lie ? (SQL_POS_POSITION | SQL_POS_REFRESH | SQL_POS_UPDATE | SQL_POS_DELETE | SQL_POS_ADD) : (SQL_POS_POSITION | SQL_POS_REFRESH);
        break;

    case SQL_POSITIONED_STATEMENTS: /* ODBC 2.0 */
		len = 4;
        value = globals.lie ? (SQL_PS_POSITIONED_DELETE | 
								SQL_PS_POSITIONED_UPDATE | 
								SQL_PS_SELECT_FOR_UPDATE) : 0;
        break;

    case SQL_PROCEDURE_TERM: /* ODBC 1.0 */
        p = "procedure";
        break;

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

    case SQL_QUALIFIER_LOCATION: /* ODBC 2.0 */
		len = 2;
        value = SQL_QL_START;
        break;

    case SQL_QUALIFIER_NAME_SEPARATOR: /* ODBC 1.0 */
		p = "";
        break;

    case SQL_QUALIFIER_TERM: /* ODBC 1.0 */
		p = "";
        break;

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

    case SQL_QUOTED_IDENTIFIER_CASE: /* ODBC 2.0 */
        /* are "quoted" identifiers case-sensitive?  YES! */
		len = 2;
        value = SQL_IC_SENSITIVE;
        break;

    case SQL_ROW_UPDATES: /* ODBC 1.0 */
        /*  Driver doesn't support keyset-driven or mixed cursors, so
			not much point in saying row updates are supported
		*/
        p = globals.lie ? "Y" : "N";
        break;

    case SQL_SCROLL_CONCURRENCY: /* ODBC 1.0 */
		len = 4;
        value = globals.lie ? (SQL_SCCO_READ_ONLY | 
								SQL_SCCO_LOCK | 
								SQL_SCCO_OPT_ROWVER | 
								SQL_SCCO_OPT_VALUES) : (SQL_SCCO_READ_ONLY);
        break;

    case SQL_SCROLL_OPTIONS: /* ODBC 1.0 */
		len = 4;
        value = globals.lie ? (SQL_SO_FORWARD_ONLY | 
								SQL_SO_STATIC | 
								SQL_SO_KEYSET_DRIVEN | 
								SQL_SO_DYNAMIC | 
								SQL_SO_MIXED) : (globals.use_declarefetch ? SQL_SO_FORWARD_ONLY : (SQL_SO_FORWARD_ONLY | SQL_SO_STATIC));
        break;

    case SQL_SEARCH_PATTERN_ESCAPE: /* ODBC 1.0 */
		p = "";
        break;

    case SQL_SERVER_NAME: /* ODBC 1.0 */
		p = CC_get_server(conn);
        break;

    case SQL_SPECIAL_CHARACTERS: /* ODBC 2.0 */
        p = "_";
        break;

    case SQL_STATIC_SENSITIVITY: /* ODBC 2.0 */
		len = 4;
        value = globals.lie ? (SQL_SS_ADDITIONS | SQL_SS_DELETIONS | SQL_SS_UPDATES) : 0;
        break;

    case SQL_STRING_FUNCTIONS: /* ODBC 1.0 */
		len = 4;
        value = (SQL_FN_STR_CONCAT |
				SQL_FN_STR_LCASE | 
				SQL_FN_STR_LENGTH | 
				SQL_FN_STR_LOCATE | 
				SQL_FN_STR_LTRIM | 
				SQL_FN_STR_RTRIM |
				SQL_FN_STR_SUBSTRING |
				SQL_FN_STR_UCASE);
        break;

    case SQL_SUBQUERIES: /* ODBC 2.0 */
		/* postgres 6.3 supports subqueries */
		len = 4;
        value = (SQL_SQ_QUANTIFIED |
				SQL_SQ_IN |
				SQL_SQ_EXISTS |
				SQL_SQ_COMPARISON);
        break;

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

    case SQL_TABLE_TERM: /* ODBC 1.0 */
		p = "table";
        break;

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

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

    case SQL_TIMEDATE_FUNCTIONS: /* ODBC 1.0 */
		len = 4;
        value = (SQL_FN_TD_NOW);
        break;

    case SQL_TXN_CAPABLE: /* ODBC 1.0 */
        /* Postgres can deal with create or drop table statements in a transaction */
		len = 2;
        value = SQL_TC_ALL;
        break;

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

    case SQL_UNION: /* ODBC 2.0 */
		/*  unions with all supported in postgres 6.3 */
		len = 4;
        value = (SQL_U_UNION | SQL_U_UNION_ALL);
        break;

    case SQL_USER_NAME: /* ODBC 1.0 */
		p = CC_get_username(conn);
        break;

    default:
        /* unrecognized key */
        conn->errormsg = "Unrecognized key passed to SQLGetInfo.";
        conn->errornumber = CONN_NOT_IMPLEMENTED_ERROR;
		CC_log_error(func, "", conn);
        return SQL_ERROR;
    }

	result = SQL_SUCCESS;

	mylog("SQLGetInfo: p='%s', len=%d, value=%d, cbMax=%d\n", p?p:"<NULL>", len, value, cbInfoValueMax);

	/*	NOTE, that if rgbInfoValue is NULL, then no warnings or errors should
		result and just pcbInfoValue is returned, which indicates what length 
		would be required if a real buffer had been passed in.
	*/
	if (p) {  /* char/binary data */
		len = strlen(p);

		if (rgbInfoValue) {
			strncpy_null((char *)rgbInfoValue, p, (size_t)cbInfoValueMax);

			if (len >= cbInfoValueMax)  {
				result = SQL_SUCCESS_WITH_INFO;
				conn->errornumber = STMT_TRUNCATED;
				conn->errormsg = "The buffer was too small for the result.";
			}
		}
	}

	else {	/* numeric data */
		
		if (rgbInfoValue) {
		
			if (len == 2 ) 
				*((WORD *)rgbInfoValue) = (WORD) value;
			else if (len == 4)
				*((DWORD *)rgbInfoValue) = (DWORD) value;
		}
	}

	if (pcbInfoValue) 
		*pcbInfoValue = len;

	return result;
}

//      -       -       -       -       -       -       -       -       -


RETCODE SQL_API SQLGetTypeInfo(
        HSTMT   hstmt,
        SWORD   fSqlType)
{
static char *func = "SQLGetTypeInfo";
StatementClass *stmt = (StatementClass *) hstmt;
TupleNode *row;
int i;
// Int4 type;
Int4 pgType; 
Int2 sqlType;

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

	if( ! stmt) {
		SC_log_error(func, "", NULL);
		return SQL_INVALID_HANDLE;
	}


	stmt->manual_result = TRUE;
	stmt->result = QR_Constructor();
	if( ! stmt->result) {
		SC_log_error(func, "Error creating result.", stmt);
		return SQL_ERROR;
	}

	extend_bindings(stmt, 15);

	QR_set_num_fields(stmt->result, 15);
	QR_set_field_info(stmt->result, 0, "TYPE_NAME", PG_TYPE_TEXT, MAX_INFO_STRING);
	QR_set_field_info(stmt->result, 1, "DATA_TYPE", PG_TYPE_INT2, 2);
	QR_set_field_info(stmt->result, 2, "PRECISION", PG_TYPE_INT4, 4);
	QR_set_field_info(stmt->result, 3, "LITERAL_PREFIX", PG_TYPE_TEXT, MAX_INFO_STRING);
	QR_set_field_info(stmt->result, 4, "LITERAL_SUFFIX", PG_TYPE_TEXT, MAX_INFO_STRING);
	QR_set_field_info(stmt->result, 5, "CREATE_PARAMS", PG_TYPE_TEXT, MAX_INFO_STRING);
	QR_set_field_info(stmt->result, 6, "NULLABLE", PG_TYPE_INT2, 2);
	QR_set_field_info(stmt->result, 7, "CASE_SENSITIVE", PG_TYPE_INT2, 2);
	QR_set_field_info(stmt->result, 8, "SEARCHABLE", PG_TYPE_INT2, 2);
	QR_set_field_info(stmt->result, 9, "UNSIGNED_ATTRIBUTE", PG_TYPE_INT2, 2);
	QR_set_field_info(stmt->result, 10, "MONEY", PG_TYPE_INT2, 2);
	QR_set_field_info(stmt->result, 11, "AUTO_INCREMENT", PG_TYPE_INT2, 2);
	QR_set_field_info(stmt->result, 12, "LOCAL_TYPE_NAME", PG_TYPE_TEXT, MAX_INFO_STRING);
	QR_set_field_info(stmt->result, 13, "MINIMUM_SCALE", PG_TYPE_INT2, 2);
	QR_set_field_info(stmt->result, 14, "MAXIMUM_SCALE", PG_TYPE_INT2, 2);

	for(i=0, sqlType = sqlTypes[0]; sqlType; sqlType = sqlTypes[++i]) {
		pgType = sqltype_to_pgtype(sqlType);

		if (fSqlType == SQL_ALL_TYPES || fSqlType == sqlType) {
			row = (TupleNode *)malloc(sizeof(TupleNode) + (15 - 1)*sizeof(TupleField));

			/*	These values can't be NULL */
			set_tuplefield_string(&row->tuple[0], pgtype_to_name(stmt, pgType));
			set_tuplefield_int2(&row->tuple[1], (Int2) sqlType);
			set_tuplefield_int2(&row->tuple[6], pgtype_nullable(stmt, pgType));
			set_tuplefield_int2(&row->tuple[7], pgtype_case_sensitive(stmt, pgType));
			set_tuplefield_int2(&row->tuple[8], pgtype_searchable(stmt, pgType));
			set_tuplefield_int2(&row->tuple[10], pgtype_money(stmt, pgType));

			/*	Localized data-source dependent data type name (always NULL) */
			set_tuplefield_null(&row->tuple[12]);	

			/*	These values can be NULL */
			set_nullfield_int4(&row->tuple[2], pgtype_precision(stmt, pgType, PG_STATIC, PG_STATIC));
			set_nullfield_string(&row->tuple[3], pgtype_literal_prefix(stmt, pgType));
			set_nullfield_string(&row->tuple[4], pgtype_literal_suffix(stmt, pgType));
			set_nullfield_string(&row->tuple[5], pgtype_create_params(stmt, pgType));
			set_nullfield_int2(&row->tuple[9], pgtype_unsigned(stmt, pgType));
			set_nullfield_int2(&row->tuple[11], pgtype_auto_increment(stmt, pgType));
			set_nullfield_int2(&row->tuple[13], pgtype_scale(stmt, pgType));
			set_nullfield_int2(&row->tuple[14], pgtype_scale(stmt, pgType));

			QR_add_tuple(stmt->result, row);
		}
	}


    stmt->status = STMT_FINISHED;
    stmt->currTuple = -1;
	stmt->rowset_start = -1;
	stmt->current_col = -1;

    return SQL_SUCCESS;
}

//      -       -       -       -       -       -       -       -       -

RETCODE SQL_API SQLGetFunctions(
        HDBC      hdbc,
        UWORD     fFunction,
        UWORD FAR *pfExists)
{
static char *func="SQLGetFunctions";

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

    if (fFunction == SQL_API_ALL_FUNCTIONS) {

		if (globals.lie) {
			int i;
			memset(pfExists, 0, sizeof(UWORD)*100);

			pfExists[SQL_API_SQLALLOCENV] = TRUE;
			pfExists[SQL_API_SQLFREEENV] = TRUE;
			for (i = SQL_API_SQLALLOCCONNECT; i <= SQL_NUM_FUNCTIONS; i++)
				pfExists[i] = TRUE;
			for (i = SQL_EXT_API_START; i <= SQL_EXT_API_LAST; i++)
				pfExists[i] = TRUE;
		}
		else {
			memset(pfExists, 0, sizeof(UWORD)*100);

			// ODBC core functions
			pfExists[SQL_API_SQLALLOCCONNECT]     = TRUE;
			pfExists[SQL_API_SQLALLOCENV]         = TRUE;
			pfExists[SQL_API_SQLALLOCSTMT]        = TRUE;
			pfExists[SQL_API_SQLBINDCOL]          = TRUE;  
			pfExists[SQL_API_SQLCANCEL]           = TRUE;
			pfExists[SQL_API_SQLCOLATTRIBUTES]    = TRUE;
			pfExists[SQL_API_SQLCONNECT]          = TRUE;
			pfExists[SQL_API_SQLDESCRIBECOL]      = TRUE;  // partial
			pfExists[SQL_API_SQLDISCONNECT]       = TRUE;
			pfExists[SQL_API_SQLERROR]            = TRUE;
			pfExists[SQL_API_SQLEXECDIRECT]       = TRUE;
			pfExists[SQL_API_SQLEXECUTE]          = TRUE;
			pfExists[SQL_API_SQLFETCH]            = TRUE;
			pfExists[SQL_API_SQLFREECONNECT]      = TRUE;
			pfExists[SQL_API_SQLFREEENV]          = TRUE;
			pfExists[SQL_API_SQLFREESTMT]         = TRUE;
			pfExists[SQL_API_SQLGETCURSORNAME]    = TRUE;
			pfExists[SQL_API_SQLNUMRESULTCOLS]    = TRUE;
			pfExists[SQL_API_SQLPREPARE]          = TRUE;  // complete?
			pfExists[SQL_API_SQLROWCOUNT]         = TRUE;
			pfExists[SQL_API_SQLSETCURSORNAME]    = TRUE;
			pfExists[SQL_API_SQLSETPARAM]         = FALSE; // odbc 1.0
			pfExists[SQL_API_SQLTRANSACT]         = TRUE;

			// ODBC level 1 functions
			pfExists[SQL_API_SQLBINDPARAMETER]    = TRUE;
			pfExists[SQL_API_SQLCOLUMNS]          = TRUE;
			pfExists[SQL_API_SQLDRIVERCONNECT]    = TRUE;
			pfExists[SQL_API_SQLGETCONNECTOPTION] = TRUE;  // partial
			pfExists[SQL_API_SQLGETDATA]          = TRUE;
			pfExists[SQL_API_SQLGETFUNCTIONS]     = TRUE;                                                       
			pfExists[SQL_API_SQLGETINFO]          = TRUE;
			pfExists[SQL_API_SQLGETSTMTOPTION]    = TRUE;  // partial
			pfExists[SQL_API_SQLGETTYPEINFO]      = TRUE;
			pfExists[SQL_API_SQLPARAMDATA]        = TRUE;
			pfExists[SQL_API_SQLPUTDATA]          = TRUE;
			pfExists[SQL_API_SQLSETCONNECTOPTION] = TRUE;  // partial
			pfExists[SQL_API_SQLSETSTMTOPTION]    = TRUE;
			pfExists[SQL_API_SQLSPECIALCOLUMNS]   = TRUE;