// srpconsts.tbl -- named constants 

SRP_NAMED_SMALL_CONSTANT fetchOrientation[] = {
  { "sql-fetch-next", SQL_FETCH_NEXT },
  { "sql-fetch-prior", SQL_FETCH_PRIOR },
  { "sql-fetch-first", SQL_FETCH_FIRST },
  { "sql-fetch-last", SQL_FETCH_LAST },
  { "sql-fetch-absolute", SQL_FETCH_ABSOLUTE },
  { "sql-fetch-relative", SQL_FETCH_RELATIVE },
  { "sql-fetch-bookmark", SQL_FETCH_BOOKMARK },
};

SRP_NAMED_CONSTANT asyncEnableBits[] = {
  { "sql-async-enable-off", SQL_ASYNC_ENABLE_OFF },
  { "sql-async-enable-on", SQL_ASYNC_ENABLE_ON },
};

SRP_NAMED_CONSTANT concurrencyBits[] = {
  { "sql-concur-read-only", SQL_CONCUR_READ_ONLY },
  { "sql-concur-lock", SQL_CONCUR_LOCK },
  { "sql-concur-rowver", SQL_CONCUR_ROWVER },
  { "sql-concur-values", SQL_CONCUR_VALUES },
};

#if (ODBCVER >= 0x0300)
SRP_NAMED_CONSTANT cursorScrollableBits[] = {
  { "sql-nonscrollable", SQL_NONSCROLLABLE },
  { "sql-scrollable", SQL_SCROLLABLE },
};
#endif

#if (ODBCVER >= 0x0300)
SRP_NAMED_CONSTANT stmtCursorSensitivityBits[] = {
  { "sql-unspecified", SQL_UNSPECIFIED },
  { "sql-insensitive", SQL_INSENSITIVE },
  { "sql-sensitive", SQL_SENSITIVE },
};
#endif

SRP_NAMED_CONSTANT cursorTypeBits[] = {
  { "sql-cursor-forward-only", SQL_CURSOR_FORWARD_ONLY },
  { "sql-cursor-static", SQL_CURSOR_STATIC },
  { "sql-cursor-keyset-driven", SQL_CURSOR_KEYSET_DRIVEN },
  { "sql-cursor-dynamic", SQL_CURSOR_DYNAMIC },
};

SRP_NAMED_CONSTANT noscanBits[] = {
  { "sql-noscan-off", SQL_NOSCAN_OFF },
  { "sql-noscan-on ", SQL_NOSCAN_ON },
};

#if (ODBCVER >= 0x0300)
SRP_NAMED_CONSTANT paramBindTypeBits[] = {
  { "sql-param-bind-by-column", SQL_PARAM_BIND_BY_COLUMN },
};
#endif

SRP_NAMED_CONSTANT retrieveDataBits[] = {
 { "sql-rd-on", SQL_RD_ON },
 { "sql-rd-off ", SQL_RD_OFF },
};

SRP_NAMED_CONSTANT rowBindTypeBits[] = {
  { "sql-bind-by-column", SQL_BIND_BY_COLUMN },
};

SRP_NAMED_CONSTANT simulateCursorBits[] = {
  { "sql-sc-non-unique", SQL_SC_NON_UNIQUE },
  { "sql-sc-try-unique", SQL_SC_TRY_UNIQUE },
  { "sql-sc-unique ", SQL_SC_UNIQUE },
};

#if (ODBCVER >= 0x0300)
SRP_NAMED_CONSTANT useBookmarksBits[] = {
 { "sql-ub-off", SQL_UB_OFF },
 { "sql-ub-variable", SQL_UB_VARIABLE },
 { "sql-ub-fixed", SQL_UB_FIXED },
};
#endif

#if (ODBCVER >= 0x0300)
SRP_NAMED_BITS_DICT namedStmtAttributes[] = {
  { "sql-attr-async-enable", asyncEnableBits, sizeray(asyncEnableBits) },
  { "sql-attr-concurrency", concurrencyBits, sizeray(concurrencyBits) },
  { "sql-attr-cursor-scrollable", cursorScrollableBits, sizeray(cursorScrollableBits) },
  { "sql-attr-cursor-sensitivity", stmtCursorSensitivityBits, sizeray(stmtCursorSensitivityBits) },
  { "sql-attr-cursor-type", cursorTypeBits, sizeray(cursorTypeBits) },
  { "sql-attr-noscan", noscanBits, sizeray(noscanBits) },
  { "sql-attr-param-bind-type", paramBindTypeBits, sizeray(paramBindTypeBits) },
  { "sql-attr-retrieve-data", retrieveDataBits, sizeray(retrieveDataBits) },
  { "sql-attr-row-bind-type", rowBindTypeBits, sizeray(rowBindTypeBits) },
  { "sql-attr-simulate-cursor", simulateCursorBits, sizeray(simulateCursorBits) },
  { "sql-attr-use-bookmarks", useBookmarksBits, sizeray(useBookmarksBits) },
};
#endif

