ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From voze...@apache.org
Subject [2/3] ignite git commit: IGNITE-6099: ODBC: Implemented SQLGetInfo for all info types. This closes #2689.
Date Tue, 19 Sep 2017 13:24:06 GMT
http://git-wip-us.apache.org/repos/asf/ignite/blob/29594dba/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>

Mime
View raw message