options.c

关系型数据库 Postgresql 6.5.2

	case SQL_AUTOCOMMIT:

		/*  Since we are almost always in a transaction, this is now ok.
			Even if we were, the logic will handle it by sending a commit
			after the statement.
		
		if (CC_is_in_trans(conn)) {
			conn->errormsg = "Cannot switch commit mode while a transaction is in progres";
			conn->errornumber = CONN_TRANSACT_IN_PROGRES;
			CC_log_error(func, "", conn);
			return SQL_ERROR;
		}
		*/

		mylog("SQLSetConnectOption: AUTOCOMMIT: transact_status=%d, vparam=%d\n", conn->transact_status, vParam);

		switch(vParam) {
		case SQL_AUTOCOMMIT_OFF:
			CC_set_autocommit_off(conn);
			break;

		case SQL_AUTOCOMMIT_ON:
			CC_set_autocommit_on(conn);
			break;

		default:
			conn->errormsg = "Illegal parameter value for SQL_AUTOCOMMIT";
			conn->errornumber = CONN_INVALID_ARGUMENT_NO;
			CC_log_error(func, "", conn);
			return SQL_ERROR;
		}

		break;

	case SQL_CURRENT_QUALIFIER: /* ignored */
		break;

	case SQL_LOGIN_TIMEOUT: /* ignored */
		break;

	case SQL_PACKET_SIZE:	/* ignored */
		break;

	case SQL_QUIET_MODE:	/* ignored */
		break;

	case SQL_TXN_ISOLATION: /* ignored */
		break;
		
	/*	These options should be handled by driver manager */
	case SQL_ODBC_CURSORS:
	case SQL_OPT_TRACE:
	case SQL_OPT_TRACEFILE:
	case SQL_TRANSLATE_DLL:
	case SQL_TRANSLATE_OPTION:
		CC_log_error(func, "This connect option (Set) is only used by the Driver Manager", conn);
		break;

	default:
		{ 
		char option[64];
		conn->errormsg = "Unknown connect option (Set)";
		conn->errornumber = CONN_UNSUPPORTED_OPTION;
		sprintf(option, "fOption=%d, vParam=%ld", fOption, vParam);
		CC_log_error(func, option, conn);
		return SQL_ERROR;
		}

	}    

	if (changed) {
		conn->errornumber = CONN_OPTION_VALUE_CHANGED;
		conn->errormsg = "Requested value changed.";
		return SQL_SUCCESS_WITH_INFO;
	}
	else
		return SQL_SUCCESS;
}

//      -       -       -       -       -       -       -       -       -

/* This function just can tell you whether you are in Autcommit mode or not */
RETCODE SQL_API SQLGetConnectOption(
        HDBC    hdbc,
        UWORD   fOption,
        PTR     pvParam)
{
static char *func="SQLGetConnectOption";
ConnectionClass *conn = (ConnectionClass *) hdbc;

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

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

	switch (fOption) {
	case SQL_ACCESS_MODE:/* NOT SUPPORTED */
		*((UDWORD *) pvParam) = SQL_MODE_READ_WRITE;
		break;

	case SQL_AUTOCOMMIT:
		*((UDWORD *)pvParam) = (UDWORD)( CC_is_in_autocommit(conn) ?
						SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF);
		break;

	case SQL_CURRENT_QUALIFIER:	/* don't use qualifiers */
		if(pvParam)
			strcpy(pvParam, "");

		break;

	case SQL_LOGIN_TIMEOUT: /* NOT SUPPORTED */
		*((UDWORD *) pvParam) = 0;
		break;

	case SQL_PACKET_SIZE: /* NOT SUPPORTED */
		*((UDWORD *) pvParam) = globals.socket_buffersize;
		break;

	case SQL_QUIET_MODE:/* NOT SUPPORTED */
		*((UDWORD *) pvParam) = (UDWORD) NULL;
		break;

	case SQL_TXN_ISOLATION:/* NOT SUPPORTED */
		*((UDWORD *) pvParam) = SQL_TXN_SERIALIZABLE;
		break;

	/*	These options should be handled by driver manager */
	case SQL_ODBC_CURSORS:
	case SQL_OPT_TRACE:
	case SQL_OPT_TRACEFILE:
	case SQL_TRANSLATE_DLL:
	case SQL_TRANSLATE_OPTION:
		CC_log_error(func, "This connect option (Get) is only used by the Driver Manager", conn);
		break;

	default:
		{
		char option[64];
		conn->errormsg = "Unknown connect option (Get)";
		conn->errornumber = CONN_UNSUPPORTED_OPTION;
		sprintf(option, "fOption=%d", fOption);
		CC_log_error(func, option, conn);
		return SQL_ERROR;
		break;
		}

	}    

	return SQL_SUCCESS;
}

//      -       -       -       -       -       -       -       -       -