#if (ODBCVER >= 0x0300)
SRP_NAMED_TYPED_CONSTANT stmtAttributes[] = {
{ "sql-attr-app-param-desc", SQL_ATTR_APP_PARAM_DESC, hdesc },
{ "sql-attr-app-row-desc", SQL_ATTR_APP_ROW_DESC, hdesc },
{ "sql-attr-async-enable", SQL_ATTR_ASYNC_ENABLE, nameduinteger },
{ "sql-attr-concurrency", SQL_ATTR_CONCURRENCY, nameduinteger },
{ "sql-attr-cursor-scrollable", SQL_ATTR_CURSOR_SCROLLABLE, nameduinteger },
{ "sql-attr-cursor-sensitivity", SQL_ATTR_CURSOR_SENSITIVITY, nameduinteger },
{ "sql-attr-cursor-type", SQL_ATTR_CURSOR_TYPE, nameduinteger },
{ "sql-attr-enable-auto-ipd", SQL_ATTR_ENABLE_AUTO_IPD, sqlbool },
{ "sql-attr-fetch-bookmark-ptr", SQL_ATTR_FETCH_BOOKMARK_PTR, sqluinteger },
{ "sql-attr-imp-param-desc", SQL_ATTR_IMP_PARAM_DESC, hdesc },
{ "sql-attr-imp-row-desc", SQL_ATTR_IMP_ROW_DESC, hdesc },
{ "sql-attr-keyset-size", SQL_ATTR_KEYSET_SIZE, sqluinteger },
{ "sql-attr-max-length", SQL_ATTR_MAX_LENGTH, sqluinteger },
{ "sql-attr-max-rows", SQL_ATTR_MAX_ROWS, sqluinteger },
{ "sql-attr-metadata-id", SQL_ATTR_METADATA_ID, sqluinteger },
{ "sql-attr-noscan", SQL_ATTR_NOSCAN, nameduinteger },
{ "sql-attr-param-bind-offset-ptr", SQL_ATTR_PARAM_BIND_OFFSET_PTR, sqlboxeduint },
{ "sql-attr-param-bind-type", SQL_ATTR_PARAM_BIND_TYPE, possiblynameduinteger },
{ "sql-attr-param-operation-ptr", SQL_ATTR_PARAM_OPERATION_PTR, opparms },
{ "sql-attr-param-status-ptr", SQL_ATTR_PARAM_STATUS_PTR, rowstatus },
{ "sql-attr-params-processed-ptr", SQL_ATTR_PARAMS_PROCESSED_PTR, sqlboxeduint },
{ "sql-attr-paramset-size", SQL_ATTR_PARAMSET_SIZE, sqluinteger },
{ "sql-attr-query-timeout", SQL_ATTR_QUERY_TIMEOUT, sqluinteger },
{ "sql-attr-retrieve-data", SQL_ATTR_RETRIEVE_DATA, nameduinteger  },
{ "sql-attr-row-array-size", SQL_ATTR_ROW_ARRAY_SIZE, sqluinteger },
{ "sql-attr-row-bind-offset-ptr", SQL_ATTR_ROW_BIND_OFFSET_PTR, sqlboxeduint },
{ "sql-attr-row-bind-type", SQL_ATTR_ROW_BIND_TYPE, possiblynameduinteger },
{ "sql-attr-row-number", SQL_ATTR_ROW_NUMBER, sqluinteger },
{ "sql-attr-row-operation-ptr", SQL_ATTR_ROW_OPERATION_PTR, opparms },
{ "sql-attr-row-status-ptr", SQL_ATTR_ROW_STATUS_PTR, rowstatus },
{ "sql-attr-rows-fetched-ptr", SQL_ATTR_ROWS_FETCHED_PTR, sqlboxeduint },
{ "sql-attr-simulate-cursor", SQL_ATTR_SIMULATE_CURSOR, nameduinteger },
{ "sql-attr-use-bookmarks", SQL_ATTR_USE_BOOKMARKS, nameduinteger },
};
#endif

SRP_NAMED_CONSTANT useBookmarksOptionBits[] = {
 { "sql-ub-off", SQL_UB_OFF },
 { "sql-ub-on", SQL_UB_ON },
};

// most of the bit tables are shared with namedStmtAttributes
// useBookmarksOptionBits is not, because values changed in ODBC 3.0

SRP_NAMED_BITS_DICT namedStmtOptions[] = {
  { "sql-async-enable", asyncEnableBits, sizeray(asyncEnableBits) },
  { "sql-bind-type", rowBindTypeBits, sizeray(rowBindTypeBits) },
  { "sql-concurrency", concurrencyBits, sizeray(concurrencyBits) },
  { "sql-cursor-type", cursorTypeBits, sizeray(cursorTypeBits) },
  { "sql-noscan", noscanBits, sizeray(noscanBits) },
  { "sql-retrieve-data", retrieveDataBits, sizeray(retrieveDataBits) },
  { "sql-simulate-cursor", simulateCursorBits, sizeray(simulateCursorBits) },
  { "sql-use-bookmarks", useBookmarksOptionBits, sizeray(useBookmarksOptionBits) },
};

SRP_NAMED_TYPED_CONSTANT stmtOptions[] = {
{ "sql-async-enable", SQL_ASYNC_ENABLE, nameduinteger },
{ "sql-bind-type", SQL_BIND_TYPE, possiblynameduinteger },
{ "sql-concurrency", SQL_CONCURRENCY, nameduinteger },
{ "sql-cursor-type", SQL_CURSOR_TYPE, nameduinteger },
{ "sql-keyset-size", SQL_KEYSET_SIZE, sqluinteger },
{ "sql-max-length", SQL_MAX_LENGTH, sqluinteger },
{ "sql-max-rows", SQL_MAX_ROWS, sqluinteger },
{ "sql-noscan", SQL_NOSCAN, nameduinteger },
{ "sql-query-timeout", SQL_QUERY_TIMEOUT, sqluinteger },
{ "sql-retrieve-data", SQL_RETRIEVE_DATA, nameduinteger  },
{ "sql-rowset-size", SQL_ROWSET_SIZE, sqluinteger },
{ "sql-simulate-cursor", SQL_SIMULATE_CURSOR, nameduinteger },
{ "sql-use-bookmarks", SQL_USE_BOOKMARKS, nameduinteger },
};

