Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | merge changes from www.androwish.org to support sizeof(SQLWCHAR)==4 |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | detect-sqlwchar-size |
Files: | files | file ages | folders |
SHA3-256: |
0385c8930d457150f722b3513f67f464 |
User & Date: | chw 2018-05-07 05:36:24.034 |
Context
2018-05-09
| ||
15:21 | add missing pieces to the changes, thanks apn for testing check-in: e566edc779 user: chw tags: detect-sqlwchar-size | |
2018-05-07
| ||
05:36 | merge changes from www.androwish.org to support sizeof(SQLWCHAR)==4 check-in: 0385c8930d user: chw tags: detect-sqlwchar-size | |
05:13 | start branch to detect size of SQLWCHAR at runtime (iODBC vs. unixODBC) check-in: 624d0ec67d user: chw tags: detect-sqlwchar-size | |
Changes
Changes to generic/fakesql.h.
︙ | ︙ | |||
88 89 90 91 92 93 94 95 96 97 98 99 100 101 | #define SQL_HANDLE_ENV 1 #define SQL_HANDLE_STMT 3 /* Null handles */ #define SQL_NULL_HANDLE ((SQLHANDLE) 0) #define SQL_NULL_HENV ((SQLHENV) 0) #define SQL_NULL_HSTMT ((SQLHSTMT) 0) /* SQL data types */ enum _SQL_DATATYPE { SQL_BIGINT = -5, SQL_BINARY = -2, | > | 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 | #define SQL_HANDLE_ENV 1 #define SQL_HANDLE_STMT 3 /* Null handles */ #define SQL_NULL_HANDLE ((SQLHANDLE) 0) #define SQL_NULL_HENV ((SQLHENV) 0) #define SQL_NULL_HDBC ((SQLHDBC) 0) #define SQL_NULL_HSTMT ((SQLHSTMT) 0) /* SQL data types */ enum _SQL_DATATYPE { SQL_BIGINT = -5, SQL_BINARY = -2, |
︙ | ︙ | |||
140 141 142 143 144 145 146 147 148 149 150 151 152 153 | /* Status returns */ #define SQL_ERROR (-1) #define SQL_NO_DATA 100 #define SQL_NO_TOTAL (-4) #define SQL_SUCCESS 0 #define SQL_SUCCESS_WITH_INFO 1 /* Diagnostic fields */ enum _SQL_DIAG { SQL_DIAG_SQLSTATE = 4, }; | > | 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 | /* Status returns */ #define SQL_ERROR (-1) #define SQL_NO_DATA 100 #define SQL_NO_TOTAL (-4) #define SQL_SUCCESS 0 #define SQL_SUCCESS_WITH_INFO 1 #define SQL_SUCCEEDED(rc) (((rc)&(~1))==0) /* Diagnostic fields */ enum _SQL_DIAG { SQL_DIAG_SQLSTATE = 4, }; |
︙ | ︙ | |||
171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 | /* ODBC attributes */ #define SQL_ATTR_ACCESS_MODE SQL_ACCESS_MODE #define SQL_ATTR_CONNECTION_TIMEOUT 113 #define SQL_ATTR_ODBC_VERSION 200 #define SQL_ATTR_TXN_ISOLATION SQL_TXN_ISOLATION /* Nullable? */ #define SQL_NULLABLE_UNKNOWN 2 /* Placeholder for length of missing data */ #define SQL_NULL_DATA (-1) /* ODBC versions */ #define SQL_OV_ODBC3 3UL /* SQLDriverConnect flags */ #define SQL_DRIVER_COMPLETE_REQUIRED 3 #define SQL_DRIVER_NOPROMPT 0 /* SQLGetTypeInfo flags */ | > > | 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 | /* ODBC attributes */ #define SQL_ATTR_ACCESS_MODE SQL_ACCESS_MODE #define SQL_ATTR_CONNECTION_TIMEOUT 113 #define SQL_ATTR_ODBC_VERSION 200 #define SQL_ATTR_TXN_ISOLATION SQL_TXN_ISOLATION #define SQL_ATTR_AUTOCOMMIT SQL_AUTOCOMMIT /* Nullable? */ #define SQL_NULLABLE_UNKNOWN 2 /* Placeholder for length of missing data */ #define SQL_NULL_DATA (-1) /* ODBC versions */ #define SQL_OV_ODBC3 3UL #define SQL_ODBC_VER 10 /* SQLDriverConnect flags */ #define SQL_DRIVER_COMPLETE_REQUIRED 3 #define SQL_DRIVER_NOPROMPT 0 /* SQLGetTypeInfo flags */ |
︙ | ︙ |
Changes to generic/odbcStubInit.c.
︙ | ︙ | |||
55 56 57 58 59 60 61 | "", "2.6", "0.0", NULL }; #else static const char *const odbcStubLibNames[] = { /* @LIBNAMES@: DO NOT EDIT THESE NAMES */ | > > > > > | > > > > > > > | > > | 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 | "", "2.6", "0.0", NULL }; #else static const char *const odbcStubLibNames[] = { /* @LIBNAMES@: DO NOT EDIT THESE NAMES */ #if defined(__APPLE__) "libiodbc.2", #elif defined(__OpenBSD__) "libiodbc", #else "odbc32", "odbc", "libodbc32", "libodbc", "libiodbc", #endif NULL /* @END@ */ }; static const char *const odbcOptLibNames[] = { #if defined(__APPLE__) "libiodbcinst.2", #elif defined(__OpenBSD__) "libiodbcinst", #else "odbccp", "odbccp32", "odbcinst", "libodbccp", "libodbccp32", "libodbcinst", "libiodbcinst", #endif NULL }; #endif /* * Names of the functions that we need from ODBC |
︙ | ︙ |
Changes to generic/odbcStubs.h.
︙ | ︙ | |||
30 31 32 33 34 35 36 37 38 39 40 41 42 43 | SQLRETURN (SQL_API*SQLFetchPtr)(SQLHSTMT); SQLRETURN (SQL_API*SQLForeignKeysWPtr)(SQLHSTMT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT); SQLRETURN (SQL_API*SQLFreeHandlePtr)(SQLSMALLINT,SQLHANDLE); SQLRETURN (SQL_API*SQLGetConnectAttrPtr)(SQLHDBC,SQLINTEGER,SQLPOINTER,SQLINTEGER,SQLINTEGER*); SQLRETURN (SQL_API*SQLGetDataPtr)(SQLHSTMT,SQLUSMALLINT,SQLSMALLINT,SQLPOINTER,SQLLEN,SQLLEN*); SQLRETURN (SQL_API*SQLGetDiagFieldAPtr)(SQLSMALLINT,SQLHANDLE,SQLSMALLINT,SQLSMALLINT,SQLPOINTER,SQLSMALLINT,SQLSMALLINT*); SQLRETURN (SQL_API*SQLGetDiagRecWPtr)(SQLSMALLINT,SQLHANDLE,SQLSMALLINT,SQLWCHAR*,SQLINTEGER*,SQLWCHAR*,SQLSMALLINT,SQLSMALLINT*); SQLRETURN (SQL_API*SQLGetTypeInfoPtr)(SQLHSTMT,SQLSMALLINT); SQLRETURN (SQL_API*SQLMoreResultsPtr)(SQLHSTMT); SQLRETURN (SQL_API*SQLNumParamsPtr)(SQLHSTMT,SQLSMALLINT*); SQLRETURN (SQL_API*SQLNumResultColsPtr)(SQLHSTMT,SQLSMALLINT*); SQLRETURN (SQL_API*SQLPrepareWPtr)(SQLHSTMT,SQLWCHAR*,SQLINTEGER); SQLRETURN (SQL_API*SQLPrimaryKeysWPtr)(SQLHSTMT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT); SQLRETURN (SQL_API*SQLRowCountPtr)(SQLHSTMT,SQLLEN*); | > | 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 | SQLRETURN (SQL_API*SQLFetchPtr)(SQLHSTMT); SQLRETURN (SQL_API*SQLForeignKeysWPtr)(SQLHSTMT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT); SQLRETURN (SQL_API*SQLFreeHandlePtr)(SQLSMALLINT,SQLHANDLE); SQLRETURN (SQL_API*SQLGetConnectAttrPtr)(SQLHDBC,SQLINTEGER,SQLPOINTER,SQLINTEGER,SQLINTEGER*); SQLRETURN (SQL_API*SQLGetDataPtr)(SQLHSTMT,SQLUSMALLINT,SQLSMALLINT,SQLPOINTER,SQLLEN,SQLLEN*); SQLRETURN (SQL_API*SQLGetDiagFieldAPtr)(SQLSMALLINT,SQLHANDLE,SQLSMALLINT,SQLSMALLINT,SQLPOINTER,SQLSMALLINT,SQLSMALLINT*); SQLRETURN (SQL_API*SQLGetDiagRecWPtr)(SQLSMALLINT,SQLHANDLE,SQLSMALLINT,SQLWCHAR*,SQLINTEGER*,SQLWCHAR*,SQLSMALLINT,SQLSMALLINT*); SQLRETURN (SQL_API*SQLGetInfoWPtr)(SQLHANDLE,SQLUSMALLINT,SQLPOINTER,SQLSMALLINT,SQLSMALLINT*); SQLRETURN (SQL_API*SQLGetTypeInfoPtr)(SQLHSTMT,SQLSMALLINT); SQLRETURN (SQL_API*SQLMoreResultsPtr)(SQLHSTMT); SQLRETURN (SQL_API*SQLNumParamsPtr)(SQLHSTMT,SQLSMALLINT*); SQLRETURN (SQL_API*SQLNumResultColsPtr)(SQLHSTMT,SQLSMALLINT*); SQLRETURN (SQL_API*SQLPrepareWPtr)(SQLHSTMT,SQLWCHAR*,SQLINTEGER); SQLRETURN (SQL_API*SQLPrimaryKeysWPtr)(SQLHSTMT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT,SQLWCHAR*,SQLSMALLINT); SQLRETURN (SQL_API*SQLRowCountPtr)(SQLHSTMT,SQLLEN*); |
︙ | ︙ | |||
61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 | #define SQLFetch (odbcStubs->SQLFetchPtr) #define SQLForeignKeysW (odbcStubs->SQLForeignKeysWPtr) #define SQLFreeHandle (odbcStubs->SQLFreeHandlePtr) #define SQLGetConnectAttr (odbcStubs->SQLGetConnectAttrPtr) #define SQLGetData (odbcStubs->SQLGetDataPtr) #define SQLGetDiagFieldA (odbcStubs->SQLGetDiagFieldAPtr) #define SQLGetDiagRecW (odbcStubs->SQLGetDiagRecWPtr) #define SQLGetTypeInfo (odbcStubs->SQLGetTypeInfoPtr) #define SQLMoreResults (odbcStubs->SQLMoreResultsPtr) #define SQLNumParams (odbcStubs->SQLNumParamsPtr) #define SQLNumResultCols (odbcStubs->SQLNumResultColsPtr) #define SQLPrepareW (odbcStubs->SQLPrepareWPtr) #define SQLPrimaryKeysW (odbcStubs->SQLPrimaryKeysWPtr) #define SQLRowCount (odbcStubs->SQLRowCountPtr) #define SQLSetConnectAttr (odbcStubs->SQLSetConnectAttrPtr) #define SQLSetConnectOption (odbcStubs->SQLSetConnectOptionPtr) #define SQLSetEnvAttr (odbcStubs->SQLSetEnvAttrPtr) #define SQLTablesW (odbcStubs->SQLTablesWPtr) MODULE_SCOPE const odbcStubDefs *odbcStubs; | > | 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 | #define SQLFetch (odbcStubs->SQLFetchPtr) #define SQLForeignKeysW (odbcStubs->SQLForeignKeysWPtr) #define SQLFreeHandle (odbcStubs->SQLFreeHandlePtr) #define SQLGetConnectAttr (odbcStubs->SQLGetConnectAttrPtr) #define SQLGetData (odbcStubs->SQLGetDataPtr) #define SQLGetDiagFieldA (odbcStubs->SQLGetDiagFieldAPtr) #define SQLGetDiagRecW (odbcStubs->SQLGetDiagRecWPtr) #define SQLGetInfoW (odbcStubs->SQLGetInfoWPtr) #define SQLGetTypeInfo (odbcStubs->SQLGetTypeInfoPtr) #define SQLMoreResults (odbcStubs->SQLMoreResultsPtr) #define SQLNumParams (odbcStubs->SQLNumParamsPtr) #define SQLNumResultCols (odbcStubs->SQLNumResultColsPtr) #define SQLPrepareW (odbcStubs->SQLPrepareWPtr) #define SQLPrimaryKeysW (odbcStubs->SQLPrimaryKeysWPtr) #define SQLRowCount (odbcStubs->SQLRowCountPtr) #define SQLSetConnectAttr (odbcStubs->SQLSetConnectAttrPtr) #define SQLSetConnectOption (odbcStubs->SQLSetConnectOptionPtr) #define SQLSetEnvAttr (odbcStubs->SQLSetEnvAttrPtr) #define SQLTablesW (odbcStubs->SQLTablesWPtr) MODULE_SCOPE const odbcStubDefs *odbcStubs; |
Changes to generic/tdbcodbc.c.
︙ | ︙ | |||
45 46 47 48 49 50 51 52 53 54 55 56 57 58 | static Tcl_LoadHandle odbcLoadHandle = NULL; /* Handle to the ODBC client library */ static Tcl_LoadHandle odbcInstLoadHandle = NULL; /* Handle to the ODBC installer library */ static SQLHENV hEnv = SQL_NULL_HENV; /* Handle to the global ODBC environment */ static int hEnvRefCount = 0; /* Reference count on the global environment */ /* * Objects to create within the literal pool */ const char* LiteralValues[] = { "0", | > > | 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 | static Tcl_LoadHandle odbcLoadHandle = NULL; /* Handle to the ODBC client library */ static Tcl_LoadHandle odbcInstLoadHandle = NULL; /* Handle to the ODBC installer library */ static SQLHENV hEnv = SQL_NULL_HENV; /* Handle to the global ODBC environment */ static int hEnvRefCount = 0; /* Reference count on the global environment */ static int sizeofSQLWCHAR = sizeof(SQLWCHAR); /* Preset, will be autodetected later */ /* * Objects to create within the literal pool */ const char* LiteralValues[] = { "0", |
︙ | ︙ | |||
779 780 781 782 783 784 785 | static void DStringAppendWChars( Tcl_DString* ds, /* Output string */ SQLWCHAR* ws, /* Input string */ int len /* Length of the input string in characters */ ) { int i; | | > > > > | > > > > > > > > > > > > > > > > > > > > | | > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 | static void DStringAppendWChars( Tcl_DString* ds, /* Output string */ SQLWCHAR* ws, /* Input string */ int len /* Length of the input string in characters */ ) { int i; char buf[TCL_UTF_MAX]; if (sizeofSQLWCHAR == sizeof(unsigned short)) { unsigned short* ptr16 = (unsigned short*) ws; for (i = 0; i < len; ++i) { unsigned int ch; int bytes; ch = ptr16[i]; if (ch > 0x10ffff) { ch = 0xfffd; } #if TCL_UTF_MAX >= 4 /* Collapse a surrogate pair, if any. */ if (ch >= 0xd800 && ch <= 0xdbff) { if (i + 1 < len) { unsigned int ch2 = ptr16[i+1]; if (ch2 >= 0xdc00 && ch2 <= 0xdfff) { ch = ((ch & 0x3ff) << 10) + 0x10000 + (ch2 & 0x3ff); i++; } } } #endif bytes = Tcl_UniCharToUtf(ch, buf); Tcl_DStringAppend(ds, buf, bytes); } } else { unsigned int* ptr32 = (unsigned int*) ws; for (i = 0; i < len; ++i) { unsigned int ch; int bytes; ch = ptr32[i]; if (ch > 0x10ffff) { ch = 0xfffd; } #if TCL_UTF_MAX >= 4 /* Collapse a surrogate pair, if any. */ if (ch >= 0xd800 && ch <= 0xdbff) { if (i + 1 < len) { unsigned int ch2 = ptr32[i+1]; if (ch2 >= 0xdc00 && ch2 <= 0xdfff) { ch = ((ch & 0x3ff) << 10) + 0x10000 + (ch2 & 0x3ff); i++; } } } #endif bytes = Tcl_UniCharToUtf(ch, buf); Tcl_DStringAppend(ds, buf, bytes); } } } /* *----------------------------------------------------------------------------- * * GetWCharStringFromObj -- |
︙ | ︙ | |||
809 810 811 812 813 814 815 | */ static SQLWCHAR* GetWCharStringFromObj( Tcl_Obj* obj, /* Tcl object whose string rep is desired */ int* lengthPtr /* Length of the string */ ) { | < | < < | > > > | > > > > > > > > | > > > > > > > | > > > | > > > > | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | > > | 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 | */ static SQLWCHAR* GetWCharStringFromObj( Tcl_Obj* obj, /* Tcl object whose string rep is desired */ int* lengthPtr /* Length of the string */ ) { int len; /* Length of the input string in bytes */ char* bytes = Tcl_GetStringFromObj(obj, &len); /* UTF-8 representation of the input string */ char* end = bytes + len; /* End of UTF-8 representation */ SQLWCHAR* retval; /* Buffer to hold the converted string */ SQLWCHAR* wcPtr; int shrink = 0; Tcl_UniChar ch = 0; len = (len + 1) * sizeofSQLWCHAR; #if TCL_UTF_MAX > 4 if (sizeofSQLWCHAR < sizeof(Tcl_UniChar)) { len *= 2; /* doubled space for surrogates */ shrink = 1; } #endif retval = wcPtr = (SQLWCHAR*) ckalloc(len); if (sizeofSQLWCHAR == sizeof(unsigned short)) { unsigned short *ptr16 = (unsigned short*) wcPtr; while (bytes < end) { unsigned int uch; if (Tcl_UtfCharComplete(bytes, end - bytes)) { bytes += Tcl_UtfToUniChar(bytes, &ch); } else { ch = *bytes++ & 0x00ff; } uch = ch; #if TCL_UTF_MAX > 4 if (uch > 0xffff) { *ptr16++ = (((uch - 0x10000) >> 10) & 0x3ff) | 0xd800; uch = ((uch - 0x10000) & 0x3ff) | 0xdc00; } #endif if (uch > 0x7f) { shrink = 1; } *ptr16++ = uch; } *ptr16 = 0; len = ptr16 - (unsigned short*) retval; wcPtr = (SQLWCHAR*) ptr16; } else { unsigned int *ptr32 = (unsigned int*) wcPtr; while (bytes < end) { unsigned int uch; if (Tcl_UtfCharComplete(bytes, end - bytes)) { bytes += Tcl_UtfToUniChar(bytes, &ch); } else { ch = *bytes++ & 0x00ff; } uch = ch; #if TCL_UTF_MAX == 4 if ((uch & 0xfc00) == 0xd800) { if (Tcl_UtfCharComplete(bytes, end - bytes)) { len = Tcl_UtfToUniChar(bytes, &ch); if ((ch & 0xfc00) == 0xdc00) { bytes += len; uch = (((uch & 0x3ff) << 10) | (ch & 0x3ff)) + 0x10000; } } } #endif if (uch > 0x7f) { shrink = 1; } *ptr32++ = uch; } *ptr32 = 0; len = ptr32 - (unsigned int*) retval; wcPtr = (SQLWCHAR*) ptr32; } if (shrink) { /* Shrink buffer to fit result */ wcPtr = (SQLWCHAR*) ckrealloc(retval, (len + 1) * sizeofSQLWCHAR); if (wcPtr != NULL) { retval = wcPtr; } } if (lengthPtr != NULL) { *lengthPtr = len; } return retval; } /* |
︙ | ︙ | |||
856 857 858 859 860 861 862 | TransferSQLError( Tcl_Interp* interp, /* Tcl interpreter */ SQLSMALLINT handleType, /* Type of the handle for which the error * has been reported. */ SQLHANDLE handle, /* Handle that reported the error */ const char* info /* Additional information to report */ ) { | | | < | > > > > | | | > > | 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 | TransferSQLError( Tcl_Interp* interp, /* Tcl interpreter */ SQLSMALLINT handleType, /* Type of the handle for which the error * has been reported. */ SQLHANDLE handle, /* Handle that reported the error */ const char* info /* Additional information to report */ ) { SQLWCHAR state[6*2]; /* SQL state code */ SQLINTEGER nativeError; /* Native error code */ SQLSMALLINT msgLen; /* Length of the error message */ SQLWCHAR msg[(SQL_MAX_MESSAGE_LENGTH+1)*2]; /* Buffer to hold the error message */ SQLSMALLINT i; /* Loop index for going through diagnostics */ const char* sep = ""; /* Separator string for messages */ const char* sqlstate; /* SQL state */ Tcl_Obj* resultObj; /* Result string containing error message */ Tcl_Obj* codeObj; /* Error code object */ Tcl_Obj* lineObj; /* Object holding one diagnostic */ Tcl_DString bufferDS; /* Buffer for transferring messages */ SQLRETURN rc; /* SQL result */ resultObj = Tcl_NewObj(); codeObj = Tcl_NewStringObj("TDBC", -1); /* Loop through the diagnostics */ i = 1; while (1) { msg[0] = msg[1] = 0; msgLen = 0; state[0] = state[1] = 0; rc = SQLGetDiagRecW(handleType, handle, i, state, &nativeError, msg, SQL_MAX_MESSAGE_LENGTH, &msgLen); if (!SQL_SUCCEEDED(rc) || rc == SQL_NO_DATA) { break; } /* Add the diagnostic to ::errorCode */ Tcl_DStringInit(&bufferDS); DStringAppendWChars(&bufferDS, state, 5); sqlstate = Tcl_DStringValue(&bufferDS); lineObj = Tcl_NewStringObj(sqlstate, Tcl_DStringLength(&bufferDS)); |
︙ | ︙ | |||
951 952 953 954 955 956 957 958 959 | SQLSMALLINT handleType, /* Type of handle reporting the state */ SQLHANDLE handle, /* Handle that reported the state */ const char* sqlstate /* State to look for */ ) { SQLCHAR state[6]; /* SQL state code from the diagnostic record */ SQLSMALLINT stateLen; /* String length of the state code */ SQLSMALLINT i; /* Loop index */ i = 1; | > > > > | | | > > | 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 | SQLSMALLINT handleType, /* Type of handle reporting the state */ SQLHANDLE handle, /* Handle that reported the state */ const char* sqlstate /* State to look for */ ) { SQLCHAR state[6]; /* SQL state code from the diagnostic record */ SQLSMALLINT stateLen; /* String length of the state code */ SQLSMALLINT i; /* Loop index */ SQLRETURN rc; /* SQL result */ i = 1; while (1) { state[0] = 0; stateLen = 0, rc = SQLGetDiagFieldA(handleType, handle, i, SQL_DIAG_SQLSTATE, (SQLPOINTER) state, sizeof(state), &stateLen); if (!SQL_SUCCEEDED(rc) || rc == SQL_NO_DATA) { break; } if (stateLen >= 0 && !strcmp(sqlstate, (const char*) state)) { return 1; } } return 0; } |
︙ | ︙ | |||
1079 1080 1081 1082 1083 1084 1085 | Tcl_MutexUnlock(&hEnvMutex); return SQL_NULL_HENV; } /* * Allocate the ODBC environment */ rc = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &hEnv); | | | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 | Tcl_MutexUnlock(&hEnvMutex); return SQL_NULL_HENV; } /* * Allocate the ODBC environment */ rc = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &hEnv); if (SQL_SUCCEEDED(rc)) { rc = SQLSetEnvAttr(hEnv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER) SQL_OV_ODBC3, 0); } if (!SQL_SUCCEEDED(rc)) { /* * The call failed. Report the error. */ if (hEnv != SQL_NULL_HENV) { if (interp != NULL) { TransferSQLError(interp, SQL_HANDLE_ENV, hEnv, "(allocating environment handle)"); } SQLFreeHandle(SQL_HANDLE_ENV, hEnv); hEnv = SQL_NULL_HENV; } else { Tcl_SetObjResult(interp, Tcl_NewStringObj("Could not allocate the " "ODBC SQL environment.", -1)); Tcl_SetErrorCode(interp, "TDBC", "GENERAL_ERROR", "HY001", "ODBC", "-1", NULL); } } else { /* * Detect real size of SQLWCHAR used by the driver manager. */ SQLHDBC hDBC = SQL_NULL_HDBC; sizeofSQLWCHAR = sizeof(SQLWCHAR); /* fallback */ rc = SQLAllocHandle(SQL_HANDLE_DBC, hEnv, &hDBC); if (SQL_SUCCEEDED(rc)) { SQLSMALLINT infoLen; int i; char info[64]; rc = SQLGetInfoW(hDBC, SQL_ODBC_VER, (SQLPOINTER) info, sizeof(info), &infoLen); if (SQL_SUCCEEDED(rc) && infoLen >= 8) { static const char BE32sig[] = { '\0', '\0', '\0', '#', '\0', '\0', '\0', '#' }; static const char LE32sig[] = { '#', '\0', '\0', '\0', '#', '\0', '\0', '\0' }; static const char BE16sig[] = { '\0', '#', '\0', '#' }; static const char LE16sig[] = { '#', '\0', '#', '\0' }; if (infoLen > sizeof(info)) { infoLen = sizeof(info); } for (i = 0; i < infoLen; i++) { if (info[i] >= '0' && info[i] <= '9') { info[i] = '#'; } } if (memcmp(info, BE32sig, sizeof(BE32sig)) == 0 || memcmp(info, LE32sig, sizeof(LE32sig)) == 0) { sizeofSQLWCHAR = 4; } else if (memcmp(info, BE16sig, sizeof(BE16sig)) == 0 || memcmp(info, LE16sig, sizeof(LE16sig)) == 0) { sizeofSQLWCHAR = 2; } } SQLFreeHandle(SQL_HANDLE_DBC, hDBC); } } } /* * On subsequent calls, simply adjust the refcount */ if (hEnv != SQL_NULL_HENV) { ++hEnvRefCount; |
︙ | ︙ | |||
1176 1177 1178 1179 1180 1181 1182 | | STATEMENT_FLAG_FOREIGNKEYS | STATEMENT_FLAG_TYPES)) { Tcl_SetObjResult(interp, Tcl_NewStringObj("cannot have multiple result " "sets in this context", -1)); return SQL_NULL_HSTMT; } rc = SQLAllocHandle(SQL_HANDLE_STMT, cdata->hDBC, &hStmt); | | | | 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 | | STATEMENT_FLAG_FOREIGNKEYS | STATEMENT_FLAG_TYPES)) { Tcl_SetObjResult(interp, Tcl_NewStringObj("cannot have multiple result " "sets in this context", -1)); return SQL_NULL_HSTMT; } rc = SQLAllocHandle(SQL_HANDLE_STMT, cdata->hDBC, &hStmt); if (!SQL_SUCCEEDED(rc)) { TransferSQLError(interp, SQL_HANDLE_DBC, cdata->hDBC, "(allocating statement handle)"); return SQL_NULL_HSTMT; } rc = SQLPrepareW(hStmt, sdata->nativeSqlW, sdata->nativeSqlLen); if (!SQL_SUCCEEDED(rc)) { TransferSQLError(interp, SQL_HANDLE_STMT, hStmt, "(preparing statement)"); SQLFreeHandle(SQL_HANDLE_STMT, hStmt); return SQL_NULL_HSTMT; } return hStmt; } |
︙ | ︙ | |||
1219 1220 1221 1222 1223 1224 1225 | ResultSetData* rdata /* Result set data object */ ) { SQLHSTMT hStmt = rdata->hStmt; /* Statement handle */ SQLRETURN rc; /* Return code from ODBC operations */ Tcl_Obj* colNames; /* List of the column names */ SQLSMALLINT nColumns; /* Number of result set columns */ | | | 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 | ResultSetData* rdata /* Result set data object */ ) { SQLHSTMT hStmt = rdata->hStmt; /* Statement handle */ SQLRETURN rc; /* Return code from ODBC operations */ Tcl_Obj* colNames; /* List of the column names */ SQLSMALLINT nColumns; /* Number of result set columns */ SQLWCHAR colNameBuf[41*2]; /* Buffer to hold the column name */ SQLSMALLINT colNameLen = 40; /* Length of the column name */ SQLSMALLINT colNameAllocLen = 40; /* Allocated length of the column name */ SQLWCHAR* colNameW = colNameBuf; /* Name of the current column */ Tcl_DString colNameDS; /* Name of the current column, translated */ |
︙ | ︙ | |||
1248 1249 1250 1251 1252 1253 1254 | Tcl_InitHashTable(&nameHash, TCL_STRING_KEYS); nameEntry = Tcl_CreateHashEntry(&nameHash, "", &new); Tcl_SetHashValue(nameEntry, (ClientData) 0); /* Count the columns of the result set */ rc = SQLNumResultCols(hStmt, &nColumns); | | | 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 | Tcl_InitHashTable(&nameHash, TCL_STRING_KEYS); nameEntry = Tcl_CreateHashEntry(&nameHash, "", &new); Tcl_SetHashValue(nameEntry, (ClientData) 0); /* Count the columns of the result set */ rc = SQLNumResultCols(hStmt, &nColumns); if (!SQL_SUCCEEDED(rc)) { TransferSQLError(interp, SQL_HANDLE_STMT, hStmt, "(getting number of result columns)"); return TCL_ERROR; } colNames = Tcl_NewObj(); Tcl_IncrRefCount(colNames); if (nColumns != 0) { |
︙ | ︙ | |||
1289 1290 1291 1292 1293 1294 1295 | retry = 0; } else { colNameAllocLen = 2 * colNameLen + 1; if (colNameW != colNameBuf) { ckfree((char*) colNameW); } colNameW = (SQLWCHAR*) | | | | 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 | retry = 0; } else { colNameAllocLen = 2 * colNameLen + 1; if (colNameW != colNameBuf) { ckfree((char*) colNameW); } colNameW = (SQLWCHAR*) ckalloc(colNameAllocLen * sizeofSQLWCHAR); retry = 1; } } while (retry); /* Bail out on an ODBC error */ if (!SQL_SUCCEEDED(rc)) { char info[80]; sprintf(info, "(describing result column #%d)", i+1); TransferSQLError(interp, SQL_HANDLE_STMT, hStmt, info); Tcl_DecrRefCount(colNames); ckfree((char*)rdata->results); goto cleanup; } |
︙ | ︙ | |||
1469 1470 1471 1472 1473 1474 1475 | Tcl_FreeEncoding(sysEncoding); } /* -isolation */ rc = SQLGetConnectAttr(hDBC, SQL_ATTR_TXN_ISOLATION, (SQLPOINTER) &mode, 0, NULL); | | | | | 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 | Tcl_FreeEncoding(sysEncoding); } /* -isolation */ rc = SQLGetConnectAttr(hDBC, SQL_ATTR_TXN_ISOLATION, (SQLPOINTER) &mode, 0, NULL); if (!SQL_SUCCEEDED(rc)) { TransferSQLError(interp, SQL_HANDLE_DBC, hDBC, "(getting isolation level of connection)"); return TCL_ERROR; } Tcl_ListObjAppendElement(NULL, retval, literals[LIT_ISOLATION]); Tcl_ListObjAppendElement(NULL, retval, TranslateOdbcIsolationLevel(mode, literals)); /* -readonly */ rc = SQLGetConnectAttr(hDBC, SQL_ATTR_ACCESS_MODE, (SQLPOINTER) &mode, 0, NULL); if (!SQL_SUCCEEDED(rc)) { TransferSQLError(interp, SQL_HANDLE_DBC, hDBC, "(getting access mode of connection)"); return TCL_ERROR; } Tcl_ListObjAppendElement(NULL, retval, literals[LIT_READONLY]); Tcl_ListObjAppendElement(NULL, retval, Tcl_NewIntObj(mode == SQL_MODE_READ_ONLY)); /* -timeout */ rc = SQLGetConnectAttr(hDBC, SQL_ATTR_CONNECTION_TIMEOUT, (SQLPOINTER)&seconds, 0, NULL); if (!SQL_SUCCEEDED(rc)) { if (SQLStateIs(SQL_HANDLE_DBC, hDBC, "HYC00")) { seconds = 0; } else { TransferSQLError(interp, SQL_HANDLE_DBC, hDBC, "(getting connection timeout value)"); return TCL_ERROR; } |
︙ | ︙ | |||
1540 1541 1542 1543 1544 1545 1546 | Tcl_FreeEncoding(sysEncoding); } break; case COPTION_ISOLATION: rc = SQLGetConnectAttr(hDBC, SQL_ATTR_TXN_ISOLATION, (SQLPOINTER) &mode, 0, NULL); | | | | | 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 | Tcl_FreeEncoding(sysEncoding); } break; case COPTION_ISOLATION: rc = SQLGetConnectAttr(hDBC, SQL_ATTR_TXN_ISOLATION, (SQLPOINTER) &mode, 0, NULL); if (!SQL_SUCCEEDED(rc)) { TransferSQLError(interp, SQL_HANDLE_DBC, hDBC, "(getting isolation level of connection)"); return TCL_ERROR; } Tcl_SetObjResult(interp, TranslateOdbcIsolationLevel(mode, literals)); break; case COPTION_PARENT: Tcl_SetObjResult(interp, Tcl_NewStringObj("-parent option cannot " "be used after connection " "is established", -1)); Tcl_SetErrorCode(interp, "TDBC", "GENERAL_ERROR", "HY010", "ODBC", "-1", NULL); return TCL_ERROR; case COPTION_READONLY: rc = SQLGetConnectAttr(hDBC, SQL_ATTR_ACCESS_MODE, (SQLPOINTER) &mode, 0, NULL); if (!SQL_SUCCEEDED(rc)) { TransferSQLError(interp, SQL_HANDLE_DBC, hDBC, "(getting access mode of connection)"); return TCL_ERROR; } Tcl_SetObjResult(interp, Tcl_NewIntObj(mode == SQL_MODE_READ_ONLY)); break; case COPTION_TIMEOUT: rc = SQLGetConnectAttr(hDBC, SQL_ATTR_CONNECTION_TIMEOUT, (SQLPOINTER)&seconds, 0, NULL); if (SQLStateIs(SQL_HANDLE_DBC, hDBC, "HYC00")) { seconds = 0; } else { if (!SQL_SUCCEEDED(rc)) { TransferSQLError(interp, SQL_HANDLE_DBC, hDBC, "(getting connection timeout value)"); return TCL_ERROR; } } Tcl_SetObjResult(interp, Tcl_NewIntObj(1000 * (int) seconds)); break; |
︙ | ︙ | |||
1636 1637 1638 1639 1640 1641 1642 | if (LookupOdbcConstant(interp, OdbcIsolationLevels, "isolation level", objv[i+1], &isol) != TCL_OK) { return TCL_ERROR; } mode = isol; rc = SQLSetConnectAttr(hDBC, SQL_ATTR_TXN_ISOLATION, | | | | 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 | if (LookupOdbcConstant(interp, OdbcIsolationLevels, "isolation level", objv[i+1], &isol) != TCL_OK) { return TCL_ERROR; } mode = isol; rc = SQLSetConnectAttr(hDBC, SQL_ATTR_TXN_ISOLATION, (SQLPOINTER)(INT2PTR(mode)), 0); if (!SQL_SUCCEEDED(rc)) { TransferSQLError(interp, SQL_HANDLE_DBC, hDBC, "(setting isolation level of connection)"); return TCL_ERROR; } break; case COPTION_PARENT: |
︙ | ︙ | |||
1707 1708 1709 1710 1711 1712 1713 | } if (j) { mode = SQL_MODE_READ_ONLY; } else { mode = SQL_MODE_READ_WRITE; } rc = SQLSetConnectAttr(hDBC, SQL_ATTR_ACCESS_MODE, | | | | | | 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 | } if (j) { mode = SQL_MODE_READ_ONLY; } else { mode = SQL_MODE_READ_WRITE; } rc = SQLSetConnectAttr(hDBC, SQL_ATTR_ACCESS_MODE, (SQLPOINTER)(INT2PTR(mode)), 0); if (!SQL_SUCCEEDED(rc)) { TransferSQLError(interp, SQL_HANDLE_DBC, hDBC, "(setting access mode of connection)"); return TCL_ERROR; } break; case COPTION_TIMEOUT: /* timeout value */ if (Tcl_GetIntFromObj(interp, objv[i+1], &j) != TCL_OK) { return TCL_ERROR; } seconds = (SQLINTEGER)((j + 999) / 1000); rc = SQLSetConnectAttr(hDBC, SQL_ATTR_CONNECTION_TIMEOUT, (SQLPOINTER)(INT2PTR(seconds)), 0); if (!SQL_SUCCEEDED(rc)) { /* * A failure is OK if the SQL state is "Optional * Function Not Implemented" and we were trying to set * a zero timeout. */ if (!SQLStateIs(SQL_HANDLE_DBC, hDBC, "HYC00") || seconds != 0) { |
︙ | ︙ | |||
1775 1776 1777 1778 1779 1780 1781 | ) { PerInterpData* pidata = (PerInterpData*) clientData; /* Per-interp data for the ODBC package */ Tcl_Object thisObject = Tcl_ObjectContextObject(objectContext); /* The current connection object */ int skip = Tcl_ObjectContextSkippedArgs(objectContext); /* Number of leading args to skip */ | > | | | 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 | ) { PerInterpData* pidata = (PerInterpData*) clientData; /* Per-interp data for the ODBC package */ Tcl_Object thisObject = Tcl_ObjectContextObject(objectContext); /* The current connection object */ int skip = Tcl_ObjectContextSkippedArgs(objectContext); /* Number of leading args to skip */ SQLHDBC hDBC = SQL_NULL_HDBC; /* Handle to the database connection */ SQLRETURN rc; /* Return code from ODBC calls */ HWND hParentWindow = NULL; /* Windows handle of the main window */ SQLWCHAR* connectionStringReq; /* Connection string requested by the caller */ int connectionStringReqLen; /* Length of the requested connection string */ SQLWCHAR connectionString[1025*2]; /* Connection string actually used */ SQLSMALLINT connectionStringLen; /* Length of the actual connection string */ Tcl_DString connectionStringDS; /* Connection string converted to UTF-8 */ SQLUSMALLINT connectFlags = SQL_DRIVER_NOPROMPT; /* Driver options */ |
︙ | ︙ | |||
1808 1809 1810 1811 1812 1813 1814 | } /* * Allocate a connection handle */ rc = SQLAllocHandle(SQL_HANDLE_DBC, pidata->hEnv, (SQLHANDLE*) &hDBC); | | | 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 | } /* * Allocate a connection handle */ rc = SQLAllocHandle(SQL_HANDLE_DBC, pidata->hEnv, (SQLHANDLE*) &hDBC); if (!SQL_SUCCEEDED(rc)) { TransferSQLError(interp, SQL_HANDLE_ENV, pidata->hEnv, "(allocating connection handle)"); return TCL_ERROR; } /* * Grab configuration options. |
︙ | ︙ | |||
1840 1841 1842 1843 1844 1845 1846 | connectionString, 1024, &connectionStringLen, connectFlags); ckfree((char*) connectionStringReq); if (rc == SQL_NO_DATA) { Tcl_SetObjResult(interp, Tcl_NewStringObj("operation cancelled", -1)); SQLFreeHandle(SQL_HANDLE_DBC, hDBC); return TCL_ERROR; | | | 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 | connectionString, 1024, &connectionStringLen, connectFlags); ckfree((char*) connectionStringReq); if (rc == SQL_NO_DATA) { Tcl_SetObjResult(interp, Tcl_NewStringObj("operation cancelled", -1)); SQLFreeHandle(SQL_HANDLE_DBC, hDBC); return TCL_ERROR; } else if (!SQL_SUCCEEDED(rc)) { TransferSQLError(interp, SQL_HANDLE_DBC, hDBC, "(connecting to database)"); SQLFreeHandle(SQL_HANDLE_DBC, hDBC); return TCL_ERROR; } /* Attach data about the connection to the object metadata */ |
︙ | ︙ | |||
2039 2040 2041 2042 2043 2044 2045 | return TCL_ERROR; } /* End transaction, turn off "transaction in progress", and report status */ rc = SQLEndTran(SQL_HANDLE_DBC, cdata->hDBC, completionType); cdata->flags &= ~ CONNECTION_FLAG_XCN_ACTIVE; | | | 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 | return TCL_ERROR; } /* End transaction, turn off "transaction in progress", and report status */ rc = SQLEndTran(SQL_HANDLE_DBC, cdata->hDBC, completionType); cdata->flags &= ~ CONNECTION_FLAG_XCN_ACTIVE; if (!SQL_SUCCEEDED(rc)) { TransferSQLError(interp, SQL_HANDLE_DBC, cdata->hDBC, "(ending the transaction)"); return TCL_ERROR; } return TCL_OK; } |
︙ | ︙ | |||
2172 2173 2174 2175 2176 2177 2178 | static int SetAutocommitFlag( Tcl_Interp* interp, /* Tcl interpreter */ ConnectionData* cdata, /* Instance data for the connection */ SQLINTEGER flag /* Auto-commit indicator */ ) { SQLRETURN rc; | < < < < < | < < < < < < | | 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 | static int SetAutocommitFlag( Tcl_Interp* interp, /* Tcl interpreter */ ConnectionData* cdata, /* Instance data for the connection */ SQLINTEGER flag /* Auto-commit indicator */ ) { SQLRETURN rc; rc = SQLSetConnectAttr(cdata->hDBC, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)(INT2PTR(flag)), 0); if (!SQL_SUCCEEDED(rc)) { TransferSQLError(interp, SQL_HANDLE_DBC, cdata->hDBC, "(changing the 'autocommit' attribute)"); return TCL_ERROR; } return TCL_OK; } |
︙ | ︙ | |||
2495 2496 2497 2498 2499 2500 2501 | } sdata->params[j].precision = 255; sdata->params[j].scale = 0; sdata->params[j].nullable = SQL_NULLABLE_UNKNOWN; sdata->params[j].flags = PARAM_IN; } rc = SQLNumParams(sdata->hStmt, &nParams); | | | 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 | } sdata->params[j].precision = 255; sdata->params[j].scale = 0; sdata->params[j].nullable = SQL_NULLABLE_UNKNOWN; sdata->params[j].flags = PARAM_IN; } rc = SQLNumParams(sdata->hStmt, &nParams); if (SQL_SUCCEEDED(rc)) { if (nParams != i) { Tcl_SetObjResult(interp, Tcl_NewStringObj("The SQL statement appears " "to contain parameters in " "native SQL syntax. You need " "to replace them with ones " "in ':variableName' form.", -1)); |
︙ | ︙ | |||
2519 2520 2521 2522 2523 2524 2525 | for (i = 0; i < nParams; ++i) { rc = SQLDescribeParam(sdata->hStmt, i+1, &(sdata->params[i].dataType), &(sdata->params[i].precision), &(sdata->params[i].scale), &(sdata->params[i].nullable)); | | | 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 | for (i = 0; i < nParams; ++i) { rc = SQLDescribeParam(sdata->hStmt, i+1, &(sdata->params[i].dataType), &(sdata->params[i].precision), &(sdata->params[i].scale), &(sdata->params[i].nullable)); if (SQL_SUCCEEDED(rc)) { /* * FIXME: SQLDescribeParam doesn't actually describe * the direction of parameter transmission for * stored procedure calls. It appears simply * to be the caller's responsibility to know * these things. If anyone has an idea how to * determine this, please send a patch! (Remember |
︙ | ︙ | |||
2854 2855 2856 2857 2858 2859 2860 | */ sdata = NewStatement(cdata, connectionObject); /* Allocate an ODBC statement handle */ rc = SQLAllocHandle(SQL_HANDLE_STMT, cdata->hDBC, &(sdata->hStmt)); | | | 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 | */ sdata = NewStatement(cdata, connectionObject); /* Allocate an ODBC statement handle */ rc = SQLAllocHandle(SQL_HANDLE_STMT, cdata->hDBC, &(sdata->hStmt)); if (!SQL_SUCCEEDED(rc)) { TransferSQLError(interp, SQL_HANDLE_DBC, cdata->hDBC, "(allocating statement handle)"); goto freeSData; } /* * Stash the table pattern in the statement data, and set a flag that |
︙ | ︙ | |||
2957 2958 2959 2960 2961 2962 2963 | */ sdata = NewStatement(cdata, connectionObject); /* Allocate an ODBC statement handle */ rc = SQLAllocHandle(SQL_HANDLE_STMT, cdata->hDBC, &(sdata->hStmt)); | | | 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 | */ sdata = NewStatement(cdata, connectionObject); /* Allocate an ODBC statement handle */ rc = SQLAllocHandle(SQL_HANDLE_STMT, cdata->hDBC, &(sdata->hStmt)); if (!SQL_SUCCEEDED(rc)) { TransferSQLError(interp, SQL_HANDLE_DBC, cdata->hDBC, "(allocating statement handle)"); goto freeSData; } /* * Stash the table name and match pattern in the statement data, |
︙ | ︙ | |||
3060 3061 3062 3063 3064 3065 3066 | */ sdata = NewStatement(cdata, connectionObject); /* Allocate an ODBC statement handle */ rc = SQLAllocHandle(SQL_HANDLE_STMT, cdata->hDBC, &(sdata->hStmt)); | | | 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 | */ sdata = NewStatement(cdata, connectionObject); /* Allocate an ODBC statement handle */ rc = SQLAllocHandle(SQL_HANDLE_STMT, cdata->hDBC, &(sdata->hStmt)); if (!SQL_SUCCEEDED(rc)) { TransferSQLError(interp, SQL_HANDLE_DBC, cdata->hDBC, "(allocating statement handle)"); goto freeSData; } /* * Stash the table name in the statement data, |
︙ | ︙ | |||
3210 3211 3212 3213 3214 3215 3216 | } have[paramIdx] = 1; } /* Allocate an ODBC statement handle */ rc = SQLAllocHandle(SQL_HANDLE_STMT, cdata->hDBC, &(sdata->hStmt)); | | | 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 | } have[paramIdx] = 1; } /* Allocate an ODBC statement handle */ rc = SQLAllocHandle(SQL_HANDLE_STMT, cdata->hDBC, &(sdata->hStmt)); if (!SQL_SUCCEEDED(rc)) { TransferSQLError(interp, SQL_HANDLE_DBC, cdata->hDBC, "(allocating statement handle)"); goto freeSData; } sdata->flags = STATEMENT_FLAG_FOREIGNKEYS; |
︙ | ︙ | |||
3310 3311 3312 3313 3314 3315 3316 | */ sdata = NewStatement(cdata, connectionObject); /* Allocate an ODBC statement handle */ rc = SQLAllocHandle(SQL_HANDLE_STMT, cdata->hDBC, &(sdata->hStmt)); | | | 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 | */ sdata = NewStatement(cdata, connectionObject); /* Allocate an ODBC statement handle */ rc = SQLAllocHandle(SQL_HANDLE_STMT, cdata->hDBC, &(sdata->hStmt)); if (!SQL_SUCCEEDED(rc)) { TransferSQLError(interp, SQL_HANDLE_DBC, cdata->hDBC, "(allocating statement handle)"); goto freeSData; } /* * Stash the type number in the statement data, and set a flag |
︙ | ︙ | |||
3695 3696 3697 3698 3699 3700 3701 | /* We prefer to transfer strings in Unicode if possible */ dataType = SQL_C_WCHAR; rdata->bindStrings[nBound] = (SQLCHAR*) GetWCharStringFromObj(paramValObj, ¶mLen); rdata->bindStringLengths[nBound] = paramExternalLen = | | | 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 | /* We prefer to transfer strings in Unicode if possible */ dataType = SQL_C_WCHAR; rdata->bindStrings[nBound] = (SQLCHAR*) GetWCharStringFromObj(paramValObj, ¶mLen); rdata->bindStringLengths[nBound] = paramExternalLen = paramLen * sizeofSQLWCHAR; } else { /* * We need to convert the character string to system * encoding and store in rdata->bindStrings[nBound]. */ |
︙ | ︙ | |||
3739 3740 3741 3742 3743 3744 3745 | dataType, sdata->params[nBound].dataType, sdata->params[nBound].precision, sdata->params[nBound].scale, rdata->bindStrings[nBound], paramExternalLen, rdata->bindStringLengths + nBound); | | | 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 | dataType, sdata->params[nBound].dataType, sdata->params[nBound].precision, sdata->params[nBound].scale, rdata->bindStrings[nBound], paramExternalLen, rdata->bindStringLengths + nBound); if (!SQL_SUCCEEDED(rc)) { char* info = ckalloc(80 * strlen(paramName)); sprintf(info, "(binding the '%s' parameter)", paramName); TransferSQLError(interp, SQL_HANDLE_STMT, rdata->hStmt, info); ckfree(info); return TCL_ERROR; } } |
︙ | ︙ | |||
3771 3772 3773 3774 3775 3776 3777 | sdata->nativeSqlW, sdata->nativeSqlLen, NULL, 0, NULL, 0, sdata->nativeMatchPatternW, sdata->nativeMatchPatLen); } else { rc = SQLExecute(rdata->hStmt); } | < | | | 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 | sdata->nativeSqlW, sdata->nativeSqlLen, NULL, 0, NULL, 0, sdata->nativeMatchPatternW, sdata->nativeMatchPatLen); } else { rc = SQLExecute(rdata->hStmt); } if (!SQL_SUCCEEDED(rc) && rc != SQL_NO_DATA) { TransferSQLError(interp, SQL_HANDLE_STMT, rdata->hStmt, "(executing the statement)"); return TCL_ERROR; } /* Extract the column information for the result set. */ if (GetResultSetDescription(interp, rdata) != TCL_OK) { return TCL_ERROR; } /* Determine and store the row count */ rc = SQLRowCount(rdata->hStmt, &(rdata->rowCount)); if (!SQL_SUCCEEDED(rc)) { TransferSQLError(interp, SQL_HANDLE_STMT, rdata->hStmt, "(counting rows in the result)"); return TCL_ERROR; } return TCL_OK; } |
︙ | ︙ | |||
3903 3904 3905 3906 3907 3908 3909 | /* Advance to the next results */ rc = SQLMoreResults(rdata->hStmt); if (rc == SQL_NO_DATA) { Tcl_SetObjResult(interp, literals[LIT_0]); return TCL_OK; } | | | | 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 | /* Advance to the next results */ rc = SQLMoreResults(rdata->hStmt); if (rc == SQL_NO_DATA) { Tcl_SetObjResult(interp, literals[LIT_0]); return TCL_OK; } if (!SQL_SUCCEEDED(rc)) { TransferSQLError(interp, SQL_HANDLE_STMT, rdata->hStmt, "(advancing to next result set)"); return TCL_ERROR; } if (GetResultSetDescription(interp, rdata) != TCL_OK) { return TCL_ERROR; } /* Determine and store the row count */ rc = SQLRowCount(rdata->hStmt, &(rdata->rowCount)); if (!SQL_SUCCEEDED(rc)) { TransferSQLError(interp, SQL_HANDLE_STMT, rdata->hStmt, "(counting rows in the result)"); return TCL_ERROR; } else { Tcl_SetObjResult(interp, literals[LIT_1]); return TCL_OK; } |
︙ | ︙ | |||
4015 4016 4017 4018 4019 4020 4021 | /* Advance to the next row of the result set */ rc = SQLFetch(rdata->hStmt); if (rc == SQL_NO_DATA) { Tcl_SetObjResult(interp, literals[LIT_0]); return TCL_OK; | | | 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 | /* Advance to the next row of the result set */ rc = SQLFetch(rdata->hStmt); if (rc == SQL_NO_DATA) { Tcl_SetObjResult(interp, literals[LIT_0]); return TCL_OK; } else if (!SQL_SUCCEEDED(rc)) { TransferSQLError(interp, SQL_HANDLE_STMT, rdata->hStmt, "(fetching the next row of the result set)"); return TCL_ERROR; } /* Walk through the current row, storing data for each column */ |
︙ | ︙ | |||
4091 4092 4093 4094 4095 4096 4097 | * or NULL */ ) { #define BUFSIZE 256 StatementData* sdata = rdata->sdata; ConnectionData* cdata = sdata->cdata; SQLSMALLINT dataType; /* Type of character data to retrieve */ | > | | | 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 | * or NULL */ ) { #define BUFSIZE 256 StatementData* sdata = rdata->sdata; ConnectionData* cdata = sdata->cdata; SQLSMALLINT dataType; /* Type of character data to retrieve */ SQLWCHAR colWBuf[(BUFSIZE+1)*2]; /* Buffer to hold the string value of a * column */ SQLCHAR* colBuf = (SQLCHAR*) colWBuf; SQLCHAR* colPtr = colBuf; /* Pointer to the current allocated buffer * (which may have grown) */ SQLLEN colAllocLen = BUFSIZE * sizeofSQLWCHAR; /* Current allocated size of the buffer, * in bytes */ SQLLEN colLen; /* Actual size of the return value, in bytes */ SQLINTEGER colLong; /* Integer value of the column */ SQLBIGINT colWide; /* Wide-integer value of the column */ SQLDOUBLE colDouble; /* Double value of the column */ Tcl_DString colDS; /* Column expressed as a Tcl_DString */ |
︙ | ︙ | |||
4150 4151 4152 4153 4154 4155 4156 | case SQL_BIGINT: convertWide: /* A wide integer */ colLen = sizeof(colWide); colWide = 0; rc = SQLGetData(rdata->hStmt, i+1, SQL_C_SBIGINT, (SQLPOINTER) &colWide, sizeof(colWide), &colLen); | | | | 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 | case SQL_BIGINT: convertWide: /* A wide integer */ colLen = sizeof(colWide); colWide = 0; rc = SQLGetData(rdata->hStmt, i+1, SQL_C_SBIGINT, (SQLPOINTER) &colWide, sizeof(colWide), &colLen); if (!SQL_SUCCEEDED(rc)) { char info[80]; sprintf(info, "(retrieving result set column #%d)\n", i+1); TransferSQLError(interp, SQL_HANDLE_STMT, rdata->hStmt, info); return TCL_ERROR; } if (colLen != SQL_NULL_DATA && colLen != SQL_NO_TOTAL) { colObj = Tcl_NewWideIntObj((Tcl_WideInt)colWide); } break; case SQL_BIT: case SQL_INTEGER: case SQL_SMALLINT: case SQL_TINYINT: convertLong: /* An integer no larger than 'long' */ colLen = sizeof(colLong); colLong = 0; rc = SQLGetData(rdata->hStmt, i+1, SQL_C_SLONG, (SQLPOINTER) &colLong, sizeof(colLong), &colLen); if (!SQL_SUCCEEDED(rc)) { char info[80]; sprintf(info, "(retrieving result set column #%d)\n", i+1); TransferSQLError(interp, SQL_HANDLE_STMT, rdata->hStmt, info); ckfree(info); return TCL_ERROR; } if (colLen != SQL_NULL_DATA && colLen != SQL_NO_TOTAL) { |
︙ | ︙ | |||
4204 4205 4206 4207 4208 4209 4210 | * A single- or double-precision floating point number. * Reals are widened to doubles. */ colLen = sizeof(colDouble); colDouble = 0.0; rc = SQLGetData(rdata->hStmt, i+1, SQL_C_DOUBLE, (SQLPOINTER) &colDouble, sizeof(colDouble), &colLen); | | | 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 | * A single- or double-precision floating point number. * Reals are widened to doubles. */ colLen = sizeof(colDouble); colDouble = 0.0; rc = SQLGetData(rdata->hStmt, i+1, SQL_C_DOUBLE, (SQLPOINTER) &colDouble, sizeof(colDouble), &colLen); if (!SQL_SUCCEEDED(rc)) { char info[80]; sprintf(info, "(retrieving result set column #%d)\n", i+1); TransferSQLError(interp, SQL_HANDLE_STMT, rdata->hStmt, info); ckfree(info); return TCL_ERROR; } if (colLen != SQL_NULL_DATA && colLen != SQL_NO_TOTAL) { |
︙ | ︙ | |||
4274 4275 4276 4277 4278 4279 4280 | */ offset = colAllocLen; if (dataType == SQL_C_BINARY) { /* no NULL terminator */ } else if (dataType == SQL_C_CHAR) { --offset; } else { | | | | | | | 4446 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 | */ offset = colAllocLen; if (dataType == SQL_C_BINARY) { /* no NULL terminator */ } else if (dataType == SQL_C_CHAR) { --offset; } else { offset -= sizeofSQLWCHAR; } if (colLen == SQL_NO_TOTAL) { /* * The driver wouldn't tell us how much space was * needed, but we got a full bufferload (less the * terminating NULL character) */ colAllocLen = 2 * colAllocLen; } else { colAllocLen += colLen; } if (colPtr == colBuf) { colPtr = (SQLCHAR*) ckalloc(colAllocLen + sizeofSQLWCHAR); memcpy(colPtr, colBuf, BUFSIZE * sizeofSQLWCHAR); } else { colPtr = (SQLCHAR*) ckrealloc((char*)colPtr, colAllocLen + sizeofSQLWCHAR); } retry = 1; } } while (retry); if (!SQL_SUCCEEDED(rc)) { char info[80]; sprintf(info, "(retrieving result set column #%d)\n", i+1); TransferSQLError(interp, SQL_HANDLE_STMT, rdata->hStmt, info); if (colPtr != colBuf) { ckfree((char*) colPtr); } return TCL_ERROR; |
︙ | ︙ | |||
4318 4319 4320 4321 4322 4323 4324 | if (dataType == SQL_C_CHAR) { Tcl_ExternalToUtfDString(NULL, (char*) colPtr, (int) (colLen + offset), &colDS); } else { DStringAppendWChars(&colDS, (SQLWCHAR*) colPtr, (int)((colLen + offset) | | | 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 | if (dataType == SQL_C_CHAR) { Tcl_ExternalToUtfDString(NULL, (char*) colPtr, (int) (colLen + offset), &colDS); } else { DStringAppendWChars(&colDS, (SQLWCHAR*) colPtr, (int)((colLen + offset) / sizeofSQLWCHAR)); } colObj = Tcl_NewStringObj(Tcl_DStringValue(&colDS), Tcl_DStringLength(&colDS)); Tcl_DStringFree(&colDS); } } if (colPtr != colBuf) { |
︙ | ︙ | |||
4527 4528 4529 4530 4531 4532 4533 | } flags[] = { { "-system", SQL_FETCH_FIRST_SYSTEM }, { "-user", SQL_FETCH_FIRST_USER }, { NULL, 0 } }; int flagIndex; SQLRETURN rc; /* SQL result code */ | | | 4699 4700 4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 | } flags[] = { { "-system", SQL_FETCH_FIRST_SYSTEM }, { "-user", SQL_FETCH_FIRST_USER }, { NULL, 0 } }; int flagIndex; SQLRETURN rc; /* SQL result code */ SQLWCHAR serverName[(SQL_MAX_DSN_LENGTH+1)*2]; /* Data source name */ SQLSMALLINT serverNameLen; /* Length of the DSN */ SQLWCHAR *description; /* Data source descroption */ SQLSMALLINT descLen; /* Length of the description */ SQLSMALLINT descAllocLen; /* Allocated size of the description */ SQLSMALLINT descLenNeeded; /* Length needed for the description */ Tcl_Obj* retval; /* Return value */ |
︙ | ︙ | |||
4569 4570 4571 4572 4573 4574 4575 | while (!finished) { direction = initDirection; finished = 1; descAllocLen = descLenNeeded; description = (SQLWCHAR*) | | | | 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773 4774 | while (!finished) { direction = initDirection; finished = 1; descAllocLen = descLenNeeded; description = (SQLWCHAR*) ckalloc(sizeofSQLWCHAR * (descAllocLen + 1)); Tcl_SetListObj(retval, 0, NULL); /* Enumerate the data sources */ while (1) { rc = SQLDataSourcesW(pidata->hEnv, direction, serverName, SQL_MAX_DSN_LENGTH + 1, &serverNameLen, description, descAllocLen, &descLen); direction = SQL_FETCH_NEXT; if (rc == SQL_SUCCESS_WITH_INFO && descLen > descLenNeeded) { /* The description buffer wasn't big enough. */ descLenNeeded = 2 * descLen; finished = 0; break; } else if (SQL_SUCCEEDED(rc)) { /* Got a data source; add key and value to the dictionary */ Tcl_DStringInit(&nameDS); DStringAppendWChars(&nameDS, serverName, serverNameLen); nameObj = Tcl_NewStringObj(Tcl_DStringValue(&nameDS), Tcl_DStringLength(&nameDS)); |
︙ | ︙ | |||
4700 4701 4702 4703 4704 4705 4706 | finished = 0; while (!finished) { finished = 1; driverAllocLen = driverLenNeeded; driver = (SQLWCHAR*) | | | | 4872 4873 4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 4884 4885 4886 4887 4888 4889 4890 | finished = 0; while (!finished) { finished = 1; driverAllocLen = driverLenNeeded; driver = (SQLWCHAR*) ckalloc(sizeofSQLWCHAR * (driverAllocLen + 1)); *driver = 0; attrAllocLen = attrLenNeeded; attributes = (SQLWCHAR*) ckalloc(sizeofSQLWCHAR * (attrAllocLen + 1)); *attributes = 0; Tcl_SetListObj(retval, 0, NULL); direction = SQL_FETCH_FIRST; /* Enumerate the data sources */ while (1) { |
︙ | ︙ | |||
4735 4736 4737 4738 4739 4740 4741 | attrLenNeeded = 2 * attrLen; finished = 0; break; } if (finished) { | | | 4907 4908 4909 4910 4911 4912 4913 4914 4915 4916 4917 4918 4919 4920 4921 | attrLenNeeded = 2 * attrLen; finished = 0; break; } if (finished) { if (SQL_SUCCEEDED(rc)) { /* Got a data source; add key and value to the dictionary */ Tcl_DStringInit(&nameDS); DStringAppendWChars(&nameDS, driver, driverLen); nameObj = Tcl_NewStringObj(Tcl_DStringValue(&nameDS), Tcl_DStringLength(&nameDS)); |
︙ | ︙ |