RETCODE SQL_API SQLSetStmtOption(
        HSTMT   hstmt,
        UWORD   fOption,
        UDWORD  vParam)
{
static char *func="SQLSetStmtOption";
StatementClass *stmt = (StatementClass *) hstmt;
char changed = FALSE;

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

    // thought we could fake Access out by just returning SQL_SUCCESS
    // all the time, but it tries to set a huge value for SQL_MAX_LENGTH
    // and expects the driver to reduce it to the real value

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

	return set_statement_option(NULL, stmt, fOption, vParam);
}


//      -       -       -       -       -       -       -       -       -

RETCODE SQL_API SQLGetStmtOption(
        HSTMT   hstmt,
        UWORD   fOption,
        PTR     pvParam)
{
static char *func="SQLGetStmtOption";
StatementClass *stmt = (StatementClass *) hstmt;
QResultClass *res;

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

    // thought we could fake Access out by just returning SQL_SUCCESS
    // all the time, but it tries to set a huge value for SQL_MAX_LENGTH
    // and expects the driver to reduce it to the real value

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

	switch(fOption) {
	case SQL_GET_BOOKMARK:
	case SQL_ROW_NUMBER:

		res = stmt->result;

		if ( stmt->manual_result || ! globals.use_declarefetch) {
			// make sure we're positioned on a valid row
			if((stmt->currTuple < 0) ||
			   (stmt->currTuple >= QR_get_num_tuples(res))) {
				stmt->errormsg = "Not positioned on a valid row.";
				stmt->errornumber = STMT_INVALID_CURSOR_STATE_ERROR;
				SC_log_error(func, "", stmt);
				return SQL_ERROR;
			}
		}
		else {
			if (stmt->currTuple == -1 || ! res || ! res->tupleField) {
				stmt->errormsg = "Not positioned on a valid row.";
				stmt->errornumber = STMT_INVALID_CURSOR_STATE_ERROR;
				SC_log_error(func, "", stmt);
				return SQL_ERROR;
			}
		}

		if (fOption == SQL_GET_BOOKMARK && stmt->options.use_bookmarks == SQL_UB_OFF) {
			stmt->errormsg = "Operation invalid because use bookmarks not enabled.";
			stmt->errornumber = STMT_OPERATION_INVALID;
			SC_log_error(func, "", stmt);
			return SQL_ERROR;
		}

		*((UDWORD *) pvParam) = SC_get_bookmark(stmt);
		
		break;

	case SQL_ASYNC_ENABLE:	/* NOT SUPPORTED */
		*((SDWORD *) pvParam) = SQL_ASYNC_ENABLE_OFF;
		break;

	case SQL_BIND_TYPE:
		*((SDWORD *) pvParam) = stmt->options.bind_size;
		break;

	case SQL_CONCURRENCY: /* NOT REALLY SUPPORTED */
		mylog("GetStmtOption(): SQL_CONCURRENCY\n");
		*((SDWORD *)pvParam) = stmt->options.scroll_concurrency;
		break;

	case SQL_CURSOR_TYPE: /* PARTIAL SUPPORT */
		mylog("GetStmtOption(): SQL_CURSOR_TYPE\n");
		*((SDWORD *)pvParam) = stmt->options.cursor_type;
		break;

	case SQL_KEYSET_SIZE: /* NOT SUPPORTED, but saved */
		mylog("GetStmtOption(): SQL_KEYSET_SIZE\n");
		*((SDWORD *)pvParam) = stmt->options.keyset_size;
		break;

	case SQL_MAX_LENGTH: /* NOT SUPPORTED, but saved */
		*((SDWORD *)pvParam) = stmt->options.maxLength;
		break;

	case SQL_MAX_ROWS: /* NOT SUPPORTED, but saved */
		*((SDWORD *)pvParam) = stmt->options.maxRows;
		mylog("GetSmtOption: MAX_ROWS, returning %d\n", stmt->options.maxRows);
		break;

	case SQL_NOSCAN:/* NOT SUPPORTED */
		*((SDWORD *) pvParam) = SQL_NOSCAN_ON;
		break;

	case SQL_QUERY_TIMEOUT: /* NOT SUPPORTED */
		*((SDWORD *) pvParam) = 0;
		break;

	case SQL_RETRIEVE_DATA: /* NOT SUPPORTED, but saved */
		*((SDWORD *) pvParam) = stmt->options.retrieve_data;
		break;

	case SQL_ROWSET_SIZE:
		*((SDWORD *) pvParam) = stmt->options.rowset_size;
		break;

	case SQL_SIMULATE_CURSOR:/* NOT SUPPORTED */
		*((SDWORD *) pvParam) = SQL_SC_NON_UNIQUE;
		break;

	case SQL_USE_BOOKMARKS:
		*((SDWORD *) pvParam) = stmt->options.use_bookmarks;
		break;

	default:
		{
		char option[64];
		stmt->errornumber = STMT_NOT_IMPLEMENTED_ERROR;
		stmt->errormsg = "Unknown statement option (Get)";
		sprintf(option, "fOption=%d", fOption);
		SC_log_error(func, option, stmt);
		return SQL_ERROR;
		}
	}

	return SQL_SUCCESS;
}

//      -       -       -       -       -       -       -       -       -