SRP_NAMED_CONSTANT sqlFunctions[] = {
#if (ODBCVER >= 0x0300) 
  { "sql-api-odbc3-all-functions",SQL_API_ODBC3_ALL_FUNCTIONS},
  { "sql-api-sqlallochandle",SQL_API_SQLALLOCHANDLE},
  { "sql-api-sqlgetdescfield",SQL_API_SQLGETDESCFIELD},
  { "sql-api-sqlgetdescrec", SQL_API_SQLGETDESCREC },
  { "sql-api-sqlgetdiagfield", SQL_API_SQLGETDIAGFIELD },
  { "sql-api-sqlclosecursor", SQL_API_SQLCLOSECURSOR },
  { "sql-api-sqlgetdiagrec", SQL_API_SQLGETDIAGREC },
  { "sql-api-sqlcolattribute", SQL_API_SQLCOLATTRIBUTE },
  { "sql-api-sqlgetenvattr", SQL_API_SQLGETENVATTR },
  { "sql-api-sqlcopydesc", SQL_API_SQLCOPYDESC },
  { "sql-api-sqlgetstmtattr", SQL_API_SQLGETSTMTATTR },
  { "sql-api-sqlendtran", SQL_API_SQLENDTRAN },
  { "sql-api-sqlsetconnectattr", SQL_API_SQLSETCONNECTATTR },
  { "sql-api-sqlfetchscroll", SQL_API_SQLFETCHSCROLL },
  { "sql-api-sqlfreehandle", SQL_API_SQLFREEHANDLE },
  { "sql-api-sqlgetconnectattr", SQL_API_SQLGETCONNECTATTR },
  { "sql-api-sqlsetdescfield", SQL_API_SQLSETDESCFIELD },
  { "sql-api-sqlsetdescrec", SQL_API_SQLSETDESCREC },
  { "sql-api-sqlsetenvattr", SQL_API_SQLSETENVATTR },
  { "sql-api-sqlsetstmtattr", SQL_API_SQLSETSTMTATTR },
  { "sql-api-sqlbulkoperations", SQL_API_SQLBULKOPERATIONS },
#endif
  { "sql-api-all-functions",SQL_API_ALL_FUNCTIONS},
  { "sql-api-sqlbindcol", SQL_API_SQLBINDCOL },
  { "sql-api-sqlcancel", SQL_API_SQLCANCEL },
  { "sql-api-sqlconnect", SQL_API_SQLCONNECT },
  { "sql-api-sqlgetfunctions", SQL_API_SQLGETFUNCTIONS },
  { "sql-api-sqlgetinfo", SQL_API_SQLGETINFO },
  { "sql-api-sqldatasources", SQL_API_SQLDATASOURCES },
  { "sql-api-sqldescribecol", SQL_API_SQLDESCRIBECOL },
  { "sql-api-sqlgettypeinfo", SQL_API_SQLGETTYPEINFO },
  { "sql-api-sqldisconnect", SQL_API_SQLDISCONNECT },
  { "sql-api-sqlnumresultcols", SQL_API_SQLNUMRESULTCOLS },
  { "sql-api-sqldrivers", SQL_API_SQLDRIVERS },
  { "sql-api-sqlparamdata", SQL_API_SQLPARAMDATA },
  { "sql-api-sqlprepare", SQL_API_SQLPREPARE },
  { "sql-api-sqlexecdirect", SQL_API_SQLEXECDIRECT },
  { "sql-api-sqlputdata", SQL_API_SQLPUTDATA },
  { "sql-api-sqlexecute", SQL_API_SQLEXECUTE },
  { "sql-api-sqlrowcount", SQL_API_SQLROWCOUNT },
  { "sql-api-sqlfetch", SQL_API_SQLFETCH },
  { "sql-api-sqlsetcursorname", SQL_API_SQLSETCURSORNAME },
  { "sql-api-sqlfreestmt", SQL_API_SQLFREESTMT },
  { "sql-api-sqlgetcursorname", SQL_API_SQLGETCURSORNAME },
  { "sql-api-sqlgetdata", SQL_API_SQLGETDATA },
  { "sql-api-sqlcolumns", SQL_API_SQLCOLUMNS },
  { "sql-api-sqlstatistics", SQL_API_SQLSTATISTICS },
  { "sql-api-sqlspecialcolumns", SQL_API_SQLSPECIALCOLUMNS },
  { "sql-api-sqltables", SQL_API_SQLTABLES },
  { "sql-api-sqlbindparameter", SQL_API_SQLBINDPARAMETER },
  { "sql-api-sqlnativesql", SQL_API_SQLNATIVESQL },
  { "sql-api-sqlbrowseconnect", SQL_API_SQLBROWSECONNECT },
  { "sql-api-sqlnumparams", SQL_API_SQLNUMPARAMS },
  { "sql-api-sqlprimarykeys", SQL_API_SQLPRIMARYKEYS },
  { "sql-api-sqlcolumnprivileges", SQL_API_SQLCOLUMNPRIVILEGES },
  { "sql-api-sqlprocedurecolumns", SQL_API_SQLPROCEDURECOLUMNS },
  { "sql-api-sqldescribeparam", SQL_API_SQLDESCRIBEPARAM },
  { "sql-api-sqlprocedures", SQL_API_SQLPROCEDURES },
  { "sql-api-sqldriverconnect", SQL_API_SQLDRIVERCONNECT },
  { "sql-api-sqlsetpos", SQL_API_SQLSETPOS },
  { "sql-api-sqlforeignkeys", SQL_API_SQLFOREIGNKEYS },
  { "sql-api-sqltableprivileges", SQL_API_SQLTABLEPRIVILEGES },
  { "sql-api-sqlmoreresults", SQL_API_SQLMORERESULTS },
};

#if (ODBCVER >= 0x0300)
SRP_NAMED_TYPED_CONSTANT envAttributes[]= {
  { "sql-attr-connection-pooling", SQL_ATTR_CONNECTION_POOLING, nameduinteger },
  { "sql-attr-cp-match", SQL_ATTR_CP_MATCH, nameduinteger },
  { "sql-attr-odbc-version", SQL_ATTR_ODBC_VERSION, nameduinteger },
  { "sql-attr-output-nts", SQL_ATTR_OUTPUT_NTS, sqlbool },
};
#endif

#if (ODBCVER >= 0x0300)
SRP_NAMED_CONSTANT connectionPoolingBits[] = {
  { "sql-cp-off", SQL_CP_OFF },
  { "sql-cp-one-per-driver", SQL_CP_ONE_PER_DRIVER },
  { "sql-cp-one-per-henv", SQL_CP_ONE_PER_HENV },
};
#endif

#if (ODBCVER >= 0x0300)
SRP_NAMED_CONSTANT cpMatchBits[] = {
  { "sql-cp-strict-match", SQL_CP_STRICT_MATCH },
  { "sql-cp-relaxed-match", SQL_CP_RELAXED_MATCH },
};
#endif

#if (ODBCVER >= 0x0300)
SRP_NAMED_CONSTANT odbcVersionBits[] = {
  { "sql-ov-odbc3", SQL_OV_ODBC3 },
  { "sql-ov-odbc2", SQL_OV_ODBC2 },
};
#endif

#if (ODBCVER >= 0x0300)
SRP_NAMED_BITS_DICT namedEnvAttrIntegers[] = {
  { "sql-attr-connection-pooling", connectionPoolingBits, sizeray(connectionPoolingBits) },
  { "sql-attr-cp-match", cpMatchBits, sizeray(cpMatchBits) },
  { "sql-attr-odbc-version", odbcVersionBits, sizeray(odbcVersionBits) },
};
#endif

#if (ODBCVER >= 0x0300)
SRP_NAMED_TYPED_CONSTANT diagFields[] = {
  { "sql-diag-dynamic-function",SQL_DIAG_DYNAMIC_FUNCTION, string },
  { "sql-diag-connection-name", SQL_DIAG_CONNECTION_NAME, string },
  { "sql-diag-class-origin", SQL_DIAG_CLASS_ORIGIN, string },
  { "sql-diag-message-text", SQL_DIAG_MESSAGE_TEXT, string },
  { "sql-diag-server-name", SQL_DIAG_SERVER_NAME, string },
  { "sql-diag-sqlstate", SQL_DIAG_SQLSTATE, string },
  { "sql-diag-subclass-origin", SQL_DIAG_SUBCLASS_ORIGIN, string },
  { "sql-diag-cursor-row-count", SQL_DIAG_CURSOR_ROW_COUNT, sqlinteger },
  { "sql-diag-dynamic-function-code", SQL_DIAG_DYNAMIC_FUNCTION_CODE, sqlinteger },
  { "sql-diag-number", SQL_DIAG_NUMBER, sqlinteger },
  { "sql-diag-row-count", SQL_DIAG_ROW_COUNT, sqlinteger },
  { "sql-diag-column-number", SQL_DIAG_COLUMN_NUMBER, possiblynamedinteger },
  { "sql-diag-native", SQL_DIAG_NATIVE, sqlinteger },
  { "sql-diag-row-number", SQL_DIAG_ROW_NUMBER, possiblynamedinteger },
  { "sql-diag-returncode", SQL_DIAG_RETURNCODE, sqlreturn },
};
#endif

#if (ODBCVER >= 0x0300)
SRP_NAMED_CONSTANT SQLColNumbers[] = {
  { "sql-no-column-number",SQL_NO_COLUMN_NUMBER },
  { "sql-column-number-unknown",SQL_COLUMN_NUMBER_UNKNOWN },
};
#endif

