http://git-wip-us.apache.org/repos/asf/ignite/blob/718e365f/modules/platforms/cpp/odbc/src/config/connection_info.cpp ---------------------------------------------------------------------- diff --git a/modules/platforms/cpp/odbc/src/config/connection_info.cpp b/modules/platforms/cpp/odbc/src/config/connection_info.cpp index 4925957..362d46b 100644 --- a/modules/platforms/cpp/odbc/src/config/connection_info.cpp +++ b/modules/platforms/cpp/odbc/src/config/connection_info.cpp @@ -48,184 +48,846 @@ namespace ignite { switch (type) { +#ifdef SQL_ACCESSIBLE_PROCEDURES + DBG_STR_CASE(SQL_ACCESSIBLE_PROCEDURES); +#endif // SQL_ACCESSIBLE_PROCEDURES +#ifdef SQL_ACCESSIBLE_TABLES + DBG_STR_CASE(SQL_ACCESSIBLE_TABLES); +#endif // SQL_ACCESSIBLE_TABLES +#ifdef SQL_ACTIVE_ENVIRONMENTS + DBG_STR_CASE(SQL_ACTIVE_ENVIRONMENTS); +#endif // SQL_ACTIVE_ENVIRONMENTS +#ifdef SQL_DRIVER_NAME DBG_STR_CASE(SQL_DRIVER_NAME); +#endif // SQL_DRIVER_NAME +#ifdef SQL_DBMS_NAME DBG_STR_CASE(SQL_DBMS_NAME); +#endif // SQL_DBMS_NAME +#ifdef SQL_DRIVER_ODBC_VER DBG_STR_CASE(SQL_DRIVER_ODBC_VER); +#endif // SQL_DRIVER_ODBC_VER +#ifdef SQL_DBMS_VER DBG_STR_CASE(SQL_DBMS_VER); +#endif // SQL_DBMS_VER +#ifdef SQL_DRIVER_VER DBG_STR_CASE(SQL_DRIVER_VER); +#endif // SQL_DRIVER_VER +#ifdef SQL_COLUMN_ALIAS DBG_STR_CASE(SQL_COLUMN_ALIAS); +#endif // SQL_COLUMN_ALIAS +#ifdef SQL_IDENTIFIER_QUOTE_CHAR DBG_STR_CASE(SQL_IDENTIFIER_QUOTE_CHAR); +#endif // SQL_IDENTIFIER_QUOTE_CHAR +#ifdef SQL_CATALOG_NAME_SEPARATOR DBG_STR_CASE(SQL_CATALOG_NAME_SEPARATOR); +#endif // SQL_CATALOG_NAME_SEPARATOR +#ifdef SQL_SPECIAL_CHARACTERS DBG_STR_CASE(SQL_SPECIAL_CHARACTERS); +#endif // SQL_SPECIAL_CHARACTERS +#ifdef SQL_CATALOG_TERM DBG_STR_CASE(SQL_CATALOG_TERM); +#endif // SQL_CATALOG_TERM +#ifdef SQL_TABLE_TERM DBG_STR_CASE(SQL_TABLE_TERM); +#endif // SQL_TABLE_TERM +#ifdef SQL_SCHEMA_TERM DBG_STR_CASE(SQL_SCHEMA_TERM); +#endif // SQL_SCHEMA_TERM +#ifdef SQL_NEED_LONG_DATA_LEN DBG_STR_CASE(SQL_NEED_LONG_DATA_LEN); -// DBG_STR_CASE(SQL_ASYNC_DBC_FUNCTIONS); +#endif // SQL_NEED_LONG_DATA_LEN +#ifdef SQL_ASYNC_DBC_FUNCTIONS + DBG_STR_CASE(SQL_ASYNC_DBC_FUNCTIONS); +#endif // SQL_ASYNC_DBC_FUNCTIONS +#ifdef SQL_ASYNC_NOTIFICATION DBG_STR_CASE(SQL_ASYNC_NOTIFICATION); +#endif // SQL_ASYNC_NOTIFICATION +#ifdef SQL_GETDATA_EXTENSIONS DBG_STR_CASE(SQL_GETDATA_EXTENSIONS); +#endif // SQL_GETDATA_EXTENSIONS +#ifdef SQL_ODBC_INTERFACE_CONFORMANCE DBG_STR_CASE(SQL_ODBC_INTERFACE_CONFORMANCE); +#endif // SQL_ODBC_INTERFACE_CONFORMANCE +#ifdef SQL_SQL_CONFORMANCE DBG_STR_CASE(SQL_SQL_CONFORMANCE); +#endif // SQL_SQL_CONFORMANCE +#ifdef SQL_CATALOG_USAGE DBG_STR_CASE(SQL_CATALOG_USAGE); +#endif // SQL_CATALOG_USAGE +#ifdef SQL_SCHEMA_USAGE DBG_STR_CASE(SQL_SCHEMA_USAGE); +#endif // SQL_SCHEMA_USAGE +#ifdef SQL_MAX_IDENTIFIER_LEN DBG_STR_CASE(SQL_MAX_IDENTIFIER_LEN); +#endif // SQL_MAX_IDENTIFIER_LEN +#ifdef SQL_AGGREGATE_FUNCTIONS DBG_STR_CASE(SQL_AGGREGATE_FUNCTIONS); +#endif // SQL_AGGREGATE_FUNCTIONS +#ifdef SQL_NUMERIC_FUNCTIONS DBG_STR_CASE(SQL_NUMERIC_FUNCTIONS); +#endif // SQL_NUMERIC_FUNCTIONS +#ifdef SQL_STRING_FUNCTIONS DBG_STR_CASE(SQL_STRING_FUNCTIONS); +#endif // SQL_STRING_FUNCTIONS +#ifdef SQL_TIMEDATE_FUNCTIONS DBG_STR_CASE(SQL_TIMEDATE_FUNCTIONS); +#endif // SQL_TIMEDATE_FUNCTIONS +#ifdef SQL_TIMEDATE_ADD_INTERVALS DBG_STR_CASE(SQL_TIMEDATE_ADD_INTERVALS); +#endif // SQL_TIMEDATE_ADD_INTERVALS +#ifdef SQL_TIMEDATE_DIFF_INTERVALS DBG_STR_CASE(SQL_TIMEDATE_DIFF_INTERVALS); +#endif // SQL_TIMEDATE_DIFF_INTERVALS +#ifdef SQL_DATETIME_LITERALS DBG_STR_CASE(SQL_DATETIME_LITERALS); +#endif // SQL_DATETIME_LITERALS +#ifdef SQL_SYSTEM_FUNCTIONS DBG_STR_CASE(SQL_SYSTEM_FUNCTIONS); +#endif // SQL_SYSTEM_FUNCTIONS +#ifdef SQL_CONVERT_FUNCTIONS DBG_STR_CASE(SQL_CONVERT_FUNCTIONS); +#endif // SQL_CONVERT_FUNCTIONS +#ifdef SQL_OJ_CAPABILITIES DBG_STR_CASE(SQL_OJ_CAPABILITIES); +#endif // SQL_OJ_CAPABILITIES +#ifdef SQL_POS_OPERATIONS DBG_STR_CASE(SQL_POS_OPERATIONS); +#endif // SQL_POS_OPERATIONS +#ifdef SQL_MAX_CONCURRENT_ACTIVITIES DBG_STR_CASE(SQL_MAX_CONCURRENT_ACTIVITIES); +#endif // SQL_MAX_CONCURRENT_ACTIVITIES +#ifdef SQL_CURSOR_COMMIT_BEHAVIOR DBG_STR_CASE(SQL_CURSOR_COMMIT_BEHAVIOR); +#endif // SQL_CURSOR_COMMIT_BEHAVIOR +#ifdef SQL_CURSOR_ROLLBACK_BEHAVIOR DBG_STR_CASE(SQL_CURSOR_ROLLBACK_BEHAVIOR); +#endif // SQL_CURSOR_ROLLBACK_BEHAVIOR +#ifdef SQL_TXN_CAPABLE DBG_STR_CASE(SQL_TXN_CAPABLE); +#endif // SQL_TXN_CAPABLE +#ifdef SQL_QUOTED_IDENTIFIER_CASE DBG_STR_CASE(SQL_QUOTED_IDENTIFIER_CASE); +#endif // SQL_QUOTED_IDENTIFIER_CASE +#ifdef SQL_SQL92_NUMERIC_VALUE_FUNCTIONS DBG_STR_CASE(SQL_SQL92_NUMERIC_VALUE_FUNCTIONS); +#endif // SQL_SQL92_NUMERIC_VALUE_FUNCTIONS +#ifdef SQL_SQL92_STRING_FUNCTIONS DBG_STR_CASE(SQL_SQL92_STRING_FUNCTIONS); +#endif // SQL_SQL92_STRING_FUNCTIONS +#ifdef SQL_SQL92_DATETIME_FUNCTIONS DBG_STR_CASE(SQL_SQL92_DATETIME_FUNCTIONS); +#endif // SQL_SQL92_DATETIME_FUNCTIONS +#ifdef SQL_SQL92_PREDICATES DBG_STR_CASE(SQL_SQL92_PREDICATES); +#endif // SQL_SQL92_PREDICATES +#ifdef SQL_SQL92_RELATIONAL_JOIN_OPERATORS DBG_STR_CASE(SQL_SQL92_RELATIONAL_JOIN_OPERATORS); +#endif // SQL_SQL92_RELATIONAL_JOIN_OPERATORS +#ifdef SQL_SQL92_VALUE_EXPRESSIONS DBG_STR_CASE(SQL_SQL92_VALUE_EXPRESSIONS); +#endif // SQL_SQL92_VALUE_EXPRESSIONS +#ifdef SQL_STATIC_CURSOR_ATTRIBUTES1 DBG_STR_CASE(SQL_STATIC_CURSOR_ATTRIBUTES1); +#endif // SQL_STATIC_CURSOR_ATTRIBUTES1 +#ifdef SQL_STATIC_CURSOR_ATTRIBUTES2 DBG_STR_CASE(SQL_STATIC_CURSOR_ATTRIBUTES2); +#endif // SQL_STATIC_CURSOR_ATTRIBUTES2 +#ifdef SQL_CONVERT_BIGINT DBG_STR_CASE(SQL_CONVERT_BIGINT); +#endif // SQL_CONVERT_BIGINT +#ifdef SQL_CONVERT_BINARY DBG_STR_CASE(SQL_CONVERT_BINARY); +#endif // SQL_CONVERT_BINARY +#ifdef SQL_CONVERT_BIT DBG_STR_CASE(SQL_CONVERT_BIT); +#endif // SQL_CONVERT_BIT +#ifdef SQL_CONVERT_CHAR DBG_STR_CASE(SQL_CONVERT_CHAR); +#endif // SQL_CONVERT_CHAR +#ifdef SQL_CONVERT_DATE DBG_STR_CASE(SQL_CONVERT_DATE); +#endif // SQL_CONVERT_DATE +#ifdef SQL_CONVERT_DECIMAL DBG_STR_CASE(SQL_CONVERT_DECIMAL); +#endif // SQL_CONVERT_DECIMAL +#ifdef SQL_CONVERT_DOUBLE DBG_STR_CASE(SQL_CONVERT_DOUBLE); +#endif // SQL_CONVERT_DOUBLE +#ifdef SQL_CONVERT_FLOAT DBG_STR_CASE(SQL_CONVERT_FLOAT); +#endif // SQL_CONVERT_FLOAT +#ifdef SQL_CONVERT_INTEGER DBG_STR_CASE(SQL_CONVERT_INTEGER); +#endif // SQL_CONVERT_INTEGER +#ifdef SQL_CONVERT_LONGVARCHAR DBG_STR_CASE(SQL_CONVERT_LONGVARCHAR); +#endif // SQL_CONVERT_LONGVARCHAR +#ifdef SQL_CONVERT_NUMERIC DBG_STR_CASE(SQL_CONVERT_NUMERIC); +#endif // SQL_CONVERT_NUMERIC +#ifdef SQL_CONVERT_REAL DBG_STR_CASE(SQL_CONVERT_REAL); +#endif // SQL_CONVERT_REAL +#ifdef SQL_CONVERT_SMALLINT DBG_STR_CASE(SQL_CONVERT_SMALLINT); +#endif // SQL_CONVERT_SMALLINT +#ifdef SQL_CONVERT_TIME DBG_STR_CASE(SQL_CONVERT_TIME); +#endif // SQL_CONVERT_TIME +#ifdef SQL_CONVERT_TIMESTAMP DBG_STR_CASE(SQL_CONVERT_TIMESTAMP); +#endif // SQL_CONVERT_TIMESTAMP +#ifdef SQL_CONVERT_TINYINT DBG_STR_CASE(SQL_CONVERT_TINYINT); +#endif // SQL_CONVERT_TINYINT +#ifdef SQL_CONVERT_VARBINARY DBG_STR_CASE(SQL_CONVERT_VARBINARY); +#endif // SQL_CONVERT_VARBINARY +#ifdef SQL_CONVERT_VARCHAR DBG_STR_CASE(SQL_CONVERT_VARCHAR); +#endif // SQL_CONVERT_VARCHAR +#ifdef SQL_CONVERT_LONGVARBINARY DBG_STR_CASE(SQL_CONVERT_LONGVARBINARY); +#endif // SQL_CONVERT_LONGVARBINARY +#ifdef SQL_CONVERT_WCHAR DBG_STR_CASE(SQL_CONVERT_WCHAR); +#endif // SQL_CONVERT_WCHAR +#ifdef SQL_CONVERT_INTERVAL_DAY_TIME DBG_STR_CASE(SQL_CONVERT_INTERVAL_DAY_TIME); +#endif // SQL_CONVERT_INTERVAL_DAY_TIME +#ifdef SQL_CONVERT_INTERVAL_YEAR_MONTH DBG_STR_CASE(SQL_CONVERT_INTERVAL_YEAR_MONTH); +#endif // SQL_CONVERT_INTERVAL_YEAR_MONTH +#ifdef SQL_CONVERT_WLONGVARCHAR DBG_STR_CASE(SQL_CONVERT_WLONGVARCHAR); +#endif // SQL_CONVERT_WLONGVARCHAR +#ifdef SQL_CONVERT_WVARCHAR DBG_STR_CASE(SQL_CONVERT_WVARCHAR); +#endif // SQL_CONVERT_WVARCHAR +#ifdef SQL_CONVERT_GUID DBG_STR_CASE(SQL_CONVERT_GUID); +#endif // SQL_CONVERT_GUID +#ifdef SQL_SCROLL_OPTIONS DBG_STR_CASE(SQL_SCROLL_OPTIONS); +#endif // SQL_SCROLL_OPTIONS +#ifdef SQL_PARAM_ARRAY_ROW_COUNTS DBG_STR_CASE(SQL_PARAM_ARRAY_ROW_COUNTS); +#endif // SQL_PARAM_ARRAY_ROW_COUNTS +#ifdef SQL_PARAM_ARRAY_SELECTS DBG_STR_CASE(SQL_PARAM_ARRAY_SELECTS); - default: - break; +#endif // SQL_PARAM_ARRAY_SELECTS +#ifdef SQL_ALTER_DOMAIN + DBG_STR_CASE(SQL_ALTER_DOMAIN); +#endif // SQL_ALTER_DOMAIN +#ifdef SQL_ASYNC_MODE + DBG_STR_CASE(SQL_ASYNC_MODE); +#endif // SQL_ASYNC_MODE +#ifdef SQL_BATCH_ROW_COUNT + DBG_STR_CASE(SQL_BATCH_ROW_COUNT); +#endif // SQL_BATCH_ROW_COUNT +#ifdef SQL_BATCH_SUPPORT + DBG_STR_CASE(SQL_BATCH_SUPPORT); +#endif // SQL_BATCH_SUPPORT +#ifdef SQL_BOOKMARK_PERSISTENCE + DBG_STR_CASE(SQL_BOOKMARK_PERSISTENCE); +#endif // SQL_BOOKMARK_PERSISTENCE +#ifdef SQL_CATALOG_LOCATION + DBG_STR_CASE(SQL_CATALOG_LOCATION); +#endif // SQL_CATALOG_LOCATION +#ifdef SQL_CATALOG_NAME + DBG_STR_CASE(SQL_CATALOG_NAME); +#endif // SQL_CATALOG_NAME +#ifdef SQL_COLLATION_SEQ + DBG_STR_CASE(SQL_COLLATION_SEQ); +#endif // SQL_COLLATION_SEQ +#ifdef SQL_CONCAT_NULL_BEHAVIOR + DBG_STR_CASE(SQL_CONCAT_NULL_BEHAVIOR); +#endif // SQL_CONCAT_NULL_BEHAVIOR +#ifdef SQL_CORRELATION_NAME + DBG_STR_CASE(SQL_CORRELATION_NAME); +#endif // SQL_CORRELATION_NAME +#ifdef SQL_CREATE_ASSERTION + DBG_STR_CASE(SQL_CREATE_ASSERTION); +#endif // SQL_CREATE_ASSERTION +#ifdef SQL_CREATE_CHARACTER_SET + DBG_STR_CASE(SQL_CREATE_CHARACTER_SET); +#endif // SQL_CREATE_CHARACTER_SET +#ifdef SQL_CREATE_COLLATION + DBG_STR_CASE(SQL_CREATE_COLLATION); +#endif // SQL_CREATE_COLLATION +#ifdef SQL_CREATE_DOMAIN + DBG_STR_CASE(SQL_CREATE_DOMAIN); +#endif // SQL_CREATE_DOMAIN +#ifdef SQL_CREATE_TABLE + DBG_STR_CASE(SQL_CREATE_TABLE); +#endif // SQL_CREATE_TABLE +#ifdef SQL_CREATE_TRANSLATION + DBG_STR_CASE(SQL_CREATE_TRANSLATION); +#endif // SQL_CREATE_TRANSLATION +#ifdef SQL_CREATE_VIEW + DBG_STR_CASE(SQL_CREATE_VIEW); +#endif // SQL_CREATE_VIEW +#ifdef SQL_CURSOR_SENSITIVITY + DBG_STR_CASE(SQL_CURSOR_SENSITIVITY); +#endif // SQL_CURSOR_SENSITIVITY +#ifdef SQL_DATA_SOURCE_NAME + DBG_STR_CASE(SQL_DATA_SOURCE_NAME); +#endif // SQL_DATA_SOURCE_NAME +#ifdef SQL_DATA_SOURCE_READ_ONLY + DBG_STR_CASE(SQL_DATA_SOURCE_READ_ONLY); +#endif // SQL_DATA_SOURCE_READ_ONLY +#ifdef SQL_DATABASE_NAME + DBG_STR_CASE(SQL_DATABASE_NAME); +#endif // SQL_DATABASE_NAME +#ifdef SQL_DDL_INDEX + DBG_STR_CASE(SQL_DDL_INDEX); +#endif // SQL_DDL_INDEX +#ifdef SQL_DEFAULT_TXN_ISOLATION + DBG_STR_CASE(SQL_DEFAULT_TXN_ISOLATION); +#endif // SQL_DEFAULT_TXN_ISOLATION +#ifdef SQL_DESCRIBE_PARAMETER + DBG_STR_CASE(SQL_DESCRIBE_PARAMETER); +#endif // SQL_DESCRIBE_PARAMETER +#ifdef SQL_DROP_ASSERTION + DBG_STR_CASE(SQL_DROP_ASSERTION); +#endif // SQL_DROP_ASSERTION +#ifdef SQL_DROP_CHARACTER_SET + DBG_STR_CASE(SQL_DROP_CHARACTER_SET); +#endif // SQL_DROP_CHARACTER_SET +#ifdef SQL_DROP_COLLATION + DBG_STR_CASE(SQL_DROP_COLLATION); +#endif // SQL_DROP_COLLATION +#ifdef SQL_DROP_DOMAIN + DBG_STR_CASE(SQL_DROP_DOMAIN); +#endif // SQL_DROP_DOMAIN +#ifdef SQL_DROP_SCHEMA + DBG_STR_CASE(SQL_DROP_SCHEMA); +#endif // SQL_DROP_SCHEMA +#ifdef SQL_DROP_TABLE + DBG_STR_CASE(SQL_DROP_TABLE); +#endif // SQL_DROP_TABLE +#ifdef SQL_DROP_TRANSLATION + DBG_STR_CASE(SQL_DROP_TRANSLATION); +#endif // SQL_DROP_TRANSLATION +#ifdef SQL_DROP_VIEW + DBG_STR_CASE(SQL_DROP_VIEW); +#endif // SQL_DROP_VIEW +#ifdef SQL_DYNAMIC_CURSOR_ATTRIBUTES1 + DBG_STR_CASE(SQL_DYNAMIC_CURSOR_ATTRIBUTES1); +#endif // SQL_DYNAMIC_CURSOR_ATTRIBUTES1 +#ifdef SQL_DYNAMIC_CURSOR_ATTRIBUTES2 + DBG_STR_CASE(SQL_DYNAMIC_CURSOR_ATTRIBUTES2); +#endif // SQL_DYNAMIC_CURSOR_ATTRIBUTES2 +#ifdef SQL_EXPRESSIONS_IN_ORDERBY + DBG_STR_CASE(SQL_EXPRESSIONS_IN_ORDERBY); +#endif // SQL_EXPRESSIONS_IN_ORDERBY +#ifdef SQL_FILE_USAGE + DBG_STR_CASE(SQL_FILE_USAGE); +#endif // SQL_FILE_USAGE +#ifdef SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1 + DBG_STR_CASE(SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1); +#endif // SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1 +#ifdef SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2 + DBG_STR_CASE(SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2); +#endif // SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2 +#ifdef SQL_GROUP_BY + DBG_STR_CASE(SQL_GROUP_BY); +#endif // SQL_GROUP_BY +#ifdef SQL_IDENTIFIER_CASE + DBG_STR_CASE(SQL_IDENTIFIER_CASE); +#endif // SQL_IDENTIFIER_CASE +#ifdef SQL_INDEX_KEYWORDS + DBG_STR_CASE(SQL_INDEX_KEYWORDS); +#endif // SQL_INDEX_KEYWORDS +#ifdef SQL_INFO_SCHEMA_VIEWS + DBG_STR_CASE(SQL_INFO_SCHEMA_VIEWS); +#endif // SQL_INFO_SCHEMA_VIEWS +#ifdef SQL_INSERT_STATEMENT + DBG_STR_CASE(SQL_INSERT_STATEMENT); +#endif // SQL_INSERT_STATEMENT +#ifdef SQL_INTEGRITY + DBG_STR_CASE(SQL_INTEGRITY); +#endif // SQL_INTEGRITY +#ifdef SQL_KEYSET_CURSOR_ATTRIBUTES1 + DBG_STR_CASE(SQL_KEYSET_CURSOR_ATTRIBUTES1); +#endif // SQL_KEYSET_CURSOR_ATTRIBUTES1 +#ifdef SQL_KEYSET_CURSOR_ATTRIBUTES2 + DBG_STR_CASE(SQL_KEYSET_CURSOR_ATTRIBUTES2); +#endif // SQL_KEYSET_CURSOR_ATTRIBUTES2 +#ifdef SQL_KEYWORDS + DBG_STR_CASE(SQL_KEYWORDS); +#endif // SQL_KEYWORDS +#ifdef SQL_LIKE_ESCAPE_CLAUSE + DBG_STR_CASE(SQL_LIKE_ESCAPE_CLAUSE); +#endif // SQL_LIKE_ESCAPE_CLAUSE +#ifdef SQL_MAX_ASYNC_CONCURRENT_STATEMENTS + DBG_STR_CASE(SQL_MAX_ASYNC_CONCURRENT_STATEMENTS); +#endif // SQL_MAX_ASYNC_CONCURRENT_STATEMENTS +#ifdef SQL_MAX_BINARY_LITERAL_LEN + DBG_STR_CASE(SQL_MAX_BINARY_LITERAL_LEN); +#endif // SQL_MAX_BINARY_LITERAL_LEN +#ifdef SQL_MAX_CATALOG_NAME_LEN + DBG_STR_CASE(SQL_MAX_CATALOG_NAME_LEN); +#endif // SQL_MAX_CATALOG_NAME_LEN +#ifdef SQL_MAX_CHAR_LITERAL_LEN + DBG_STR_CASE(SQL_MAX_CHAR_LITERAL_LEN); +#endif // SQL_MAX_CHAR_LITERAL_LEN +#ifdef SQL_MAX_COLUMN_NAME_LEN + DBG_STR_CASE(SQL_MAX_COLUMN_NAME_LEN); +#endif // SQL_MAX_COLUMN_NAME_LEN +#ifdef SQL_MAX_COLUMNS_IN_GROUP_BY + DBG_STR_CASE(SQL_MAX_COLUMNS_IN_GROUP_BY); +#endif // SQL_MAX_COLUMNS_IN_GROUP_BY +#ifdef SQL_MAX_COLUMNS_IN_INDEX + DBG_STR_CASE(SQL_MAX_COLUMNS_IN_INDEX); +#endif // SQL_MAX_COLUMNS_IN_INDEX +#ifdef SQL_MAX_COLUMNS_IN_ORDER_BY + DBG_STR_CASE(SQL_MAX_COLUMNS_IN_ORDER_BY); +#endif // SQL_MAX_COLUMNS_IN_ORDER_BY +#ifdef SQL_MAX_COLUMNS_IN_SELECT + DBG_STR_CASE(SQL_MAX_COLUMNS_IN_SELECT); +#endif // SQL_MAX_COLUMNS_IN_SELECT +#ifdef SQL_MAX_COLUMNS_IN_TABLE + DBG_STR_CASE(SQL_MAX_COLUMNS_IN_TABLE); +#endif // SQL_MAX_COLUMNS_IN_TABLE +#ifdef SQL_MAX_CURSOR_NAME_LEN + DBG_STR_CASE(SQL_MAX_CURSOR_NAME_LEN); +#endif // SQL_MAX_CURSOR_NAME_LEN +#ifdef SQL_MAX_DRIVER_CONNECTIONS + DBG_STR_CASE(SQL_MAX_DRIVER_CONNECTIONS); +#endif // SQL_MAX_DRIVER_CONNECTIONS +#ifdef SQL_MAX_INDEX_SIZE + DBG_STR_CASE(SQL_MAX_INDEX_SIZE); +#endif // SQL_MAX_INDEX_SIZE +#ifdef SQL_MAX_PROCEDURE_NAME_LEN + DBG_STR_CASE(SQL_MAX_PROCEDURE_NAME_LEN); +#endif // SQL_MAX_PROCEDURE_NAME_LEN +#ifdef SQL_MAX_ROW_SIZE + DBG_STR_CASE(SQL_MAX_ROW_SIZE); +#endif // SQL_MAX_ROW_SIZE +#ifdef SQL_MAX_ROW_SIZE_INCLUDES_LONG + DBG_STR_CASE(SQL_MAX_ROW_SIZE_INCLUDES_LONG); +#endif // SQL_MAX_ROW_SIZE_INCLUDES_LONG +#ifdef SQL_MAX_SCHEMA_NAME_LEN + DBG_STR_CASE(SQL_MAX_SCHEMA_NAME_LEN); +#endif // SQL_MAX_SCHEMA_NAME_LEN +#ifdef SQL_MAX_STATEMENT_LEN + DBG_STR_CASE(SQL_MAX_STATEMENT_LEN); +#endif // SQL_MAX_STATEMENT_LEN +#ifdef SQL_MAX_TABLE_NAME_LEN + DBG_STR_CASE(SQL_MAX_TABLE_NAME_LEN); +#endif // SQL_MAX_TABLE_NAME_LEN +#ifdef SQL_MAX_TABLES_IN_SELECT + DBG_STR_CASE(SQL_MAX_TABLES_IN_SELECT); +#endif // SQL_MAX_TABLES_IN_SELECT +#ifdef SQL_MAX_USER_NAME_LEN + DBG_STR_CASE(SQL_MAX_USER_NAME_LEN); +#endif // SQL_MAX_USER_NAME_LEN +#ifdef SQL_MULT_RESULT_SETS + DBG_STR_CASE(SQL_MULT_RESULT_SETS); +#endif // SQL_MULT_RESULT_SETS +#ifdef SQL_MULTIPLE_ACTIVE_TXN + DBG_STR_CASE(SQL_MULTIPLE_ACTIVE_TXN); +#endif // SQL_MULTIPLE_ACTIVE_TXN +#ifdef SQL_NON_NULLABLE_COLUMNS + DBG_STR_CASE(SQL_NON_NULLABLE_COLUMNS); +#endif // SQL_NON_NULLABLE_COLUMNS +#ifdef SQL_NULL_COLLATION + DBG_STR_CASE(SQL_NULL_COLLATION); +#endif // SQL_NULL_COLLATION +#ifdef SQL_ORDER_BY_COLUMNS_IN_SELECT + DBG_STR_CASE(SQL_ORDER_BY_COLUMNS_IN_SELECT); +#endif // SQL_ORDER_BY_COLUMNS_IN_SELECT +#ifdef SQL_PROCEDURE_TERM + DBG_STR_CASE(SQL_PROCEDURE_TERM); +#endif // SQL_PROCEDURE_TERM +#ifdef SQL_PROCEDURES + DBG_STR_CASE(SQL_PROCEDURES); +#endif // SQL_PROCEDURES +#ifdef SQL_ROW_UPDATES + DBG_STR_CASE(SQL_ROW_UPDATES); +#endif // SQL_ROW_UPDATES +#ifdef SQL_SEARCH_PATTERN_ESCAPE + DBG_STR_CASE(SQL_SEARCH_PATTERN_ESCAPE); +#endif // SQL_SEARCH_PATTERN_ESCAPE +#ifdef SQL_SERVER_NAME + DBG_STR_CASE(SQL_SERVER_NAME); +#endif // SQL_SERVER_NAME +#ifdef SQL_SQL92_FOREIGN_KEY_DELETE_RULE + DBG_STR_CASE(SQL_SQL92_FOREIGN_KEY_DELETE_RULE); +#endif // SQL_SQL92_FOREIGN_KEY_DELETE_RULE +#ifdef SQL_SQL92_FOREIGN_KEY_UPDATE_RULE + DBG_STR_CASE(SQL_SQL92_FOREIGN_KEY_UPDATE_RULE); +#endif // SQL_SQL92_FOREIGN_KEY_UPDATE_RULE +#ifdef SQL_SQL92_GRANT + DBG_STR_CASE(SQL_SQL92_GRANT); +#endif // SQL_SQL92_GRANT +#ifdef SQL_SQL92_REVOKE + DBG_STR_CASE(SQL_SQL92_REVOKE); +#endif // SQL_SQL92_REVOKE +#ifdef SQL_SQL92_ROW_VALUE_CONSTRUCTOR + DBG_STR_CASE(SQL_SQL92_ROW_VALUE_CONSTRUCTOR); +#endif // SQL_SQL92_ROW_VALUE_CONSTRUCTOR +#ifdef SQL_STANDARD_CLI_CONFORMANCE + DBG_STR_CASE(SQL_STANDARD_CLI_CONFORMANCE); +#endif // SQL_STANDARD_CLI_CONFORMANCE +#ifdef SQL_SUBQUERIES + DBG_STR_CASE(SQL_SUBQUERIES); +#endif // SQL_SUBQUERIES +#ifdef SQL_TXN_ISOLATION_OPTION + DBG_STR_CASE(SQL_TXN_ISOLATION_OPTION); +#endif // SQL_TXN_ISOLATION_OPTION +#ifdef SQL_UNION + DBG_STR_CASE(SQL_UNION); +#endif // SQL_UNION +#ifdef SQL_USER_NAME + DBG_STR_CASE(SQL_USER_NAME); +#endif // SQL_USER_NAME +#ifdef SQL_ALTER_TABLE + DBG_STR_CASE(SQL_ALTER_TABLE); +#endif // SQL_ALTER_TABLE + default: + break; } return "<< UNKNOWN TYPE >>"; } #undef DBG_STR_CASE - ConnectionInfo::ConnectionInfo() : strParams(), intParams(), - shortParams() + ConnectionInfo::ConnectionInfo(const Configuration& config) : + strParams(), + intParams(), + shortParams(), + config(config) { + // //======================= String Params ======================= + // + // Driver name. +#ifdef SQL_DRIVER_NAME strParams[SQL_DRIVER_NAME] = "Apache Ignite"; +#endif // SQL_DRIVER_NAME +#ifdef SQL_DBMS_NAME strParams[SQL_DBMS_NAME] = "Apache Ignite"; +#endif // SQL_DBMS_NAME // ODBC version. +#ifdef SQL_DRIVER_ODBC_VER strParams[SQL_DRIVER_ODBC_VER] = "03.00"; - strParams[SQL_DBMS_VER] = "03.00"; +#endif // SQL_DRIVER_ODBC_VER #ifdef SQL_DRIVER_VER - // Driver version. At a minimum, the version is of the form - // ##.##.####, where the first two digits are the major version, - // the next two digits are the minor version, and the last four - // digits are the release version. - strParams[SQL_DRIVER_VER] = "01.05.0000"; + // Driver version. At a minimum, the version is of the form ##.##.####, where the first two digits are + // the major version, the next two digits are the minor version, and the last four digits are the + // release version. + strParams[SQL_DRIVER_VER] = "02.03.0000"; #endif // SQL_DRIVER_VER +#ifdef SQL_DBMS_VER + strParams[SQL_DBMS_VER] = "02.03.0000"; +#endif // SQL_DBMS_VER #ifdef SQL_COLUMN_ALIAS - // A character string: "Y" if the data source supports column - // aliases; otherwise, "N". + // A character string: "Y" if the data source supports column aliases; otherwise, "N". strParams[SQL_COLUMN_ALIAS] = "Y"; #endif // SQL_COLUMN_ALIAS #ifdef SQL_IDENTIFIER_QUOTE_CHAR - // The character string that is used as the starting and ending - // delimiter of a quoted (delimited) identifier in SQL statements. - // Identifiers passed as arguments to ODBC functions do not have to - // be quoted. If the data source does not support quoted - // identifiers, a blank is returned. + // The character string that is used as the starting and ending delimiter of a quoted (delimited) + // identifier in SQL statements. Identifiers passed as arguments to ODBC functions do not have to be + // quoted. If the data source does not support quoted identifiers, a blank is returned. strParams[SQL_IDENTIFIER_QUOTE_CHAR] = ""; #endif // SQL_IDENTIFIER_QUOTE_CHAR #ifdef SQL_CATALOG_NAME_SEPARATOR - // A character string: the character or characters that the data - // source defines as the separator between a catalog name and the - // qualified name element that follows or precedes it. + // A character string: the character or characters that the data source defines as the separator between + // a catalog name and the qualified name element that follows or precedes it. strParams[SQL_CATALOG_NAME_SEPARATOR] = "."; #endif // SQL_CATALOG_NAME_SEPARATOR #ifdef SQL_SPECIAL_CHARACTERS - // A character string that contains all special characters (that - // is, all characters except a through z, A through Z, 0 through 9, - // and underscore) that can be used in an identifier name, such as - // a table name, column name, or index name, on the data source. + // A character string that contains all special characters (that is, all characters except a through z, + // A through Z, 0 through 9, and underscore) that can be used in an identifier name, such as a table + // name, column name, or index name, on the data source. strParams[SQL_SPECIAL_CHARACTERS] = ""; #endif // SQL_SPECIAL_CHARACTERS #ifdef SQL_CATALOG_TERM - // A character string with the data source vendor's name for - // a catalog; for example, "database" or "directory". This string - // can be in upper, lower, or mixed case. - strParams[SQL_CATALOG_TERM] = "catalog"; + // A character string with the data source vendor's name for a catalog; for example, "database" or + // "directory". This string can be in upper, lower, or mixed case. This InfoType has been renamed for + // ODBC 3.0 from the ODBC 2.0 InfoType SQL_QUALIFIER_TERM. + strParams[SQL_CATALOG_TERM] = ""; #endif // SQL_CATALOG_TERM +#ifdef SQL_QUALIFIER_TERM + strParams[SQL_QUALIFIER_TERM] = ""; +#endif // SQL_QUALIFIER_TERM + #ifdef SQL_TABLE_TERM - // A character string with the data source vendor's name for - // a table; for example, "table" or "file". + // A character string with the data source vendor's name for a table; for example, "table" or "file". strParams[SQL_TABLE_TERM] = "table"; #endif // SQL_TABLE_TERM #ifdef SQL_SCHEMA_TERM - // A character string with the data source vendor's name for - // a schema; for example, "owner", "Authorization ID", or "Schema". + // A character string with the data source vendor's name for a schema; for example, "owner", + // "Authorization ID", or "Schema". strParams[SQL_SCHEMA_TERM] = "schema"; #endif // SQL_SCHEMA_TERM #ifdef SQL_NEED_LONG_DATA_LEN - // A character string: "Y" if the data source needs the length - // of a long data value (the data type is SQL_LONGVARCHAR, - // SQL_LONGVARBINARY) before that value is sent to the data - // source, "N" if it does not. + // A character string: "Y" if the data source needs the length of a long data value (the data type is + // SQL_LONGVARCHAR, SQL_LONGVARBINARY) before that value is sent to the data source, "N" if it does not. strParams[SQL_NEED_LONG_DATA_LEN ] = "Y"; #endif // SQL_NEED_LONG_DATA_LEN -#ifdef SQL_ASYNC_DBC_FUNCTIONS +#ifdef SQL_ACCESSIBLE_PROCEDURES + // A character string: "Y" if the user can execute all procedures returned by SQLProcedures; "N" if + // there may be procedures returned that the user cannot execute. + strParams[SQL_ACCESSIBLE_PROCEDURES] = "Y"; +#endif // SQL_ACCESSIBLE_PROCEDURES + +#ifdef SQL_ACCESSIBLE_TABLES + // A character string: "Y" if the user is guaranteed SELECT privileges to all tables returned by + // SQLTables; "N" if there may be tables returned that the user cannot access. + strParams[SQL_ACCESSIBLE_TABLES] = "Y"; +#endif // SQL_ACCESSIBLE_TABLES + +#ifdef SQL_CATALOG_NAME + // A character string: "Y" if the server supports catalog names, or "N" if it does not. + // An SQL - 92 Full level-conformant driver will always return "Y". + strParams[SQL_CATALOG_NAME] = "N"; +#endif // SQL_CATALOG_NAME + +#ifdef SQL_COLLATION_SEQ + // The name of the collation sequence. This is a character string that indicates the name of the default + // collation for the default character set for this server (for example, 'ISO 8859-1' or EBCDIC). If + // this is unknown, an empty string will be returned. An SQL-92 Full level-conformant driver will always + // return a non-empty string. + strParams[SQL_COLLATION_SEQ] = "UTF-8"; +#endif // SQL_COLLATION_SEQ + +#ifdef SQL_DATA_SOURCE_NAME + // A character string with the data source name that was used during connection. + // + // If the application called SQLConnect, this is the value of the szDSN argument. If the application + // called SQLDriverConnect or SQLBrowseConnect, this is the value of the DSN keyword in the connection + // string passed to the driver. If the connection string did not contain the DSN keyword (such as when + // it contains the DRIVER keyword), this is an empty string. + strParams[SQL_DATA_SOURCE_NAME] = config.GetDsn(); +#endif // SQL_DATA_SOURCE_NAME + +#ifdef SQL_DATA_SOURCE_READ_ONLY + // A character string. "Y" if the data source is set to READ ONLY mode, "N" if it is otherwise. + // + // This characteristic pertains only to the data source itself; it is not a characteristic of the driver + // that enables access to the data source. A driver that is read/write can be used with a data source + // that is read-only. If a driver is read-only, all of its data sources must be read-only and must + // return SQL_DATA_SOURCE_READ_ONLY. + strParams[SQL_DATA_SOURCE_READ_ONLY] = "N"; +#endif // SQL_DATA_SOURCE_READ_ONLY + +#ifdef SQL_DATABASE_NAME + // A character string with the name of the current database in use, if the data source defines a named + // object called "database". + strParams[SQL_DATABASE_NAME] = ""; +#endif // SQL_DATABASE_NAME + +#ifdef SQL_DESCRIBE_PARAMETER + // A character string: "Y" if parameters can be described; "N", if not. + // An SQL-92 Full level-conformant driver will usually return "Y" because it will support the DESCRIBE + // INPUT statement. Because this does not directly specify the underlying SQL support, however, + // describing parameters might not be supported, even in a SQL-92 Full level-conformant driver. + strParams[SQL_DESCRIBE_PARAMETER] = "N"; +#endif // SQL_DESCRIBE_PARAMETER + +#ifdef SQL_EXPRESSIONS_IN_ORDERBY + // A character string: "Y" if the data source supports expressions in the ORDER BY list; "N" if it does + // not. + strParams[SQL_EXPRESSIONS_IN_ORDERBY] = "Y"; +#endif // SQL_EXPRESSIONS_IN_ORDERBY + +#ifdef SQL_INTEGRITY + // A character string: "Y" if the data source supports the Integrity Enhancement Facility; "N" if it + // does not. + strParams[SQL_INTEGRITY] = "N"; +#endif // SQL_INTEGRITY + +#ifdef SQL_KEYWORDS + // A character string that contains a comma-separated list of all data source-specific keywords. This + // list does not contain keywords specific to ODBC or keywords used by both the data source and ODBC. + // This list represents all the reserved keywords; interoperable applications should not use these words + // in object names. + // The #define value SQL_ODBC_KEYWORDS contains a comma - separated list of ODBC keywords. + strParams[SQL_KEYWORDS] = "LIMIT,MINUS,OFFSET,ROWNUM,SYSDATE,SYSTIME,SYSTIMESTAMP,TODAY"; +#endif // SQL_KEYWORDS + +#ifdef SQL_LIKE_ESCAPE_CLAUSE + // A character string: "Y" if the data source supports an escape character for the percent character (%) + // and underscore character (_) in a LIKE predicate and the driver supports the ODBC syntax for defining + // a LIKE predicate escape character; "N" otherwise. + strParams[SQL_LIKE_ESCAPE_CLAUSE] = "N"; +#endif // SQL_LIKE_ESCAPE_CLAUSE + +#ifdef SQL_MAX_ROW_SIZE_INCLUDES_LONG + // A character string: "Y" if the maximum row size returned for the SQL_MAX_ROW_SIZE information type + // includes the length of all SQL_LONGVARCHAR and SQL_LONGVARBINARY columns in the row; "N" otherwise. + strParams[SQL_MAX_ROW_SIZE_INCLUDES_LONG] = "Y"; +#endif // SQL_MAX_ROW_SIZE_INCLUDES_LONG + +#ifdef SQL_MULT_RESULT_SETS + // A character string: "Y" if the data source supports multiple result sets, "N" if it does not. + strParams[SQL_MULT_RESULT_SETS] = "N"; +#endif // SQL_MULT_RESULT_SETS + +#ifdef SQL_MULTIPLE_ACTIVE_TXN + // A character string: "Y" if the driver supports more than one active transaction at the same time, + // "N" if only one transaction can be active at any time. + strParams[SQL_MULTIPLE_ACTIVE_TXN] = "N"; +#endif // SQL_MULTIPLE_ACTIVE_TXN + +#ifdef SQL_ORDER_BY_COLUMNS_IN_SELECT + // A character string: "Y" if the columns in the ORDER BY clause must be in the select list; + // otherwise, "N". + strParams[SQL_ORDER_BY_COLUMNS_IN_SELECT] = "N"; +#endif // SQL_ORDER_BY_COLUMNS_IN_SELECT + +#ifdef SQL_PROCEDURE_TERM + // A character string with the data source vendor's name for a procedure; for example, + // "database procedure", "stored procedure", "procedure", "package", or "stored query". + strParams[SQL_PROCEDURE_TERM] = "stored procedure"; +#endif // SQL_PROCEDURE_TERM + +#ifdef SQL_PROCEDURE_TERM + // A character string: "Y" if the data source supports procedures and the driver supports the ODBC + // procedure invocation syntax; "N" otherwise. + strParams[SQL_PROCEDURE_TERM] = "N"; +#endif // SQL_PROCEDURE_TERM + +#ifdef SQL_ROW_UPDATES + // A character string: "Y" if a keyset-driven or mixed cursor maintains row versions or values for all + // fetched rows and therefore can detect any updates that were made to a row by any user since the row + // was last fetched. (This applies only to updates, not to deletions or insertions.) The driver can + // return the SQL_ROW_UPDATED flag to the row status array when SQLFetchScroll is called. Otherwise, "N" + strParams[SQL_ROW_UPDATES] = "N"; +#endif // SQL_ROW_UPDATES + +#ifdef SQL_SEARCH_PATTERN_ESCAPE + // A character string specifying what the driver supports as an escape character that allows the use of + // the pattern match metacharacters underscore (_) and percent sign (%) as valid characters in search + // patterns. This escape character applies only for those catalog function arguments that support search + // strings. If this string is empty, the driver does not support a search-pattern escape character. + // Because this information type does not indicate general support of the escape character in the LIKE + // predicate, SQL-92 does not include requirements for this character string. + // This InfoType is limited to catalog functions. For a description of the use of the escape character + // in search pattern strings, see Pattern Value Arguments. + strParams[SQL_SEARCH_PATTERN_ESCAPE] = "\\"; +#endif // SQL_SEARCH_PATTERN_ESCAPE + +#ifdef SQL_SERVER_NAME + // A character string with the actual data source-specific server name; useful when a data source name + // is used during SQLConnect, SQLDriverConnect, and SQLBrowseConnect. + strParams[SQL_SERVER_NAME] = "Apache Ignite"; +#endif // SQL_SERVER_NAME + +#ifdef SQL_USER_NAME + // A character string with the name used in a particular database, which can be different from the login + // name. + strParams[SQL_USER_NAME] = "apache_ignite_user"; +#endif // SQL_USER_NAME + + // //====================== Integer Params ======================= - // Indicates if the driver can execute functions asynchronously - // on the connection handle. - // SQL_ASYNC_DBC_CAPABLE = The driver can execute connection - // functions asynchronously. - // SQL_ASYNC_DBC_NOT_CAPABLE = The driver can not execute - // connection functions asynchronously. + // + +#ifdef SQL_ASYNC_DBC_FUNCTIONS + // Indicates if the driver can execute functions asynchronously on the connection handle. + // SQL_ASYNC_DBC_CAPABLE = The driver can execute connection functions asynchronously. + // SQL_ASYNC_DBC_NOT_CAPABLE = The driver can not execute connection functions asynchronously. intParams[SQL_ASYNC_DBC_FUNCTIONS] = SQL_ASYNC_DBC_NOT_CAPABLE; #endif // SQL_ASYNC_DBC_FUNCTIONS +#ifdef SQL_ASYNC_MODE + // Indicates the level of asynchronous support in the driver: + // SQL_AM_CONNECTION = Connection level asynchronous execution is supported.Either all statement handles + // associated with a given connection handle are in asynchronous mode or all are in synchronous mode. + // A statement handle on a connection cannot be in asynchronous mode while another statement handle + // on the same connection is in synchronous mode, and vice versa. + // SQL_AM_STATEMENT = Statement level asynchronous execution is supported.Some statement handles + // associated with a connection handle can be in asynchronous mode, while other statement handles on + // the same connection are in synchronous mode. + // SQL_AM_NONE = Asynchronous mode is not supported. + intParams[SQL_ASYNC_MODE] = SQL_AM_NONE; +#endif // SQL_ASYNC_MODE + #ifdef SQL_ASYNC_NOTIFICATION - // Indicates if the driver supports asynchronous notification. - // SQL_ASYNC_NOTIFICATION_CAPABLE = Asynchronous execution - // notification is supported by the driver. - // SQL_ASYNC_NOTIFICATION_NOT_CAPABLE Asynchronous execution - // notification is not supported by the driver. + // Indicates if the driver supports asynchronous notification: + // SQL_ASYNC_NOTIFICATION_CAPABLE Asynchronous execution notification is supported by the driver. + // SQL_ASYNC_NOTIFICATION_NOT_CAPABLE Asynchronous execution notification is not supported by the + // driver. + // + // There are two categories of ODBC asynchronous operations: connection level asynchronous operations + // and statement level asynchronous operations. If a driver returns SQL_ASYNC_NOTIFICATION_CAPABLE, it + // must support notification for all APIs that it can execute asynchronously. intParams[SQL_ASYNC_NOTIFICATION] = SQL_ASYNC_NOTIFICATION_NOT_CAPABLE; #endif // SQL_ASYNC_NOTIFICATION +#ifdef SQL_BATCH_ROW_COUNT + // Enumerates the behavior of the driver with respect to the availability of row counts. The following + // bitmasks are used together with the information type: + // SQL_BRC_ROLLED_UP = Row counts for consecutive INSERT, DELETE, or UPDATE statements are rolled up + // into one. If this bit is not set, row counts are available for each statement. + // SQL_BRC_PROCEDURES = Row counts, if any, are available when a batch is executed in a stored + // procedure. If row counts are available, they can be rolled up or individually available, + // depending on the SQL_BRC_ROLLED_UP bit. + // SQL_BRC_EXPLICIT = Row counts, if any, are available when a batch is executed directly by calling + // SQLExecute or SQLExecDirect. If row counts are available, they can be rolled up or individually + // available, depending on the SQL_BRC_ROLLED_UP bit. + intParams[SQL_BATCH_ROW_COUNT] = SQL_BRC_ROLLED_UP | SQL_BRC_EXPLICIT; +#endif // SQL_BATCH_ROW_COUNT + +#ifdef SQL_BATCH_SUPPORT + // Bitmask enumerating the driver's support for batches. The following bitmasks are used to determine + // which level is supported: + // SQL_BS_SELECT_EXPLICIT = The driver supports explicit batches that can have result - set generating + // statements. + // SQL_BS_ROW_COUNT_EXPLICIT = The driver supports explicit batches that can have row - count generating + // statements. + // SQL_BS_SELECT_PROC = The driver supports explicit procedures that can have result - set generating + // statements. + // SQL_BS_ROW_COUNT_PROC = The driver supports explicit procedures that can have row - count generating + // statements. + intParams[SQL_BATCH_SUPPORT] = SQL_BS_ROW_COUNT_EXPLICIT; +#endif // SQL_BATCH_SUPPORT + +#ifdef SQL_BOOKMARK_PERSISTENCE + // Bitmask enumerating the operations through which bookmarks persist. The following bitmasks are used + // together with the flag to determine through which options bookmarks persist: + // SQL_BP_CLOSE = Bookmarks are valid after an application calls SQLFreeStmt with the SQL_CLOSE option, + // or SQLCloseCursor to close the cursor associated with a statement. + // SQL_BP_DELETE = The bookmark for a row is valid after that row has been deleted. + // SQL_BP_DROP = Bookmarks are valid after an application calls SQLFreeHandle with a HandleType of + // SQL_HANDLE_STMT to drop a statement. + // SQL_BP_TRANSACTION = Bookmarks are valid after an application commits or rolls back a transaction. + // SQL_BP_UPDATE = The bookmark for a row is valid after any column in that row has been updated, + // including key columns. + // SQL_BP_OTHER_HSTMT = A bookmark associated with one statement can be used with another statement. + // Unless SQL_BP_CLOSE or SQL_BP_DROP is specified, the cursor on the first statement must be open. + intParams[SQL_BOOKMARK_PERSISTENCE] = 0; +#endif // SQL_BOOKMARK_PERSISTENCE + +#ifdef SQL_CATALOG_LOCATION + // Value that indicates the position of the catalog in a qualified table name: SQL_CL_START, SQL_CL_END + // + // An SQL - 92 Full level-conformant driver will always return SQL_CL_START.A value of 0 is returned if + // catalogs are not supported by the data source. This InfoType has been renamed for ODBC 3.0 from the + // ODBC 2.0 InfoType SQL_QUALIFIER_LOCATION. + intParams[SQL_CATALOG_LOCATION] = 0; +#endif // SQL_CATALOG_LOCATION + +#ifdef SQL_QUALIFIER_LOCATION + intParams[SQL_QUALIFIER_LOCATION] = 0; +#endif // SQL_QUALIFIER_LOCATION + #ifdef SQL_GETDATA_EXTENSIONS // Bitmask enumerating extensions to SQLGetData. intParams[SQL_GETDATA_EXTENSIONS] = SQL_GD_ANY_COLUMN | SQL_GD_ANY_ORDER | SQL_GD_BOUND; @@ -244,92 +906,100 @@ namespace ignite #ifdef SQL_CATALOG_USAGE // Bitmask enumerating the statements in which catalogs can be used. + // The following bitmasks are used to determine where catalogs can be used: + // SQL_CU_DML_STATEMENTS = Catalogs are supported in all Data Manipulation Language statements : + // SELECT, INSERT, UPDATE, DELETE, and if supported, SELECT FOR UPDATE and positioned update and + // delete statements. + // SQL_CU_PROCEDURE_INVOCATION = Catalogs are supported in the ODBC procedure invocation statement. + // SQL_CU_TABLE_DEFINITION = Catalogs are supported in all table definition statements : CREATE TABLE, + // CREATE VIEW, ALTER TABLE, DROP TABLE, and DROP VIEW. + // SQL_CU_INDEX_DEFINITION = Catalogs are supported in all index definition statements : CREATE INDEX + // and DROP INDEX. + // SQL_CU_PRIVILEGE_DEFINITION = Catalogs are supported in all privilege definition statements : GRANT + // and REVOKE. + // + // A value of 0 is returned if catalogs are not supported by the data source.To determine whether + // catalogs are supported, an application calls SQLGetInfo with the SQL_CATALOG_NAME information type. + // An SQL - 92 Full level-conformant driver will always return a bitmask with all of these bits set. + // This InfoType has been renamed for ODBC 3.0 from the ODBC 2.0 InfoType SQL_QUALIFIER_USAGE. intParams[SQL_CATALOG_USAGE] = 0; #endif // SQL_CATALOG_USAGE +#ifdef SQL_QUALIFIER_USAGE + intParams[SQL_QUALIFIER_USAGE] = 0; +#endif // SQL_QUALIFIER_USAGE + #ifdef SQL_SCHEMA_USAGE // Bitmask enumerating the statements in which schemas can be used. - intParams[SQL_SCHEMA_USAGE] = SQL_SU_DML_STATEMENTS | - SQL_SU_TABLE_DEFINITION | SQL_SU_PRIVILEGE_DEFINITION; + intParams[SQL_SCHEMA_USAGE] = SQL_SU_DML_STATEMENTS | SQL_SU_TABLE_DEFINITION | + SQL_SU_PRIVILEGE_DEFINITION | SQL_SU_INDEX_DEFINITION; #endif // SQL_SCHEMA_USAGE -#ifdef SQL_MAX_IDENTIFIER_LEN - // Indicates the maximum size in characters that the data source - // supports for user-defined names. - intParams[SQL_MAX_IDENTIFIER_LEN] = 128; -#endif // SQL_MAX_IDENTIFIER_LEN - #ifdef SQL_AGGREGATE_FUNCTIONS // Bitmask enumerating support for aggregation functions. - intParams[SQL_AGGREGATE_FUNCTIONS] = SQL_AF_AVG | SQL_AF_COUNT | - SQL_AF_DISTINCT | SQL_AF_MAX | SQL_AF_MIN | SQL_AF_SUM; + intParams[SQL_AGGREGATE_FUNCTIONS] = SQL_AF_AVG | SQL_AF_COUNT | SQL_AF_MAX | SQL_AF_MIN | SQL_AF_SUM | + SQL_AF_DISTINCT; #endif // SQL_AGGREGATE_FUNCTIONS #ifdef SQL_NUMERIC_FUNCTIONS - // Bitmask enumerating the scalar numeric functions supported by - // the driver and associated data source. - intParams[SQL_NUMERIC_FUNCTIONS] = SQL_FN_NUM_ABS | SQL_FN_NUM_ACOS | SQL_FN_NUM_ASIN | - SQL_FN_NUM_ATAN | SQL_FN_NUM_ATAN2 | SQL_FN_NUM_CEILING | SQL_FN_NUM_COS | SQL_FN_NUM_COT | - SQL_FN_NUM_EXP | SQL_FN_NUM_FLOOR | SQL_FN_NUM_LOG | SQL_FN_NUM_MOD | SQL_FN_NUM_SIGN | - SQL_FN_NUM_SIN | SQL_FN_NUM_SQRT | SQL_FN_NUM_TAN | SQL_FN_NUM_PI | SQL_FN_NUM_RAND | - SQL_FN_NUM_DEGREES | SQL_FN_NUM_LOG10 | SQL_FN_NUM_POWER | SQL_FN_NUM_RADIANS | SQL_FN_NUM_ROUND | - SQL_FN_NUM_TRUNCATE; + // Bitmask enumerating the scalar numeric functions supported by the driver and associated data source. + intParams[SQL_NUMERIC_FUNCTIONS] = SQL_FN_NUM_ABS | SQL_FN_NUM_ACOS | SQL_FN_NUM_ASIN | SQL_FN_NUM_EXP | + SQL_FN_NUM_ATAN | SQL_FN_NUM_ATAN2 | SQL_FN_NUM_CEILING | SQL_FN_NUM_COS | SQL_FN_NUM_TRUNCATE | + SQL_FN_NUM_FLOOR | SQL_FN_NUM_DEGREES | SQL_FN_NUM_POWER | SQL_FN_NUM_RADIANS | SQL_FN_NUM_SIGN | + SQL_FN_NUM_SIN | SQL_FN_NUM_LOG | SQL_FN_NUM_TAN | SQL_FN_NUM_PI | SQL_FN_NUM_MOD | SQL_FN_NUM_COT | + SQL_FN_NUM_LOG10 | SQL_FN_NUM_ROUND | SQL_FN_NUM_SQRT | SQL_FN_NUM_RAND; #endif // SQL_NUMERIC_FUNCTIONS #ifdef SQL_STRING_FUNCTIONS - // Bitmask enumerating the scalar string functions supported by the - // driver and associated data source. - intParams[SQL_STRING_FUNCTIONS] = SQL_FN_STR_ASCII | SQL_FN_STR_BIT_LENGTH | SQL_FN_STR_CHAR | - SQL_FN_STR_CONCAT | SQL_FN_STR_DIFFERENCE | SQL_FN_STR_INSERT | SQL_FN_STR_LEFT | - SQL_FN_STR_LENGTH | SQL_FN_STR_LOCATE | SQL_FN_STR_LTRIM | SQL_FN_STR_OCTET_LENGTH | + // Bitmask enumerating the scalar string functions supported by the driver and associated data source. + intParams[SQL_STRING_FUNCTIONS] = SQL_FN_STR_ASCII | SQL_FN_STR_BIT_LENGTH | SQL_FN_STR_CHAR_LENGTH | + SQL_FN_STR_CHAR | SQL_FN_STR_CONCAT | SQL_FN_STR_DIFFERENCE | SQL_FN_STR_INSERT | SQL_FN_STR_LEFT | + SQL_FN_STR_LENGTH | SQL_FN_STR_CHARACTER_LENGTH | SQL_FN_STR_LTRIM | SQL_FN_STR_OCTET_LENGTH | SQL_FN_STR_POSITION | SQL_FN_STR_REPEAT | SQL_FN_STR_REPLACE | SQL_FN_STR_RIGHT | SQL_FN_STR_RTRIM | SQL_FN_STR_SOUNDEX | SQL_FN_STR_SPACE | SQL_FN_STR_SUBSTRING | SQL_FN_STR_LCASE | SQL_FN_STR_UCASE | - SQL_FN_STR_LOCATE_2 | SQL_FN_STR_CHAR_LENGTH | SQL_FN_STR_CHARACTER_LENGTH; + SQL_FN_STR_LOCATE_2 | SQL_FN_STR_LOCATE; #endif // SQL_STRING_FUNCTIONS #ifdef SQL_TIMEDATE_FUNCTIONS - // Bitmask enumerating the scalar date and time functions supported - // by the driver and associated data source. - intParams[SQL_TIMEDATE_FUNCTIONS] = SQL_FN_TD_CURRENT_DATE | SQL_FN_TD_CURRENT_TIME | - SQL_FN_TD_CURRENT_TIMESTAMP | SQL_FN_TD_CURDATE | SQL_FN_TD_CURTIME | SQL_FN_TD_DAYNAME | - SQL_FN_TD_DAYOFMONTH | SQL_FN_TD_DAYOFWEEK | SQL_FN_TD_DAYOFYEAR | SQL_FN_TD_EXTRACT | - SQL_FN_TD_HOUR | SQL_FN_TD_MINUTE | SQL_FN_TD_MONTH | SQL_FN_TD_MONTHNAME | SQL_FN_TD_NOW | - SQL_FN_TD_QUARTER | SQL_FN_TD_SECOND | SQL_FN_TD_WEEK | SQL_FN_TD_YEAR; + // Bitmask enumerating the scalar date and time functions supported by the driver and associated data + // source. + intParams[SQL_TIMEDATE_FUNCTIONS] = SQL_FN_TD_CURRENT_DATE | SQL_FN_TD_CURRENT_TIME | SQL_FN_TD_WEEK | + SQL_FN_TD_QUARTER | SQL_FN_TD_SECOND | SQL_FN_TD_CURDATE | SQL_FN_TD_CURTIME | SQL_FN_TD_DAYNAME | + SQL_FN_TD_MINUTE | SQL_FN_TD_DAYOFWEEK | SQL_FN_TD_DAYOFYEAR | SQL_FN_TD_EXTRACT | SQL_FN_TD_HOUR | + SQL_FN_TD_DAYOFMONTH | SQL_FN_TD_MONTH | SQL_FN_TD_MONTHNAME | SQL_FN_TD_NOW | SQL_FN_TD_YEAR | + SQL_FN_TD_CURRENT_TIMESTAMP; #endif // SQL_TIMEDATE_FUNCTIONS #ifdef SQL_TIMEDATE_ADD_INTERVALS - // Bitmask enumerating timestamp intervals supported by the driver - // and associated data source for the TIMESTAMPADD scalar function. + // Bitmask enumerating timestamp intervals supported by the driver and associated data source for the + // TIMESTAMPADD scalar function. intParams[SQL_TIMEDATE_ADD_INTERVALS] = 0; #endif // SQL_TIMEDATE_ADD_INTERVALS #ifdef SQL_TIMEDATE_DIFF_INTERVALS - // Bitmask enumerating timestamp intervals supported by the driver - // and associated data source for the TIMESTAMPDIFF scalar function. + // Bitmask enumerating timestamp intervals supported by the driver and associated data source for the + // TIMESTAMPDIFF scalar function. intParams[SQL_TIMEDATE_DIFF_INTERVALS] = 0; #endif // SQL_TIMEDATE_DIFF_INTERVALS #ifdef SQL_DATETIME_LITERALS - // Bitmask enumerating the SQL-92 datetime literals supported by - // the data source. + // Bitmask enumerating the SQL-92 datetime literals supported by the data source. intParams[SQL_DATETIME_LITERALS] = SQL_DL_SQL92_DATE | SQL_DL_SQL92_TIME | SQL_DL_SQL92_TIMESTAMP; #endif // SQL_DATETIME_LITERALS #ifdef SQL_SYSTEM_FUNCTIONS - // Bitmask enumerating the scalar system functions supported by the - // driver and associated data source. + // Bitmask enumerating the scalar system functions supported by the driver and associated data source. intParams[SQL_SYSTEM_FUNCTIONS] = SQL_FN_SYS_USERNAME | SQL_FN_SYS_DBNAME | SQL_FN_SYS_IFNULL; #endif // SQL_SYSTEM_FUNCTIONS #ifdef SQL_CONVERT_FUNCTIONS - // Bitmask enumerating the scalar conversion functions supported - // by the driver and associated data source. + // Bitmask enumerating the scalar conversion functions supported by the driver and associated data + // source. intParams[SQL_CONVERT_FUNCTIONS] = SQL_FN_CVT_CONVERT | SQL_FN_CVT_CAST; #endif // SQL_CONVERT_FUNCTIONS #ifdef SQL_OJ_CAPABILITIES - // Bitmask enumerating the types of outer joins supported by the - // driver and data source. + // Bitmask enumerating the types of outer joins supported by the driver and data source. intParams[SQL_OJ_CAPABILITIES] = SQL_OJ_LEFT | SQL_OJ_NOT_ORDERED | SQL_OJ_ALL_COMPARISON_OPS; #endif // SQL_OJ_CAPABILITIES @@ -339,14 +1009,23 @@ namespace ignite #endif // SQL_POS_OPERATIONS #ifdef SQL_SQL92_NUMERIC_VALUE_FUNCTIONS - // Bitmask enumerating the numeric value scalar functions. - intParams[SQL_SQL92_NUMERIC_VALUE_FUNCTIONS] = 0; + // Bitmask enumerating the numeric value scalar functions that are supported by the driver and the + // associated data source, as defined in SQL-92. + // The following bitmasks are used to determine which numeric functions are supported : + // SQL_SNVF_BIT_LENGTH + // SQL_SNVF_CHAR_LENGTH + // SQL_SNVF_CHARACTER_LENGTH + // SQL_SNVF_EXTRACT + // SQL_SNVF_OCTET_LENGTH + // SQL_SNVF_POSITION + intParams[SQL_SQL92_NUMERIC_VALUE_FUNCTIONS] = SQL_SNVF_BIT_LENGTH | SQL_SNVF_CHARACTER_LENGTH | + SQL_SNVF_EXTRACT | SQL_SNVF_OCTET_LENGTH | SQL_SNVF_POSITION; #endif // SQL_SQL92_NUMERIC_VALUE_FUNCTIONS #ifdef SQL_SQL92_STRING_FUNCTIONS // Bitmask enumerating the string scalar functions. - intParams[SQL_SQL92_STRING_FUNCTIONS] = SQL_SSF_LOWER | SQL_SSF_UPPER | SQL_SSF_SUBSTRING | - SQL_SSF_TRIM_BOTH | SQL_SSF_TRIM_LEADING | SQL_SSF_TRIM_TRAILING; + intParams[SQL_SQL92_STRING_FUNCTIONS] = SQL_SSF_LOWER | SQL_SSF_UPPER | SQL_SSF_TRIM_TRAILING | + SQL_SSF_SUBSTRING | SQL_SSF_TRIM_BOTH | SQL_SSF_TRIM_LEADING; #endif // SQL_SQL92_STRING_FUNCTIONS #ifdef SQL_SQL92_DATETIME_FUNCTIONS @@ -356,8 +1035,7 @@ namespace ignite #endif // SQL_SQL92_DATETIME_FUNCTIONS #ifdef SQL_SQL92_VALUE_EXPRESSIONS - // Bitmask enumerating the value expressions supported, - // as defined in SQL-92. + // Bitmask enumerating the value expressions supported, as defined in SQL-92. intParams[SQL_SQL92_VALUE_EXPRESSIONS] = SQL_SVE_CASE | SQL_SVE_CAST | SQL_SVE_COALESCE | SQL_SVE_NULLIF; #endif // SQL_SQL92_VALUE_EXPRESSIONS @@ -371,222 +1049,216 @@ namespace ignite #endif // SQL_SQL92_PREDICATES #ifdef SQL_SQL92_RELATIONAL_JOIN_OPERATORS - // Bitmask enumerating the relational join operators supported - // in a SELECT statement, as defined in SQL-92. + // Bitmask enumerating the relational join operators supported in a SELECT statement, as defined + // in SQL-92. intParams[SQL_SQL92_RELATIONAL_JOIN_OPERATORS] = SQL_SRJO_CORRESPONDING_CLAUSE | SQL_SRJO_CROSS_JOIN | SQL_SRJO_EXCEPT_JOIN | SQL_SRJO_INNER_JOIN | SQL_SRJO_LEFT_OUTER_JOIN| SQL_SRJO_RIGHT_OUTER_JOIN | SQL_SRJO_NATURAL_JOIN | SQL_SRJO_INTERSECT_JOIN | SQL_SRJO_UNION_JOIN; #endif // SQL_SQL92_RELATIONAL_JOIN_OPERATORS #ifdef SQL_STATIC_CURSOR_ATTRIBUTES1 - // Bitmask that describes the attributes of a static cursor that - // are supported by the driver. This bitmask contains the first - // subset of attributes; for the second subset, see + // Bitmask that describes the attributes of a static cursor that are supported by the driver. This + // bitmask contains the first subset of attributes; for the second subset, see // SQL_STATIC_CURSOR_ATTRIBUTES2. intParams[SQL_STATIC_CURSOR_ATTRIBUTES1] = SQL_CA1_NEXT; -#endif //SQL_STATIC_CURSOR_ATTRIBUTES1 +#endif // SQL_STATIC_CURSOR_ATTRIBUTES1 #ifdef SQL_STATIC_CURSOR_ATTRIBUTES2 - // Bitmask that describes the attributes of a static cursor that - // are supported by the driver. This bitmask contains the second - // subset of attributes; for the first subset, see + // Bitmask that describes the attributes of a static cursor that are supported by the driver. This + // bitmask contains the second subset of attributes; for the first subset, see // SQL_STATIC_CURSOR_ATTRIBUTES1. intParams[SQL_STATIC_CURSOR_ATTRIBUTES2] = 0; -#endif //SQL_STATIC_CURSOR_ATTRIBUTES2 +#endif // SQL_STATIC_CURSOR_ATTRIBUTES2 #ifdef SQL_CONVERT_BIGINT // Bitmask indicates the conversions supported by the CONVERT scalar function for target type BIGINT intParams[SQL_CONVERT_BIGINT] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_WCHAR | - SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | SQL_CVT_NUMERIC | SQL_CVT_BIT | - SQL_CVT_TINYINT | SQL_CVT_SMALLINT | SQL_CVT_INTEGER | SQL_CVT_BIGINT | - SQL_CVT_TIMESTAMP; -#endif //SQL_CONVERT_BIGINT + SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | SQL_CVT_NUMERIC | SQL_CVT_TIMESTAMP | SQL_CVT_TINYINT | + SQL_CVT_SMALLINT | SQL_CVT_INTEGER | SQL_CVT_BIGINT | SQL_CVT_BIT; +#endif // SQL_CONVERT_BIGINT #ifdef SQL_CONVERT_BINARY // Bitmask indicates the conversions supported by the CONVERT scalar function for target type BINARY - intParams[SQL_CONVERT_BINARY] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | - SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | - SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_SMALLINT | SQL_CVT_INTEGER | SQL_CVT_BIGINT | SQL_CVT_REAL | - SQL_CVT_FLOAT | SQL_CVT_DOUBLE | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_LONGVARBINARY | - SQL_CVT_DATE | SQL_CVT_TIME | SQL_CVT_TIMESTAMP | SQL_CVT_GUID; -#endif //SQL_CONVERT_BINARY + intParams[SQL_CONVERT_BINARY] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_BIT | + SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | SQL_CVT_NUMERIC | SQL_CVT_LONGVARBINARY | + SQL_CVT_FLOAT | SQL_CVT_SMALLINT | SQL_CVT_INTEGER | SQL_CVT_BIGINT | SQL_CVT_REAL | SQL_CVT_DATE | + SQL_CVT_TINYINT | SQL_CVT_DOUBLE | SQL_CVT_BINARY | SQL_CVT_DECIMAL | SQL_CVT_TIME | SQL_CVT_GUID | + SQL_CVT_TIMESTAMP | SQL_CVT_VARBINARY; +#endif // SQL_CONVERT_BINARY #ifdef SQL_CONVERT_BIT // Bitmask indicates the conversions supported by the CONVERT scalar function for target type BIT - intParams[SQL_CONVERT_BIT] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | - SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | SQL_CVT_NUMERIC | - SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_SMALLINT | SQL_CVT_INTEGER | SQL_CVT_BIGINT; -#endif //SQL_CONVERT_BIT + intParams[SQL_CONVERT_BIT] = SQL_CVT_BIGINT | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_WVARCHAR | + SQL_CVT_NUMERIC | SQL_CVT_BIT | SQL_CVT_CHAR | SQL_CVT_SMALLINT | SQL_CVT_INTEGER | SQL_CVT_TINYINT; +#endif // SQL_CONVERT_BIT #ifdef SQL_CONVERT_CHAR // Bitmask indicates the conversions supported by the CONVERT scalar function for target type CHAR - intParams[SQL_CONVERT_CHAR] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | - SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | - SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_SMALLINT | SQL_CVT_INTEGER | - SQL_CVT_BIGINT | SQL_CVT_REAL | SQL_CVT_FLOAT | SQL_CVT_DOUBLE | SQL_CVT_BINARY | SQL_CVT_VARBINARY | - SQL_CVT_LONGVARBINARY | SQL_CVT_DATE | SQL_CVT_TIME | SQL_CVT_TIMESTAMP | SQL_CVT_GUID; -#endif //SQL_CONVERT_CHAR + intParams[SQL_CONVERT_CHAR] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_VARBINARY | + SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | + SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_SMALLINT | SQL_CVT_INTEGER | SQL_CVT_BIGINT | SQL_CVT_REAL | + SQL_CVT_FLOAT | SQL_CVT_DOUBLE | SQL_CVT_BINARY | SQL_CVT_TIMESTAMP | SQL_CVT_DATE | SQL_CVT_TIME | + SQL_CVT_LONGVARBINARY | SQL_CVT_GUID; +#endif // SQL_CONVERT_CHAR #ifdef SQL_CONVERT_VARCHAR // Bitmask indicates the conversions supported by the CONVERT scalar function for target type VARCHAR - intParams[SQL_CONVERT_VARCHAR] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | - SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | - SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_SMALLINT | SQL_CVT_INTEGER | - SQL_CVT_BIGINT | SQL_CVT_REAL | SQL_CVT_FLOAT | SQL_CVT_DOUBLE | SQL_CVT_BINARY | SQL_CVT_VARBINARY | - SQL_CVT_LONGVARBINARY | SQL_CVT_DATE | SQL_CVT_TIME | SQL_CVT_TIMESTAMP | SQL_CVT_GUID; -#endif //SQL_CONVERT_VARCHAR + intParams[SQL_CONVERT_VARCHAR] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_WCHAR | + SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_TINYINT | + SQL_CVT_SMALLINT | SQL_CVT_INTEGER | SQL_CVT_BIGINT | SQL_CVT_REAL | SQL_CVT_FLOAT | SQL_CVT_BIT | + SQL_CVT_DOUBLE | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_GUID | SQL_CVT_DATE | SQL_CVT_TIME | + SQL_CVT_LONGVARBINARY | SQL_CVT_TIMESTAMP; +#endif // SQL_CONVERT_VARCHAR #ifdef SQL_CONVERT_LONGVARCHAR - // Bitmask indicates the conversions supported by the CONVERT scalar function for target type LONGVARCHAR - intParams[SQL_CONVERT_LONGVARCHAR] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | - SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | - SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_SMALLINT | SQL_CVT_INTEGER | - SQL_CVT_BIGINT | SQL_CVT_REAL | SQL_CVT_FLOAT | SQL_CVT_DOUBLE | SQL_CVT_BINARY | SQL_CVT_VARBINARY | - SQL_CVT_LONGVARBINARY | SQL_CVT_DATE | SQL_CVT_TIME | SQL_CVT_TIMESTAMP | SQL_CVT_GUID; -#endif //SQL_CONVERT_LONGVARCHAR + // Bitmask indicates the conversions supported by the CONVERT scalar function for target type + // LONGVARCHAR + intParams[SQL_CONVERT_LONGVARCHAR] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_DATE | SQL_CVT_TIME | + SQL_CVT_LONGVARCHAR | SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | SQL_CVT_NUMERIC | + SQL_CVT_DECIMAL | SQL_CVT_BIT | SQL_CVT_REAL | SQL_CVT_SMALLINT | SQL_CVT_INTEGER | SQL_CVT_GUID | + SQL_CVT_BIGINT | SQL_CVT_LONGVARBINARY | SQL_CVT_DOUBLE | SQL_CVT_BINARY | SQL_CVT_VARBINARY | + SQL_CVT_TINYINT | SQL_CVT_FLOAT | SQL_CVT_TIMESTAMP; +#endif // SQL_CONVERT_LONGVARCHAR #ifdef SQL_CONVERT_WCHAR // Bitmask indicates the conversions supported by the CONVERT scalar function for target type WCHAR - intParams[SQL_CONVERT_WCHAR] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | - SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | - SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_SMALLINT | SQL_CVT_INTEGER | - SQL_CVT_BIGINT | SQL_CVT_REAL | SQL_CVT_FLOAT | SQL_CVT_DOUBLE | SQL_CVT_BINARY | SQL_CVT_VARBINARY | - SQL_CVT_LONGVARBINARY | SQL_CVT_DATE | SQL_CVT_TIME | SQL_CVT_TIMESTAMP | SQL_CVT_GUID; -#endif //SQL_CONVERT_WCHAR + intParams[SQL_CONVERT_WCHAR] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_WCHAR | + SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_VARBINARY | + SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_SMALLINT | SQL_CVT_INTEGER | SQL_CVT_BIGINT | SQL_CVT_REAL | + SQL_CVT_FLOAT | SQL_CVT_DOUBLE | SQL_CVT_BINARY | SQL_CVT_LONGVARBINARY | SQL_CVT_TIMESTAMP | + SQL_CVT_DATE | SQL_CVT_TIME | SQL_CVT_GUID; +#endif // SQL_CONVERT_WCHAR #ifdef SQL_CONVERT_WVARCHAR // Bitmask indicates the conversions supported by the CONVERT scalar function for target type WVARCHAR - intParams[SQL_CONVERT_WVARCHAR] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | - SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | - SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_SMALLINT | SQL_CVT_INTEGER | - SQL_CVT_BIGINT | SQL_CVT_REAL | SQL_CVT_FLOAT | SQL_CVT_DOUBLE | SQL_CVT_BINARY | SQL_CVT_VARBINARY | - SQL_CVT_LONGVARBINARY | SQL_CVT_DATE | SQL_CVT_TIME | SQL_CVT_TIMESTAMP | SQL_CVT_GUID; -#endif //SQL_CONVERT_WVARCHAR + intParams[SQL_CONVERT_WVARCHAR] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_REAL | + SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | SQL_CVT_NUMERIC | SQL_CVT_LONGVARBINARY | + SQL_CVT_DECIMAL | SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_SMALLINT | SQL_CVT_DATE | SQL_CVT_TIME | + SQL_CVT_INTEGER | SQL_CVT_BIGINT | SQL_CVT_FLOAT | SQL_CVT_DOUBLE | SQL_CVT_BINARY | SQL_CVT_GUID | + SQL_CVT_VARBINARY | SQL_CVT_TIMESTAMP; +#endif // SQL_CONVERT_WVARCHAR #ifdef SQL_CONVERT_WLONGVARCHAR - // Bitmask indicates the conversions supported by the CONVERT scalar function for target type WLONGVARCHAR - intParams[SQL_CONVERT_WLONGVARCHAR] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | - SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | - SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_SMALLINT | SQL_CVT_INTEGER | - SQL_CVT_BIGINT | SQL_CVT_REAL | SQL_CVT_FLOAT | SQL_CVT_DOUBLE | SQL_CVT_BINARY | SQL_CVT_VARBINARY | - SQL_CVT_LONGVARBINARY | SQL_CVT_DATE | SQL_CVT_TIME | SQL_CVT_TIMESTAMP | SQL_CVT_GUID; -#endif //SQL_CONVERT_WLONGVARCHAR + // Bitmask indicates the conversions supported by the CONVERT scalar function for target type + // WLONGVARCHAR + intParams[SQL_CONVERT_WLONGVARCHAR] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_BIGINT | SQL_CVT_REAL | + SQL_CVT_LONGVARCHAR | SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | SQL_CVT_VARBINARY | + SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_DATE | SQL_CVT_FLOAT | + SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_DOUBLE | SQL_CVT_BINARY | SQL_CVT_LONGVARBINARY | + SQL_CVT_TIME | SQL_CVT_TIMESTAMP | SQL_CVT_GUID; +#endif // SQL_CONVERT_WLONGVARCHAR + +#ifdef SQL_CONVERT_GUID + // Bitmask indicates the conversions supported by the CONVERT scalar function for target type GUID + intParams[SQL_CONVERT_GUID] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_WVARCHAR | + SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_LONGVARBINARY | + SQL_CVT_GUID; +#endif // SQL_CONVERT_GUID #ifdef SQL_CONVERT_DATE // Bitmask indicates the conversions supported by the CONVERT scalar function for target type DATE - intParams[SQL_CONVERT_DATE] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | - SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | - SQL_CVT_NUMERIC | SQL_CVT_INTEGER | SQL_CVT_BIGINT | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_LONGVARBINARY | - SQL_CVT_DATE | SQL_CVT_TIMESTAMP; -#endif //SQL_CONVERT_DATE + intParams[SQL_CONVERT_DATE] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_WCHAR | + SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | SQL_CVT_NUMERIC | SQL_CVT_INTEGER | SQL_CVT_BIGINT | + SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_LONGVARBINARY | SQL_CVT_DATE | SQL_CVT_TIMESTAMP; +#endif // SQL_CONVERT_DATE #ifdef SQL_CONVERT_DECIMAL // Bitmask indicates the conversions supported by the CONVERT scalar function for target type DECIMAL - intParams[SQL_CONVERT_DECIMAL] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | - SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | - SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_SMALLINT | SQL_CVT_INTEGER | SQL_CVT_BIGINT | - SQL_CVT_REAL | SQL_CVT_FLOAT | SQL_CVT_DOUBLE | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_LONGVARBINARY | SQL_CVT_TIMESTAMP; -#endif //SQL_CONVERT_DECIMAL + intParams[SQL_CONVERT_DECIMAL] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_WCHAR | + SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_TIMESTAMP | + SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_SMALLINT | SQL_CVT_INTEGER | SQL_CVT_BIGINT | SQL_CVT_REAL | + SQL_CVT_FLOAT | SQL_CVT_DOUBLE | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_LONGVARBINARY; +#endif // SQL_CONVERT_DECIMAL #ifdef SQL_CONVERT_DOUBLE // Bitmask indicates the conversions supported by the CONVERT scalar function for target type DOUBLE - intParams[SQL_CONVERT_DOUBLE] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | - SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_SMALLINT | SQL_CVT_INTEGER | - SQL_CVT_BIGINT | SQL_CVT_REAL | SQL_CVT_FLOAT | SQL_CVT_DOUBLE | SQL_CVT_BINARY | SQL_CVT_VARBINARY | - SQL_CVT_LONGVARBINARY | SQL_CVT_TIMESTAMP; -#endif //SQL_CONVERT_DOUBLE + intParams[SQL_CONVERT_DOUBLE] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_WCHAR | + SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_TIMESTAMP | + SQL_CVT_TINYINT | SQL_CVT_BIGINT | SQL_CVT_INTEGER | SQL_CVT_FLOAT | SQL_CVT_REAL | SQL_CVT_DOUBLE | + SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_SMALLINT | SQL_CVT_LONGVARBINARY; +#endif // SQL_CONVERT_DOUBLE #ifdef SQL_CONVERT_FLOAT // Bitmask indicates the conversions supported by the CONVERT scalar function for target type FLOAT - intParams[SQL_CONVERT_FLOAT] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | - SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | - SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_SMALLINT | SQL_CVT_INTEGER | - SQL_CVT_BIGINT | SQL_CVT_REAL | SQL_CVT_FLOAT | SQL_CVT_DOUBLE | SQL_CVT_BINARY | SQL_CVT_VARBINARY | - SQL_CVT_LONGVARBINARY | SQL_CVT_TIMESTAMP; -#endif //SQL_CONVERT_FLOAT + intParams[SQL_CONVERT_FLOAT] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_WVARCHAR | + SQL_CVT_WLONGVARCHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_TINYINT | SQL_CVT_SMALLINT | + SQL_CVT_INTEGER | SQL_CVT_BIGINT | SQL_CVT_REAL | SQL_CVT_FLOAT | SQL_CVT_DOUBLE | SQL_CVT_BINARY | + SQL_CVT_VARBINARY | SQL_CVT_WCHAR | SQL_CVT_LONGVARBINARY | SQL_CVT_TIMESTAMP | SQL_CVT_BIT; +#endif // SQL_CONVERT_FLOAT #ifdef SQL_CONVERT_REAL // Bitmask indicates the conversions supported by the CONVERT scalar function for target type REAL - intParams[SQL_CONVERT_REAL] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | - SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | - SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_SMALLINT | - SQL_CVT_INTEGER | SQL_CVT_BIGINT | SQL_CVT_REAL | SQL_CVT_FLOAT | SQL_CVT_DOUBLE | - SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_LONGVARBINARY | SQL_CVT_TIMESTAMP; -#endif //SQL_CONVERT_REAL + intParams[SQL_CONVERT_REAL] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_WVARCHAR | + SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_BIT | SQL_CVT_FLOAT | SQL_CVT_SMALLINT | SQL_CVT_REAL | + SQL_CVT_INTEGER | SQL_CVT_BIGINT | SQL_CVT_DOUBLE | SQL_CVT_TINYINT | SQL_CVT_WLONGVARCHAR | + SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_LONGVARBINARY | SQL_CVT_TIMESTAMP | SQL_CVT_WCHAR; +#endif // SQL_CONVERT_REAL #ifdef SQL_CONVERT_INTEGER // Bitmask indicates the conversions supported by the CONVERT scalar function for target type INTEGER - intParams[SQL_CONVERT_INTEGER] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | - SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | - SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_SMALLINT | - SQL_CVT_INTEGER | SQL_CVT_BIGINT | SQL_CVT_REAL | SQL_CVT_FLOAT | SQL_CVT_DOUBLE | SQL_CVT_BINARY | - SQL_CVT_VARBINARY | SQL_CVT_LONGVARBINARY | SQL_CVT_TIMESTAMP; -#endif //SQL_CONVERT_INTEGER + intParams[SQL_CONVERT_INTEGER] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_WCHAR | + SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_TINYINT | + SQL_CVT_SMALLINT | SQL_CVT_BIT | SQL_CVT_INTEGER | SQL_CVT_BIGINT | SQL_CVT_REAL | SQL_CVT_FLOAT | + SQL_CVT_DOUBLE | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_LONGVARBINARY | SQL_CVT_TIMESTAMP; +#endif // SQL_CONVERT_INTEGER #ifdef SQL_CONVERT_NUMERIC // Bitmask indicates the conversions supported by the CONVERT scalar function for target type NUMERIC - intParams[SQL_CONVERT_NUMERIC] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | - SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | - SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_BIT | SQL_CVT_TINYINT | - SQL_CVT_SMALLINT | SQL_CVT_INTEGER | SQL_CVT_BIGINT | SQL_CVT_REAL | - SQL_CVT_FLOAT | SQL_CVT_DOUBLE | SQL_CVT_BINARY | SQL_CVT_VARBINARY | - SQL_CVT_LONGVARBINARY | SQL_CVT_TIMESTAMP; -#endif //SQL_CONVERT_NUMERIC + intParams[SQL_CONVERT_NUMERIC] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_WCHAR | + SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_SMALLINT | + SQL_CVT_INTEGER | SQL_CVT_BIGINT | SQL_CVT_REAL | SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_FLOAT | + SQL_CVT_DOUBLE | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_LONGVARBINARY | SQL_CVT_TIMESTAMP; +#endif // SQL_CONVERT_NUMERIC #ifdef SQL_CONVERT_SMALLINT // Bitmask indicates the conversions supported by the CONVERT scalar function for target type SMALLINT - intParams[SQL_CONVERT_SMALLINT] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | - SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | - SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_BIT | SQL_CVT_TINYINT | - SQL_CVT_SMALLINT | SQL_CVT_INTEGER | SQL_CVT_BIGINT | SQL_CVT_REAL | - SQL_CVT_FLOAT | SQL_CVT_DOUBLE | SQL_CVT_BINARY | SQL_CVT_VARBINARY | - SQL_CVT_LONGVARBINARY | SQL_CVT_TIMESTAMP; -#endif //SQL_CONVERT_SMALLINT + intParams[SQL_CONVERT_SMALLINT] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_WCHAR | + SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_VARBINARY | + SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_SMALLINT | SQL_CVT_INTEGER | SQL_CVT_BIGINT | SQL_CVT_REAL | + SQL_CVT_FLOAT | SQL_CVT_DOUBLE | SQL_CVT_BINARY | SQL_CVT_LONGVARBINARY | SQL_CVT_TIMESTAMP; +#endif // SQL_CONVERT_SMALLINT #ifdef SQL_CONVERT_TINYINT // Bitmask indicates the conversions supported by the CONVERT scalar function for target type TINYINT - intParams[SQL_CONVERT_TINYINT] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | - SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | - SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_SMALLINT | - SQL_CVT_INTEGER | SQL_CVT_BIGINT | SQL_CVT_REAL | SQL_CVT_FLOAT | SQL_CVT_DOUBLE | - SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_LONGVARBINARY | SQL_CVT_TIMESTAMP; -#endif //SQL_CONVERT_TINYINT + intParams[SQL_CONVERT_TINYINT] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_WCHAR | + SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_TINYINT | + SQL_CVT_SMALLINT | SQL_CVT_BIT | SQL_CVT_INTEGER | SQL_CVT_BIGINT | SQL_CVT_REAL | SQL_CVT_FLOAT | + SQL_CVT_DOUBLE | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_LONGVARBINARY | SQL_CVT_TIMESTAMP; +#endif // SQL_CONVERT_TINYINT #ifdef SQL_CONVERT_TIME // Bitmask indicates the conversions supported by the CONVERT scalar function for target type TIME - intParams[SQL_CONVERT_TIME] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | - SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | - SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_LONGVARBINARY | + intParams[SQL_CONVERT_TIME] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_WVARCHAR | + SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_LONGVARBINARY | SQL_CVT_TIME | SQL_CVT_TIMESTAMP; -#endif //SQL_CONVERT_TIME +#endif // SQL_CONVERT_TIME #ifdef SQL_CONVERT_TIMESTAMP // Bitmask indicates the conversions supported by the CONVERT scalar function for target type TIMESTAMP - intParams[SQL_CONVERT_TIMESTAMP] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | - SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | - SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_INTEGER | SQL_CVT_BIGINT | SQL_CVT_BINARY | - SQL_CVT_VARBINARY | SQL_CVT_LONGVARBINARY | SQL_CVT_DATE | SQL_CVT_TIME | SQL_CVT_TIMESTAMP; -#endif //SQL_CONVERT_TIMESTAMP + intParams[SQL_CONVERT_TIMESTAMP] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_DATE | + SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | SQL_CVT_NUMERIC | SQL_CVT_LONGVARBINARY | + SQL_CVT_DECIMAL | SQL_CVT_INTEGER | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_TIMESTAMP | + SQL_CVT_BIGINT | SQL_CVT_TIME; +#endif // SQL_CONVERT_TIMESTAMP #ifdef SQL_CONVERT_VARBINARY // Bitmask indicates the conversions supported by the CONVERT scalar function for target type VARBINARY - intParams[SQL_CONVERT_VARBINARY] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | - SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | - SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_SMALLINT | - SQL_CVT_INTEGER | SQL_CVT_BIGINT | SQL_CVT_REAL | SQL_CVT_FLOAT | SQL_CVT_DOUBLE | - SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_LONGVARBINARY | SQL_CVT_DATE | + intParams[SQL_CONVERT_VARBINARY] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_BIT | + SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | + SQL_CVT_TINYINT | SQL_CVT_SMALLINT | SQL_CVT_DATE | SQL_CVT_BIGINT | SQL_CVT_REAL | SQL_CVT_FLOAT | + SQL_CVT_DOUBLE | SQL_CVT_INTEGER | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_LONGVARBINARY | SQL_CVT_TIME | SQL_CVT_TIMESTAMP | SQL_CVT_GUID; -#endif //SQL_CONVERT_VARBINARY +#endif // SQL_CONVERT_VARBINARY #ifdef SQL_CONVERT_LONGVARBINARY - // Bitmask indicates the conversions supported by the CONVERT scalar function for target type LONGVARBINARY - intParams[SQL_CONVERT_LONGVARBINARY] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | - SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | - SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_SMALLINT | - SQL_CVT_INTEGER | SQL_CVT_BIGINT | SQL_CVT_REAL | SQL_CVT_FLOAT | SQL_CVT_DOUBLE | - SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_LONGVARBINARY | SQL_CVT_DATE | - SQL_CVT_TIME | SQL_CVT_TIMESTAMP | SQL_CVT_GUID; -#endif //SQL_CONVERT_LONGVARBINARY + // Bitmask indicates the conversions supported by the CONVERT scalar function for target type + // LONGVARBINARY + intParams[SQL_CONVERT_LONGVARBINARY] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_BIT | SQL_CVT_TINYINT | + SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_NUMERIC | + SQL_CVT_DECIMAL | SQL_CVT_FLOAT | SQL_CVT_INTEGER | SQL_CVT_BIGINT | SQL_CVT_REAL | SQL_CVT_DATE | + SQL_CVT_DOUBLE | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_LONGVARBINARY | SQL_CVT_TIMESTAMP | + SQL_CVT_SMALLINT | SQL_CVT_TIME | SQL_CVT_GUID; +#endif // SQL_CONVERT_LONGVARBINARY #ifdef SQL_PARAM_ARRAY_ROW_COUNTS // Enumerating the driver's properties regarding the availability of row counts in a parameterized @@ -602,7 +1274,7 @@ namespace ignite // conceptually equivalent to treating the statement together with the complete parameter array as // one atomic unit. Errors are handled the same as if one statement were executed. intParams[SQL_PARAM_ARRAY_ROW_COUNTS] = SQL_PARC_NO_BATCH; -#endif //SQL_PARAM_ARRAY_ROW_COUNTS +#endif // SQL_PARAM_ARRAY_ROW_COUNTS #ifdef SQL_PARAM_ARRAY_SELECTS // Enumerating the driver's properties regarding the availability of result sets in a parameterized @@ -620,14 +1292,7 @@ namespace ignite // SQL_PAS_NO_SELECT = A driver does not allow a result - set generating statement to be executed with // an array of parameters. intParams[SQL_PARAM_ARRAY_SELECTS] = SQL_PAS_NO_SELECT; -#endif //SQL_PARAM_ARRAY_SELECTS - -#ifdef SQL_CONVERT_GUID - // Bitmask indicates the conversions supported by the CONVERT scalar function for target type GUID - intParams[SQL_CONVERT_GUID] = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | - SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR | SQL_CVT_WVARCHAR | - SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_LONGVARBINARY | SQL_CVT_GUID; -#endif //SQL_CONVERT_GUID +#endif // SQL_PARAM_ARRAY_SELECTS #ifdef SQL_SCROLL_OPTIONS // Bitmask enumerating the scroll options supported for scrollable cursors @@ -640,24 +1305,877 @@ namespace ignite // than the rowset size.The cursor is keyset - driven inside the keyset and dynamic outside the // keyset. (ODBC 1.0) intParams[SQL_SCROLL_OPTIONS] = SQL_SO_FORWARD_ONLY | SQL_SO_STATIC; -#endif //SQL_SCROLL_OPTIONS +#endif // SQL_SCROLL_OPTIONS + +#ifdef SQL_ALTER_DOMAIN + // Bitmask enumerating the clauses in the ALTER DOMAIN statement, as defined in SQL-92, supported by the + // data source. An SQL-92 Full level-compliant driver will always return all the bitmasks. A return + // value of "0" means that the ALTER DOMAIN statement is not supported. + // + // The SQL - 92 or FIPS conformance level at which this feature must be supported is shown in + // parentheses next to each bitmask. + // + // The following bitmasks are used to determine which clauses are supported : + // SQL_AD_ADD_DOMAIN_CONSTRAINT = Adding a domain constraint is supported (Full level). + // SQL_AD_ADD_DOMAIN_DEFAULT = <alter domain> <set domain default clause> is supported (Full level). + // SQL_AD_CONSTRAINT_NAME_DEFINITION = <constraint name definition clause> is supported for naming + // domain constraint (Intermediate level). + // SQL_AD_DROP_DOMAIN_CONSTRAINT = <drop domain constraint clause> is supported (Full level). + // SQL_AD_DROP_DOMAIN_DEFAULT = <alter domain> <drop domain default clause> is supported (Full level). + // + // The following bits specify the supported <constraint attributes> if <add domain constraint> is + // supported (the SQL_AD_ADD_DOMAIN_CONSTRAINT bit is set) : + // SQL_AD_ADD_CONSTRAINT_DEFERRABLE (Full level) + // SQL_AD_ADD_CONSTRAINT_NON_DEFERRABLE (Full level) + // SQL_AD_ADD_CONSTRAINT_INITIALLY_DEFERRED (Full level) + // SQL_AD_ADD_CONSTRAINT_INITIALLY_IMMEDIATE (Full level) + intParams[SQL_ALTER_DOMAIN] = 0; +#endif // SQL_ALTER_DOMAIN + +#ifdef SQL_ALTER_TABLE + // Bitmask enumerating the clauses in the ALTER TABLE statement supported by the data source. + // + // The SQL - 92 or FIPS conformance level at which this feature must be supported is shown in + // parentheses next to each bitmask. The following bitmasks are used to determine which clauses are + // supported : + // SQL_AT_ADD_COLUMN_COLLATION = <add column> clause is supported, with facility to specify column + // collation (Full level) (ODBC 3.0) + // SQL_AT_ADD_COLUMN_DEFAULT = <add colu
<TRUNCATED>