#if (ODBCVER >= 0x0300)
SRP_NAMED_CONSTANT SQLRowNumbers[] = {
  { "sql-no-row-number",SQL_NO_ROW_NUMBER },
  { "sql-row-number-unknown",SQL_ROW_NUMBER_UNKNOWN },
};
#endif

#if (ODBCVER >= 0x0300)
SRP_NAMED_BITS_DICT namedDiagFieldIntegers[] = {
  { "sql-diag-column-number", SQLColNumbers, sizeray(SQLColNumbers) },
  { "sql-diag-row-number", SQLRowNumbers, sizeray(SQLRowNumbers) },
};
#endif

#if (ODBCVER >= 0x0300)
SRP_NAMED_CONSTANT datetimeIntervalCodes[] = {
  // Datetime types

  { "sql-code-date",SQL_CODE_DATE },
  { "sql-code-time",SQL_CODE_TIME },
  { "sql-code-timestamp",SQL_CODE_TIMESTAMP },

  // Interval types
  { "sql-code-day",SQL_CODE_DAY },
  { "sql-code-day-to-hour",SQL_CODE_DAY_TO_HOUR },
  { "sql-code-day-to-minute",SQL_CODE_DAY_TO_MINUTE },
  { "sql-code-day-to-second",SQL_CODE_DAY_TO_SECOND },
  { "sql-code-hour",SQL_CODE_HOUR },
  { "sql-code-hour-to-minute",SQL_CODE_HOUR_TO_MINUTE },
  { "sql-code-hour-to-second",SQL_CODE_HOUR_TO_SECOND },
  { "sql-code-minute",SQL_CODE_MINUTE },
  { "sql-code-minute-to-second",SQL_CODE_MINUTE_TO_SECOND },
  { "sql-code-month",SQL_CODE_MONTH },
  { "sql-code-second",SQL_CODE_SECOND },
  { "sql-code-year",SQL_CODE_YEAR },
  { "sql-code-year-to-month",SQL_CODE_YEAR_TO_MONTH },
};
#endif

#if (ODBCVER >= 0x0300)
SRP_NAMED_CONSTANT SQLDescParameterTypes[] = {
  { "sql-param-input", SQL_PARAM_INPUT },
  { "sql-param-output", SQL_PARAM_OUTPUT },
  { "sql-param-input-output", SQL_PARAM_INPUT_OUTPUT },
};
#endif

SRP_NAMED_CONSTANT SQLDescSearchable[] = {
#if (ODBCVER >= 0x0300)
  { "sql-pred-char", SQL_PRED_CHAR },
  { "sql-pred-basic", SQL_PRED_BASIC },
  { "sql-pred-searchable", SQL_PRED_SEARCHABLE },
  { "sql-pred-none", SQL_PRED_NONE },
#else
  { "sql-like-only", SQL_LIKE_ONLY },
  { "sql-searchable", SQL_SEARCHABLE },
  { "sql-all-except-like", SQL_ALL_EXCEPT_LIKE },
  { "sql-unsearchable", SQL_UNSEARCHABLE },
#endif
};

#if (ODBCVER >= 0x0300)
SRP_NAMED_CONSTANT SQLDescUnnamed[] = {
  { "sql-named", SQL_NAMED },
  { "sql-unnamed", SQL_UNNAMED },
};
#endif

#if (ODBCVER >= 0x0300)
SRP_NAMED_CONSTANT descDataTypes[] = {
  { "sql-char", SQL_CHAR },
  { "sql-varchar", SQL_VARCHAR },
  { "sql-longvarchar", SQL_LONGVARCHAR },
  { "sql-wchar", SQL_WCHAR },
  { "sql-wvarchar", SQL_WVARCHAR },
  { "sql-wlongvarchar", SQL_WLONGVARCHAR }, 
  { "sql-decimal", SQL_DECIMAL },
  { "sql-numeric", SQL_NUMERIC },
  { "sql-smallint", SQL_SMALLINT },
  { "sql-integer", SQL_INTEGER },
  { "sql-real", SQL_REAL },
  { "sql-float", SQL_FLOAT },
  { "sql-double", SQL_DOUBLE },
  { "sql-bit", SQL_BIT },
  { "sql-tinyint", SQL_TINYINT },
  { "sql-bigint", SQL_BIGINT },
  { "sql-binary", SQL_BINARY },
  { "sql-varbinary", SQL_VARBINARY },
  { "sql-longvarbinary", SQL_LONGVARBINARY },
  { "sql-datetime", SQL_DATETIME },
  { "sql-type-date", SQL_TYPE_DATE },
  { "sql-type-time", SQL_TYPE_TIME },
  { "sql-type-timestamp", SQL_TYPE_TIMESTAMP },
  { "sql-interval", SQL_INTERVAL },
#if (ODBCVER >= 0x0350)
  { "sql-guid", SQL_GUID },
#endif
};
#endif

#if (ODBCVER >= 0x0300)
SRP_NAMED_TYPED_CONSTANT settableConnectionAttributes[] = {
  { "sql-attr-access-mode", SQL_ATTR_ACCESS_MODE, nameduinteger },
  { "sql-attr-async-enable", SQL_ATTR_ASYNC_ENABLE, nameduinteger },
  { "sql-attr-autocommit", SQL_ATTR_AUTOCOMMIT, nameduinteger },
  { "sql-attr-connection-timeout", SQL_ATTR_CONNECTION_TIMEOUT, sqluinteger },
  { "sql-attr-current-catalog", SQL_ATTR_CURRENT_CATALOG, string },
  { "sql-attr-login-timeout", SQL_ATTR_LOGIN_TIMEOUT, sqluinteger },
  { "sql-attr-metadata-id", SQL_ATTR_METADATA_ID, sqlbool },
  { "sql-attr-odbc-cursors", SQL_ATTR_ODBC_CURSORS, nameduinteger },
  { "sql-attr-packet-size", SQL_ATTR_PACKET_SIZE, sqluinteger },
  { "sql-attr-quiet-mode", SQL_ATTR_QUIET_MODE, sqluinteger },
  { "sql-attr-trace", SQL_ATTR_TRACE, nameduinteger },
  { "sql-attr-tracefile", SQL_ATTR_TRACEFILE, string },
  { "sql-attr-translate-lib", SQL_ATTR_TRANSLATE_LIB, string },
  { "sql-attr-translate-option", SQL_ATTR_TRANSLATE_OPTION, sqluinteger },
  { "sql-attr-txn-isolation", SQL_ATTR_TXN_ISOLATION, nameduinteger },
};
#endif

#if (ODBCVER >= 0x0300)
SRP_NAMED_TYPED_CONSTANT readOnlyConnectionAttributes[] = {
  { "sql-attr-auto-ipd", SQL_ATTR_AUTO_IPD, sqlbool },
  { "sql-attr-connection-dead", SQL_ATTR_CONNECTION_DEAD, nameduinteger },
};
#endif

SRP_NAMED_CONSTANT accessModeBits[] = {
  { "sql-mode-read-only", SQL_MODE_READ_ONLY },	
  { "sql-mode-read-write", SQL_MODE_READ_WRITE },
};

SRP_NAMED_CONSTANT autocommitBits[] = {
  { "sql-autocommit-off", SQL_AUTOCOMMIT_OFF },
  { "sql-autocommit-on", SQL_AUTOCOMMIT_ON },
};

SRP_NAMED_CONSTANT odbcCursorsBits[] = {
  { "sql-cur-use-if-needed", SQL_CUR_USE_IF_NEEDED },
  { "sql-cur-use-odbc", SQL_CUR_USE_ODBC },
  { "sql-cur-use-driver ", SQL_CUR_USE_DRIVER },
};

SRP_NAMED_CONSTANT traceBits[] = {
  { "sql-opt-trace-off", SQL_OPT_TRACE_OFF },
  { "sql-opt-trace-on", SQL_OPT_TRACE_ON },
};

#if (ODBCVER >= 0x0300)
SRP_NAMED_CONSTANT connectionDeadBits[] = {
  { "sql-cd-true", SQL_CD_TRUE },
  { "sql-cd-false", SQL_CD_FALSE },
};
#endif

SRP_NAMED_CONSTANT txnIsolationBits[] = {
  { "sql-txn-read-uncommitted", SQL_TXN_READ_UNCOMMITTED },
  { "sql-txn-read-committed", SQL_TXN_READ_COMMITTED },
  { "sql-txn-repeatable-read", SQL_TXN_REPEATABLE_READ },
  { "sql-txn-serializable", SQL_TXN_SERIALIZABLE },
};

#if (ODBCVER >= 0x0300)
SRP_NAMED_BITS_DICT namedConnectAttrIntegers[] = {
  { "sql-attr-access-mode", accessModeBits, sizeray(accessModeBits) },
  { "sql-attr-async-enable", asyncEnableBits, sizeray(asyncEnableBits) },
  { "sql-attr-autocommit", autocommitBits, sizeray(autocommitBits) },
  { "sql-attr-odbc-cursors", odbcCursorsBits, sizeray(odbcCursorsBits) },
  { "sql-attr-trace", traceBits, sizeray(traceBits) },
  { "sql-attr-connection-dead", connectionDeadBits, sizeray(connectionDeadBits) },
  { "sql-attr-txn-isolation", txnIsolationBits, sizeray(txnIsolationBits) },
};
#endif

// the bit tables are shared with namedConnectAttrIntegers

SRP_NAMED_BITS_DICT namedConnectOptionIntegers[] = {
  { "sql-access-mode", accessModeBits, sizeray(accessModeBits) },
  { "sql-autocommit", autocommitBits, sizeray(autocommitBits) },
  { "sql-odbc-cursors", odbcCursorsBits, sizeray(odbcCursorsBits) },
  { "sql-opt-trace", traceBits, sizeray(traceBits) },
  { "sql-txn-isolation", txnIsolationBits, sizeray(txnIsolationBits) },
};

SRP_NAMED_TYPED_CONSTANT connectionOptions[] = {
  { "sql-access-mode", SQL_ACCESS_MODE, nameduinteger },
  { "sql-autocommit", SQL_AUTOCOMMIT, nameduinteger },
  { "sql-current-qualifier", SQL_CURRENT_QUALIFIER, string },
  { "sql-login-timeout", SQL_LOGIN_TIMEOUT, sqluinteger },
  { "sql-odbc-cursors", SQL_ODBC_CURSORS, nameduinteger },
  { "sql-opt-trace", SQL_OPT_TRACE, nameduinteger },
  { "sql-opt-tracefile", SQL_OPT_TRACEFILE, string },
  { "sql-packet-size", SQL_PACKET_SIZE, sqluinteger },
  { "sql-quiet-mode", SQL_QUIET_MODE, sqluinteger },
  { "sql-translate-dll",SQL_TRANSLATE_DLL, string },
  { "sql-translate-option",SQL_TRANSLATE_OPTION, sqluinteger },
  { "sql-txn-isolation", SQL_TXN_ISOLATION, nameduinteger },
};

SRP_NAMED_SMALL_CONSTANT fetchDirections[] = {
  { "sql-fetch-next", SQL_FETCH_NEXT },
  { "sql-fetch-first", SQL_FETCH_FIRST },
#if (ODBCVER >= 0x0300)
  { "sql-fetch-first-user", SQL_FETCH_FIRST_USER },
  { "sql-fetch-first-system", SQL_FETCH_FIRST_SYSTEM },
#endif
};

SRP_NAMED_SMALL_CONSTANT fetchScrolls[] = {
  { "sql-fetch-next", SQL_FETCH_NEXT },
  { "sql-fetch-prior", SQL_FETCH_PRIOR },
  { "sql-fetch-first", SQL_FETCH_FIRST },
  { "sql-fetch-last", SQL_FETCH_LAST },
  { "sql-fetch-absolute", SQL_FETCH_ABSOLUTE },
  { "sql-fetch-relative", SQL_FETCH_RELATIVE },
  { "sql-fetch-bookmark", SQL_FETCH_BOOKMARK },
};

SRP_NAMED_SMALL_CONSTANT CDataTypes[] = {
#if (ODBCVER >= 0x300)
  { "sql-c-wchar", SQL_C_WCHAR },
  { "sql-c-numeric", SQL_C_NUMERIC },
  { "sql-c-type-timestamp", SQL_C_TYPE_TIMESTAMP },
  { "sql-c-type-date", SQL_C_TYPE_DATE },
  { "sql-c-type-time", SQL_C_TYPE_TIME },
  { "sql-c-interval-year", SQL_C_INTERVAL_YEAR },
  { "sql-c-interval-month", SQL_C_INTERVAL_MONTH },
  { "sql-c-interval-day", SQL_C_INTERVAL_DAY },
  { "sql-c-interval-hour", SQL_C_INTERVAL_HOUR },
  { "sql-c-interval-minute", SQL_C_INTERVAL_MINUTE },
  { "sql-c-interval-second", SQL_C_INTERVAL_SECOND },
  { "sql-c-interval-year-to-month", SQL_C_INTERVAL_YEAR_TO_MONTH },
  { "sql-c-interval-day-to-hour", SQL_C_INTERVAL_DAY_TO_HOUR },
  { "sql-c-interval-day-to-minute", SQL_C_INTERVAL_DAY_TO_MINUTE },
  { "sql-c-interval-day-to-second", SQL_C_INTERVAL_DAY_TO_SECOND },
  { "sql-c-interval-hour-to-minute", SQL_C_INTERVAL_HOUR_TO_MINUTE },
  { "sql-c-interval-hour-to-second", SQL_C_INTERVAL_HOUR_TO_SECOND },
  { "sql-c-interval-minute-to-second", SQL_C_INTERVAL_MINUTE_TO_SECOND },
  { "sql-c-sbigint", SQL_C_SBIGINT },
  { "sql-c-ubigint", SQL_C_UBIGINT },
  { "sql-c-varbookmark", SQL_C_VARBOOKMARK },
#endif
#if (ODBCVER >= 0x0350)
  { "sql-c-guid", SQL_C_GUID },
#endif
  { "sql-c-char", SQL_C_CHAR },
  { "sql-c-long", SQL_C_LONG },
  { "sql-c-short", SQL_C_SHORT },
  { "sql-c-float", SQL_C_FLOAT },
  { "sql-c-double", SQL_C_DOUBLE },
  { "sql-c-date", SQL_C_DATE },
  { "sql-c-time", SQL_C_TIME },
  { "sql-c-timestamp", SQL_C_TIMESTAMP },
  { "sql-c-binary", SQL_C_BINARY },
  { "sql-c-bit", SQL_C_BIT },
  { "sql-c-tinyint", SQL_C_TINYINT },
  { "sql-c-slong", SQL_C_SLONG },
  { "sql-c-sshort", SQL_C_SSHORT },
  { "sql-c-stinyint", SQL_C_STINYINT },
  { "sql-c-ulong", SQL_C_ULONG },
  { "sql-c-ushort", SQL_C_USHORT },
  { "sql-c-utinyint", SQL_C_UTINYINT },
  { "sql-c-bookmark", SQL_C_BOOKMARK },
};

SRP_NAMED_SMALL_CONSTANT SQLDataTypes[] = {
#if (ODBCVER >= 0x0300)
  { "sql-type-date", SQL_TYPE_DATE },
  { "sql-type-time", SQL_TYPE_TIME },
  { "sql-type-timestamp", SQL_TYPE_TIMESTAMP },
  { "sql-wchar", SQL_WCHAR },
  { "sql-wvarchar", SQL_WVARCHAR },
  { "sql-wlongvarchar", SQL_WLONGVARCHAR }, 
#endif
#if (ODBCVER >= 0x0350)
  { "sql-guid", SQL_GUID },
#endif
  { "sql-char", SQL_CHAR },
  { "sql-varchar", SQL_VARCHAR },
  { "sql-longvarchar", SQL_LONGVARCHAR },
  { "sql-date", SQL_DATE },
  { "sql-time", SQL_TIME },
  { "sql-timestamp", SQL_TIMESTAMP },
  { "sql-decimal", SQL_DECIMAL },
  { "sql-numeric", SQL_NUMERIC },
  { "sql-smallint", SQL_SMALLINT },
  { "sql-integer", SQL_INTEGER },
  { "sql-real", SQL_REAL },
  { "sql-float", SQL_FLOAT },
  { "sql-double", SQL_DOUBLE },
  { "sql-bit", SQL_BIT },
  { "sql-tinyint", SQL_TINYINT },
  { "sql-bigint", SQL_BIGINT },
  { "sql-binary", SQL_BINARY },
  { "sql-varbinary", SQL_VARBINARY },
  { "sql-longvarbinary", SQL_LONGVARBINARY },
  { "sql-interval-year", SQL_INTERVAL_YEAR },
  { "sql-interval-year-to-month", SQL_INTERVAL_YEAR_TO_MONTH },
  { "sql-interval-hour", SQL_INTERVAL_HOUR },
  { "sql-interval-minute", SQL_INTERVAL_MINUTE },
  { "sql-interval-day-to-hour", SQL_INTERVAL_DAY_TO_HOUR },
  { "sql-interval-day-to-minute", SQL_INTERVAL_DAY_TO_MINUTE },
  { "sql-interval-day-to-second", SQL_INTERVAL_DAY_TO_SECOND },
  { "sql-interval-hour-to-minute", SQL_INTERVAL_HOUR_TO_MINUTE },
  { "sql-interval-hour-to-second", SQL_INTERVAL_HOUR_TO_SECOND },
  { "sql-interval-minute-to-second", SQL_INTERVAL_MINUTE_TO_SECOND },
};

SRP_NAMED_CONSTANT descNullableBits[] = {
  { "sql-nullable", SQL_NULLABLE },
  { "sql-no-nulls", SQL_NO_NULLS },
  { "sql-nullable-unknown", SQL_NULLABLE_UNKNOWN },
};

SRP_NAMED_CONSTANT SQLColDataTypes[] = {
#if (ODBCVER >= 0x0300)	
  { "sql-type-date", SQL_TYPE_DATE },
  { "sql-type-time", SQL_TYPE_TIME },
  { "sql-type-timestamp", SQL_TYPE_TIMESTAMP },
  { "sql-datetime", SQL_DATETIME },
  { "sql-interval", SQL_INTERVAL },
  { "sql-wchar", SQL_WCHAR },
  { "sql-wvarchar", SQL_WVARCHAR },
  { "sql-wlongvarchar", SQL_WLONGVARCHAR }, 
#endif
#if (ODBCVER >= 0x0350)	
  { "sql-guid", SQL_GUID },
#endif
  { "sql-char", SQL_CHAR },
  { "sql-varchar", SQL_VARCHAR },
  { "sql-longvarchar", SQL_LONGVARCHAR },
  { "sql-decimal", SQL_DECIMAL },
  { "sql-numeric", SQL_NUMERIC },
  { "sql-smallint", SQL_SMALLINT },
  { "sql-integer", SQL_INTEGER },
  { "sql-real", SQL_REAL },
  { "sql-float", SQL_FLOAT },
  { "sql-double", SQL_DOUBLE },
  { "sql-bit", SQL_BIT },
  { "sql-tinyint", SQL_TINYINT },
  { "sql-bigint", SQL_BIGINT },
  { "sql-binary", SQL_BINARY },
  { "sql-varbinary", SQL_VARBINARY },
  { "sql-longvarbinary", SQL_LONGVARBINARY },
  { "sql-interval-year", SQL_INTERVAL_YEAR },
  { "sql-interval-year-to-month", SQL_INTERVAL_YEAR_TO_MONTH },
  { "sql-interval-hour", SQL_INTERVAL_HOUR },
  { "sql-interval-minute", SQL_INTERVAL_MINUTE },
  { "sql-interval-day-to-hour", SQL_INTERVAL_DAY_TO_HOUR },
  { "sql-interval-day-to-minute", SQL_INTERVAL_DAY_TO_MINUTE },
  { "sql-interval-day-to-second", SQL_INTERVAL_DAY_TO_SECOND },
  { "sql-interval-hour-to-minute", SQL_INTERVAL_HOUR_TO_MINUTE },
  { "sql-interval-hour-to-second", SQL_INTERVAL_HOUR_TO_SECOND },
  { "sql-interval-minute-to-second", SQL_INTERVAL_MINUTE_TO_SECOND },
};

SRP_NAMED_CONSTANT descUpdatableBits[] = {
  { "sql-attr-readonly", SQL_ATTR_READONLY },
  { "sql-attr-write", SQL_ATTR_WRITE },
  { "sql-attr-readwrite-unknown", SQL_ATTR_READWRITE_UNKNOWN },
};

#if (ODBCVER >= 0x0300)
SRP_NAMED_BITS_DICT namedFieldDescriptors[] = {
  { "sql-desc-datetime-interval-code",datetimeIntervalCodes,sizeray(datetimeIntervalCodes) },
  { "sql-desc-parameter-type",SQLDescParameterTypes,sizeray(SQLDescParameterTypes) },
  { "sql-desc-searchable",SQLDescSearchable,sizeray(SQLDescSearchable) },
  { "sql-desc-type",descDataTypes,sizeray(descDataTypes) },
  { "sql-desc-unnamed",SQLDescUnnamed, sizeray(SQLDescUnnamed) },
  { "sql-desc-concise-type",SQLColDataTypes, sizeray(SQLColDataTypes) },
  { "sql-desc-nullable",descNullableBits,sizeray(descNullableBits) },
  { "sql-desc-updatable",descUpdatableBits,sizeray(descUpdatableBits) },
};

#endif

#if (ODBCVER >= 0x0300)
SRP_NAMED_TYPED_CONSTANT fieldDescriptors[] = {
  
  // header fields

  { "sql-desc-alloc-type", SQL_DESC_ALLOC_TYPE, sqlsmallint},
  { "sql-desc-array-size", SQL_DESC_ARRAY_SIZE, sqluinteger },
  { "sql-desc-array-status-ptr", SQL_DESC_ARRAY_STATUS_PTR, arraystatus },
  { "sql-desc-bind-offset-ptr", SQL_DESC_BIND_OFFSET_PTR, bindingoffset },
  { "sql-desc-bind-type", SQL_DESC_BIND_TYPE, sqlinteger },
  { "sql-desc-count", SQL_DESC_COUNT, sqlsmallint },
  { "sql-desc-rows-processed-ptr", SQL_DESC_ROWS_PROCESSED_PTR, rowsprocessed },

  // record fields

  { "sql-desc-auto-unique-value", SQL_DESC_AUTO_UNIQUE_VALUE, sqlinteger },
  { "sql-desc-base-column-name", SQL_DESC_BASE_COLUMN_NAME, string },
  { "sql-desc-case-sensitive", SQL_DESC_CASE_SENSITIVE, sqlbool },
  { "sql-desc-concise-type",  SQL_DESC_CONCISE_TYPE, namedinteger },
  { "sql-desc-base-table-name ", SQL_DESC_BASE_TABLE_NAME, string },
  { "sql-desc-catalog-name", SQL_DESC_CATALOG_NAME, string },
  { "sql-desc-data-ptr", SQL_DESC_DATA_PTR, sqlbuffer },
  { "sql-desc-datetime-interval-code", SQL_DESC_DATETIME_INTERVAL_CODE, namedinteger },
  { "sql-desc-datetime-interval-precision", SQL_DESC_DATETIME_INTERVAL_PRECISION, sqlinteger },
  { "sql-desc-display-size", SQL_DESC_DISPLAY_SIZE, sqlinteger },
  { "sql-desc-fixed-prec-scale", SQL_DESC_FIXED_PREC_SCALE, sqlbool },
  { "sql-desc-indicator-ptr", SQL_DESC_INDICATOR_PTR, sqlindicator },
  { "sql-desc-label", SQL_DESC_LABEL, string },
  { "sql-desc-length", SQL_DESC_LENGTH, sqluinteger },
  { "sql-desc-literal-prefix", SQL_DESC_LITERAL_PREFIX, string },
  { "sql-desc-literal-suffix", SQL_DESC_LITERAL_SUFFIX, string },
  { "sql-desc-local-type-name", SQL_DESC_LOCAL_TYPE_NAME, string },
  { "sql-desc-name", SQL_DESC_NAME, string },
  { "sql-desc-nullable", SQL_DESC_NULLABLE, namedinteger },
  { "sql-desc-num-prec-radix", SQL_DESC_NUM_PREC_RADIX, sqlinteger },
  { "sql-desc-octet-length", SQL_DESC_OCTET_LENGTH, sqlinteger },
  { "sql-desc-octet-length-ptr", SQL_DESC_OCTET_LENGTH_PTR, octetlength },
  { "sql-desc-parameter-type", SQL_DESC_PARAMETER_TYPE, namedinteger },
  { "sql-desc-precision", SQL_DESC_PRECISION, sqlsmallint },
#if ODBCVER >= 0x0350
  { "sql-desc-rowver", SQL_DESC_ROWVER, sqlbool },
#endif
  { "sql-desc-scale", SQL_DESC_SCALE, sqlsmallint },
  { "sql-desc-schema-name", SQL_DESC_SCHEMA_NAME, string },
  { "sql-desc-searchable", SQL_DESC_SEARCHABLE, namedinteger },
  { "sql-desc-table-name", SQL_DESC_TABLE_NAME, string },
  { "sql-desc-type", SQL_DESC_TYPE, namedinteger },
  { "sql-desc-type-name", SQL_DESC_TYPE_NAME, string },
  { "sql-desc-unnamed", SQL_DESC_UNNAMED, namedinteger },
  { "sql-desc-unsigned", SQL_DESC_UNSIGNED, sqlbool },
  { "sql-desc-updatable", SQL_DESC_UPDATABLE, namedinteger },
};
#endif

// SQLColAttribute - no 's'

SRP_NAMED_CONSTANT descSearchableBits[] = {
#if (ODBVER >= 0x0300)
  { "sql-pred-none", SQL_PRED_NONE },
  { "sql-pred-char", SQL_PRED_CHAR },
  { "sql-pred-basic", SQL_PRED_BASIC },
  { "sql-pred-searchable", SQL_PRED_SEARCHABLE },
#else 
  { "sql-unsearchable", SQL_UNSEARCHABLE },
  { "sql-like-only", SQL_LIKE_ONLY },
  { "sql-all-except-like", SQL_ALL_EXCEPT_LIKE },
  { "sql-searchable", SQL_SEARCHABLE },
#endif
};

#if (ODBCVER >= 0x0300)
SRP_NAMED_BITS_DICT namedColAttrIntegers[] = {
  { "sql-desc-concise-type", SQLColDataTypes, sizeray(SQLColDataTypes) },
  { "sql-desc-nullable", descNullableBits, sizeray(descNullableBits) },
  { "sql-desc-searchable", descSearchableBits, sizeray(descSearchableBits) },
  { "sql-desc-type", SQLColDataTypes, sizeray(SQLColDataTypes) },
  { "sql-desc-unnamed", SQLDescUnnamed, sizeray(SQLDescUnnamed) },
  { "sql-desc-updatable", descUpdatableBits, sizeray(descUpdatableBits) },
};
#endif

#if (ODBCVER >= 0x0300)
SRP_NAMED_TYPED_CONSTANT colAttributes[] = {
  { "sql-desc-count", SQL_DESC_COUNT, sqlinteger },
  { "sql-desc-auto-unique-value", SQL_DESC_AUTO_UNIQUE_VALUE, sqlbool },
  { "sql-desc-base-column-name", SQL_DESC_BASE_COLUMN_NAME, string },
  { "sql-desc-base-table-name ", SQL_DESC_BASE_TABLE_NAME, string },
  { "sql-desc-case-sensitive", SQL_DESC_CASE_SENSITIVE, sqlbool },
  { "sql-desc-catalog-name", SQL_DESC_CATALOG_NAME, string },
  { "sql-desc-concise-type",  SQL_DESC_CONCISE_TYPE, namedinteger },
  { "sql-desc-data-ptr", SQL_DESC_DATA_PTR },
  { "sql-desc-display-size", SQL_DESC_DISPLAY_SIZE, sqlinteger },
  { "sql-desc-fixed-prec-scale", SQL_DESC_FIXED_PREC_SCALE, sqlbool },
  { "sql-desc-label", SQL_DESC_LABEL, string },
  { "sql-desc-length", SQL_DESC_LENGTH, sqlinteger },
  { "sql-desc-literal-prefix", SQL_DESC_LITERAL_PREFIX, string },
  { "sql-desc-literal-suffix", SQL_DESC_LITERAL_SUFFIX, string },
  { "sql-desc-local-type-name", SQL_DESC_LOCAL_TYPE_NAME, string },
  { "sql-desc-name", SQL_DESC_NAME, string },
  { "sql-desc-nullable", SQL_DESC_NULLABLE, namedinteger },
  { "sql-desc-num-prec-radix", SQL_DESC_NUM_PREC_RADIX, sqlinteger },
  { "sql-desc-octet-length", SQL_DESC_OCTET_LENGTH, sqlinteger },
  { "sql-desc-precision", SQL_DESC_PRECISION, sqlinteger },
  { "sql-desc-scale", SQL_DESC_SCALE, sqlinteger },
  { "sql-desc-schema-name", SQL_DESC_SCHEMA_NAME, string },
  { "sql-desc-searchable", SQL_DESC_SEARCHABLE, namedinteger },
  { "sql-desc-table-name", SQL_DESC_TABLE_NAME, string },
  { "sql-desc-type", SQL_DESC_TYPE, namedinteger },
  { "sql-desc-type-name", SQL_DESC_TYPE_NAME, string },
  { "sql-desc-unnamed", SQL_DESC_UNNAMED, namedinteger },
  { "sql-desc-unsigned", SQL_DESC_UNSIGNED, sqlbool },
  { "sql-desc-updatable", SQL_DESC_UPDATABLE, namedinteger },
};
#endif

// SQLColAttributes - with an 's'

SRP_NAMED_BITS_DICT namedColAttrsIntegers[] = {
  { "sql-column-nullable", descNullableBits, sizeray(descNullableBits) },
  { "sql-column-searchable", descSearchableBits, sizeray(descSearchableBits) },
  { "sql-column-type", SQLColDataTypes, sizeray(SQLColDataTypes) },
  { "sql-column-updatable", descUpdatableBits, sizeray(descUpdatableBits) },
};

SRP_NAMED_TYPED_CONSTANT colAttributesOld[] = {
  { "sql-column-count",SQL_COLUMN_COUNT, sqlinteger },
  { "sql-column-name",SQL_COLUMN_NAME, string },
  { "sql-column-type",SQL_COLUMN_TYPE, namedinteger },
  { "sql-column-length",SQL_COLUMN_LENGTH, sqlinteger },
  { "sql-column-precision",SQL_COLUMN_PRECISION, sqlinteger },
  { "sql-column-scale",SQL_COLUMN_SCALE, sqlinteger },
  { "sql-column-display-size",SQL_COLUMN_DISPLAY_SIZE, sqlinteger },
  { "sql-column-nullable",SQL_COLUMN_NULLABLE, namedinteger },
  { "sql-column-unsigned",SQL_COLUMN_UNSIGNED, sqlbool },
  { "sql-column-money",SQL_COLUMN_MONEY, sqlbool },
  { "sql-column-updatable",SQL_COLUMN_UPDATABLE, namedinteger },
  { "sql-column-auto-increment",SQL_COLUMN_AUTO_INCREMENT, sqlbool },
  { "sql-column-case-sensitive",SQL_COLUMN_CASE_SENSITIVE, sqlbool },
  { "sql-column-searchable",SQL_COLUMN_SEARCHABLE, namedinteger },
  { "sql-column-type-name",SQL_COLUMN_TYPE_NAME, string },
  { "sql-column-table-name",SQL_COLUMN_TABLE_NAME, string },
  { "sql-column-owner-name",SQL_COLUMN_OWNER_NAME, string },
  { "sql-column-qualifier-name",SQL_COLUMN_QUALIFIER_NAME, string },
  { "sql-column-label",SQL_COLUMN_LABEL, string },
};

SRP_NAMED_SMALL_CONSTANT scrollConcurrency[] = {
  { "sql-concur-read-only", SQL_CONCUR_READ_ONLY },
  { "sql-concur-lock", SQL_CONCUR_LOCK },
  { "sql-concur-rowver", SQL_CONCUR_ROWVER },
  { "sql-concur-values", SQL_CONCUR_VALUES },
};

SRP_NAMED_CONSTANT scrollCursor[] = {
  { "sql-scroll-forward-only", SQL_SCROLL_FORWARD_ONLY },
  { "sql-scroll-keyset-driven", SQL_SCROLL_KEYSET_DRIVEN },
  { "sql-scroll-dynamic", SQL_SCROLL_DYNAMIC },
  { "sql-scroll-static", SQL_SCROLL_STATIC },
};

SRP_NAMED_SMALL_CONSTANT posOperations[] = {
  { "sql-position", SQL_POSITION },
  { "sql-refresh", SQL_REFRESH },
  { "sql-add", SQL_ADD },
  { "sql-update", SQL_UPDATE },
  { "sql-delete", SQL_DELETE },
};

SRP_NAMED_SMALL_CONSTANT lockTypes[] = {
  { "sql-lock-no-change", SQL_LOCK_NO_CHANGE },
  { "sql-lock-exclusive", SQL_LOCK_EXCLUSIVE },
  { "sql-lock-unlock", SQL_LOCK_UNLOCK },
};

SRP_NAMED_SMALL_CONSTANT stmtFreeOptions[] = {
  { "sql-close", SQL_CLOSE },
  { "sql-drop", SQL_DROP },
  { "sql-unbind", SQL_UNBIND },
  { "sql-reset-params", SQL_RESET_PARAMS },
};

