14 #if defined(SQLITE_HAS_CODEC) && defined(SQLITE_API) 15 #undef WITH_SQLITE_DLLS 20 #if defined(WITH_SQLITE_DLLS) && (WITH_SQLITE_DLLS > 1) 21 #define SQLITE_DYNLOAD 1 22 #undef HAVE_SQLITE3CLOSEV2 31 #if defined(_WIN32) || defined(_WIN64) 32 static void dls_init(
void);
33 static void dls_fini(
void);
39 static struct dl_sqlite3_funcs {
40 void (*activate_see)(
const char *p0);
41 int (*bind_blob)(sqlite3_stmt *p0,
int p1,
const void *p2,
int p3,
43 int (*bind_double)(sqlite3_stmt *p0,
int p1,
double p2);
44 int (*bind_int)(sqlite3_stmt *p0,
int p1,
int p2);
45 int (*bind_int64)(sqlite3_stmt *p0,
int p1, sqlite_int64 p2);
46 int (*bind_null)(sqlite3_stmt *p0,
int p1);
47 int (*bind_parameter_count)(sqlite3_stmt *p0);
48 int (*bind_text)(sqlite3_stmt *p0,
int p1,
const char *p2,
int p3,
50 int (*
busy_handler)(sqlite3 *p0, int (*p2)(
void *, int),
void *p3);
51 int (*changes)(sqlite3 *p0);
52 int (*close)(sqlite3 *p0);
53 const void * (*column_blob)(sqlite3_stmt *p0,
int p1);
54 int (*column_bytes)(sqlite3_stmt *p0,
int p1);
55 int (*column_count)(sqlite3_stmt *p0);
56 const char * (*column_database_name)(sqlite3_stmt *p0,
int p1);
57 const char * (*column_decltype)(sqlite3_stmt *p0,
int p1);
58 double (*column_double)(sqlite3_stmt *p0,
int p1);
59 const char * (*column_name)(sqlite3_stmt *p0,
int p1);
60 const char * (*column_origin_name)(sqlite3_stmt *p0,
int p1);
61 const char * (*column_table_name)(sqlite3_stmt *p0,
int p1);
62 const unsigned char * (*column_text)(sqlite3_stmt *p0,
int p1);
63 int (*column_type)(sqlite3_stmt *p0,
int p1);
64 int (*create_function)(sqlite3 *p0,
const char *p1,
int p2,
int p3,
66 void (*p5)(sqlite3_context *, int, sqlite3_value **),
67 void (*p6)(sqlite3_context *, int, sqlite3_value **),
68 void (*p7)(sqlite3_context *));
69 int (*enable_load_extension)(sqlite3 *p0,
int p1);
70 int (*errcode)(sqlite3 *p0);
71 const char * (*errmsg)(sqlite3 *p0);
72 int (*exec)(sqlite3 *p0,
const char *p1,
73 int (*p2)(
void *, int,
char **,
char **),
75 int (*finalize)(sqlite3_stmt *p0);
76 void (*free)(
void *p0);
77 void (*free_table)(
char **p0);
78 int (*get_table)(sqlite3 *p0,
const char *p1,
char ***p2,
79 int *p3,
int *p4,
char **p5);
80 void (*interrupt)(sqlite3 *p0);
81 int (*key)(sqlite3 *p0,
const void *p1,
int p2);
82 sqlite_int64 (*last_insert_rowid)(sqlite3 *p0);
83 const char * (*libversion)(void);
84 int (*load_extension)(sqlite3 *p0,
const char *p1,
const char *p2,
86 void * (*malloc)(
int p0);
87 char * (*mprintf)(
const char *p0, ...);
88 int (*open)(
const char *p0, sqlite3 **p1);
89 int (*open16)(
const void *p0, sqlite3 **p1);
90 int (*open_v2)(
const char *p0, sqlite3 **p1,
int p2,
const char *p3);
91 int (*prepare)(sqlite3 *p0,
const char *p1,
int p2, sqlite3_stmt **p3,
93 int (*prepare_v2)(sqlite3 *p0,
const char *p1,
int p2, sqlite3_stmt **p3,
95 void * (*profile)(sqlite3 *p0,
96 void (*p1)(
void *,
const char *, sqlite3_uint64),
98 void * (*realloc)(
void *p0,
int p1);
99 int (*rekey)(sqlite3 *p0,
const void *p1,
int p2);
100 int (*reset)(sqlite3_stmt *p0);
101 void (*result_blob)(sqlite3_context *p0,
const void *p1,
102 int p2, void (*p3)(
void *));
103 void (*result_error)(sqlite3_context *p0,
const char *p1,
int p2);
104 void (*result_int)(sqlite3_context *p0,
int p1);
105 void (*result_null)(sqlite3_context *p0);
106 int (*step)(sqlite3_stmt *p0);
107 int (*xstrnicmp)(
const char *p0,
const char *p1,
int p2);
108 int (*table_column_metadata)(sqlite3 *p0,
const char *p1,
109 const char *p2,
const char *p3,
110 char const **p4,
char const **p5,
111 int *p6,
int *p7,
int *p8);
112 void * (*trace)(sqlite3 *p0, void (*p1)(
void *,
const char *),
void *p2);
113 void * (*user_data)(sqlite3_context *p0);
114 const void * (*value_blob)(sqlite3_value *p0);
115 int (*value_bytes)(sqlite3_value *p0);
116 const unsigned char * (*value_text)(sqlite3_value *p0);
117 int (*value_type)(sqlite3_value *p0);
120 #define sqlite3_activate_see dls_funcs.activate_see 121 #define sqlite3_bind_blob dls_funcs.bind_blob 122 #define sqlite3_bind_double dls_funcs.bind_double 123 #define sqlite3_bind_int dls_funcs.bind_int 124 #define sqlite3_bind_int64 dls_funcs.bind_int64 125 #define sqlite3_bind_null dls_funcs.bind_null 126 #define sqlite3_bind_parameter_count dls_funcs.bind_parameter_count 127 #define sqlite3_bind_text dls_funcs.bind_text 128 #define sqlite3_busy_handler dls_funcs.busy_handler 129 #define sqlite3_changes dls_funcs.changes 130 #define sqlite3_close dls_funcs.close 131 #define sqlite3_column_blob dls_funcs.column_blob 132 #define sqlite3_column_bytes dls_funcs.column_bytes 133 #define sqlite3_column_count dls_funcs.column_count 134 #define sqlite3_column_database_name dls_funcs.column_database_name 135 #define sqlite3_column_decltype dls_funcs.column_decltype 136 #define sqlite3_column_double dls_funcs.column_double 137 #define sqlite3_column_name dls_funcs.column_name 138 #define sqlite3_column_origin_name dls_funcs.column_origin_name 139 #define sqlite3_column_table_name dls_funcs.column_table_name 140 #define sqlite3_column_text dls_funcs.column_text 141 #define sqlite3_column_type dls_funcs.column_type 142 #define sqlite3_create_function dls_funcs.create_function 143 #define sqlite3_enable_load_extension dls_funcs.enable_load_extension 144 #define sqlite3_errcode dls_funcs.errcode 145 #define sqlite3_errmsg dls_funcs.errmsg 146 #define sqlite3_exec dls_funcs.exec 147 #define sqlite3_finalize dls_funcs.finalize 148 #define sqlite3_free dls_funcs.free 149 #define sqlite3_free_table dls_funcs.free_table 150 #define sqlite3_get_table dls_funcs.get_table 151 #define sqlite3_interrupt dls_funcs.interrupt 152 #define sqlite3_key dls_funcs.key 153 #define sqlite3_last_insert_rowid dls_funcs.last_insert_rowid 154 #define sqlite3_libversion dls_funcs.libversion 155 #define sqlite3_load_extension dls_funcs.load_extension 156 #define sqlite3_malloc dls_funcs.malloc 157 #define sqlite3_mprintf dls_funcs.mprintf 158 #define sqlite3_open dls_funcs.open 159 #define sqlite3_open16 dls_funcs.open16 160 #define sqlite3_open_v2 dls_funcs.open_v2 161 #define sqlite3_prepare dls_funcs.prepare 162 #define sqlite3_prepare_v2 dls_funcs.prepare_v2 163 #define sqlite3_profile dls_funcs.profile 164 #define sqlite3_realloc dls_funcs.realloc 165 #define sqlite3_rekey dls_funcs.rekey 166 #define sqlite3_reset dls_funcs.reset 167 #define sqlite3_result_blob dls_funcs.result_blob 168 #define sqlite3_result_error dls_funcs.result_error 169 #define sqlite3_result_int dls_funcs.result_int 170 #define sqlite3_result_null dls_funcs.result_null 171 #define sqlite3_step dls_funcs.step 172 #define sqlite3_strnicmp dls_funcs.xstrnicmp 173 #define sqlite3_table_column_metadata dls_funcs.table_column_metadata 174 #define sqlite3_trace dls_funcs.trace 175 #define sqlite3_user_data dls_funcs.user_data 176 #define sqlite3_value_blob dls_funcs.value_blob 177 #define sqlite3_value_bytes dls_funcs.value_bytes 178 #define sqlite3_value_text dls_funcs.value_text 179 #define sqlite3_value_type dls_funcs.value_type 183 #ifndef WITHOUT_WINTERFACE 188 #if !defined(_WIN32) && !defined(_WIN64) 189 #if !defined(WCHARSUPPORT) && defined(HAVE_SQLWCHAR) && (HAVE_SQLWCHAR) 194 #if defined(WINTERFACE) 195 #include <sqlucode.h> 198 #if defined(_WIN32) || defined(_WIN64) 199 #include "resource3.h" 200 #define ODBC_INI "ODBC.INI" 201 #ifndef DRIVER_VER_INFO 202 #define DRIVER_VER_INFO VERSION 205 #define ODBC_INI ".odbc.ini" 208 #ifndef DRIVER_VER_INFO 209 #define DRIVER_VER_INFO "0.0" 212 #ifndef COLATTRIBUTE_LAST_ARG_TYPE 214 #define COLATTRIBUTE_LAST_ARG_TYPE SQLLEN * 216 #define COLATTRIBUTE_LAST_ARG_TYPE SQLPOINTER 220 #ifndef SETSTMTOPTION_LAST_ARG_TYPE 221 #define SETSTMTOPTION_LAST_ARG_TYPE SQLROWCOUNT 225 #define min(a, b) ((a) < (b) ? (a) : (b)) 227 #define max(a, b) ((a) < (b) ? (b) : (a)) 230 #define PTRDIFF_T int 233 #define array_size(x) (sizeof (x) / sizeof (x[0])) 235 #define stringify1(s) #s 236 #define stringify(s) stringify1(s) 238 #define verinfo(maj, min, lev) ((maj) << 16 | (min) << 8 | (lev)) 242 #if defined(HAVE_SQLITE3TABLECOLUMNMETADATA) && (HAVE_SQLITE3TABLECOLUMNMETADATA) 243 #if defined(HAVE_SQLITE3COLUMNDATABASENAME) && (HAVE_SQLITE3COLUMNDATABASENAME) 244 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME) 245 #if defined(HAVE_SQLITE3COLUMNORIGINNAME) && (HAVE_SQLITE3COLUMNORIGINNAME) 246 #define FULL_METADATA 1 254 #if defined(WINTERFACE) && !defined(_WIN32) && !defined(_WIN64) 255 #define SCOL_VARCHAR SQL_WVARCHAR 256 #define SCOL_CHAR SQL_WCHAR 258 #define SCOL_VARCHAR SQL_VARCHAR 259 #define SCOL_CHAR SQL_CHAR 262 #define ENV_MAGIC 0x53544145 263 #define DBC_MAGIC 0x53544144 264 #define DEAD_MAGIC 0xdeadbeef 279 static const char *
xdigits =
"0123456789ABCDEFabcdef";
284 xmalloc_(
int n,
char *file,
int line)
286 int nn = n + 4 *
sizeof (long);
291 #if (MEMORY_DEBUG > 1) 292 fprintf(stderr,
"malloc\t%d\tNULL\t%s:%d\n", n, file, line);
297 nn = nn /
sizeof (long) - 1;
300 #if (MEMORY_DEBUG > 1) 301 fprintf(stderr,
"malloc\t%d\t%p\t%s:%d\n", n, &p[2], file, line);
303 return (
void *) &p[2];
307 xrealloc_(
void *old,
int n,
char *file,
int line)
309 int nn = n + 4 *
sizeof (long), nnn;
312 if (n == 0 || !old) {
313 return xmalloc_(n, file, line);
315 p = &((
long *) old)[-2];
316 if (p[0] != 0xdead1234) {
317 fprintf(stderr,
"*** low end corruption @ %p\n", old);
320 nnn = p[1] + 4 *
sizeof (long);
321 nnn = nnn /
sizeof (long) - 1;
322 if (p[nnn] != 0xdead5678) {
323 fprintf(stderr,
"*** high end corruption @ %p\n", old);
328 #if (MEMORY_DEBUG > 1) 329 fprintf(stderr,
"realloc\t%p,%d\tNULL\t%s:%d\n", old, n, file, line);
333 #if (MEMORY_DEBUG > 1) 334 fprintf(stderr,
"realloc\t%p,%d\t%p\t%s:%d\n", old, n, &pp[2], file, line);
338 nn = nn /
sizeof (long) - 1;
340 return (
void *) &p[2];
344 xfree_(
void *x,
char *file,
int line)
352 p = &((
long *) x)[-2];
353 if (p[0] != 0xdead1234) {
354 fprintf(stderr,
"*** low end corruption @ %p\n", x);
357 n = p[1] + 4 *
sizeof (long);
358 n = n /
sizeof (long) - 1;
359 if (p[n] != 0xdead5678) {
360 fprintf(stderr,
"*** high end corruption @ %p\n", x);
363 #if (MEMORY_DEBUG > 1) 364 fprintf(stderr,
"free\t%p\t\t%s:%d\n", x, file, line);
372 xfree_(x,
"unknown location", 0);
376 xstrdup_(
const char *str,
char *file,
int line)
381 #if (MEMORY_DEBUG > 1) 382 fprintf(stderr,
"strdup\tNULL\tNULL\t%s:%d\n", file, line);
386 p = xmalloc_(strlen(str) + 1, file, line);
390 #if (MEMORY_DEBUG > 1) 391 fprintf(stderr,
"strdup\t%p\t%p\t%s:%d\n", str, p, file, line);
396 #define xmalloc(x) xmalloc_(x, __FILE__, __LINE__) 397 #define xrealloc(x,y) xrealloc_(x, y, __FILE__, __LINE__) 398 #define xfree(x) xfree_(x, __FILE__, __LINE__) 399 #define xstrdup(x) xstrdup_(x, __FILE__, __LINE__) 403 #define xmalloc(x) sqlite3_malloc(x) 404 #define xrealloc(x,y) sqlite3_realloc(x, y) 405 #define xfree(x) sqlite3_free(x) 406 #define xstrdup(x) strdup_(x) 410 #if defined(_WIN32) || defined(_WIN64) 412 #define vsnprintf _vsnprintf 413 #define snprintf _snprintf 414 #define strcasecmp _stricmp 415 #define strncasecmp _strnicmp 418 #define strtoll _strtoi64 419 #define strtoull _strtoui64 422 static HINSTANCE NEAR hModule;
426 #ifdef HAVE_SQLITE3STRNICMP 428 #define strncasecmp(A,B,C) sqlite3_strnicmp(A,B,C) 430 #define strcasecmp(A,B) strcasecmp_(A,B) 432 #if defined(__GNUC__) && (__GNUC__ >= 2) 433 static int strcasecmp_(
const char *a,
const char *b)
434 __attribute__((__unused__));
437 static int strcasecmp_(
const char *a,
const char *b)
439 int c = strlen(a), d = strlen(b);
442 return strncasecmp(a, b, c);
444 return strncasecmp(a, b, d);
448 #if defined(_WIN32) || defined(_WIN64) 456 #define HDBC_LOCK(hdbc) \ 460 if ((hdbc) == SQL_NULL_HDBC) { \ 461 return SQL_INVALID_HANDLE; \ 463 d = (DBC *) (hdbc); \ 464 if (d->magic != DBC_MAGIC) { \ 465 return SQL_INVALID_HANDLE; \ 467 EnterCriticalSection(&d->cs); \ 468 d->owner = GetCurrentThreadId(); \ 471 #define HDBC_UNLOCK(hdbc) \ 472 if ((hdbc) != SQL_NULL_HDBC) { \ 475 d = (DBC *) (hdbc); \ 476 if (d->magic == DBC_MAGIC) { \ 478 LeaveCriticalSection(&d->cs); \ 482 #define HSTMT_LOCK(hstmt) \ 486 if ((hstmt) == SQL_NULL_HSTMT) { \ 487 return SQL_INVALID_HANDLE; \ 489 d = (DBC *) ((STMT *) (hstmt))->dbc; \ 490 if (d->magic != DBC_MAGIC) { \ 491 return SQL_INVALID_HANDLE; \ 493 EnterCriticalSection(&d->cs); \ 494 d->owner = GetCurrentThreadId(); \ 497 #define HSTMT_UNLOCK(hstmt) \ 498 if ((hstmt) != SQL_NULL_HSTMT) { \ 501 d = (DBC *) ((STMT *) (hstmt))->dbc; \ 502 if (d->magic == DBC_MAGIC) { \ 504 LeaveCriticalSection(&d->cs); \ 530 #define HDBC_LOCK(hdbc) 531 #define HDBC_UNLOCK(hdbc) 532 #define HSTMT_LOCK(hdbc) 533 #define HSTMT_UNLOCK(hdbc) 537 #if defined(ENABLE_NVFS) && (ENABLE_NVFS) 538 extern void nvfs_init(
void);
539 extern const char *nvfs_makevfs(
const char *);
553 char *p = strchr(upper_chars, c);
569 ((c) && strchr(digit_chars, (c)) != NULL) 578 ((c) && strchr(space_chars, (c)) != NULL) 599 static SQLRETURN
getrowdata(
STMT *s, SQLUSMALLINT col, SQLSMALLINT otype,
600 SQLPOINTER val, SQLINTEGER len,
SQLLEN *lenp,
603 #if (defined(_WIN32) || defined(_WIN64)) && defined(WINTERFACE) 605 static COL *statSpec2P, *statSpec3P;
608 #if (MEMORY_DEBUG < 1) 663 if (dsp->
len + len > dsp->
max) {
664 int max = dsp->
max + len + 256;
668 strcpy(dsp->
buffer,
"OUT OF MEMORY");
700 for (p = str; *p; ++p) {
722 if (dsp->
len + len > dsp->
max) {
723 int max = dsp->
max + len + 256;
727 strcpy(dsp->
buffer,
"OUT OF MEMORY");
736 for (p = str, q = dsp->
buffer + dsp->
len; *p; ++p) {
757 return (
const char *) dsp->
buffer;
771 return !dsp || dsp->
oom;
846 ucLen = ucLen /
sizeof (SQLWCHAR);
847 if (!uc || ucLen < 0) {
857 while (i < len && *str && i < ucLen) {
858 unsigned char c = str[0];
863 }
else if (c <= 0xc1 || c >= 0xf5) {
866 }
else if (c < 0xe0) {
867 if ((str[1] & 0xc0) == 0x80) {
868 unsigned long t = ((c & 0x1f) << 6) | (str[1] & 0x3f);
876 }
else if (c < 0xf0) {
877 if ((str[1] & 0xc0) == 0x80 && (str[2] & 0xc0) == 0x80) {
878 unsigned long t = ((c & 0x0f) << 12) |
879 ((str[1] & 0x3f) << 6) | (str[2] & 0x3f);
887 }
else if (c < 0xf8) {
888 if ((str[1] & 0xc0) == 0x80 && (str[2] & 0xc0) == 0x80 &&
889 (str[3] & 0xc0) == 0x80) {
890 unsigned long t = ((c & 0x03) << 18) |
891 ((str[1] & 0x3f) << 12) | ((str[2] & 0x3f) << 6) |
894 if (
sizeof (SQLWCHAR) == 2 *
sizeof (char) &&
897 uc[i++] = 0xd800 | ((t >> 10) & 0x3ff);
901 t = 0xdc00 | (t & 0x3ff);
909 }
else if (c < 0xfc) {
910 if ((str[1] & 0xc0) == 0x80 && (str[2] & 0xc0) == 0x80 &&
911 (str[3] & 0xc0) == 0x80 && (str[4] & 0xc0) == 0x80) {
912 unsigned long t = ((c & 0x01) << 24) |
913 ((str[1] & 0x3f) << 18) | ((str[2] & 0x3f) << 12) |
914 ((str[3] & 0x3f) << 6) | (str[4] & 0x3f);
916 if (
sizeof (SQLWCHAR) == 2 *
sizeof (char) &&
919 uc[i++] = 0xd800 | ((t >> 10) & 0x3ff);
923 t = 0xdc00 | (t & 0x3ff);
956 if (len == SQL_NTS) {
957 len = strlen((
char *) str);
959 ucLen =
sizeof (SQLWCHAR) * (len + 1);
979 char *cp, *ret = NULL;
984 if (len == SQL_NTS) {
987 len = len /
sizeof (SQLWCHAR);
994 for (i = 0; i < len; i++) {
995 unsigned long c = str[i];
997 if (
sizeof (SQLWCHAR) == 2 *
sizeof (
char)) {
1002 }
else if (c < 0x800) {
1003 *cp++ = 0xc0 | ((c >> 6) & 0x1f);
1004 *cp++ = 0x80 | (c & 0x3f);
1005 }
else if (c < 0x10000) {
1006 if (
sizeof (SQLWCHAR) == 2 *
sizeof (char) &&
1007 c >= 0xd800 && c <= 0xdbff && i + 1 < len) {
1008 unsigned long c2 = str[i + 1] & 0xffff;
1010 if (c2 >= 0xdc00 && c2 <= 0xdfff) {
1011 c = (((c & 0x3ff) << 10) | (c2 & 0x3ff)) + 0x10000;
1012 *cp++ = 0xf0 | ((c >> 18) & 0x07);
1013 *cp++ = 0x80 | ((c >> 12) & 0x3f);
1014 *cp++ = 0x80 | ((c >> 6) & 0x3f);
1015 *cp++ = 0x80 | (c & 0x3f);
1020 *cp++ = 0xe0 | ((c >> 12) & 0x0f);
1021 *cp++ = 0x80 | ((c >> 6) & 0x3f);
1022 *cp++ = 0x80 | (c & 0x3f);
1023 }
else if (c < 0x200000) {
1024 *cp++ = 0xf0 | ((c >> 18) & 0x07);
1025 *cp++ = 0x80 | ((c >> 12) & 0x3f);
1026 *cp++ = 0x80 | ((c >> 6) & 0x3f);
1027 *cp++ = 0x80 | (c & 0x3f);
1028 }
else if (c < 0x4000000) {
1029 *cp++ = 0xf8 | ((c >> 24) & 0x03);
1030 *cp++ = 0x80 | ((c >> 18) & 0x3f);
1031 *cp++ = 0x80 | ((c >> 12) & 0x3f);
1032 *cp++ = 0x80 | ((c >> 6) & 0x3f);
1033 *cp++ = 0x80 | (c & 0x3f);
1034 }
else if (c < 0x80000000) {
1035 *cp++ = 0xfc | ((c >> 31) & 0x01);
1036 *cp++ = 0x80 | ((c >> 24) & 0x3f);
1037 *cp++ = 0x80 | ((c >> 18) & 0x3f);
1038 *cp++ = 0x80 | ((c >> 12) & 0x3f);
1039 *cp++ = 0x80 | ((c >> 6) & 0x3f);
1040 *cp++ = 0x80 | (c & 0x3f);
1061 if (len != SQL_NTS) {
1062 len = len *
sizeof (SQLWCHAR);
1069 #if defined(WCHARSUPPORT) || defined(_WIN32) || defined(_WIN64) 1086 #if defined(_WIN32) || defined(_WIN64) 1096 wmb_to_utf(
char *str,
int len)
1100 int nchar, is2k, cp = CP_OEMCP;
1102 ovi.dwOSVersionInfoSize =
sizeof (ovi);
1104 is2k = ovi.dwPlatformId == VER_PLATFORM_WIN32_NT && ovi.dwMajorVersion > 4;
1105 if (AreFileApisANSI()) {
1106 cp = is2k ? CP_THREAD_ACP : CP_ACP;
1108 nchar = MultiByteToWideChar(cp, 0, str, len, NULL, 0);
1109 wstr =
xmalloc((nchar + 1) *
sizeof (WCHAR));
1114 nchar = MultiByteToWideChar(cp, 0, str, len, wstr, nchar);
1116 str =
xmalloc((nchar + 1) * 7);
1122 nchar = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, str, nchar * 7, 0, 0);
1138 wmb_to_utf_c(
char *str,
int len)
1140 if (len == SQL_NTS) {
1143 return wmb_to_utf(str, len);
1156 utf_to_wmb(
char *str,
int len)
1160 int nchar, is2k, cp = CP_OEMCP;
1162 ovi.dwOSVersionInfoSize =
sizeof (ovi);
1164 is2k = ovi.dwPlatformId == VER_PLATFORM_WIN32_NT && ovi.dwMajorVersion > 4;
1165 if (AreFileApisANSI()) {
1166 cp = is2k ? CP_THREAD_ACP : CP_ACP;
1168 nchar = MultiByteToWideChar(CP_UTF8, 0, str, len, NULL, 0);
1169 wstr =
xmalloc((nchar + 1) *
sizeof (WCHAR));
1174 nchar = MultiByteToWideChar(CP_UTF8, 0, str, len, wstr, nchar);
1176 str =
xmalloc((nchar + 1) * 7);
1182 nchar = WideCharToMultiByte(cp, 0, wstr, -1, str, nchar * 7, 0, 0);
1198 wmb_to_uc(
char *str,
int len)
1202 int nchar, is2k, cp = CP_OEMCP;
1204 ovi.dwOSVersionInfoSize =
sizeof (ovi);
1206 is2k = ovi.dwPlatformId == VER_PLATFORM_WIN32_NT && ovi.dwMajorVersion > 4;
1207 if (AreFileApisANSI()) {
1208 cp = is2k ? CP_THREAD_ACP : CP_ACP;
1210 nchar = MultiByteToWideChar(cp, 0, str, len, NULL, 0);
1211 wstr =
xmalloc((nchar + 1) *
sizeof (WCHAR));
1216 nchar = MultiByteToWideChar(cp, 0, str, len, wstr, nchar);
1229 uc_to_wmb(WCHAR *wstr,
int len)
1233 int nchar, is2k, cp = CP_OEMCP;
1235 ovi.dwOSVersionInfoSize =
sizeof (ovi);
1237 is2k = ovi.dwPlatformId == VER_PLATFORM_WIN32_NT && ovi.dwMajorVersion > 4;
1238 if (AreFileApisANSI()) {
1239 cp = is2k ? CP_THREAD_ACP : CP_ACP;
1241 nchar = WideCharToMultiByte(cp, 0, wstr, len, NULL, 0, 0, 0);
1242 str =
xmalloc((nchar + 1) * 2);
1247 nchar = WideCharToMultiByte(cp, 0, wstr, len, str, nchar * 2, 0, 0);
1257 #ifdef USE_DLOPEN_FOR_GPPS 1261 #define SQLGetPrivateProfileString(A,B,C,D,E,F) drvgpps(d,A,B,C,D,E,F) 1276 lib = dlopen(
"libodbcinst.so.2", RTLD_LAZY);
1278 lib = dlopen(
"libodbcinst.so.1", RTLD_LAZY);
1281 lib = dlopen(
"libodbcinst.so", RTLD_LAZY);
1284 lib = dlopen(
"libiodbcinst.so.2", RTLD_LAZY);
1287 lib = dlopen(
"libiodbcinst.so", RTLD_LAZY);
1290 gpps = (int (*)()) dlsym(lib,
"SQLGetPrivateProfileString");
1304 dlclose(d->instlib);
1310 drvgpps(
DBC *d,
char *sect,
char *ent,
char *def,
char *buf,
1311 int bufsiz,
char *fname)
1314 return d->gpps(sect, ent, def, buf, bufsiz, fname);
1316 strncpy(buf, def, bufsiz);
1317 buf[bufsiz - 1] =
'\0';
1321 #include <odbcinst.h> 1322 #define drvgetgpps(d) 1323 #define drvrelgpps(d) 1335 if (stmt && p && nparams > 0) {
1336 for (i = 0; i < nparams; i++, p++) {
1340 sqlite3_bind_null(stmt, i + 1);
1342 fprintf(d->
trace,
"-- parameter %d: NULL\n", i + 1);
1347 sqlite3_bind_text(stmt, i + 1, p->
s3val, p->
s3size,
1350 fprintf(d->
trace,
"-- parameter %d: '%*s'\n", i + 1,
1356 sqlite3_bind_blob(stmt, i + 1, p->
s3val, p->
s3size,
1359 fprintf(d->
trace,
"-- parameter %d: [BLOB]'\n", i + 1);
1364 sqlite3_bind_double(stmt, i + 1, p->
s3dval);
1366 fprintf(d->
trace,
"-- parameter %d: %g\n",
1371 case SQLITE_INTEGER:
1372 if (p->
s3size > sizeof (
int)) {
1373 sqlite3_bind_int64(stmt, i + 1, p->
s3lival);
1377 "-- parameter %d: %I64d\n",
1379 "-- parameter %d: %lld\n",
1385 sqlite3_bind_int(stmt, i + 1, p->
s3ival);
1387 fprintf(d->
trace,
"-- parameter %d: %d\n",
1429 if (t->
nrow == 0 && rc == SQLITE_ROW) {
1436 int nalloc = t->
nalloc * 2 + need + 1;
1441 t->
rc = SQLITE_NOMEM;
1450 for (i = 0; i < ncol; i++) {
1451 p = (
char *) sqlite3_column_name(t->
stmt, i);
1453 char *q =
xmalloc(strlen(p) + 1);
1470 }
else if (t->
ncol != ncol) {
1471 t->
errmsg = sqlite3_mprintf(
"drvgettable() called with two or" 1472 " more incompatible queries");
1473 t->
rc = SQLITE_ERROR;
1477 if (rc == SQLITE_ROW) {
1478 for (i = 0; i < ncol; i++) {
1479 int coltype = sqlite3_column_type(t->
stmt, i);
1482 if (coltype == SQLITE_BLOB) {
1483 int k, nbytes = sqlite3_column_bytes(t->
stmt, i);
1485 unsigned const char *bp;
1487 bp = sqlite3_column_blob(t->
stmt, i);
1495 for (k = 0; k < nbytes; k++) {
1496 *qp++ =
xdigits[(bp[k] >> 4)];
1497 *qp++ =
xdigits[(bp[k] & 0xF)];
1502 }
else if (coltype == SQLITE_FLOAT) {
1503 static struct lconv *lc = 0;
1504 double val = sqlite3_column_double(t->
stmt, i);
1512 snprintf(buffer,
sizeof (buffer),
"%.15g", val);
1516 if (lc && lc->decimal_point && lc->decimal_point[0] &&
1517 lc->decimal_point[0] !=
'.') {
1518 p = strchr(buffer, lc->decimal_point[0]);
1528 }
else if (coltype != SQLITE_NULL) {
1529 p =
xstrdup((
char *) sqlite3_column_text(t->
stmt, i));
1543 int *ncolp,
char **errp,
int nparam,
BINDPARM *p)
1546 int rc = SQLITE_OK, keep = sql == NULL;
1548 const char *sqlleft = 0;
1549 int nretry = 0, haveerr = 0;
1552 return SQLITE_ERROR;
1566 tres.rc = SQLITE_OK;
1567 tres.resarr =
xmalloc(
sizeof (
char *) * tres.nalloc);
1571 return SQLITE_NOMEM;
1576 if (tres.stmt == NULL) {
1577 return SQLITE_NOMEM;
1581 while (sql && *sql && (rc == SQLITE_OK ||
1582 (rc == SQLITE_SCHEMA && (++nretry) < 2))) {
1586 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 1588 rc = sqlite3_prepare_v2(d->
sqlite, sql, -1, &tres.stmt, &sqlleft);
1591 rc = sqlite3_prepare(d->
sqlite, sql, -1, &tres.stmt, &sqlleft);
1593 if (rc != SQLITE_OK) {
1596 sqlite3_finalize(tres.stmt);
1607 if (sqlite3_bind_parameter_count(tres.stmt) != nparam) {
1610 sqlite3_mprintf(
"%s",
"parameter marker count incorrect");
1617 ncol = sqlite3_column_count(tres.stmt);
1623 rc = sqlite3_step(tres.stmt);
1624 if (rc == SQLITE_ROW || rc == SQLITE_DONE) {
1630 if (rc != SQLITE_ROW) {
1633 rc = sqlite3_reset(tres.stmt);
1637 rc = sqlite3_finalize(tres.stmt);
1640 if (rc != SQLITE_SCHEMA) {
1643 while (sql &&
ISSPACE(*sql)) {
1647 if (rc == SQLITE_DONE) {
1659 sqlite3_reset(tres.stmt);
1664 sqlite3_finalize(tres.stmt);
1669 }
else if (rc != SQLITE_OK && rc == sqlite3_errcode(d->
sqlite) && errp) {
1670 *errp = sqlite3_mprintf(
"%s", sqlite3_errmsg(d->
sqlite));
1675 tres.resarr[0] = (
char *) (tres.ndata - 1);
1677 if (rc == SQLITE_ABORT) {
1682 sqlite3_free(*errp);
1684 *errp = tres.errmsg;
1686 sqlite3_free(tres.errmsg);
1691 sqlite3_free(tres.errmsg);
1692 if (rc != SQLITE_OK) {
1696 *resp = &tres.resarr[1];
1714 #if defined(__GNUC__) && (__GNUC__ >= 2) 1715 static void setstatd(
DBC *,
int,
char *,
char *, ...)
1716 __attribute__((format (printf, 3, 5)));
1733 count = vsnprintf((
char *) d->
logmsg, sizeof (d->
logmsg), msg, ap);
1754 #if defined(__GNUC__) && (__GNUC__ >= 2) 1755 static void setstat(
STMT *,
int,
char *,
char *, ...)
1756 __attribute__((format (printf, 3, 5)));
1773 count = vsnprintf((
char *) s->
logmsg, sizeof (s->
logmsg), msg, ap);
1797 if (dbc == SQL_NULL_HDBC) {
1798 return SQL_INVALID_HANDLE;
1801 setstatd(d, -1,
"not supported",
"IM001");
1816 if (stmt == SQL_NULL_HSTMT) {
1817 return SQL_INVALID_HANDLE;
1820 setstat(s, -1,
"not supported",
"IM001");
1832 if (x && ((
char **) x)[0]) {
1833 xfree(((
char **) x)[0]);
1834 ((
char **) x)[0] = NULL;
1847 setstat(s, -1,
"out of memory", (*s->
ov3) ?
"HY000" :
"S1000");
1860 setstat(s, -1,
"not connected", (*s->
ov3) ?
"HY000" :
"S1000");
1871 #if defined(HAVE_LOCALECONV) || defined(_WIN32) || defined(_WIN64) 1876 static struct lconv *lc = 0;
1877 char buf[128], *p, *end;
1883 if (lc && lc->decimal_point && lc->decimal_point[0] &&
1884 lc->decimal_point[0] !=
'.') {
1885 strncpy(buf, data,
sizeof (buf) - 1);
1886 buf[
sizeof (buf) - 1] =
'\0';
1887 p = strchr(buf,
'.');
1889 *p = lc->decimal_point[0];
1895 value = strtod(p, &end);
1896 end = (
char *) data + (end - p);
1905 #define ln_strtod(A,B) strtod(A,B) 1918 int len = strlen(str);
1923 if ((str[0] ==
'\'' && str[end] ==
'\'') ||
1924 (str[0] ==
'"' && str[end] ==
'"') ||
1925 (str[0] ==
'[' && str[end] ==
']')) {
1926 memmove(str, str + 1, end - 1);
1927 str[end - 1] =
'\0';
1948 while ((q = strchr(p,
'_')) != NULL) {
1949 if (q == str || q[-1] !=
'\\') {
1955 while ((q = strchr(p,
'%')) != NULL) {
1956 if (q == str || q[-1] !=
'\\') {
1962 while ((q = strchr(p,
'\\')) != NULL) {
1963 if (q[1] ==
'\\' || q[1] ==
'_' || q[1] ==
'%') {
1964 memmove(q, q + 1, strlen(q));
1992 if (*str ==
'\0' && cp !=
'%') {
1996 while (*pat ==
'%') {
2004 if (cp !=
'_' && cp !=
'\\') {
2028 if (esc && cp ==
'\\' &&
2029 (pat[1] ==
'\\' || pat[1] ==
'%' || pat[1] ==
'_')) {
2058 #if !defined(_WIN32) && !defined(_WIN64) 2060 #ifdef HAVE_NANOSLEEP 2073 #if defined(_WIN32) || defined(_WIN64) 2074 d->
t0 = GetTickCount();
2076 gettimeofday(&tv, NULL);
2077 d->
t0 = tv.tv_sec * 1000 + tv.tv_usec / 1000;
2080 #if defined(_WIN32) || defined(_WIN64) 2081 t1 = GetTickCount();
2083 gettimeofday(&tv, NULL);
2084 t1 = tv.tv_sec * 1000 + tv.tv_usec / 1000;
2089 #if defined(_WIN32) || defined(_WIN64) 2092 #ifdef HAVE_NANOSLEEP 2094 ts.tv_nsec = 10000000;
2096 ret = nanosleep(&ts, &ts);
2097 if (ret < 0 && errno != EINTR) {
2107 select(0, NULL, NULL, NULL, &tv);
2130 int count = 0, step = 0,
max, rc = SQLITE_ERROR;
2132 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME) 2140 while (step <
max) {
2142 rc = sqlite3_exec(x,
"PRAGMA empty_result_callbacks = on;",
2144 if (rc == SQLITE_OK) {
2146 "PRAGMA foreign_keys = on;" :
2147 "PRAGMA foreign_keys = off;",
2150 }
else if (step < 2) {
2152 "PRAGMA full_column_names = off;" :
2153 "PRAGMA full_column_names = on;",
2155 }
else if (step < 3) {
2157 "PRAGMA short_column_names = on;" :
2158 "PRAGMA short_column_names = off;",
2161 if (rc != SQLITE_OK) {
2162 if (rc != SQLITE_BUSY ||
2194 for (i = 1; i <= size; i++) {
2211 mapsqltype(
const char *
typename,
int *nosign,
int ov3,
int nowchar,
2215 int testsign = 0, result;
2218 result = nowchar ? SQL_VARCHAR : SQL_WVARCHAR;
2220 result = SQL_VARCHAR;
2225 q = p =
xmalloc(strlen(
typename) + 1);
2229 strcpy(p,
typename);
2234 if (strncmp(p,
"inter", 5) == 0) {
2235 }
else if (strncmp(p,
"int", 3) == 0 ||
2236 strncmp(p,
"mediumint", 9) == 0) {
2238 result = SQL_INTEGER;
2239 }
else if (strncmp(p,
"numeric", 7) == 0) {
2240 result = SQL_DOUBLE;
2241 }
else if (strncmp(p,
"tinyint", 7) == 0) {
2243 result = SQL_TINYINT;
2244 }
else if (strncmp(p,
"smallint", 8) == 0) {
2246 result = SQL_SMALLINT;
2247 }
else if (strncmp(p,
"float", 5) == 0) {
2248 result = SQL_DOUBLE;
2249 }
else if (strncmp(p,
"double", 6) == 0 ||
2250 strncmp(p,
"real", 4) == 0) {
2251 result = SQL_DOUBLE;
2252 }
else if (strncmp(p,
"timestamp", 9) == 0) {
2253 #ifdef SQL_TYPE_TIMESTAMP 2254 result = ov3 ? SQL_TYPE_TIMESTAMP : SQL_TIMESTAMP;
2256 result = SQL_TIMESTAMP;
2258 }
else if (strncmp(p,
"datetime", 8) == 0) {
2259 #ifdef SQL_TYPE_TIMESTAMP 2260 result = ov3 ? SQL_TYPE_TIMESTAMP : SQL_TIMESTAMP;
2262 result = SQL_TIMESTAMP;
2264 }
else if (strncmp(p,
"time", 4) == 0) {
2265 #ifdef SQL_TYPE_TIME 2266 result = ov3 ? SQL_TYPE_TIME : SQL_TIME;
2270 }
else if (strncmp(p,
"date", 4) == 0) {
2271 #ifdef SQL_TYPE_DATE 2272 result = ov3 ? SQL_TYPE_DATE : SQL_DATE;
2276 #ifdef SQL_LONGVARCHAR 2277 }
else if (strncmp(p,
"text", 4) == 0 ||
2278 strncmp(p,
"memo", 4) == 0 ||
2279 strncmp(p,
"longvarchar", 11) == 0) {
2281 result = nowchar ? SQL_LONGVARCHAR : SQL_WLONGVARCHAR;
2283 result = SQL_LONGVARCHAR;
2286 }
else if (strncmp(p,
"wtext", 5) == 0 ||
2287 strncmp(p,
"wvarchar", 8) == 0 ||
2288 strncmp(p,
"longwvarchar", 12) == 0) {
2289 result = SQL_WLONGVARCHAR;
2293 }
else if (strncmp(p,
"bool", 4) == 0 ||
2294 strncmp(p,
"bit", 3) == 0) {
2298 }
else if (strncmp(p,
"bigint", 6) == 0) {
2300 result = SQL_BIGINT;
2302 }
else if (strncmp(p,
"blob", 4) == 0) {
2303 result = SQL_BINARY;
2304 }
else if (strncmp(p,
"varbinary", 9) == 0) {
2305 result = SQL_VARBINARY;
2306 }
else if (strncmp(p,
"longvarbinary", 13) == 0) {
2307 result = SQL_LONGVARBINARY;
2311 *nosign = strstr(p,
"unsigned") != NULL;
2317 if (dobigint && result == SQL_INTEGER) {
2318 result = SQL_BIGINT;
2335 getmd(
const char *
typename,
int sqltype,
int *mp,
int *dp)
2340 case SQL_INTEGER: m = 10; d = 9;
break;
2341 case SQL_TINYINT: m = 4; d = 3;
break;
2342 case SQL_SMALLINT: m = 6; d = 5;
break;
2343 case SQL_FLOAT: m = 25; d = 24;
break;
2344 case SQL_DOUBLE: m = 54; d = 53;
break;
2345 case SQL_VARCHAR: m = 255; d = 0;
break;
2348 case SQL_WVARCHAR: m = 255; d = 0;
break;
2351 #ifdef SQL_TYPE_DATE 2354 case SQL_DATE: m = 10; d = 0;
break;
2355 #ifdef SQL_TYPE_TIME 2358 case SQL_TIME: m = 8; d = 0;
break;
2359 #ifdef SQL_TYPE_TIMESTAMP 2360 case SQL_TYPE_TIMESTAMP:
2362 case SQL_TIMESTAMP: m = 32; d = 3;
break;
2363 #ifdef SQL_LONGVARCHAR 2364 case SQL_LONGVARCHAR : m = 65536; d = 0;
break;
2367 #ifdef SQL_WLONGVARCHAR 2368 case SQL_WLONGVARCHAR: m = 65536; d = 0;
break;
2372 case SQL_VARBINARY: m = 255; d = 0;
break;
2373 case SQL_LONGVARBINARY: m = 65536; d = 0;
break;
2375 case SQL_BIGINT: m = 20; d = 19;
break;
2378 case SQL_BIT: m = 1; d = 1;
break;
2381 if (m &&
typename) {
2385 if (sscanf(
typename,
"%*[^(](%d,%d %1[)]", &mm, &dd, clbr) == 3) {
2388 }
else if (sscanf(
typename,
"%*[^(](%d %1[)]", &mm, clbr) == 2) {
2389 if (sqltype == SQL_TIMESTAMP) {
2392 #ifdef SQL_TYPE_TIMESTAMP 2393 else if (sqltype == SQL_TYPE_TIMESTAMP) {
2422 if (type == SQL_C_DEFAULT) {
2425 type = (nosign > 0) ? SQL_C_ULONG : SQL_C_LONG;
2428 type = (nosign > 0) ? SQL_C_UTINYINT : SQL_C_TINYINT;
2431 type = (nosign > 0) ? SQL_C_USHORT : SQL_C_SHORT;
2437 type = SQL_C_DOUBLE;
2440 type = SQL_C_TIMESTAMP;
2448 #ifdef SQL_C_TYPE_TIMESTAMP 2449 case SQL_TYPE_TIMESTAMP:
2450 type = SQL_C_TYPE_TIMESTAMP;
2453 #ifdef SQL_C_TYPE_TIME 2455 type = SQL_C_TYPE_TIME;
2458 #ifdef SQL_C_TYPE_DATE 2460 type = SQL_C_TYPE_DATE;
2466 #ifdef SQL_WLONGVARCHAR 2467 case SQL_WLONGVARCHAR:
2469 type = nowchar ? SQL_C_CHAR : SQL_C_WCHAR;
2474 case SQL_LONGVARBINARY:
2475 type = SQL_C_BINARY;
2489 type = nowchar ? SQL_C_CHAR : SQL_C_WCHAR;
2511 fixupsql(
char *sql,
int sqlLen,
int cte,
int *nparam,
int *isselect,
2514 char *q = sql, *qz = NULL, *p, *inq = NULL, *out;
2515 int np = 0, isddl = -1, size;
2520 if (sqlLen != SQL_NTS) {
2525 memcpy(q, sql, sqlLen);
2529 size = strlen(sql) * 4;
2531 size +=
sizeof (
char *) - 1;
2532 size &= ~(
sizeof (
char *) - 1);
2577 if (*qq && *qq !=
';') {
2579 static const struct {
2601 if (size >= ddlstr[i].len &&
2602 strncasecmp(qq, ddlstr[i].str, ddlstr[i].len)
2618 }
while (*qq &&
ISSPACE(*qq));
2619 if (*qq && *qq !=
';') {
2622 *errmsg =
"only one SQL statement allowed";
2637 int ojfn = 0, brc = 0;
2638 char *inq2 = NULL, *end = q + 1, *start;
2640 while (*end &&
ISSPACE(*end)) {
2643 if (*end !=
'd' && *end !=
'D' &&
2644 *end !=
't' && *end !=
'T') {
2649 if (inq2 && *end == *inq2) {
2651 }
else if (inq2 == NULL && *end ==
'{') {
2652 char *nerr = 0, *nsql;
2654 nsql =
fixupsql(end, SQL_NTS, cte, 0, 0, &nerr);
2655 if (nsql && !nerr) {
2661 }
else if (inq2 == NULL && *end ==
'}') {
2665 }
else if (inq2 == NULL && (*end ==
'\'' || *end ==
'"')) {
2667 }
else if (inq2 == NULL && *end ==
'?') {
2673 char *end2 = end - 1;
2676 while (start < end) {
2682 while (start < end) {
2689 while (start < end2 && *start !=
'\'') {
2692 while (end2 > start && *end2 !=
'\'') {
2695 if (*start ==
'\'' && *end2 ==
'\'') {
2696 while (start <= end2) {
2727 if (!incom && p[1] ==
'-') {
2737 if (incom > 0 && p[-1] ==
'*') {
2741 }
else if (!incom && p[1] ==
'*') {
2753 (strncasecmp(p,
"select", 6) == 0 ||
2754 strncasecmp(p,
"pragma", 6) == 0)) {
2756 }
else if (cte && size >= 4 && strncasecmp(p,
"with", 4) == 0) {
2758 }
else if (size >= 7 && strncasecmp(p,
"explain", 7) == 0) {
2782 for (i = 0; i < ncols; i++) {
2783 if (strcmp(cols[i], name) == 0) {
2811 #ifndef FULL_METADATA 2812 int pk, nn, t, r, nrows, ncols;
2813 char **rowp, *flagp, flags[128];
2824 for (i = 1; table[0] && i < s->
dcols; i++) {
2829 if (i >= s->
dcols) {
2830 for (i = 0; i < s->
dcols; i++) {
2834 }
else if (s->
dcols == 1) {
2838 for (i = 0; i < s->
dcols; i++) {
2844 #ifdef SQL_LONGVARCHAR 2851 #ifdef SQL_WLONGVARCHAR 2863 #ifndef FULL_METADATA 2866 if (flagp == NULL) {
2872 memset(flagp, 0,
sizeof (flags[0]) * s->
dcols);
2873 for (i = 0; i < s->
dcols; i++) {
2877 for (i = 0; i < s->
dcols; i++) {
2878 int ret, lastpk = -1, autoinccount = 0;
2887 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", s->
dyncols[i].
table);
2892 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, NULL);
2894 if (ret != SQLITE_OK) {
2897 k =
findcol(rowp, ncols,
"name");
2898 t =
findcol(rowp, ncols,
"type");
2899 pk =
findcol(rowp, ncols,
"pk");
2900 nn =
findcol(rowp, ncols,
"notnull");
2901 if (k < 0 || t < 0) {
2904 for (r = 1; r <= nrows; r++) {
2907 for (m = i; m < s->
dcols; m++) {
2911 char *dotp = strchr(colname,
'.');
2918 strcmp(colname, rowp[r * ncols + k]) == 0 &&
2920 char *
typename = rowp[r * ncols + t];
2931 #ifdef SQL_LONGVARCHAR 2938 #ifdef SQL_WLONGVARCHAR 2949 if (pk >= 0 && strcmp(rowp[r * ncols + pk],
"1") == 0) {
2951 if (++autoinccount > 1) {
2958 if (strlen(
typename) == 7 &&
2959 strncasecmp(
typename,
"integer", 7) == 0) {
2966 if (nn >= 0 && rowp[r * ncols + nn][0] !=
'0') {
2973 sqlite3_free_table(rowp);
2975 for (i = k = 0; i < s->
dcols; i++) {
2976 if (flagp[i] == 0) {
2981 }
else if (flagp[i] != k) {
2989 for (i = 0; i < s->
dcols; i++) {
2996 if (flagp != flags) {
3000 for (i = 1, k = 0; i < s->
dcols; i++) {
3008 for (i = 0; i < s->
dcols; i++) {
3030 int z, a, b, c, d, e, x1;
3033 ijd = jd * 86400000.0 + 0.5;
3034 z = (int) ((ijd + 43200000) / 86400000);
3035 a = (int) ((z - 1867216.25) / 36524.25);
3036 a = z + 1 + a - (a / 4);
3038 c = (int) ((b - 122.1) / 365.25);
3039 d = (36525 * c) / 100;
3040 e = (int) ((b - d) / 30.6001);
3041 x1 = (int) (30.6001 * e);
3042 ds->day = b - d - x1;
3043 ds->month = (e < 14) ? (e - 1) : (e - 13);
3044 ds->year = (ds->month > 2) ? (c - 4716) : (c - 4715);
3062 ijd = jd * 86400000.0 + 0.5;
3063 s = (int)((ijd + 43200000) % 86400000);
3066 *fp = (s % 1000) * 1000000;
3070 ts->hour = s / 3600;
3071 s -= ts->hour * 3600;
3072 ts->minute = s / 60;
3073 ds += s - ts->minute *60;
3074 ts->second = (int) ds;
3087 static const int mdays[] = {
3088 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
3095 mday = mdays[(month - 1) % 12];
3096 if (mday == 28 && year % 4 == 0 &&
3097 (!(year % 100 == 0) || year % 400 == 0)) {
3123 char *p, *q, sepc =
'\0';
3125 ds->year = ds->month = ds->day = 0;
3127 p = strchr(str,
'.');
3151 strncpy(buf, p + 0, 4); buf[4] =
'\0';
3152 ds->year = strtol(buf, NULL, 10);
3153 strncpy(buf, p + 4, 2); buf[2] =
'\0';
3154 ds->month = strtol(buf, NULL, 10);
3155 strncpy(buf, p + 6, 2); buf[2] =
'\0';
3156 ds->day = strtol(buf, NULL, 10);
3164 n = strtol(p, &q, 10);
3176 if (*q ==
'-' || *q ==
'/' || *q ==
'\0' || i == 2) {
3178 case 0: ds->year = n;
break;
3179 case 1: ds->month = n;
break;
3180 case 2: ds->day = n;
break;
3197 ds->month < 1 || ds->month > 12 ||
3198 ds->day < 1 || ds->day >
getmdays(ds->year, ds->month)) {
3209 if (ds->month >= 1 && ds->month <= 12 &&
3210 (ds->day >= 1 || ds->day <=
getmdays(ds->year, ds->month))) {
3236 int i, err = 0, ampm = -1;
3240 ts->hour = ts->minute = ts->second = 0;
3242 p = strchr(str,
'.');
3266 strncpy(buf, p + 0, 2); buf[2] =
'\0';
3267 ts->hour = strtol(buf, NULL, 10);
3268 strncpy(buf, p + 2, 2); buf[2] =
'\0';
3269 ts->minute = strtol(buf, NULL, 10);
3270 strncpy(buf, p + 4, 2); buf[2] =
'\0';
3271 ts->second = strtol(buf, NULL, 10);
3279 n = strtol(p, &q, 10);
3288 if (*q ==
':' || *q ==
'\0' || i == 2) {
3290 case 0: ts->hour = n;
break;
3291 case 1: ts->minute = n;
break;
3292 case 2: ts->second = n;
break;
3308 if ((p[0] ==
'p' || p[0] ==
'P') &&
3309 (p[1] ==
'm' || p[1] ==
'M')) {
3311 }
else if ((p[0] ==
'a' || p[0] ==
'A') &&
3312 (p[1] ==
'm' || p[1] ==
'M')) {
3318 if (ts->hour < 12) {
3321 }
else if (ampm == 0) {
3322 if (ts->hour == 12) {
3329 if (err || ts->hour > 23 || ts->minute > 59 || ts->second > 59) {
3357 int i, m, n, err = 0, ampm = -1;
3359 char *p, *q, in =
'\0', sepc =
'\0';
3361 tss->year = tss->month = tss->day = 0;
3362 tss->hour = tss->minute = tss->second = 0;
3365 p = strchr(str,
'.');
3367 q = strchr(str,
'-');
3372 q = strchr(str,
'/');
3374 q = strchr(str,
':');
3387 tss->year = ds.year;
3388 tss->month = ds.month;
3390 tss->hour = ts.hour;
3391 tss->minute = ts.minute;
3392 tss->second = ts.second;
3412 strncpy(buf, p + 0, 4); buf[4] =
'\0';
3413 tss->year = strtol(buf, NULL, 10);
3414 strncpy(buf, p + 4, 2); buf[2] =
'\0';
3415 tss->month = strtol(buf, NULL, 10);
3416 strncpy(buf, p + 6, 2); buf[2] =
'\0';
3417 tss->day = strtol(buf, NULL, 10);
3418 strncpy(buf, p + 8, 2); buf[2] =
'\0';
3419 tss->hour = strtol(buf, NULL, 10);
3420 strncpy(buf, p + 10, 2); buf[2] =
'\0';
3421 tss->minute = strtol(buf, NULL, 10);
3422 strncpy(buf, p + 12, 2); buf[2] =
'\0';
3423 tss->second = strtol(buf, NULL, 10);
3426 strncpy(buf, p + 14, m);
3432 tss->fraction = strtol(buf, NULL, 10);
3438 while ((m & 7) != 7) {
3440 n = strtol(p, &q, 10);
3480 case 0: tss->year = n;
break;
3481 case 1: tss->month = n;
break;
3482 case 2: tss->day = n;
break;
3497 case 0: tss->hour = n;
break;
3498 case 1: tss->minute = n;
break;
3499 case 2: tss->second = n;
break;
3512 (void) strtol(q + 1, &e, 10);
3513 if (e && *e ==
'-') {
3529 if (p[0] ==
'+' || p[0] ==
'-') {
3545 if ((q[0] ==
'a' || q[0] ==
'A') &&
3546 (q[1] ==
'm' || q[1] ==
'M')) {
3549 }
else if ((q[0] ==
'p' || q[0] ==
'P') &&
3550 (q[1] ==
'm' || q[1] ==
'M')) {
3559 if ((m & 7) > 1 && (m & 8)) {
3565 if (*q !=
'+' && *q !=
'-') {
3568 sign = (*q ==
'+') ? -1 : 1;
3570 n = strtol(p, &q, 10);
3571 if (!q || *q++ !=
':' || !
ISDIGIT(*q)) {
3576 nn = strtol(p, &q, 10);
3577 tss->minute += nn * sign;
3578 if ((SQLSMALLINT) tss->minute < 0) {
3581 }
else if (tss->minute >= 60) {
3585 tss->hour += n * sign;
3586 if ((SQLSMALLINT) tss->hour < 0) {
3589 }
else if (tss->hour >= 24) {
3593 if ((
short) tss->day < 1 || tss->day >= 28) {
3594 int mday, pday, pmon;
3596 mday =
getmdays(tss->year, tss->month);
3597 pmon = tss->month - 1;
3602 if ((SQLSMALLINT) tss->day < 1) {
3605 }
else if (tss->day > mday) {
3609 if ((SQLSMALLINT) tss->month < 1) {
3612 }
else if (tss->month > 12) {
3621 (tss->month < 1 || tss->month > 12 ||
3622 tss->day < 1 || tss->day >
getmdays(tss->year, tss->month))) {
3636 if (!err && (m & 1) == 0) {
3641 tss->year = t.wYear;
3642 tss->month = t.wMonth;
3648 gettimeofday(&tv, NULL);
3649 tm = *localtime(&tv.tv_sec);
3650 tss->year = tm.tm_year + 1900;
3651 tss->month = tm.tm_mon + 1;
3652 tss->day = tm.tm_mday;
3656 if (tss->fraction < 0) {
3661 tss->month < 1 || tss->month > 12 ||
3662 tss->day < 1 || tss->day >
getmdays(tss->year, tss->month) ||
3663 tss->hour > 23 || tss->minute > 59 || tss->second > 59) {
3668 if (tss->hour < 12) {
3671 }
else if (ampm == 0) {
3672 if (tss->hour == 12) {
3677 return ((m & 7) < 1) ? -1 : 0;
3690 return string[0] && strchr(
"Yy123456789Tt",
string[0]) != NULL;
3706 DBC *d = (
DBC *) sqlite3_user_data(ctx);
3711 if (sqlite3_value_type(args[0]) != SQLITE_NULL) {
3712 filename = (
char *) sqlite3_value_text(args[0]);
3717 char *wname = utf_to_wmb(filename, -1);
3720 FILE *f = fopen(filename,
"r");
3727 f = fopen(wname,
"rb");
3729 sqlite3_result_error(ctx,
"out of memory", -1);
3735 if (fseek(f, 0, SEEK_END) == 0) {
3737 if (fseek(f, 0, SEEK_SET) == 0) {
3738 p = sqlite3_malloc(n);
3740 nn = fread(p, 1, n, f);
3742 sqlite3_result_error(ctx,
"read error", -1);
3745 sqlite3_result_blob(ctx, p, n, sqlite3_free);
3748 sqlite3_result_error(ctx,
"out of memory", -1);
3751 sqlite3_result_error(ctx,
"seek error", -1);
3754 sqlite3_result_error(ctx,
"seek error", -1);
3758 sqlite3_result_error(ctx,
"cannot open file", -1);
3761 sqlite3_result_error(ctx,
"no filename given", -1);
3776 DBC *d = (
DBC *) sqlite3_user_data(ctx);
3783 p = (
char *) sqlite3_value_blob(args[0]);
3784 n = sqlite3_value_bytes(args[0]);
3787 if (sqlite3_value_type(args[1]) != SQLITE_NULL) {
3788 filename = (
char *) sqlite3_value_text(args[1]);
3794 char *wname = utf_to_wmb(filename, -1);
3797 FILE *f = fopen(filename,
"w");
3803 f = fopen(wname,
"wb");
3805 sqlite3_result_error(ctx,
"out of memory", -1);
3811 nn = fwrite(p, 1, n, f);
3814 sqlite3_result_error(ctx,
"write error", -1);
3816 sqlite3_result_int(ctx, nn);
3819 sqlite3_result_error(ctx,
"cannot open file", -1);
3822 sqlite3_result_error(ctx,
"no filename given", -1);
3825 sqlite3_result_null(ctx);
3837 #if defined(HAVE_SQLITE3PROFILE) && (HAVE_SQLITE3PROFILE) 3838 dbtrace(
void *arg,
const char *msg, sqlite_uint64 et)
3840 dbtrace(
void *arg,
const char *msg)
3845 if (msg && d->
trace) {
3846 int len = strlen(msg);
3847 #if defined(HAVE_SQLITE3PROFILE) && (HAVE_SQLITE3PROFILE) 3854 if (msg[len - 1] !=
';') {
3857 fprintf(d->
trace,
"%s%s", msg, end);
3858 #if defined(HAVE_SQLITE3PROFILE) && (HAVE_SQLITE3PROFILE) 3859 s = et / 1000000000LL;
3860 f = et % 1000000000LL;
3861 fprintf(d->
trace,
"-- took %lu.%09lu seconds\n", s, f);
3878 if (fn && d->
trace) {
3880 fprintf(d->
trace,
"-- %s: %s\n", fn, sql);
3882 fprintf(d->
trace,
"-- %s\n", fn);
3898 if (rc != SQLITE_OK && d->
trace) {
3899 fprintf(d->
trace,
"-- SQLITE ERROR CODE %d", rc);
3900 fprintf(d->
trace, err ?
": %s\n" :
"\n", err);
3921 char *spflag,
char *ntflag,
char *jmode,
char *busy)
3924 int rc, tmp, busyto = 100000;
3925 #if defined(HAVE_SQLITE3VFS) && (HAVE_SQLITE3VFS) 3926 int flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
3928 const char *vfs_name = NULL;
3933 fprintf(d->
trace,
"-- sqlite3_close (deferred): '%s'\n",
3937 #if defined(HAVE_SQLITE3CLOSEV2) && (HAVE_SQLITE3CLOSEV2) 3938 sqlite3_close_v2(d->
sqlite);
3940 sqlite3_close(d->
sqlite);
3944 #if defined(HAVE_SQLITE3VFS) && (HAVE_SQLITE3VFS) 3946 flags &= ~ SQLITE_OPEN_CREATE;
3948 #if defined(_WIN32) || defined(_WIN64) 3950 char expname[MAX_PATH];
3953 rc = ExpandEnvironmentStrings(name, expname,
sizeof (expname));
3954 if (rc <=
sizeof (expname)) {
3955 uname = wmb_to_utf(expname, rc - 1);
3957 uname = wmb_to_utf(name, -1);
3961 setstatd(d, rc,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
3966 #if defined(ENABLE_NVFS) && (ENABLE_NVFS) 3967 vfs_name = nvfs_makevfs(uname);
3969 #ifdef SQLITE_OPEN_URI 3970 flags |= SQLITE_OPEN_URI;
3972 rc = sqlite3_open_v2(uname, &d->
sqlite, flags, vfs_name);
3973 #if defined(WINTERFACE) || defined(_WIN32) || defined(_WIN64) 3974 if (uname != name) {
3979 #if defined(_WIN32) || defined(_WIN64) 3984 cname = utf_to_wmb(name, -1);
3986 if (GetFileAttributesA(cname ? cname : name) ==
3987 INVALID_FILE_ATTRIBUTES) {
3989 rc = SQLITE_CANTOPEN;
3990 setstatd(d, rc,
"cannot open database",
3991 (*d->
ov3) ?
"HY000" :
"S1000");
3997 if (d->
nocreat && access(name, 004) < 0) {
3998 rc = SQLITE_CANTOPEN;
3999 setstatd(d, rc,
"cannot open database", (*d->
ov3) ?
"HY000" :
"S1000");
4003 #if defined(_WIN32) || defined(_WIN64) 4005 WCHAR *wname = wmb_to_uc(name, -1);
4009 setstatd(d, rc,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
4012 rc = sqlite3_open16(wname, &d->
sqlite);
4016 rc = sqlite3_open(name, &d->
sqlite);
4018 if (rc != SQLITE_OK) {
4020 setstatd(d, rc,
"connect failed", (*d->
ov3) ?
"HY000" :
"S1000");
4022 sqlite3_close(d->
sqlite);
4027 #if defined(SQLITE_DYNLOAD) || defined(SQLITE_HAS_CODEC) 4035 #if defined(HAVE_SQLITE3PROFILE) && (HAVE_SQLITE3PROFILE) 4044 SQL_CURSOR_FORWARD_ONLY : SQL_CURSOR_STATIC;
4045 tmp = strtol(busy, &endp, 0);
4046 if (endp && *endp ==
'\0' && endp != busy) {
4049 if (busyto < 1 || busyto > 1000000) {
4059 fprintf(d->
trace,
"-- sqlite3_close: '%s'\n",
4063 sqlite3_close(d->
sqlite);
4067 if (!spflag || spflag[0] ==
'\0') {
4070 if (spflag[0] !=
'\0') {
4073 sprintf(syncp,
"PRAGMA synchronous = %8.8s;", spflag);
4074 sqlite3_exec(d->
sqlite, syncp, NULL, NULL, NULL);
4076 if (jmode[0] !=
'\0') {
4079 sprintf(jourp,
"PRAGMA journal_mode = %16.16s;", jmode);
4080 sqlite3_exec(d->
sqlite, jourp, NULL, NULL, NULL);
4083 fprintf(d->
trace,
"-- sqlite3_open: '%s'\n", d->
dbname);
4086 #if defined(_WIN32) || defined(_WIN64) 4088 char pname[MAX_PATH];
4089 HANDLE h = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
4090 FALSE, GetCurrentProcessId());
4094 HMODULE m = NULL, l = LoadLibrary(
"psapi.dll");
4096 typedef BOOL (WINAPI *epmfunc)(HANDLE, HMODULE *, DWORD, LPDWORD);
4097 typedef BOOL (WINAPI *gmbfunc)(HANDLE, HMODULE, LPSTR, DWORD);
4102 epm = (epmfunc) GetProcAddress(l,
"EnumProcessModules");
4103 gmb = (gmbfunc) GetProcAddress(l,
"GetModuleBaseNameA");
4104 if (epm && gmb && epm(h, &m,
sizeof (m), &need)) {
4105 gmb(h, m, pname,
sizeof (pname));
4111 d->xcelqrx = strncasecmp(pname,
"EXCEL", 5) == 0 ||
4112 strncasecmp(pname,
"MSQRY", 5) == 0;
4113 if (d->
trace && d->xcelqrx) {
4115 fprintf(d->
trace,
"-- enabled EXCEL quirks\n");
4120 sqlite3_create_function(d->
sqlite,
"blob_import", 1, SQLITE_UTF8,
4122 sqlite3_create_function(d->
sqlite,
"blob_export", 2, SQLITE_UTF8,
4136 #if defined(HAVE_SQLITE3LOADEXTENSION) && (HAVE_SQLITE3LOADEXTENSION) 4138 char path[SQL_MAX_MESSAGE_LENGTH];
4144 sqlite3_enable_load_extension(d->
sqlite, 1);
4145 #if defined(_WIN32) || defined(_WIN64) 4146 GetModuleFileName(hModule, path,
sizeof (path));
4147 p = strrchr(path,
'\\');
4148 plen = p ? ((p + 1) - path) : 0;
4151 p = strchr(exts,
',');
4153 strncpy(path + plen, exts, p - exts);
4154 path[plen + (p - exts)] =
'\0';
4156 strcpy(path + plen, exts);
4159 char *errmsg = NULL;
4161 #if defined(_WIN32) || defined(_WIN64) 4166 ((q[1] ==
':' && (q[2] ==
'\\' || q[2] ==
'/')) ||
4167 q[0] ==
'\\' || q[0] ==
'/' || q[0] ==
'.'))) {
4170 rc = sqlite3_load_extension(d->
sqlite, q, 0, &errmsg);
4172 rc = sqlite3_load_extension(d->
sqlite, path, 0, &errmsg);
4174 if (rc != SQLITE_OK) {
4175 #if defined(_WIN32) || defined(_WIN64) 4176 char buf[512], msg[512];
4178 LoadString(hModule, IDS_EXTERR, buf,
sizeof (buf));
4179 wsprintf(msg, buf, q, errmsg ?
4180 errmsg :
"no error info available");
4181 LoadString(hModule, IDS_EXTTITLE, buf,
sizeof (buf));
4182 MessageBox(NULL, msg, buf,
4183 MB_ICONEXCLAMATION | MB_OK | MB_TASKMODAL |
4186 fprintf(stderr,
"extension '%s' did not load%s%s\n",
4187 path, errmsg ?
": " :
"", errmsg ? errmsg :
"");
4210 char *
typename = (
char *) sqlite3_column_decltype(s3stmt, col);
4215 int coltype = sqlite3_column_type(s3stmt, col);
4217 if (guessed_types) {
4221 sprintf(guess,
" (guessed from %d)", coltype);
4224 case SQLITE_INTEGER:
typename =
"integer";
break;
4225 case SQLITE_FLOAT:
typename =
"double";
break;
4227 case SQLITE_TEXT:
typename =
"varchar";
break;
4228 case SQLITE_BLOB:
typename =
"blob";
break;
4230 case SQLITE_NULL:
typename =
"null";
break;
4235 fprintf(d->
trace,
"-- column %d type%s: '%s'\n", col + 1,
4242 #ifdef FULL_METADATA 4253 s3stmt_addmeta(sqlite3_stmt *s3stmt,
int col,
DBC *d,
COL *ci)
4255 int nn = 0, pk = 0, ai = 0;
4256 const char *dn = NULL, *tn = NULL, *cn = NULL, *dummy[4];
4258 dn = sqlite3_column_database_name(s3stmt, col);
4259 tn = sqlite3_column_table_name(s3stmt, col);
4260 cn = sqlite3_column_origin_name(s3stmt, col);
4261 dummy[0] = dummy[1] = 0;
4263 sqlite3_table_column_metadata(d->
sqlite, dn, tn, cn,
4267 ci->
autoinc = ai ? SQL_TRUE: SQL_FALSE;
4268 ci->
notnull = nn ? SQL_NO_NULLS : SQL_NULLABLE;
4269 ci->
ispk = pk ? 1 : 0;
4271 fprintf(d->
trace,
"-- column %d %s\n",
4272 col + 1, nn ?
"notnull" :
"nullable");
4274 fprintf(d->
trace,
"-- column %d autoincrement\n", col + 1);
4279 if (ci->
ispk && tn) {
4281 dummy[2] = dummy[3] = 0;
4283 sqlite3_table_column_metadata(d->
sqlite, dn, tn,
"rowid",
4284 dummy + 2, dummy + 3,
4286 if (pk && dummy[0] && dummy[0] == dummy[2]) {
4305 const char *errp = NULL;
4309 setstat(s, -1,
"stale statement", (*s->
ov3) ?
"HY000" :
"S1000");
4312 rc = sqlite3_step(s->
s3stmt);
4313 if (rc == SQLITE_ROW || rc == SQLITE_DONE) {
4315 ncols = sqlite3_column_count(s->
s3stmt);
4320 const char *colname, *
typename;
4321 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME) 4325 for (i = size = 0; i < ncols; i++) {
4326 colname = sqlite3_column_name(s->
s3stmt, i);
4327 size += 3 + 3 * strlen(colname);
4329 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME) 4330 tblname = (
char *) size;
4331 for (i = 0; i < ncols; i++) {
4332 p = (
char *) sqlite3_column_table_name(s->
s3stmt, i);
4333 size += 2 + (p ? strlen(p) : 0);
4336 dyncols =
xmalloc(ncols *
sizeof (
COL) + size);
4341 sqlite3_finalize(s->
s3stmt);
4346 p = (
char *) (dyncols + ncols);
4347 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME) 4350 for (i = 0; i < ncols; i++) {
4353 colname = sqlite3_column_name(s->
s3stmt, i);
4355 fprintf(d->
trace,
"-- column %d name: '%s'\n",
4359 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME) 4360 q = (
char *) sqlite3_column_table_name(s->
s3stmt, i);
4361 strcpy(tblname, q ? q :
"");
4363 fprintf(d->
trace,
"-- table %d name: '%s'\n",
4367 dyncols[i].
table = tblname;
4368 tblname += strlen(tblname) + 1;
4371 dyncols[i].
db = ((
DBC *) (s->
dbc))->dbname;
4373 dyncols[i].
label = p;
4375 q = strchr(colname,
'.');
4377 char *q2 = strchr(q + 1,
'.');
4385 #if !defined(HAVE_SQLITE3COLUMNTABLENAME) || !(HAVE_SQLITE3COLUMNTABLENAME) 4386 dyncols[i].
table = p;
4388 strncpy(p, colname, q - colname);
4389 p[q - colname] =
'\0';
4395 #if !defined(HAVE_SQLITE3COLUMNTABLENAME) || !(HAVE_SQLITE3COLUMNTABLENAME) 4396 dyncols[i].
table =
"";
4405 #ifdef SQL_LONGVARCHAR 4406 dyncols[i].
type = SQL_LONGVARCHAR;
4407 dyncols[i].
size = 65535;
4409 dyncols[i].
type = SQL_VARCHAR;
4410 dyncols[i].
size = 255;
4412 dyncols[i].
index = i;
4413 dyncols[i].
scale = 0;
4414 dyncols[i].
prec = 0;
4416 dyncols[i].
autoinc = SQL_FALSE;
4417 dyncols[i].
notnull = SQL_NULLABLE;
4418 dyncols[i].
ispk = -1;
4420 #ifdef FULL_METADATA 4421 s3stmt_addmeta(s->
s3stmt, i, d, &dyncols[i]);
4435 if (rc == SQLITE_DONE) {
4439 sqlite3_finalize(s->
s3stmt);
4444 rowd =
xmalloc((1 + 2 * ncols) *
sizeof (
char *));
4446 const unsigned char *value;
4448 rowd[0] = (
char *) ((
PTRDIFF_T) (ncols * 2));
4450 for (i = 0; i < ncols; i++) {
4451 int coltype = sqlite3_column_type(s->
s3stmt, i);
4453 rowd[i] = rowd[i + ncols] = NULL;
4454 if (coltype == SQLITE_BLOB) {
4455 int k, nbytes = sqlite3_column_bytes(s->
s3stmt, i);
4457 unsigned const char *bp;
4459 bp = sqlite3_column_blob(s->
s3stmt, i);
4462 rowd[i + ncols] = qp;
4465 for (k = 0; k < nbytes; k++) {
4466 *qp++ =
xdigits[(bp[k] >> 4)];
4467 *qp++ =
xdigits[(bp[k] & 0xF)];
4473 }
else if (coltype == SQLITE_FLOAT) {
4474 static struct lconv *lc = 0;
4475 double d = sqlite3_column_double(s->
s3stmt, i);
4476 char *p, buffer[128];
4483 snprintf(buffer,
sizeof (buffer),
"%.15g", d);
4487 if (lc && lc->decimal_point && lc->decimal_point[0] &&
4488 lc->decimal_point[0] !=
'.') {
4489 p = strchr(buffer, lc->decimal_point[0]);
4494 rowd[i + ncols] =
xstrdup(buffer);
4496 }
else if (coltype != SQLITE_NULL) {
4497 value = sqlite3_column_text(s->
s3stmt, i);
4498 rowd[i + ncols] =
xstrdup((
char *) value);
4501 for (i = 0; i < ncols; i++) {
4502 int coltype = sqlite3_column_type(s->
s3stmt, i);
4505 if (coltype == SQLITE_BLOB) {
4506 value = sqlite3_column_blob(s->
s3stmt, i);
4507 }
else if (coltype != SQLITE_NULL) {
4508 value = sqlite3_column_text(s->
s3stmt, i);
4510 if (value && !rowd[i + ncols]) {
4522 if (rc == SQLITE_DONE) {
4524 sqlite3_finalize(s->
s3stmt);
4533 rc = sqlite3_reset(s->
s3stmt);
4535 errp = sqlite3_errmsg(d->
sqlite);
4539 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
4540 errp ? errp :
"unknown error", rc);
4563 sqlite3_reset(s->
s3stmt);
4604 sqlite3_finalize(s->
s3stmt);
4621 sqlite3_stmt *s3stmt = NULL;
4626 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 4633 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 4634 rc = sqlite3_prepare_v2(d->
sqlite, (
char *) s->
query, -1,
4637 rc = sqlite3_prepare(d->
sqlite, (
char *) s->
query, -1,
4640 if (rc != SQLITE_OK) {
4642 sqlite3_finalize(s3stmt);
4646 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
4648 if (rc != SQLITE_OK) {
4651 sqlite3_finalize(s3stmt);
4653 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
4654 sqlite3_errmsg(d->
sqlite), rc);
4657 if (sqlite3_bind_parameter_count(s3stmt) != s->
nparams) {
4659 sqlite3_finalize(s3stmt);
4660 setstat(s, SQLITE_ERROR,
"parameter marker count incorrect",
4661 (*s->
ov3) ?
"HY000" :
"S1000");
4680 SQLDataSources(SQLHENV env, SQLUSMALLINT dir, SQLCHAR *srvname,
4681 SQLSMALLINT buflen1, SQLSMALLINT *lenp1,
4682 SQLCHAR *desc, SQLSMALLINT buflen2, SQLSMALLINT *lenp2)
4684 if (env == SQL_NULL_HENV) {
4685 return SQL_INVALID_HANDLE;
4698 SQLSMALLINT buflen1, SQLSMALLINT *lenp1,
4699 SQLWCHAR *desc, SQLSMALLINT buflen2, SQLSMALLINT *lenp2)
4701 if (env == SQL_NULL_HENV) {
4702 return SQL_INVALID_HANDLE;
4714 SQLDrivers(SQLHENV env, SQLUSMALLINT dir, SQLCHAR *drvdesc,
4715 SQLSMALLINT descmax, SQLSMALLINT *desclenp,
4716 SQLCHAR *drvattr, SQLSMALLINT attrmax, SQLSMALLINT *attrlenp)
4718 if (env == SQL_NULL_HENV) {
4719 return SQL_INVALID_HANDLE;
4732 SQLSMALLINT descmax, SQLSMALLINT *desclenp,
4733 SQLWCHAR *drvattr, SQLSMALLINT attrmax, SQLSMALLINT *attrlenp)
4735 if (env == SQL_NULL_HENV) {
4736 return SQL_INVALID_HANDLE;
4748 SQLBrowseConnect(SQLHDBC
dbc, SQLCHAR *connin, SQLSMALLINT conninLen,
4749 SQLCHAR *connout, SQLSMALLINT connoutMax,
4750 SQLSMALLINT *connoutLen)
4768 SQLWCHAR *connout, SQLSMALLINT connoutMax,
4769 SQLSMALLINT *connoutLen)
4792 int i, dlen, done = 0;
4795 if (stmt == SQL_NULL_HSTMT) {
4796 return SQL_INVALID_HANDLE;
4801 setstat(s, -1,
"sequence error",
"HY010");
4804 for (i = (s->
pdcount < 0) ? 0 : s->
pdcount; i < s->nparams; i++) {
4809 if (len == SQL_NULL_DATA) {
4812 p->
len = SQL_NULL_DATA;
4814 }
else if (type != SQL_C_CHAR
4816 && type != SQL_C_WCHAR
4818 && type != SQL_C_BINARY) {
4823 case SQL_C_UTINYINT:
4824 case SQL_C_STINYINT:
4828 size =
sizeof (SQLCHAR);
4833 size =
sizeof (SQLSMALLINT);
4838 size =
sizeof (SQLINTEGER);
4843 size =
sizeof (SQLBIGINT);
4847 size =
sizeof (float);
4850 size =
sizeof (double);
4852 #ifdef SQL_C_TYPE_DATE 4853 case SQL_C_TYPE_DATE:
4856 size =
sizeof (DATE_STRUCT);
4858 #ifdef SQL_C_TYPE_DATE 4859 case SQL_C_TYPE_TIME:
4862 size =
sizeof (TIME_STRUCT);
4864 #ifdef SQL_C_TYPE_DATE 4865 case SQL_C_TYPE_TIMESTAMP:
4867 case SQL_C_TIMESTAMP:
4868 size =
sizeof (TIMESTAMP_STRUCT);
4877 memcpy(p->
param, data, size);
4880 }
else if (len == SQL_NTS && (
4883 || type == SQL_C_WCHAR
4889 if (type == SQL_C_WCHAR) {
4896 #if defined(_WIN32) || defined(_WIN64) 4898 dp = wmb_to_utf(data, strlen (data));
4914 strcpy(p->
param, dp);
4920 }
else if (len < 0) {
4921 setstat(s, -1,
"invalid length",
"HY090");
4926 setstat(s, -1,
"no memory for parameter",
"HY013");
4929 memcpy((
char *) p->
param + p->
offs, data, dlen);
4933 if (type == SQL_C_WCHAR) {
4955 *((
char *) p->
param + p->
len) =
'\0';
4957 p->
need = (type == SQL_C_CHAR || type == SQL_C_WCHAR)
4960 *((
char *) p->
param + p->
len) =
'\0';
4961 p->
need = (type == SQL_C_CHAR) ? -1 : 0;
4963 #if defined(_WIN32) || defined(_WIN64) 4964 if (type == SQL_C_CHAR && *s->
oemcp &&
4965 !(p->
stype == SQL_BINARY ||
4966 p->
stype == SQL_VARBINARY ||
4967 p->
stype == SQL_LONGVARBINARY)) {
4968 char *dp = wmb_to_utf(p->
param, p->
len);
4977 p->
len = strlen(dp);
4979 if (p->
type == SQL_C_WCHAR &&
4980 (p->
stype == SQL_VARCHAR ||
4981 p->
stype == SQL_LONGVARCHAR) &&
4982 p->
len == p->
coldef * sizeof (SQLWCHAR)) {
5051 int type, len = 0, needalloc = 0;
5059 #if (defined(_WIN32) || defined(_WIN64)) && defined(WINTERFACE) 5061 if (type == SQL_C_WCHAR && p->
type == SQL_C_DEFAULT) {
5074 if (type == SQL_C_CHAR &&
5075 (p->
stype == SQL_BINARY ||
5076 p->
stype == SQL_VARBINARY ||
5077 p->
stype == SQL_LONGVARBINARY)) {
5078 type = SQL_C_BINARY;
5090 }
else if (*p->
lenp == SQL_DATA_AT_EXEC) {
5094 if (len <= SQL_LEN_DATA_AT_EXEC_OFFSET) {
5095 len = SQL_LEN_DATA_AT_EXEC(len);
5099 setstat(s, -1,
"invalid length",
"HY009");
5116 if (type == SQL_C_WCHAR) {
5117 if (!p->
lenp || *p->
lenp == SQL_NTS) {
5119 }
else if (*p->
lenp >= 0) {
5124 if (type == SQL_C_CHAR) {
5125 if (!p->
lenp || *p->
lenp == SQL_NTS) {
5127 #if defined(_WIN32) || defined(_WIN64) 5130 }
else if (*p->
lenp >= 0) {
5140 if (type == SQL_C_WCHAR) {
5156 if (type == SQL_C_CHAR) {
5161 #if defined(_WIN32) || defined(_WIN64) 5173 #if defined(_WIN32) || defined(_WIN64) 5175 p->
len = strlen(dp);
5194 case SQL_C_UTINYINT:
5196 case SQL_C_STINYINT:
5197 p->
s3type = SQLITE_INTEGER;
5198 p->
s3size =
sizeof (int);
5202 p->
s3type = SQLITE_INTEGER;
5203 p->
s3size =
sizeof (int);
5208 p->
s3type = SQLITE_INTEGER;
5209 p->
s3size =
sizeof (int);
5213 p->
s3type = SQLITE_INTEGER;
5214 p->
s3size =
sizeof (int);
5219 p->
s3type = SQLITE_INTEGER;
5220 p->
s3size =
sizeof (int);
5225 p->
s3type = SQLITE_INTEGER;
5226 p->
s3size =
sizeof (int);
5232 p->
s3type = SQLITE_INTEGER;
5233 p->
s3size =
sizeof (sqlite_int64);
5237 p->
s3type = SQLITE_INTEGER;
5238 p->
s3size =
sizeof (sqlite_int64);
5243 p->
s3type = SQLITE_FLOAT;
5244 p->
s3size =
sizeof (double);
5248 p->
s3type = SQLITE_FLOAT;
5249 p->
s3size =
sizeof (double);
5252 #ifdef SQL_C_TYPE_DATE 5253 case SQL_C_TYPE_DATE:
5257 int a, b, x1, x2, y, m, d;
5259 p->
s3type = SQLITE_FLOAT;
5260 p->
s3size =
sizeof (double);
5261 y = ((DATE_STRUCT *) p->
param)->year;
5262 m = ((DATE_STRUCT *) p->
param)->month;
5263 d = ((DATE_STRUCT *) p->
param)->day;
5269 b = 2 - a + (a / 4);
5270 x1 = 36525 * (y + 4716) / 100;
5271 x2 = 306001 * (m + 1) / 10000;
5272 p->
s3dval = x1 + x2 + d + b - 1524.5;
5275 sprintf(p->
strbuf,
"%04d-%02d-%02d",
5276 ((DATE_STRUCT *) p->
param)->year,
5277 ((DATE_STRUCT *) p->
param)->month,
5278 ((DATE_STRUCT *) p->
param)->day);
5283 #ifdef SQL_C_TYPE_TIME 5284 case SQL_C_TYPE_TIME:
5288 p->
s3type = SQLITE_FLOAT;
5289 p->
s3size =
sizeof (double);
5291 (((TIME_STRUCT *) p->
param)->hour * 3600000.0 +
5292 ((TIME_STRUCT *) p->
param)->minute * 60000.0 +
5293 ((TIME_STRUCT *) p->
param)->second * 1000.0) / 86400000.0;
5296 sprintf(p->
strbuf,
"%02d:%02d:%02d",
5297 ((TIME_STRUCT *) p->
param)->hour,
5298 ((TIME_STRUCT *) p->
param)->minute,
5299 ((TIME_STRUCT *) p->
param)->second);
5304 #ifdef SQL_C_TYPE_TIMESTAMP 5305 case SQL_C_TYPE_TIMESTAMP:
5307 case SQL_C_TIMESTAMP:
5309 int a, b, x1, x2, y, m, d;
5311 p->
s3type = SQLITE_FLOAT;
5312 p->
s3size =
sizeof (double);
5313 y = ((TIMESTAMP_STRUCT *) p->
param)->year;
5314 m = ((TIMESTAMP_STRUCT *) p->
param)->month;
5315 d = ((TIMESTAMP_STRUCT *) p->
param)->day;
5321 b = 2 - a + (a / 4);
5322 x1 = 36525 * (y + 4716) / 100;
5323 x2 = 306001 * (m + 1) / 10000;
5324 p->
s3dval = x1 + x2 + d + b - 1524.5 +
5325 (((TIMESTAMP_STRUCT *) p->
param)->hour * 3600000.0 +
5326 ((TIMESTAMP_STRUCT *) p->
param)->minute * 60000.0 +
5327 ((TIMESTAMP_STRUCT *) p->
param)->second * 1000.0 +
5328 ((TIMESTAMP_STRUCT *) p->
param)->fraction / 1.0E6)
5332 len = (int) ((TIMESTAMP_STRUCT *) p->
param)->fraction;
5339 sprintf(p->
strbuf,
"%04d-%02d-%02d %02d:%02d:00.000",
5340 ((TIMESTAMP_STRUCT *) p->
param)->year,
5341 ((TIMESTAMP_STRUCT *) p->
param)->month,
5342 ((TIMESTAMP_STRUCT *) p->
param)->day,
5343 ((TIMESTAMP_STRUCT *) p->
param)->hour,
5344 ((TIMESTAMP_STRUCT *) p->
param)->minute);
5346 sprintf(p->
strbuf,
"%04d-%02d-%02d %02d:%02d:%02d.000",
5347 ((TIMESTAMP_STRUCT *) p->
param)->year,
5348 ((TIMESTAMP_STRUCT *) p->
param)->month,
5349 ((TIMESTAMP_STRUCT *) p->
param)->day,
5350 ((TIMESTAMP_STRUCT *) p->
param)->hour,
5351 ((TIMESTAMP_STRUCT *) p->
param)->minute,
5352 ((TIMESTAMP_STRUCT *) p->
param)->second);
5354 sprintf(p->
strbuf,
"%04d-%02d-%02d %02d:%02d:%02d.%03d",
5355 ((TIMESTAMP_STRUCT *) p->
param)->year,
5356 ((TIMESTAMP_STRUCT *) p->
param)->month,
5357 ((TIMESTAMP_STRUCT *) p->
param)->day,
5358 ((TIMESTAMP_STRUCT *) p->
param)->hour,
5359 ((TIMESTAMP_STRUCT *) p->
param)->minute,
5360 ((TIMESTAMP_STRUCT *) p->
param)->second,
5369 setstat(s, -1,
"unsupported parameter type",
5370 (*s->
ov3) ?
"07009" :
"S1093");
5393 SQLSMALLINT buftype, SQLSMALLINT ptype, SQLUINTEGER coldef,
5395 SQLPOINTER data, SQLINTEGER buflen,
SQLLEN *len)
5400 if (stmt == SQL_NULL_HSTMT) {
5401 return SQL_INVALID_HANDLE;
5405 setstat(s, -1,
"invalid parameter", (*s->
ov3) ?
"07009" :
"S1093");
5408 if (!data && !len) {
5409 setstat(s, -1,
"invalid buffer",
"HY003");
5429 int npar =
max(10, pnum + 1);
5439 case SQL_C_STINYINT:
5440 case SQL_C_UTINYINT:
5445 buflen =
sizeof (SQLCHAR);
5450 buflen =
sizeof (SQLSMALLINT);
5455 buflen =
sizeof (SQLINTEGER);
5458 buflen =
sizeof (float);
5461 buflen =
sizeof (double);
5463 case SQL_C_TIMESTAMP:
5464 #ifdef SQL_C_TYPE_TIMESTAMP 5465 case SQL_C_TYPE_TIMESTAMP:
5467 buflen =
sizeof (TIMESTAMP_STRUCT);
5470 #ifdef SQL_C_TYPE_TIME 5471 case SQL_C_TYPE_TIME:
5473 buflen =
sizeof (TIME_STRUCT);
5476 #ifdef SQL_C_TYPE_DATE 5477 case SQL_C_TYPE_DATE:
5479 buflen =
sizeof (DATE_STRUCT);
5481 #ifdef SQL_C_UBIGINT 5483 buflen =
sizeof (SQLBIGINT);
5486 #ifdef SQL_C_SBIGINT 5488 buflen =
sizeof (SQLBIGINT);
5493 buflen =
sizeof (SQLBIGINT);
5532 SQLSMALLINT buftype, SQLSMALLINT ptype,
SQLULEN coldef,
5539 ret =
drvbindparam(stmt, pnum, iotype, buftype, ptype, coldef,
5540 scale, data, buflen, len);
5561 SQLSMALLINT ptype,
SQLULEN lenprec,
5562 SQLSMALLINT scale, SQLPOINTER val,
5568 ret =
drvbindparam(stmt, pnum, SQL_PARAM_INPUT, vtype, ptype,
5569 lenprec, scale, val, 0, lenp);
5589 if (stmt == SQL_NULL_HSTMT) {
5590 return SQL_INVALID_HANDLE;
5612 if (*p->
lenp == SQL_DATA_AT_EXEC) {
5615 p->
len = SQL_LEN_DATA_AT_EXEC(*p->
lenp);
5617 if (p->
len < 0 && p->
len != SQL_NTS &&
5618 p->
len != SQL_NULL_DATA) {
5619 setstat(s, -1,
"invalid length",
"HY009");
5632 return SQL_NEED_DATA;
5652 if (stmt == SQL_NULL_HSTMT) {
5653 return SQL_INVALID_HANDLE;
5662 for (i = 0; i < s->
pdcount; i++) {
5667 p->
need = (type == SQL_C_CHAR || type == SQL_C_WCHAR) ? -1 : 0;
5673 *pind = (SQLPOINTER) p->
param0;
5698 SQLULEN *size, SQLSMALLINT *decdigits, SQLSMALLINT *nullable)
5701 SQLRETURN ret = SQL_ERROR;
5704 if (stmt == SQL_NULL_HSTMT) {
5705 return SQL_INVALID_HANDLE;
5710 setstat(s, -1,
"invalid parameter index",
5711 (*s->
ov3) ?
"HY000" :
"S1000");
5715 #ifdef SQL_LONGVARCHAR 5717 *dtype = s->
nowchar[0] ? SQL_LONGVARCHAR : SQL_WLONGVARCHAR;
5719 *dtype = SQL_LONGVARCHAR;
5723 *dtype = s->
nowchar[0] ? SQL_VARCHAR : SQL_WVARCHAR;
5725 *dtype = SQL_VARCHAR;
5730 #ifdef SQL_LONGVARCHAR 5740 *nullable = SQL_NULLABLE;
5763 SQLSMALLINT sqltype,
SQLULEN coldef,
5764 SQLSMALLINT scale, SQLPOINTER val,
SQLLEN *nval)
5770 type, sqltype, coldef, scale, val,
5771 SQL_SETPARAM_VALUE_MAX, nval);
5797 SQLGetDescField(SQLHDESC handle, SQLSMALLINT recno,
5798 SQLSMALLINT fieldid, SQLPOINTER value,
5799 SQLINTEGER buflen, SQLINTEGER *strlen)
5812 SQLSMALLINT fieldid, SQLPOINTER value,
5813 SQLINTEGER buflen, SQLINTEGER *strlen)
5825 SQLSetDescField(SQLHDESC handle, SQLSMALLINT recno,
5826 SQLSMALLINT fieldid, SQLPOINTER value,
5840 SQLSMALLINT fieldid, SQLPOINTER value,
5853 SQLGetDescRec(SQLHDESC handle, SQLSMALLINT recno,
5854 SQLCHAR *name, SQLSMALLINT buflen,
5855 SQLSMALLINT *strlen, SQLSMALLINT *type,
5856 SQLSMALLINT *subtype,
SQLLEN *len,
5857 SQLSMALLINT *prec, SQLSMALLINT *scale,
5858 SQLSMALLINT *nullable)
5871 SQLWCHAR *name, SQLSMALLINT buflen,
5872 SQLSMALLINT *strlen, SQLSMALLINT *type,
5873 SQLSMALLINT *subtype,
SQLLEN *len,
5874 SQLSMALLINT *prec, SQLSMALLINT *scale,
5875 SQLSMALLINT *nullable)
5887 SQLSMALLINT type, SQLSMALLINT subtype,
5888 SQLLEN len, SQLSMALLINT prec,
5889 SQLSMALLINT scale, SQLPOINTER data,
5908 int ncols3,
int *nret)
5913 if (stmt == SQL_NULL_HSTMT) {
5914 return SQL_INVALID_HANDLE;
5917 if (s->
dbc == SQL_NULL_HDBC) {
5927 if (colspec3 && *s->
ov3) {
5950 {
"SYSTEM",
"TABLEPRIV",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
5951 {
"SYSTEM",
"TABLEPRIV",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
5952 {
"SYSTEM",
"TABLEPRIV",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
5953 {
"SYSTEM",
"TABLEPRIV",
"GRANTOR",
SCOL_VARCHAR, 50 },
5954 {
"SYSTEM",
"TABLEPRIV",
"GRANTEE",
SCOL_VARCHAR, 50 },
5955 {
"SYSTEM",
"TABLEPRIV",
"PRIVILEGE",
SCOL_VARCHAR, 50 },
5956 {
"SYSTEM",
"TABLEPRIV",
"IS_GRANTABLE",
SCOL_VARCHAR, 50 }
5960 {
"SYSTEM",
"TABLEPRIV",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
5961 {
"SYSTEM",
"TABLEPRIV",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
5962 {
"SYSTEM",
"TABLEPRIV",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
5963 {
"SYSTEM",
"TABLEPRIV",
"GRANTOR",
SCOL_VARCHAR, 50 },
5964 {
"SYSTEM",
"TABLEPRIV",
"GRANTEE",
SCOL_VARCHAR, 50 },
5965 {
"SYSTEM",
"TABLEPRIV",
"PRIVILEGE",
SCOL_VARCHAR, 50 },
5966 {
"SYSTEM",
"TABLEPRIV",
"IS_GRANTABLE",
SCOL_VARCHAR, 50 }
5983 SQLCHAR *cat, SQLSMALLINT catLen,
5984 SQLCHAR *schema, SQLSMALLINT schemaLen,
5985 SQLCHAR *table, SQLSMALLINT tableLen)
5990 int ncols, rc, size, npatt;
5991 char *errp = NULL, *sql, tname[512];
5994 tablePrivSpec3,
array_size(tablePrivSpec3), NULL);
5995 if (ret != SQL_SUCCESS) {
6000 if (cat && (catLen > 0 || catLen == SQL_NTS) && cat[0] ==
'%') {
6004 if (schema && (schemaLen > 0 || schemaLen == SQL_NTS) &&
6006 if ((!cat || catLen == 0 || !cat[0]) &&
6007 (!table || tableLen == 0 || !table[0])) {
6017 if (tableLen == SQL_NTS) {
6018 size =
sizeof (tname) - 1;
6020 size =
min(
sizeof (tname) - 1, tableLen);
6022 strncpy(tname, (
char *) table, size);
6026 #if defined(_WIN32) || defined(_WIN64) 6027 sql = sqlite3_mprintf(
"select %s as 'TABLE_QUALIFIER', " 6028 "%s as 'TABLE_OWNER', " 6029 "tbl_name as 'TABLE_NAME', " 6032 "'SELECT' AS 'PRIVILEGE', " 6033 "NULL as 'IS_GRANTABLE' " 6034 "from sqlite_master where " 6035 "(type = 'table' or type = 'view') " 6036 "and tbl_name %s %Q " 6038 "select %s as 'TABLE_QUALIFIER', " 6039 "%s as 'TABLE_OWNER', " 6040 "tbl_name as 'TABLE_NAME', " 6043 "'UPDATE' AS 'PRIVILEGE', " 6044 "NULL as 'IS_GRANTABLE' " 6045 "from sqlite_master where " 6046 "(type = 'table' or type = 'view') " 6047 "and tbl_name %s %Q " 6049 "select %s as 'TABLE_QUALIFIER', " 6050 "%s as 'TABLE_OWNER', " 6051 "tbl_name as 'TABLE_NAME', " 6054 "'DELETE' AS 'PRIVILEGE', " 6055 "NULL as 'IS_GRANTABLE' " 6056 "from sqlite_master where " 6057 "(type = 'table' or type = 'view') " 6058 "and tbl_name %s %Q " 6060 "select %s as 'TABLE_QUALIFIER', " 6061 "%s as 'TABLE_OWNER', " 6062 "tbl_name as 'TABLE_NAME', " 6065 "'INSERT' AS 'PRIVILEGE', " 6066 "NULL as 'IS_GRANTABLE' " 6067 "from sqlite_master where " 6068 "(type = 'table' or type = 'view') " 6069 "and tbl_name %s %Q " 6071 "select %s as 'TABLE_QUALIFIER', " 6072 "%s as 'TABLE_OWNER', " 6073 "tbl_name as 'TABLE_NAME', " 6076 "'REFERENCES' AS 'PRIVILEGE', " 6077 "NULL as 'IS_GRANTABLE' " 6078 "from sqlite_master where " 6079 "(type = 'table' or type = 'view') " 6080 "and tbl_name %s %Q",
6081 d->xcelqrx ?
"'main'" :
"NULL",
6082 d->xcelqrx ?
"''" :
"NULL",
6083 npatt ?
"like" :
"=", tname,
6084 d->xcelqrx ?
"'main'" :
"NULL",
6085 d->xcelqrx ?
"''" :
"NULL",
6086 npatt ?
"like" :
"=", tname,
6087 d->xcelqrx ?
"'main'" :
"NULL",
6088 d->xcelqrx ?
"''" :
"NULL",
6089 npatt ?
"like" :
"=", tname,
6090 d->xcelqrx ?
"'main'" :
"NULL",
6091 d->xcelqrx ?
"''" :
"NULL",
6092 npatt ?
"like" :
"=", tname,
6093 d->xcelqrx ?
"'main'" :
"NULL",
6094 d->xcelqrx ?
"''" :
"NULL",
6095 npatt ?
"like" :
"=", tname);
6097 sql = sqlite3_mprintf(
"select NULL as 'TABLE_QUALIFIER', " 6098 "NULL as 'TABLE_OWNER', " 6099 "tbl_name as 'TABLE_NAME', " 6102 "'SELECT' AS 'PRIVILEGE', " 6103 "NULL as 'IS_GRANTABLE' " 6104 "from sqlite_master where " 6105 "(type = 'table' or type = 'view') " 6106 "and tbl_name %s %Q " 6108 "select NULL as 'TABLE_QUALIFIER', " 6109 "NULL as 'TABLE_OWNER', " 6110 "tbl_name as 'TABLE_NAME', " 6113 "'UPDATE' AS 'PRIVILEGE', " 6114 "NULL as 'IS_GRANTABLE' " 6115 "from sqlite_master where " 6116 "(type = 'table' or type = 'view') " 6117 "and tbl_name %s %Q " 6119 "select NULL as 'TABLE_QUALIFIER', " 6120 "NULL as 'TABLE_OWNER', " 6121 "tbl_name as 'TABLE_NAME', " 6124 "'DELETE' AS 'PRIVILEGE', " 6125 "NULL as 'IS_GRANTABLE' " 6126 "from sqlite_master where " 6127 "(type = 'table' or type = 'view') " 6128 "and tbl_name %s %Q " 6130 "select NULL as 'TABLE_QUALIFIER', " 6131 "NULL as 'TABLE_OWNER', " 6132 "tbl_name as 'TABLE_NAME', " 6135 "'INSERT' AS 'PRIVILEGE', " 6136 "NULL as 'IS_GRANTABLE' " 6137 "from sqlite_master where " 6138 "(type = 'table' or type = 'view') " 6139 "and tbl_name %s %Q " 6141 "select NULL as 'TABLE_QUALIFIER', " 6142 "NULL as 'TABLE_OWNER', " 6143 "tbl_name as 'TABLE_NAME', " 6146 "'REFERENCES' AS 'PRIVILEGE', " 6147 "NULL as 'IS_GRANTABLE' " 6148 "from sqlite_master where " 6149 "(type = 'table' or type = 'view') " 6150 "and tbl_name %s %Q",
6151 npatt ?
"like" :
"=", tname,
6152 npatt ?
"like" :
"=", tname,
6153 npatt ?
"like" :
"=", tname,
6154 npatt ?
"like" :
"=", tname,
6155 npatt ?
"like" :
"=", tname);
6161 if (ret != SQL_SUCCESS) {
6166 rc = sqlite3_get_table(d->
sqlite, sql, &s->
rows, &s->
nrows, &ncols, &errp);
6168 if (rc == SQLITE_OK) {
6169 if (ncols != s->
ncols) {
6173 s->
rowfree = sqlite3_free_table;
6189 #if !defined(WINTERFACE) || (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC)) 6203 SQLTablePrivileges(SQLHSTMT
stmt,
6204 SQLCHAR *catalog, SQLSMALLINT catalogLen,
6205 SQLCHAR *schema, SQLSMALLINT schemaLen,
6206 SQLCHAR *table, SQLSMALLINT tableLen)
6208 #if defined(_WIN32) || defined(_WIN64) 6209 char *c = NULL, *s = NULL, *t = NULL;
6214 #if defined(_WIN32) || defined(_WIN64) 6215 if (!((
STMT *) stmt)->oemcp[0]) {
6221 c = wmb_to_utf_c((
char *) catalog, catalogLen);
6228 s = wmb_to_utf_c((
char *) schema, schemaLen);
6235 t = wmb_to_utf_c((
char *) table, tableLen);
6242 (SQLCHAR *) s, SQL_NTS,
6243 (SQLCHAR *) t, SQL_NTS);
6248 #if defined(_WIN32) || defined(_WIN64) 6261 #if !defined(HAVE_UNIXODBC) || !(HAVE_UNIXODBC) 6277 SQLWCHAR *catalog, SQLSMALLINT catalogLen,
6278 SQLWCHAR *schema, SQLSMALLINT schemaLen,
6279 SQLWCHAR *table, SQLSMALLINT tableLen)
6281 char *c = NULL, *s = NULL, *t = NULL;
6307 (SQLCHAR *) s, SQL_NTS,
6308 (SQLCHAR *) t, SQL_NTS);
6324 {
"SYSTEM",
"COLPRIV",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
6325 {
"SYSTEM",
"COLPRIV",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
6326 {
"SYSTEM",
"COLPRIV",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
6327 {
"SYSTEM",
"COLPRIV",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6334 {
"SYSTEM",
"COLPRIV",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
6335 {
"SYSTEM",
"COLPRIV",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
6336 {
"SYSTEM",
"COLPRIV",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
6337 {
"SYSTEM",
"COLPRIV",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6343 #if !defined(WINTERFACE) || (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC)) 6359 SQLColumnPrivileges(SQLHSTMT stmt,
6360 SQLCHAR *catalog, SQLSMALLINT catalogLen,
6361 SQLCHAR *schema, SQLSMALLINT schemaLen,
6362 SQLCHAR *table, SQLSMALLINT tableLen,
6363 SQLCHAR *column, SQLSMALLINT columnLen)
6369 colPrivSpec3,
array_size(colPrivSpec3), NULL);
6375 #if !defined(HAVE_UNIXODBC) || !(HAVE_UNIXODBC) 6393 SQLWCHAR *catalog, SQLSMALLINT catalogLen,
6394 SQLWCHAR *schema, SQLSMALLINT schemaLen,
6395 SQLWCHAR *table, SQLSMALLINT tableLen,
6396 SQLWCHAR *column, SQLSMALLINT columnLen)
6402 colPrivSpec3,
array_size(colPrivSpec3), NULL);
6414 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
6415 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
6416 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
6417 {
"SYSTEM",
"PRIMARYKEY",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6418 {
"SYSTEM",
"PRIMARYKEY",
"KEY_SEQ", SQL_SMALLINT, 50 },
6419 {
"SYSTEM",
"PRIMARYKEY",
"PK_NAME",
SCOL_VARCHAR, 50 }
6423 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
6424 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
6425 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
6426 {
"SYSTEM",
"PRIMARYKEY",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6427 {
"SYSTEM",
"PRIMARYKEY",
"KEY_SEQ", SQL_SMALLINT, 50 },
6428 {
"SYSTEM",
"PRIMARYKEY",
"PK_NAME",
SCOL_VARCHAR, 50 }
6445 SQLCHAR *cat, SQLSMALLINT catLen,
6446 SQLCHAR *schema, SQLSMALLINT schemaLen,
6447 SQLCHAR *table, SQLSMALLINT tableLen)
6452 int i, asize, ret, nrows, ncols, nrows2 = 0, ncols2 = 0;
6453 int namec = -1, uniquec = -1, namec2 = -1, uniquec2 = -1, offs, seq = 1;
6455 char **rowp = NULL, **rowp2 = NULL, *errp = NULL, *sql, tname[512];
6459 if (sret != SQL_SUCCESS) {
6464 if (!table || table[0] ==
'\0' || table[0] ==
'%') {
6465 setstat(s, -1,
"need table name", (*s->
ov3) ?
"HY000" :
"S1000");
6468 if (tableLen == SQL_NTS) {
6469 size =
sizeof (tname) - 1;
6471 size =
min(
sizeof (tname) - 1, tableLen);
6473 strncpy(tname, (
char *) table, size);
6476 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", tname);
6481 if (sret != SQL_SUCCESS) {
6486 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
6488 if (ret != SQLITE_OK) {
6489 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
6490 errp ? errp :
"unknown error", ret);
6502 if (ncols * nrows > 0) {
6505 namec =
findcol(rowp, ncols,
"name");
6506 uniquec =
findcol(rowp, ncols,
"pk");
6507 typec =
findcol(rowp, ncols,
"type");
6508 if (namec >= 0 && uniquec >= 0 && typec >= 0) {
6509 for (i = 1; i <= nrows; i++) {
6510 if (*rowp[i * ncols + uniquec] !=
'0') {
6517 sql = sqlite3_mprintf(
"PRAGMA index_list(%Q)", tname);
6519 sqlite3_free_table(rowp);
6523 ret = sqlite3_get_table(d->
sqlite, sql, &rowp2, &nrows2, &ncols2,
6526 if (ret != SQLITE_OK) {
6527 sqlite3_free_table(rowp);
6528 sqlite3_free_table(rowp2);
6529 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
6530 errp ? errp :
"unknown error", ret);
6542 if (ncols2 * nrows2 > 0) {
6543 namec2 =
findcol(rowp2, ncols2,
"name");
6544 uniquec2 =
findcol(rowp2, ncols2,
"unique");
6545 if (namec2 >= 0 && uniquec2 >= 0) {
6546 for (i = 1; i <= nrows2; i++) {
6547 int nnrows, nncols, nlen = 0;
6550 if (rowp2[i * ncols2 + namec2]) {
6551 nlen = strlen(rowp2[i * ncols2 + namec2]);
6554 strncmp(rowp2[i * ncols2 + namec2],
6555 "sqlite_autoindex_", 17)) {
6558 if (*rowp2[i * ncols2 + uniquec2] !=
'0') {
6560 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
6561 rowp2[i * ncols2 + namec2]);
6564 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
6565 &nnrows, &nncols, NULL);
6568 if (ret == SQLITE_OK) {
6570 sqlite3_free_table(rowpp);
6577 sqlite3_free_table(rowp);
6578 sqlite3_free_table(rowp2);
6582 size = (size + 1) * asize;
6586 sqlite3_free_table(rowp);
6587 sqlite3_free_table(rowp2);
6590 s->
rows[0] = (
char *) size;
6592 memset(s->
rows, 0, sizeof (
char *) * size);
6596 for (i = 1; i <= nrows; i++) {
6597 if (*rowp[i * ncols + uniquec] !=
'0') {
6600 #if defined(_WIN32) || defined(_WIN64) 6601 s->
rows[offs + 0] =
xstrdup(d->xcelqrx ?
"main" :
"");
6608 s->
rows[offs + 3] =
xstrdup(rowp[i * ncols + namec]);
6609 sprintf(buf,
"%d", seq++);
6616 for (i = 1; i <= nrows2; i++) {
6617 int nnrows, nncols, nlen = 0;
6620 if (rowp2[i * ncols2 + namec2]) {
6621 nlen = strlen(rowp2[i * ncols2 + namec2]);
6624 strncmp(rowp2[i * ncols2 + namec2],
"sqlite_autoindex_", 17)) {
6627 if (*rowp2[i * ncols2 + uniquec2] !=
'0') {
6631 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
6632 rowp2[i * ncols2 + namec2]);
6635 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
6636 &nnrows, &nncols, NULL);
6639 if (ret != SQLITE_OK) {
6642 for (k = 0; nnrows && k < nncols; k++) {
6643 if (strcmp(rowpp[k],
"name") == 0) {
6646 for (m = 1; m <= nnrows; m++) {
6647 int roffs = offs + (m - 1) * s->
ncols;
6649 #
if defined(_WIN32) || defined(_WIN64)
6650 s->
rows[roffs + 0] =
6651 xstrdup(d->xcelqrx ?
"main" :
"");
6658 s->
rows[roffs + 3] =
6659 xstrdup(rowpp[m * nncols + k]);
6660 s->
rows[roffs + 5] =
6661 xstrdup(rowp2[i * ncols2 + namec2]);
6663 }
else if (strcmp(rowpp[k],
"seqno") == 0) {
6666 for (m = 1; m <= nnrows; m++) {
6667 int roffs = offs + (m - 1) * s->
ncols;
6671 sscanf(rowpp[m * nncols + k],
"%d", &pos);
6672 sprintf(buf,
"%d", pos + 1);
6677 offs += nnrows * s->
ncols;
6678 sqlite3_free_table(rowpp);
6682 sqlite3_free_table(rowp);
6683 sqlite3_free_table(rowp2);
6701 SQLPrimaryKeys(SQLHSTMT stmt,
6702 SQLCHAR *cat, SQLSMALLINT catLen,
6703 SQLCHAR *schema, SQLSMALLINT schemaLen,
6704 SQLCHAR *table, SQLSMALLINT tableLen)
6706 #if defined(_WIN32) || defined(_WIN64) 6707 char *c = NULL, *s = NULL, *t = NULL;
6712 #if defined(_WIN32) || defined(_WIN64) 6713 if (!((
STMT *) stmt)->oemcp[0]) {
6719 c = wmb_to_utf_c((
char *) cat, catLen);
6726 s = wmb_to_utf_c((
char *) schema, schemaLen);
6733 t = wmb_to_utf_c((
char *) table, tableLen);
6740 (SQLCHAR *) s, SQL_NTS, (SQLCHAR *) t, SQL_NTS);
6745 #if defined(_WIN32) || defined(_WIN64) 6773 SQLWCHAR *cat, SQLSMALLINT catLen,
6774 SQLWCHAR *schema, SQLSMALLINT schemaLen,
6775 SQLWCHAR *table, SQLSMALLINT tableLen)
6777 char *c = NULL, *s = NULL, *t = NULL;
6803 (SQLCHAR *) s, SQL_NTS, (SQLCHAR *) t, SQL_NTS);
6818 {
"SYSTEM",
"COLUMN",
"SCOPE", SQL_SMALLINT, 1 },
6819 {
"SYSTEM",
"COLUMN",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6820 {
"SYSTEM",
"COLUMN",
"DATA_TYPE", SQL_SMALLINT, 50 },
6822 {
"SYSTEM",
"COLUMN",
"PRECISION", SQL_INTEGER, 50 },
6823 {
"SYSTEM",
"COLUMN",
"LENGTH", SQL_INTEGER, 50 },
6824 {
"SYSTEM",
"COLUMN",
"DECIMAL_DIGITS", SQL_INTEGER, 50 },
6825 {
"SYSTEM",
"COLUMN",
"PSEUDO_COLUMN", SQL_SMALLINT, 1 },
6826 {
"SYSTEM",
"COLUMN",
"NULLABLE", SQL_SMALLINT, 1 }
6830 {
"SYSTEM",
"COLUMN",
"SCOPE", SQL_SMALLINT, 1 },
6831 {
"SYSTEM",
"COLUMN",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6832 {
"SYSTEM",
"COLUMN",
"DATA_TYPE", SQL_SMALLINT, 50 },
6834 {
"SYSTEM",
"COLUMN",
"COLUMN_SIZE", SQL_INTEGER, 50 },
6835 {
"SYSTEM",
"COLUMN",
"BUFFER_LENGTH", SQL_INTEGER, 50 },
6836 {
"SYSTEM",
"COLUMN",
"DECIMAL_DIGITS", SQL_INTEGER, 50 },
6837 {
"SYSTEM",
"COLUMN",
"PSEUDO_COLUMN", SQL_SMALLINT, 1 },
6838 {
"SYSTEM",
"COLUMN",
"NULLABLE", SQL_SMALLINT, 1 }
6858 SQLCHAR *cat, SQLSMALLINT catLen,
6859 SQLCHAR *schema, SQLSMALLINT schemaLen,
6860 SQLCHAR *table, SQLSMALLINT tableLen,
6861 SQLUSMALLINT scope, SQLUSMALLINT nullable)
6866 int i, asize, ret, nrows, ncols, nnnrows, nnncols, offs;
6868 int namec = -1, uniquec = -1, namecc = -1, typecc = -1;
6869 int notnullcc = -1, mkrowid = 0;
6870 char *errp = NULL, *sql, tname[512];
6871 char **rowp = NULL, **rowppp = NULL;
6875 if (sret != SQL_SUCCESS) {
6880 if (!table || table[0] ==
'\0' || table[0] ==
'%') {
6881 setstat(s, -1,
"need table name", (*s->
ov3) ?
"HY000" :
"S1000");
6884 if (tableLen == SQL_NTS) {
6885 size =
sizeof (tname) - 1;
6887 size =
min(
sizeof (tname) - 1, tableLen);
6889 strncpy(tname, (
char *) table, size);
6892 if (
id != SQL_BEST_ROWID) {
6895 sql = sqlite3_mprintf(
"PRAGMA index_list(%Q)", tname);
6900 if (sret != SQL_SUCCESS) {
6905 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
6907 if (ret != SQLITE_OK) {
6909 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
6910 errp ? errp :
"unknown error", ret);
6922 if (ncols * nrows <= 0) {
6923 goto nodata_but_rowid;
6925 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", tname);
6930 ret = sqlite3_get_table(d->
sqlite, sql, &rowppp, &nnnrows, &nnncols,
6933 if (ret != SQLITE_OK) {
6934 sqlite3_free_table(rowp);
6941 namec =
findcol(rowp, ncols,
"name");
6942 uniquec =
findcol(rowp, ncols,
"unique");
6943 if (namec < 0 || uniquec < 0) {
6944 goto nodata_but_rowid;
6946 namecc =
findcol(rowppp, nnncols,
"name");
6947 typecc =
findcol(rowppp, nnncols,
"type");
6948 notnullcc =
findcol(rowppp, nnncols,
"notnull");
6949 for (i = 1; i <= nrows; i++) {
6951 char **rowpp = NULL;
6953 if (*rowp[i * ncols + uniquec] !=
'0') {
6955 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
6956 rowp[i * ncols + namec]);
6959 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
6960 &nnrows, &nncols, NULL);
6963 if (ret == SQLITE_OK) {
6965 sqlite3_free_table(rowpp);
6975 size = (size + 1) * asize;
6979 sqlite3_free_table(rowp);
6980 sqlite3_free_table(rowppp);
6983 s->
rows[0] = (
char *) size;
6985 memset(s->
rows, 0, sizeof (
char *) * size);
6992 for (i = 1; i <= nrows; i++) {
6994 char **rowpp = NULL;
6996 if (*rowp[i * ncols + uniquec] !=
'0') {
7000 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
7001 rowp[i * ncols + namec]);
7004 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
7005 &nnrows, &nncols, NULL);
7008 if (ret != SQLITE_OK) {
7011 for (k = 0; nnrows && k < nncols; k++) {
7012 if (strcmp(rowpp[k],
"name") == 0) {
7015 for (m = 1; m <= nnrows; m++) {
7016 int roffs = (offs + m) * s->
ncols;
7018 s->
rows[roffs + 0] =
7020 s->
rows[roffs + 1] =
xstrdup(rowpp[m * nncols + k]);
7022 s->
rows[roffs + 7] =
7024 if (namecc >= 0 && typecc >= 0) {
7027 for (ii = 1; ii <= nnnrows; ii++) {
7028 if (strcmp(rowppp[ii * nnncols + namecc],
7029 rowpp[m * nncols + k]) == 0) {
7030 char *typen = rowppp[ii * nnncols + typecc];
7031 int sqltype, mm, dd, isnullable = 0;
7038 getmd(typen, sqltype, &mm, &dd);
7039 #ifdef SQL_LONGVARCHAR 7040 if (sqltype == SQL_VARCHAR && mm > 255) {
7041 sqltype = SQL_LONGVARCHAR;
7045 #ifdef SQL_WLONGVARCHAR 7046 if (sqltype == SQL_WVARCHAR && mm > 255) {
7047 sqltype = SQL_WLONGVARCHAR;
7051 if (sqltype == SQL_VARBINARY && mm > 255) {
7052 sqltype = SQL_LONGVARBINARY;
7054 sprintf(buf,
"%d", sqltype);
7056 sprintf(buf,
"%d", mm);
7058 sprintf(buf,
"%d", dd);
7060 if (notnullcc >= 0) {
7062 rowppp[ii * nnncols + notnullcc];
7064 isnullable = inp[0] !=
'0';
7066 sprintf(buf,
"%d", isnullable);
7075 sqlite3_free_table(rowpp);
7078 if (nullable == SQL_NO_NULLS) {
7079 for (i = 1; i < s->
nrows; i++) {
7080 if (s->
rows[i * s->
ncols + 8][0] ==
'0') {
7083 for (m = 0; m < s->
ncols; m++) {
7086 size = s->
ncols *
sizeof (
char *) * (s->
nrows - i1);
7092 s->
ncols * sizeof (
char *));
7100 sqlite3_free_table(rowp);
7101 sqlite3_free_table(rowppp);
7102 if (s->
nrows == 0) {
7134 SQLSpecialColumns(SQLHSTMT stmt, SQLUSMALLINT
id,
7135 SQLCHAR *cat, SQLSMALLINT catLen,
7136 SQLCHAR *schema, SQLSMALLINT schemaLen,
7137 SQLCHAR *table, SQLSMALLINT tableLen,
7138 SQLUSMALLINT scope, SQLUSMALLINT nullable)
7140 #if defined(_WIN32) || defined(_WIN64) 7141 char *c = NULL, *s = NULL, *t = NULL;
7146 #if defined(_WIN32) || defined(_WIN64) 7147 if (!((
STMT *) stmt)->oemcp[0]) {
7149 table, tableLen, scope, nullable);
7153 c = wmb_to_utf_c((
char *) cat, catLen);
7160 s = wmb_to_utf_c((
char *) schema, schemaLen);
7167 t = wmb_to_utf_c((
char *) table, tableLen);
7174 (SQLCHAR *) s, SQL_NTS, (SQLCHAR *) t, SQL_NTS,
7178 table, tableLen, scope, nullable);
7180 #if defined(_WIN32) || defined(_WIN64) 7211 SQLWCHAR *cat, SQLSMALLINT catLen,
7212 SQLWCHAR *schema, SQLSMALLINT schemaLen,
7213 SQLWCHAR *table, SQLSMALLINT tableLen,
7214 SQLUSMALLINT scope, SQLUSMALLINT nullable)
7216 char *c = NULL, *s = NULL, *t = NULL;
7242 (SQLCHAR *) s, SQL_NTS, (SQLCHAR *) t, SQL_NTS,
7258 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
7259 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_OWNER",
SCOL_VARCHAR, 50 },
7260 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_NAME",
SCOL_VARCHAR, 255 },
7261 {
"SYSTEM",
"FOREIGNKEY",
"PKCOLUMN_NAME",
SCOL_VARCHAR, 255 },
7262 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
7263 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_OWNER",
SCOL_VARCHAR, 50 },
7264 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_NAME",
SCOL_VARCHAR, 255 },
7265 {
"SYSTEM",
"FOREIGNKEY",
"FKCOLUMN_NAME",
SCOL_VARCHAR, 255 },
7266 {
"SYSTEM",
"FOREIGNKEY",
"KEY_SEQ", SQL_SMALLINT, 5 },
7267 {
"SYSTEM",
"FOREIGNKEY",
"UPDATE_RULE", SQL_SMALLINT, 5 },
7268 {
"SYSTEM",
"FOREIGNKEY",
"DELETE_RULE", SQL_SMALLINT, 5 },
7269 {
"SYSTEM",
"FOREIGNKEY",
"FK_NAME",
SCOL_VARCHAR, 255 },
7270 {
"SYSTEM",
"FOREIGNKEY",
"PK_NAME",
SCOL_VARCHAR, 255 },
7271 {
"SYSTEM",
"FOREIGNKEY",
"DEFERRABILITY", SQL_SMALLINT, 5 }
7275 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_CAT",
SCOL_VARCHAR, 50 },
7276 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_SCHEM",
SCOL_VARCHAR, 50 },
7277 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_NAME",
SCOL_VARCHAR, 255 },
7278 {
"SYSTEM",
"FOREIGNKEY",
"PKCOLUMN_NAME",
SCOL_VARCHAR, 255 },
7279 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_CAT",
SCOL_VARCHAR, 50 },
7280 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_SCHEM",
SCOL_VARCHAR, 50 },
7281 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_NAME",
SCOL_VARCHAR, 255 },
7282 {
"SYSTEM",
"FOREIGNKEY",
"FKCOLUMN_NAME",
SCOL_VARCHAR, 255 },
7283 {
"SYSTEM",
"FOREIGNKEY",
"KEY_SEQ", SQL_SMALLINT, 5 },
7284 {
"SYSTEM",
"FOREIGNKEY",
"UPDATE_RULE", SQL_SMALLINT, 5 },
7285 {
"SYSTEM",
"FOREIGNKEY",
"DELETE_RULE", SQL_SMALLINT, 5 },
7286 {
"SYSTEM",
"FOREIGNKEY",
"FK_NAME",
SCOL_VARCHAR, 255 },
7287 {
"SYSTEM",
"FOREIGNKEY",
"PK_NAME",
SCOL_VARCHAR, 255 },
7288 {
"SYSTEM",
"FOREIGNKEY",
"DEFERRABILITY", SQL_SMALLINT, 5 }
7311 SQLCHAR *PKcatalog, SQLSMALLINT PKcatalogLen,
7312 SQLCHAR *PKschema, SQLSMALLINT PKschemaLen,
7313 SQLCHAR *PKtable, SQLSMALLINT PKtableLen,
7314 SQLCHAR *FKcatalog, SQLSMALLINT FKcatalogLen,
7315 SQLCHAR *FKschema, SQLSMALLINT FKschemaLen,
7316 SQLCHAR *FKtable, SQLSMALLINT FKtableLen)
7321 int i, asize, ret, nrows, ncols, offs, namec, seqc, fromc, toc;
7324 char **rowp, *errp = NULL, *sql, pname[512], fname[512];
7328 if (sret != SQL_SUCCESS) {
7333 if (sret != SQL_SUCCESS) {
7337 if ((!PKtable || PKtable[0] ==
'\0' || PKtable[0] ==
'%') &&
7338 (!FKtable || FKtable[0] ==
'\0' || FKtable[0] ==
'%')) {
7339 setstat(s, -1,
"need table name", (*s->
ov3) ?
"HY000" :
"S1000");
7344 if (PKtableLen == SQL_NTS) {
7345 size =
sizeof (pname) - 1;
7347 size =
min(
sizeof (pname) - 1, PKtableLen);
7349 strncpy(pname, (
char *) PKtable, size);
7355 if (FKtableLen == SQL_NTS) {
7356 size =
sizeof (fname) - 1;
7358 size =
min(
sizeof (fname) - 1, FKtableLen);
7360 strncpy(fname, (
char *) FKtable, size);
7363 if (fname[0] !=
'\0') {
7367 sql = sqlite3_mprintf(
"PRAGMA foreign_key_list(%Q)", fname);
7370 ret = sqlite3_get_table(d->
sqlite, sql, &rowp,
7371 &nrows, &ncols, &errp);
7374 if (ret != SQLITE_OK) {
7375 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
7376 errp ? errp :
"unknown error", ret);
7387 if (ncols * nrows <= 0) {
7389 sqlite3_free_table(rowp);
7393 namec =
findcol(rowp, ncols,
"table");
7394 seqc =
findcol(rowp, ncols,
"seq");
7395 fromc =
findcol(rowp, ncols,
"from");
7396 toc =
findcol(rowp, ncols,
"to");
7397 onu =
findcol(rowp, ncols,
"on_update");
7398 ond =
findcol(rowp, ncols,
"on_delete");
7399 if (namec < 0 || seqc < 0 || fromc < 0 || toc < 0) {
7402 plen = strlen(pname);
7403 for (i = 1; i <= nrows; i++) {
7404 char *ptab =
unquote(rowp[i * ncols + namec]);
7407 int len = strlen(ptab);
7409 if (plen != len || strncasecmp(pname, ptab, plen) != 0) {
7419 size = (size + 1) * asize;
7425 s->
rows[0] = (
char *) size;
7427 memset(s->
rows, 0, sizeof (
char *) * size);
7430 for (i = 1; i <= nrows; i++) {
7431 int pos = 0, roffs = (offs + 1) * s->
ncols;
7432 char *ptab = rowp[i * ncols + namec];
7436 int len = strlen(ptab);
7438 if (plen != len || strncasecmp(pname, ptab, plen) != 0) {
7442 #if defined(_WIN32) || defined(_WIN64) 7443 s->
rows[roffs + 0] =
xstrdup(d->xcelqrx ?
"main" :
"");
7450 s->
rows[roffs + 3] =
xstrdup(rowp[i * ncols + toc]);
7454 s->
rows[roffs + 7] =
xstrdup(rowp[i * ncols + fromc]);
7455 sscanf(rowp[i * ncols + seqc],
"%d", &pos);
7456 sprintf(buf,
"%d", pos + 1);
7461 if (strcmp(rowp[i * ncols + onu],
"SET NULL") == 0) {
7463 }
else if (strcmp(rowp[i * ncols + onu],
"SET DEFAULT") == 0) {
7465 }
else if (strcmp(rowp[i * ncols + onu],
"CASCADE") == 0) {
7467 }
else if (strcmp(rowp[i * ncols + onu],
"RESTRICT") == 0) {
7476 if (strcmp(rowp[i * ncols + ond],
"SET NULL") == 0) {
7478 }
else if (strcmp(rowp[i * ncols + ond],
"SET DEFAULT") == 0) {
7480 }
else if (strcmp(rowp[i * ncols + ond],
"CASCADE") == 0) {
7482 }
else if (strcmp(rowp[i * ncols + ond],
"RESTRICT") == 0) {
7488 s->
rows[roffs + 11] = NULL;
7489 s->
rows[roffs + 12] = NULL;
7493 sqlite3_free_table(rowp);
7495 int nnrows, nncols, plen = strlen(pname);
7498 sql =
"select name from sqlite_master where type='table'";
7500 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
7501 if (ret != SQLITE_OK) {
7502 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
7503 errp ? errp :
"unknown error", ret);
7514 if (ncols * nrows <= 0) {
7518 for (i = 1; i <= nrows; i++) {
7526 sql = sqlite3_mprintf(
"PRAGMA foreign_key_list(%Q)", rowp[i]);
7529 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
7530 &nnrows, &nncols, NULL);
7533 if (ret != SQLITE_OK || nncols * nnrows <= 0) {
7534 sqlite3_free_table(rowpp);
7537 namec =
findcol(rowpp, nncols,
"table");
7538 seqc =
findcol(rowpp, nncols,
"seq");
7539 fromc =
findcol(rowpp, nncols,
"from");
7540 toc =
findcol(rowpp, nncols,
"to");
7541 if (namec < 0 || seqc < 0 || fromc < 0 || toc < 0) {
7542 sqlite3_free_table(rowpp);
7545 for (k = 1; k <= nnrows; k++) {
7546 char *ptab =
unquote(rowpp[k * nncols + namec]);
7549 int len = strlen(ptab);
7551 if (len != plen || strncasecmp(pname, ptab, plen) != 0) {
7557 sqlite3_free_table(rowpp);
7563 size = (size + 1) * asize;
7569 s->
rows[0] = (
char *) size;
7571 memset(s->
rows, 0, sizeof (
char *) * size);
7574 for (i = 1; i <= nrows; i++) {
7582 sql = sqlite3_mprintf(
"PRAGMA foreign_key_list(%Q)", rowp[i]);
7585 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
7586 &nnrows, &nncols, NULL);
7589 if (ret != SQLITE_OK || nncols * nnrows <= 0) {
7590 sqlite3_free_table(rowpp);
7593 namec =
findcol(rowpp, nncols,
"table");
7594 seqc =
findcol(rowpp, nncols,
"seq");
7595 fromc =
findcol(rowpp, nncols,
"from");
7596 toc =
findcol(rowpp, nncols,
"to");
7597 onu =
findcol(rowpp, nncols,
"on_update");
7598 ond =
findcol(rowpp, nncols,
"on_delete");
7599 if (namec < 0 || seqc < 0 || fromc < 0 || toc < 0) {
7600 sqlite3_free_table(rowpp);
7603 for (k = 1; k <= nnrows; k++) {
7604 int pos = 0, roffs = (offs + 1) * s->
ncols;
7605 char *ptab =
unquote(rowpp[k * nncols + namec]);
7609 int len = strlen(ptab);
7611 if (len != plen || strncasecmp(pname, ptab, plen) != 0) {
7615 #if defined(_WIN32) || defined(_WIN64) 7616 s->
rows[roffs + 0] =
xstrdup(d->xcelqrx ?
"main" :
"");
7623 s->
rows[roffs + 3] =
xstrdup(rowpp[k * nncols + toc]);
7627 s->
rows[roffs + 7] =
xstrdup(rowpp[k * nncols + fromc]);
7628 sscanf(rowpp[k * nncols + seqc],
"%d", &pos);
7629 sprintf(buf,
"%d", pos + 1);
7634 if (strcmp(rowpp[k * nncols + onu],
"SET NULL") == 0) {
7636 }
else if (strcmp(rowpp[k * nncols + onu],
"SET DEFAULT")
7638 s->
rows[roffs + 9] =
7640 }
else if (strcmp(rowpp[k * nncols + onu],
"CASCADE")
7643 }
else if (strcmp(rowpp[k * nncols + onu],
"RESTRICT")
7647 s->
rows[roffs + 9] =
7654 if (strcmp(rowpp[k * nncols + ond],
"SET NULL") == 0) {
7656 }
else if (strcmp(rowpp[k * nncols + ond],
"SET DEFAULT")
7658 s->
rows[roffs + 10] =
7660 }
else if (strcmp(rowpp[k * nncols + ond],
"CASCADE")
7663 }
else if (strcmp(rowpp[k * nncols + ond],
"RESTRICT")
7667 s->
rows[roffs + 10] =
7671 s->
rows[roffs + 11] = NULL;
7672 s->
rows[roffs + 12] = NULL;
7676 sqlite3_free_table(rowpp);
7678 sqlite3_free_table(rowp);
7703 SQLForeignKeys(SQLHSTMT stmt,
7704 SQLCHAR *PKcatalog, SQLSMALLINT PKcatalogLen,
7705 SQLCHAR *PKschema, SQLSMALLINT PKschemaLen,
7706 SQLCHAR *PKtable, SQLSMALLINT PKtableLen,
7707 SQLCHAR *FKcatalog, SQLSMALLINT FKcatalogLen,
7708 SQLCHAR *FKschema, SQLSMALLINT FKschemaLen,
7709 SQLCHAR *FKtable, SQLSMALLINT FKtableLen)
7711 #if defined(_WIN32) || defined(_WIN64) 7712 char *pc = NULL, *ps = NULL, *pt = NULL;
7713 char *fc = NULL, *fs = NULL, *ft = NULL;
7718 #if defined(_WIN32) || defined(_WIN64) 7719 if (!((
STMT *) stmt)->oemcp[0]) {
7721 PKcatalog, PKcatalogLen,
7722 PKschema, PKschemaLen, PKtable, PKtableLen,
7723 FKcatalog, FKcatalogLen,
7724 FKschema, FKschemaLen,
7725 FKtable, FKtableLen);
7729 pc = wmb_to_utf_c((
char *) PKcatalog, PKcatalogLen);
7736 ps = wmb_to_utf_c((
char *) PKschema, PKschemaLen);
7743 pt = wmb_to_utf_c((
char *) PKtable, PKtableLen);
7750 fc = wmb_to_utf_c((
char *) FKcatalog, FKcatalogLen);
7757 fs = wmb_to_utf_c((
char *) FKschema, FKschemaLen);
7764 ft = wmb_to_utf_c((
char *) FKtable, FKtableLen);
7771 (SQLCHAR *) ps, SQL_NTS, (SQLCHAR *) pt, SQL_NTS,
7772 (SQLCHAR *) fc, SQL_NTS, (SQLCHAR *) fs, SQL_NTS,
7773 (SQLCHAR *) ft, SQL_NTS);
7776 PKcatalog, PKcatalogLen,
7777 PKschema, PKschemaLen, PKtable, PKtableLen,
7778 FKcatalog, FKcatalogLen,
7779 FKschema, FKschemaLen,
7780 FKtable, FKtableLen);
7782 #if defined(_WIN32) || defined(_WIN64) 7819 SQLWCHAR *PKcatalog, SQLSMALLINT PKcatalogLen,
7820 SQLWCHAR *PKschema, SQLSMALLINT PKschemaLen,
7821 SQLWCHAR *PKtable, SQLSMALLINT PKtableLen,
7822 SQLWCHAR *FKcatalog, SQLSMALLINT FKcatalogLen,
7823 SQLWCHAR *FKschema, SQLSMALLINT FKschemaLen,
7824 SQLWCHAR *FKtable, SQLSMALLINT FKtableLen)
7826 char *pc = NULL, *ps = NULL, *pt = NULL;
7827 char *fc = NULL, *fs = NULL, *ft = NULL;
7874 (SQLCHAR *) ps, SQL_NTS, (SQLCHAR *) pt, SQL_NTS,
7875 (SQLCHAR *) fc, SQL_NTS, (SQLCHAR *) fs, SQL_NTS,
7876 (SQLCHAR *) ft, SQL_NTS);
7898 int ret = SQL_SUCCESS, rc, busy_count = 0;
7904 rc = sqlite3_exec(d->
sqlite,
"BEGIN TRANSACTION", NULL, NULL, &errp);
7905 if (rc == SQLITE_BUSY) {
7915 if (rc != SQLITE_OK) {
7916 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
7917 errp ? errp :
"unknown error", rc);
7941 int ret, busy_count = 0;
7942 char *sql, *errp = NULL;
7945 setstatd(d, -1,
"not connected", (*d->
ov3) ?
"HY000" :
"S1000");
7953 sql =
"COMMIT TRANSACTION";
7956 sql =
"ROLLBACK TRANSACTION";
7958 ret = sqlite3_exec(d->
sqlite, sql, NULL, NULL, &errp);
7960 if (ret == SQLITE_BUSY && busy_count < 10) {
7969 if (ret != SQLITE_OK) {
7970 setstatd(d, ret,
"%s", (*d->
ov3) ?
"HY000" :
"S1000",
7971 errp ? errp :
"transaction failed");
7985 setstatd(d, -1,
"invalid completion type", (*d->
ov3) ?
"HY000" :
"S1000");
7998 drvendtran(SQLSMALLINT type, SQLHANDLE handle, SQLSMALLINT comptype)
8003 #if defined(_WIN32) || defined(_WIN64) 8008 case SQL_HANDLE_DBC:
8010 if (handle == SQL_NULL_HDBC) {
8011 return SQL_INVALID_HANDLE;
8014 ret =
endtran(d, comptype, 0);
8017 case SQL_HANDLE_ENV:
8018 if (handle == SQL_NULL_HENV) {
8019 return SQL_INVALID_HANDLE;
8021 #if defined(_WIN32) || defined(_WIN64) 8024 return SQL_INVALID_HANDLE;
8026 EnterCriticalSection(&e->cs);
8028 d = ((
ENV *) handle)->dbcs;
8031 ret =
endtran(d, comptype, 0);
8033 if (ret != SQL_SUCCESS) {
8038 #if defined(_WIN32) || defined(_WIN64) 8039 LeaveCriticalSection(&e->cs);
8041 return fail ? SQL_ERROR : SQL_SUCCESS;
8043 return SQL_INVALID_HANDLE;
8055 SQLEndTran(SQLSMALLINT type, SQLHANDLE handle, SQLSMALLINT comptype)
8071 if (dbc != SQL_NULL_HDBC) {
8072 return drvendtran(SQL_HANDLE_DBC, (SQLHANDLE) dbc, type);
8074 return drvendtran(SQL_HANDLE_ENV, (SQLHANDLE) env, type);
8100 SQLNativeSql(SQLHSTMT stmt, SQLCHAR *sqlin, SQLINTEGER sqlinLen,
8101 SQLCHAR *sql, SQLINTEGER sqlMax, SQLINTEGER *sqlLen)
8104 SQLRETURN ret = SQL_SUCCESS;
8107 if (sqlinLen == SQL_NTS) {
8108 sqlinLen = strlen((
char *) sqlin);
8112 strncpy((
char *) sql, (
char *) sqlin, sqlMax - 1);
8113 sqlin[sqlMax - 1] =
'\0';
8114 outLen =
min(sqlMax - 1, sqlinLen);
8122 if (sql && outLen < sqlinLen) {
8123 setstat((
STMT *) stmt, -1,
"data right truncated",
"01004");
8124 ret = SQL_SUCCESS_WITH_INFO;
8145 SQLWCHAR *sql, SQLINTEGER sqlMax, SQLINTEGER *sqlLen)
8148 SQLRETURN ret = SQL_SUCCESS;
8151 if (sqlinLen == SQL_NTS) {
8157 sqlin[sqlMax - 1] = 0;
8158 outLen =
min(sqlMax - 1, sqlinLen);
8166 if (sql && outLen < sqlinLen) {
8167 setstat((
STMT *) stmt, -1,
"data right truncated",
"01004");
8168 ret = SQL_SUCCESS_WITH_INFO;
8180 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_QUALIFIER",
SCOL_VARCHAR, 50 },
8181 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_OWNER",
SCOL_VARCHAR, 50 },
8182 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_NAME",
SCOL_VARCHAR, 255 },
8183 {
"SYSTEM",
"PROCEDURE",
"NUM_INPUT_PARAMS", SQL_SMALLINT, 5 },
8184 {
"SYSTEM",
"PROCEDURE",
"NUM_OUTPUT_PARAMS", SQL_SMALLINT, 5 },
8185 {
"SYSTEM",
"PROCEDURE",
"NUM_RESULT_SETS", SQL_SMALLINT, 5 },
8186 {
"SYSTEM",
"PROCEDURE",
"REMARKS",
SCOL_VARCHAR, 255 },
8187 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_TYPE", SQL_SMALLINT, 5 }
8191 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_CAT",
SCOL_VARCHAR, 50 },
8192 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_SCHEM",
SCOL_VARCHAR, 50 },
8193 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_NAME",
SCOL_VARCHAR, 255 },
8194 {
"SYSTEM",
"PROCEDURE",
"NUM_INPUT_PARAMS", SQL_SMALLINT, 5 },
8195 {
"SYSTEM",
"PROCEDURE",
"NUM_OUTPUT_PARAMS", SQL_SMALLINT, 5 },
8196 {
"SYSTEM",
"PROCEDURE",
"NUM_RESULT_SETS", SQL_SMALLINT, 5 },
8197 {
"SYSTEM",
"PROCEDURE",
"REMARKS",
SCOL_VARCHAR, 255 },
8198 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_TYPE", SQL_SMALLINT, 5 }
8215 SQLProcedures(SQLHSTMT stmt,
8216 SQLCHAR *catalog, SQLSMALLINT catalogLen,
8217 SQLCHAR *schema, SQLSMALLINT schemaLen,
8218 SQLCHAR *proc, SQLSMALLINT procLen)
8245 SQLWCHAR *catalog, SQLSMALLINT catalogLen,
8246 SQLWCHAR *schema, SQLSMALLINT schemaLen,
8247 SQLWCHAR *proc, SQLSMALLINT procLen)
8264 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_QUALIFIER",
SCOL_VARCHAR, 50 },
8265 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_OWNER",
SCOL_VARCHAR, 50 },
8266 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_NAME",
SCOL_VARCHAR, 255 },
8267 {
"SYSTEM",
"PROCCOL",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
8268 {
"SYSTEM",
"PROCCOL",
"COLUMN_TYPE", SQL_SMALLINT, 5 },
8269 {
"SYSTEM",
"PROCCOL",
"DATA_TYPE", SQL_SMALLINT, 5 },
8270 {
"SYSTEM",
"PROCCOL",
"TYPE_NAME",
SCOL_VARCHAR, 50 },
8271 {
"SYSTEM",
"PROCCOL",
"PRECISION", SQL_INTEGER, 10 },
8272 {
"SYSTEM",
"PROCCOL",
"LENGTH", SQL_INTEGER, 10 },
8273 {
"SYSTEM",
"PROCCOL",
"SCALE", SQL_SMALLINT, 5 },
8274 {
"SYSTEM",
"PROCCOL",
"RADIX", SQL_SMALLINT, 5 },
8275 {
"SYSTEM",
"PROCCOL",
"NULLABLE", SQL_SMALLINT, 5 },
8277 {
"SYSTEM",
"PROCCOL",
"COLUMN_DEF",
SCOL_VARCHAR, 50 },
8278 {
"SYSTEM",
"PROCCOL",
"SQL_DATA_TYPE", SQL_SMALLINT, 5 },
8279 {
"SYSTEM",
"PROCCOL",
"SQL_DATETIME_SUB", SQL_SMALLINT, 5 },
8280 {
"SYSTEM",
"PROCCOL",
"CHAR_OCTET_LENGTH", SQL_SMALLINT, 5 },
8281 {
"SYSTEM",
"PROCCOL",
"ORDINAL_POSITION", SQL_SMALLINT, 5 },
8282 {
"SYSTEM",
"PROCCOL",
"IS_NULLABLE",
SCOL_VARCHAR, 50 }
8286 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_CAT",
SCOL_VARCHAR, 50 },
8287 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_SCHEM",
SCOL_VARCHAR, 50 },
8288 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_NAME",
SCOL_VARCHAR, 255 },
8289 {
"SYSTEM",
"PROCCOL",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
8290 {
"SYSTEM",
"PROCCOL",
"COLUMN_TYPE", SQL_SMALLINT, 5 },
8291 {
"SYSTEM",
"PROCCOL",
"DATA_TYPE", SQL_SMALLINT, 5 },
8292 {
"SYSTEM",
"PROCCOL",
"TYPE_NAME",
SCOL_VARCHAR, 50 },
8293 {
"SYSTEM",
"PROCCOL",
"COLUMN_SIZE", SQL_INTEGER, 10 },
8294 {
"SYSTEM",
"PROCCOL",
"BUFFER_LENGTH", SQL_INTEGER, 10 },
8295 {
"SYSTEM",
"PROCCOL",
"DECIMAL_DIGITS", SQL_SMALLINT, 5 },
8296 {
"SYSTEM",
"PROCCOL",
"NUM_PREC_RADIX", SQL_SMALLINT, 5 },
8297 {
"SYSTEM",
"PROCCOL",
"NULLABLE", SQL_SMALLINT, 5 },
8299 {
"SYSTEM",
"PROCCOL",
"COLUMN_DEF",
SCOL_VARCHAR, 50 },
8300 {
"SYSTEM",
"PROCCOL",
"SQL_DATA_TYPE", SQL_SMALLINT, 5 },
8301 {
"SYSTEM",
"PROCCOL",
"SQL_DATETIME_SUB", SQL_SMALLINT, 5 },
8302 {
"SYSTEM",
"PROCCOL",
"CHAR_OCTET_LENGTH", SQL_SMALLINT, 5 },
8303 {
"SYSTEM",
"PROCCOL",
"ORDINAL_POSITION", SQL_SMALLINT, 5 },
8304 {
"SYSTEM",
"PROCCOL",
"IS_NULLABLE",
SCOL_VARCHAR, 50 }
8323 SQLProcedureColumns(SQLHSTMT stmt,
8324 SQLCHAR *catalog, SQLSMALLINT catalogLen,
8325 SQLCHAR *schema, SQLSMALLINT schemaLen,
8326 SQLCHAR *proc, SQLSMALLINT procLen,
8327 SQLCHAR *column, SQLSMALLINT columnLen)
8333 procColSpec3,
array_size(procColSpec3), NULL);
8357 SQLWCHAR *catalog, SQLSMALLINT catalogLen,
8358 SQLWCHAR *schema, SQLSMALLINT schemaLen,
8359 SQLWCHAR *proc, SQLSMALLINT procLen,
8360 SQLWCHAR *column, SQLSMALLINT columnLen)
8366 procColSpec3,
array_size(procColSpec3), NULL);
8384 SQLINTEGER len, SQLINTEGER *lenp)
8387 SQLRETURN ret = SQL_ERROR;
8389 if (env == SQL_NULL_HENV) {
8390 return SQL_INVALID_HANDLE;
8394 return SQL_INVALID_HANDLE;
8396 #if defined(_WIN32) || defined(_WIN64) 8397 EnterCriticalSection(&e->cs);
8400 case SQL_ATTR_CONNECTION_POOLING:
8403 case SQL_ATTR_CP_MATCH:
8406 case SQL_ATTR_OUTPUT_NTS:
8408 *((SQLINTEGER *) val) = SQL_TRUE;
8411 *lenp =
sizeof (SQLINTEGER);
8415 case SQL_ATTR_ODBC_VERSION:
8417 *((SQLINTEGER *) val) = e->
ov3 ? SQL_OV_ODBC3 : SQL_OV_ODBC2;
8420 *lenp =
sizeof (SQLINTEGER);
8425 #if defined(_WIN32) || defined(_WIN64) 8426 LeaveCriticalSection(&e->cs);
8444 SQLRETURN ret = SQL_ERROR;
8446 if (env == SQL_NULL_HENV) {
8447 return SQL_INVALID_HANDLE;
8451 return SQL_INVALID_HANDLE;
8453 #if defined(_WIN32) || defined(_WIN64) 8454 EnterCriticalSection(&e->cs);
8457 case SQL_ATTR_CONNECTION_POOLING:
8460 case SQL_ATTR_CP_MATCH:
8463 case SQL_ATTR_OUTPUT_NTS:
8464 if (val == (SQLPOINTER) SQL_TRUE) {
8468 case SQL_ATTR_ODBC_VERSION:
8472 if (val == (SQLPOINTER) SQL_OV_ODBC2) {
8476 if (val == (SQLPOINTER) SQL_OV_ODBC3) {
8482 #if defined(_WIN32) || defined(_WIN64) 8483 LeaveCriticalSection(&e->cs);
8503 SQLCHAR *sqlstate, SQLINTEGER *nativeerr, SQLCHAR *msg,
8504 SQLSMALLINT buflen, SQLSMALLINT *msglen)
8509 char *logmsg, *sqlst;
8510 SQLRETURN ret = SQL_ERROR;
8512 if (handle == SQL_NULL_HANDLE) {
8513 return SQL_INVALID_HANDLE;
8518 if (msg && buflen > 0) {
8528 case SQL_HANDLE_ENV:
8529 case SQL_HANDLE_DESC:
8531 case SQL_HANDLE_DBC:
8534 logmsg = (
char *) d->
logmsg;
8538 case SQL_HANDLE_STMT:
8540 s = (
STMT *) handle;
8541 logmsg = (
char *) s->
logmsg;
8546 return SQL_INVALID_HANDLE;
8555 len = strlen(logmsg);
8561 *nativeerr = naterr;
8564 strcpy((
char *) sqlstate, sqlst);
8569 if (len >= buflen) {
8570 if (msg && buflen > 0) {
8571 strncpy((
char *) msg, logmsg, buflen);
8572 msg[buflen - 1] =
'\0';
8576 strcpy((
char *) msg, logmsg);
8582 case SQL_HANDLE_DBC:
8585 case SQL_HANDLE_STMT:
8592 #if !defined(WINTERFACE) || (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC)) 8607 SQLGetDiagRec(SQLSMALLINT htype, SQLHANDLE handle, SQLSMALLINT recno,
8608 SQLCHAR *sqlstate, SQLINTEGER *nativeerr, SQLCHAR *msg,
8609 SQLSMALLINT buflen, SQLSMALLINT *msglen)
8612 nativeerr, msg, buflen, msglen);
8616 #if !defined(HAVE_UNIXODBC) || !(HAVE_UNIXODBC) 8634 SQLWCHAR *sqlstate, SQLINTEGER *nativeerr, SQLWCHAR *msg,
8635 SQLSMALLINT buflen, SQLSMALLINT *msglen)
8641 ret =
drvgetdiagrec(htype, handle, recno, (SQLCHAR *) state,
8642 nativeerr, (SQLCHAR *) msg, buflen, &len);
8643 if (ret == SQL_SUCCESS) {
8646 6 *
sizeof (SQLWCHAR));
8655 buflen /=
sizeof (SQLWCHAR);
8675 len *=
sizeof (SQLWCHAR);
8680 }
else if (ret == SQL_NO_DATA) {
8712 SQLSMALLINT
id, SQLPOINTER info,
8713 SQLSMALLINT buflen, SQLSMALLINT *stringlen)
8717 int len, naterr,
strbuf = 1;
8718 char *logmsg, *sqlst, *clrmsg = NULL;
8719 SQLRETURN ret = SQL_ERROR;
8721 if (handle == SQL_NULL_HANDLE) {
8722 return SQL_INVALID_HANDLE;
8728 case SQL_HANDLE_ENV:
8729 case SQL_HANDLE_DESC:
8731 case SQL_HANDLE_DBC:
8734 logmsg = (
char *) d->
logmsg;
8738 case SQL_HANDLE_STMT:
8740 s = (
STMT *) handle;
8742 logmsg = (
char *) s->
logmsg;
8747 return SQL_INVALID_HANDLE;
8751 case SQL_IS_POINTER:
8752 case SQL_IS_UINTEGER:
8753 case SQL_IS_INTEGER:
8754 case SQL_IS_USMALLINT:
8755 case SQL_IS_SMALLINT:
8768 case SQL_DIAG_CLASS_ORIGIN:
8769 logmsg =
"ISO 9075";
8770 if (sqlst[0] ==
'I' && sqlst[1] ==
'M') {
8771 logmsg =
"ODBC 3.0";
8774 case SQL_DIAG_SUBCLASS_ORIGIN:
8775 logmsg =
"ISO 9075";
8776 if (sqlst[0] ==
'I' && sqlst[1] ==
'M') {
8777 logmsg =
"ODBC 3.0";
8778 }
else if (sqlst[0] ==
'H' && sqlst[1] ==
'Y') {
8779 logmsg =
"ODBC 3.0";
8780 }
else if (sqlst[0] ==
'2' || sqlst[0] ==
'0' || sqlst[0] ==
'4') {
8781 logmsg =
"ODBC 3.0";
8784 case SQL_DIAG_CONNECTION_NAME:
8785 case SQL_DIAG_SERVER_NAME:
8786 logmsg = d->
dsn ? d->
dsn :
"No DSN";
8788 case SQL_DIAG_SQLSTATE:
8791 case SQL_DIAG_MESSAGE_TEXT:
8796 case SQL_DIAG_NUMBER:
8799 case SQL_DIAG_NATIVE:
8800 len = strlen(logmsg);
8806 *((SQLINTEGER *) info) = naterr;
8810 case SQL_DIAG_DYNAMIC_FUNCTION:
8813 case SQL_DIAG_CURSOR_ROW_COUNT:
8814 if (htype == SQL_HANDLE_STMT) {
8822 case SQL_DIAG_ROW_COUNT:
8823 if (htype == SQL_HANDLE_STMT) {
8834 if (info && buflen > 0) {
8835 ((
char *) info)[0] =
'\0';
8837 len = strlen(logmsg);
8846 if (len >= buflen) {
8847 if (info && buflen > 0) {
8849 *stringlen = buflen - 1;
8851 strncpy((
char *) info, logmsg, buflen);
8852 ((
char *) info)[buflen - 1] =
'\0';
8855 strcpy((
char *) info, logmsg);
8864 case SQL_HANDLE_DBC:
8867 case SQL_HANDLE_STMT:
8888 SQLGetDiagField(SQLSMALLINT htype, SQLHANDLE handle, SQLSMALLINT recno,
8889 SQLSMALLINT
id, SQLPOINTER info,
8890 SQLSMALLINT buflen, SQLSMALLINT *stringlen)
8892 return drvgetdiagfield(htype, handle, recno,
id, info, buflen, stringlen);
8911 SQLSMALLINT
id, SQLPOINTER info,
8912 SQLSMALLINT buflen, SQLSMALLINT *stringlen)
8918 if (ret == SQL_SUCCESS) {
8921 case SQL_DIAG_CLASS_ORIGIN:
8922 case SQL_DIAG_SUBCLASS_ORIGIN:
8923 case SQL_DIAG_CONNECTION_NAME:
8924 case SQL_DIAG_SERVER_NAME:
8925 case SQL_DIAG_SQLSTATE:
8926 case SQL_DIAG_MESSAGE_TEXT:
8927 case SQL_DIAG_DYNAMIC_FUNCTION:
8934 buflen /=
sizeof (SQLWCHAR);
8942 len *=
sizeof (SQLWCHAR);
8950 ((SQLWCHAR *) info)[0] = 0;
8956 case SQL_DIAG_CLASS_ORIGIN:
8957 case SQL_DIAG_SUBCLASS_ORIGIN:
8958 case SQL_DIAG_CONNECTION_NAME:
8959 case SQL_DIAG_SERVER_NAME:
8960 case SQL_DIAG_SQLSTATE:
8961 case SQL_DIAG_MESSAGE_TEXT:
8962 case SQL_DIAG_DYNAMIC_FUNCTION:
8963 len *=
sizeof (SQLWCHAR);
8987 SQLINTEGER bufmax, SQLINTEGER *buflen)
8998 uval = (SQLPOINTER) dummybuf;
9001 case SQL_QUERY_TIMEOUT:
9005 case SQL_ATTR_CURSOR_TYPE:
9009 case SQL_ATTR_CURSOR_SCROLLABLE:
9010 *uval = (s->
curtype != SQL_CURSOR_FORWARD_ONLY) ?
9011 SQL_SCROLLABLE : SQL_NONSCROLLABLE;
9014 #ifdef SQL_ATTR_CURSOR_SENSITIVITY 9015 case SQL_ATTR_CURSOR_SENSITIVITY:
9016 *uval = SQL_UNSPECIFIED;
9020 case SQL_ATTR_ROW_NUMBER:
9025 *uval = (s->
rowp < 0) ? SQL_ROW_NUMBER_UNKNOWN : (s->
rowp + 1);
9029 case SQL_ATTR_ASYNC_ENABLE:
9030 *uval = SQL_ASYNC_ENABLE_OFF;
9033 case SQL_CONCURRENCY:
9034 *uval = SQL_CONCUR_LOCK;
9037 case SQL_ATTR_RETRIEVE_DATA:
9041 case SQL_ROWSET_SIZE:
9042 case SQL_ATTR_ROW_ARRAY_SIZE:
9047 case SQL_ATTR_IMP_ROW_DESC:
9048 case SQL_ATTR_APP_ROW_DESC:
9049 case SQL_ATTR_IMP_PARAM_DESC:
9050 case SQL_ATTR_APP_PARAM_DESC:
9051 *((SQLHDESC *) uval) = (SQLHDESC)
DEAD_MAGIC;
9052 *buflen =
sizeof (SQLHDESC);
9054 case SQL_ATTR_ROW_STATUS_PTR:
9056 *buflen =
sizeof (SQLUSMALLINT *);
9058 case SQL_ATTR_ROWS_FETCHED_PTR:
9062 case SQL_ATTR_USE_BOOKMARKS: {
9065 *(SQLUINTEGER *) uval = s->
bkmrk;
9066 *buflen = sizeof (SQLUINTEGER);
9069 case SQL_ATTR_FETCH_BOOKMARK_PTR:
9070 *(SQLPOINTER *) uval = s->
bkmrkptr;
9071 *buflen = sizeof (SQLPOINTER);
9073 case SQL_ATTR_PARAM_BIND_OFFSET_PTR:
9077 case SQL_ATTR_PARAM_BIND_TYPE:
9081 case SQL_ATTR_PARAM_OPERATION_PTR:
9082 *((SQLUSMALLINT **) uval) = s->
parm_oper;
9083 *buflen =
sizeof (SQLUSMALLINT *);
9085 case SQL_ATTR_PARAM_STATUS_PTR:
9087 *buflen =
sizeof (SQLUSMALLINT *);
9089 case SQL_ATTR_PARAMS_PROCESSED_PTR:
9093 case SQL_ATTR_PARAMSET_SIZE:
9097 case SQL_ATTR_ROW_BIND_TYPE:
9101 case SQL_ATTR_ROW_BIND_OFFSET_PTR:
9105 case SQL_ATTR_MAX_ROWS:
9109 case SQL_ATTR_MAX_LENGTH:
9110 *((
SQLULEN *) uval) = 1000000000;
9113 #ifdef SQL_ATTR_METADATA_ID 9114 case SQL_ATTR_METADATA_ID:
9115 *((
SQLULEN *) uval) = SQL_FALSE;
9123 #if (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC)) || !defined(WINTERFACE) 9135 SQLGetStmtAttr(SQLHSTMT stmt, SQLINTEGER attr, SQLPOINTER val,
9136 SQLINTEGER bufmax, SQLINTEGER *buflen)
9160 SQLINTEGER bufmax, SQLINTEGER *buflen)
9185 #if defined(SQL_BIGINT) && defined(__WORDSIZE) && (__WORDSIZE == 64) 9188 uval = (SQLBIGINT) val;
9195 case SQL_ATTR_CURSOR_TYPE:
9196 if (val == (SQLPOINTER) SQL_CURSOR_FORWARD_ONLY) {
9197 s->
curtype = SQL_CURSOR_FORWARD_ONLY;
9199 s->
curtype = SQL_CURSOR_STATIC;
9201 if (val != (SQLPOINTER) SQL_CURSOR_FORWARD_ONLY &&
9202 val != (SQLPOINTER) SQL_CURSOR_STATIC) {
9206 case SQL_ATTR_CURSOR_SCROLLABLE:
9207 if (val == (SQLPOINTER) SQL_NONSCROLLABLE) {
9208 s->
curtype = SQL_CURSOR_FORWARD_ONLY;
9210 s->
curtype = SQL_CURSOR_STATIC;
9213 case SQL_ATTR_ASYNC_ENABLE:
9214 if (val != (SQLPOINTER) SQL_ASYNC_ENABLE_OFF) {
9216 setstat(s, -1,
"option value changed",
"01S02");
9217 return SQL_SUCCESS_WITH_INFO;
9220 case SQL_CONCURRENCY:
9221 if (val != (SQLPOINTER) SQL_CONCUR_LOCK) {
9225 #ifdef SQL_ATTR_CURSOR_SENSITIVITY 9226 case SQL_ATTR_CURSOR_SENSITIVITY:
9227 if (val != (SQLPOINTER) SQL_UNSPECIFIED) {
9232 case SQL_ATTR_QUERY_TIMEOUT:
9234 case SQL_ATTR_RETRIEVE_DATA:
9235 if (val != (SQLPOINTER) SQL_RD_ON &&
9236 val != (SQLPOINTER) SQL_RD_OFF) {
9241 case SQL_ROWSET_SIZE:
9242 case SQL_ATTR_ROW_ARRAY_SIZE:
9244 setstat(s, -1,
"invalid rowset size",
"HY000");
9250 rst =
xmalloc(
sizeof (SQLUSMALLINT) * uval);
9262 case SQL_ATTR_ROW_STATUS_PTR:
9265 case SQL_ATTR_ROWS_FETCHED_PTR:
9268 case SQL_ATTR_PARAM_BIND_OFFSET_PTR:
9271 case SQL_ATTR_PARAM_BIND_TYPE:
9274 case SQL_ATTR_PARAM_OPERATION_PTR:
9277 case SQL_ATTR_PARAM_STATUS_PTR:
9280 case SQL_ATTR_PARAMS_PROCESSED_PTR:
9283 case SQL_ATTR_PARAMSET_SIZE:
9290 case SQL_ATTR_ROW_BIND_TYPE:
9293 case SQL_ATTR_ROW_BIND_OFFSET_PTR:
9296 case SQL_ATTR_USE_BOOKMARKS:
9297 if (val != (SQLPOINTER) SQL_UB_OFF &&
9298 val != (SQLPOINTER) SQL_UB_ON &&
9299 val != (SQLPOINTER) SQL_UB_VARIABLE) {
9302 if (*s->
ov3 && val == (SQLPOINTER) SQL_UB_VARIABLE) {
9303 s->
bkmrk = SQL_UB_VARIABLE;
9306 if (val == (SQLPOINTER) SQL_UB_VARIABLE) {
9307 s->
bkmrk = SQL_UB_ON;
9310 s->
bkmrk = (val == (SQLPOINTER) SQL_UB_ON) ? SQL_UB_ON : SQL_UB_OFF;
9312 case SQL_ATTR_FETCH_BOOKMARK_PTR:
9315 case SQL_ATTR_MAX_ROWS:
9318 case SQL_ATTR_MAX_LENGTH:
9319 if (val != (SQLPOINTER) 1000000000) {
9323 #ifdef SQL_ATTR_METADATA_ID 9324 case SQL_ATTR_METADATA_ID:
9325 if (val != (SQLPOINTER) SQL_FALSE) {
9334 #if (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC)) || !defined(WINTERFACE) 9345 SQLSetStmtAttr(SQLHSTMT stmt, SQLINTEGER attr, SQLPOINTER val,
9392 SQLUINTEGER *ret = (SQLUINTEGER *) param;
9395 case SQL_QUERY_TIMEOUT:
9398 case SQL_CURSOR_TYPE:
9401 case SQL_ROW_NUMBER:
9406 *ret = (s->
rowp < 0) ? SQL_ROW_NUMBER_UNKNOWN : (s->
rowp + 1);
9409 case SQL_ASYNC_ENABLE:
9410 *ret = SQL_ASYNC_ENABLE_OFF;
9412 case SQL_CONCURRENCY:
9413 *ret = SQL_CONCUR_LOCK;
9415 case SQL_ATTR_RETRIEVE_DATA:
9418 case SQL_ROWSET_SIZE:
9419 case SQL_ATTR_ROW_ARRAY_SIZE:
9422 case SQL_ATTR_MAX_ROWS:
9425 case SQL_ATTR_MAX_LENGTH:
9486 case SQL_CURSOR_TYPE:
9487 if (param == SQL_CURSOR_FORWARD_ONLY) {
9490 s->
curtype = SQL_CURSOR_STATIC;
9492 if (param != SQL_CURSOR_FORWARD_ONLY &&
9493 param != SQL_CURSOR_STATIC) {
9497 case SQL_ASYNC_ENABLE:
9498 if (param != SQL_ASYNC_ENABLE_OFF) {
9502 case SQL_CONCURRENCY:
9503 if (param != SQL_CONCUR_LOCK) {
9507 case SQL_QUERY_TIMEOUT:
9509 case SQL_RETRIEVE_DATA:
9510 if (param != SQL_RD_ON && param != SQL_RD_OFF) {
9512 setstat(s, -1,
"option value changed",
"01S02");
9513 return SQL_SUCCESS_WITH_INFO;
9517 case SQL_ROWSET_SIZE:
9518 case SQL_ATTR_ROW_ARRAY_SIZE:
9520 setstat(s, -1,
"invalid rowset size",
"HY000");
9526 rst =
xmalloc(
sizeof (SQLUSMALLINT) * param);
9538 case SQL_ATTR_MAX_ROWS:
9541 case SQL_ATTR_MAX_LENGTH:
9542 if (param != 1000000000) {
9605 setstat(s, -1,
"unbound columns", (*s->
ov3) ?
"HY000" :
"S1000");
9608 for (i = 0; i < s->
ncols; i++) {
9611 if (b->
type == SQL_UNKNOWN_TYPE || !b->
valp) {
9640 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
9641 dp = (SQLPOINTER) ((
char *) b->valp + s->
bind_type * rsi);
9643 dp = (SQLPOINTER) ((
char *) b->valp + b->max * rsi);
9646 dp = (SQLPOINTER) ((
char *) dp + *s->
bind_offs);
9650 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
9660 setstat(s, -1,
"unbound column in positional update",
9661 (*s->
ov3) ?
"HY000" :
"S1000");
9664 if (*lp == SQL_NULL_DATA) {
9665 sqlite3_bind_null(stmt, si);
9667 fprintf(d->
trace,
"-- parameter %d: NULL\n", si);
9673 case SQL_C_UTINYINT:
9675 case SQL_C_STINYINT:
9676 sqlite3_bind_int(stmt, si, *(SQLCHAR *) dp);
9678 fprintf(d->
trace,
"-- parameter %d: %d\n", si, *(SQLCHAR *) dp);
9684 sqlite3_bind_int(stmt, si, (*(SQLCHAR *) dp) ? 1 : 0);
9686 fprintf(d->
trace,
"-- parameter %d: %d\n", si,
9687 (*(SQLCHAR *) dp) ? 1 : 0);
9693 sqlite3_bind_int(stmt, si, *(SQLUSMALLINT *) dp);
9695 fprintf(d->
trace,
"-- parameter %d: %d\n", si,
9696 *(SQLUSMALLINT *) dp);
9702 sqlite3_bind_int(stmt, si, *(SQLSMALLINT *) dp);
9704 fprintf(d->
trace,
"-- parameter %d: %d\n", si,
9705 *(SQLSMALLINT *) dp);
9710 sqlite3_bind_int(stmt, si, *(SQLUINTEGER *) dp);
9712 fprintf(d->
trace,
"-- parameter %d: %ld\n", si,
9713 (
long) *(SQLUINTEGER *) dp);
9719 sqlite3_bind_int(stmt, si, *(SQLINTEGER *) dp);
9721 fprintf(d->
trace,
"-- parameter %d: %ld\n", si,
9722 (
long) *(SQLINTEGER *) dp);
9729 sqlite3_bind_int64(stmt, si, *(SQLBIGINT *) dp);
9733 "-- parameter %d: %I64d\n",
9735 "-- parameter %d: %lld\n",
9737 si, (sqlite_int64) *(SQLBIGINT *) dp);
9743 sqlite3_bind_double(stmt, si, *(
float *) dp);
9745 fprintf(d->
trace,
"-- parameter %d: %g\n", si,
9751 sqlite3_bind_double(stmt, si, *(
double *) dp);
9753 fprintf(d->
trace,
"-- parameter %d: %g\n", si,
9759 sqlite3_bind_blob(stmt, si, (
char *) dp, *lp, SQLITE_STATIC);
9761 fprintf(d->
trace,
"-- parameter %d: [BLOB]\n", si);
9771 sqlite3_bind_text(stmt, si, cp, -1, SQLITE_TRANSIENT);
9773 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si, cp);
9780 #if defined(_WIN32) || defined(_WIN64) 9782 cp = wmb_to_utf((
char *) dp, *lp);
9786 sqlite3_bind_text(stmt, si, cp, -1, SQLITE_TRANSIENT);
9788 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si, cp);
9795 if (*lp == SQL_NTS) {
9796 sqlite3_bind_text(stmt, si, (
char *) dp, -1,
9799 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si,
9804 sqlite3_bind_text(stmt, si, (
char *) dp, *lp,
9807 fprintf(d->
trace,
"-- parameter %d: '%*s'\n", si,
9808 (
int) *lp, (
char *) dp);
9814 #ifdef SQL_C_TYPE_DATE 9815 case SQL_C_TYPE_DATE:
9819 int a, b, x1, x2, y, m, dd;
9822 y = ((DATE_STRUCT *) dp)->year;
9823 m = ((DATE_STRUCT *) dp)->month;
9824 dd = ((DATE_STRUCT *) dp)->day;
9830 b = 2 - a + (a / 4);
9831 x1 = 36525 * (y + 4716) / 100;
9832 x2 = 306001 * (m + 1) / 10000;
9833 v = x1 + x2 + dd + b - 1524.5;
9834 sqlite3_bind_double(stmt, si, v);
9836 fprintf(d->
trace,
"-- parameter %d: %g\n", si, v);
9840 sprintf(strbuf,
"%04d-%02d-%02d",
9841 ((DATE_STRUCT *) dp)->year,
9842 ((DATE_STRUCT *) dp)->month,
9843 ((DATE_STRUCT *) dp)->day);
9844 sqlite3_bind_text(stmt, si, strbuf, -1, SQLITE_TRANSIENT);
9846 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si, strbuf);
9851 #ifdef SQL_C_TYPE_TIME 9852 case SQL_C_TYPE_TIME:
9859 (((TIME_STRUCT *) dp)->hour * 3600000.0 +
9860 ((TIME_STRUCT *) dp)->minute * 60000.0 +
9861 ((TIME_STRUCT *) dp)->second * 1000.0) / 86400000.0;
9862 sqlite3_bind_double(stmt, si, v);
9864 fprintf(d->
trace,
"-- parameter %d: %g\n", si, v);
9868 sprintf(strbuf,
"%02d:%02d:%02d",
9869 ((TIME_STRUCT *) dp)->hour,
9870 ((TIME_STRUCT *) dp)->minute,
9871 ((TIME_STRUCT *) dp)->second);
9872 sqlite3_bind_text(stmt, si, strbuf, -1, SQLITE_TRANSIENT);
9874 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si, strbuf);
9879 #ifdef SQL_C_TYPE_TIMESTAMP 9880 case SQL_C_TYPE_TIMESTAMP:
9882 case SQL_C_TIMESTAMP:
9884 int a, b, x1, x2, y, m, dd;
9887 y = ((TIMESTAMP_STRUCT *) dp)->year;
9888 m = ((TIMESTAMP_STRUCT *) dp)->month;
9889 dd = ((TIMESTAMP_STRUCT *) dp)->day;
9895 b = 2 - a + (a / 4);
9896 x1 = 36525 * (y + 4716) / 100;
9897 x2 = 306001 * (m + 1) / 10000;
9898 v = x1 + x2 + dd + b - 1524.5 +
9899 (((TIMESTAMP_STRUCT *) dp)->hour * 3600000.0 +
9900 ((TIMESTAMP_STRUCT *) dp)->minute * 60000.0 +
9901 ((TIMESTAMP_STRUCT *) dp)->second * 1000.0 +
9902 ((TIMESTAMP_STRUCT *) dp)->fraction / 1.0E6)
9904 sqlite3_bind_double(stmt, si, v);
9906 fprintf(d->
trace,
"-- parameter %d: %g\n", si, v);
9912 frac = (int) ((TIMESTAMP_STRUCT *) dp)->fraction;
9918 if (c->prec && c->prec <= 16) {
9919 sprintf(strbuf,
"%04d-%02d-%02d %02d:%02d:00.000",
9920 ((TIMESTAMP_STRUCT *) dp)->year,
9921 ((TIMESTAMP_STRUCT *) dp)->month,
9922 ((TIMESTAMP_STRUCT *) dp)->day,
9923 ((TIMESTAMP_STRUCT *) dp)->hour,
9924 ((TIMESTAMP_STRUCT *) dp)->minute);
9925 }
else if (c->prec && c->prec <= 19) {
9926 sprintf(strbuf,
"%04d-%02d-%02d %02d:%02d:%02d.000",
9927 ((TIMESTAMP_STRUCT *) dp)->year,
9928 ((TIMESTAMP_STRUCT *) dp)->month,
9929 ((TIMESTAMP_STRUCT *) dp)->day,
9930 ((TIMESTAMP_STRUCT *) dp)->hour,
9931 ((TIMESTAMP_STRUCT *) dp)->minute,
9932 ((TIMESTAMP_STRUCT *) dp)->second);
9934 sprintf(strbuf,
"%04d-%02d-%02d %02d:%02d:%02d.%03d",
9935 ((TIMESTAMP_STRUCT *) dp)->year,
9936 ((TIMESTAMP_STRUCT *) dp)->month,
9937 ((TIMESTAMP_STRUCT *) dp)->day,
9938 ((TIMESTAMP_STRUCT *) dp)->hour,
9939 ((TIMESTAMP_STRUCT *) dp)->minute,
9940 ((TIMESTAMP_STRUCT *) dp)->second,
9943 sqlite3_bind_text(stmt, si, strbuf, -1, SQLITE_TRANSIENT);
9945 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si, strbuf);
9951 setstat(s, -1,
"unsupported column type in positional update",
9952 (*s->
ov3) ?
"HY000" :
"S1000");
9978 setstat(s, -1,
"row out of range", (*s->
ov3) ?
"HY107" :
"S1107");
9983 if (*data == NULL) {
9984 sqlite3_bind_null(stmt, si);
9986 fprintf(d->
trace,
"-- parameter %d: NULL\n", si);
9990 sqlite3_bind_text(stmt, si, *data, -1, SQLITE_STATIC);
9992 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si, *data);
10009 int i, withinfo = 0;
10010 SQLRETURN ret = SQL_SUCCESS;
10019 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10022 dp = (SQLPOINTER) ((
char *) b->
valp + b->
max * rsi);
10025 dp = (SQLPOINTER) ((
char *) dp + *s->
bind_offs);
10029 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10032 lp = b->
lenp + rsi;
10039 int rowp = s->
rowp;
10045 if (!SQL_SUCCEEDED(ret)) {
10049 if (ret != SQL_SUCCESS) {
10051 #ifdef SQL_ROW_SUCCESS_WITH_INFO 10057 if (SQL_SUCCEEDED(ret)) {
10058 ret = withinfo ? SQL_SUCCESS_WITH_INFO : SQL_SUCCESS;
10077 int rowp, i, k, rc, nretry = 0;
10080 sqlite3_stmt *s3stmt = NULL;
10083 if (lock != SQL_LOCK_NO_CHANGE) {
10084 setstat(s, -1,
"unsupported locking mode",
10085 (*s->
ov3) ?
"HY000" :
"S1000");
10089 setstat(s, -1,
"incompatible statement",
10090 (*s->
ov3) ?
"HY000" :
"S1000");
10093 if (op == SQL_ADD) {
10095 setstat(s, -1,
"incompatible rowset",
10096 (*s->
ov3) ?
"HY000" :
"S1000");
10103 if (ret != SQL_SUCCESS) {
10106 sql =
dsappend(sql,
"INSERT INTO ");
10112 for (i = 0; i < s->
ncols; i++) {
10113 sql =
dsappend(sql, (i > 0) ?
"," :
"(");
10117 for (i = 0; i < s->
ncols; i++) {
10118 sql =
dsappend(sql, (i > 0) ?
",?" :
"(?");
10125 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10132 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10133 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10139 if (rc != SQLITE_OK) {
10141 sqlite3_finalize(s3stmt);
10145 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10148 if (rc != SQLITE_OK) {
10150 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10151 sqlite3_errmsg(d->
sqlite), rc);
10154 sqlite3_finalize(s3stmt);
10160 if (ret != SQL_SUCCESS) {
10162 sqlite3_finalize(s3stmt);
10167 rc = sqlite3_step(s3stmt);
10168 if (rc != SQLITE_DONE) {
10171 sqlite3_finalize(s3stmt);
10172 if (sqlite3_changes(d->
sqlite) > 0 && row <= s->rowset_size) {
10180 return SQL_SUCCESS;
10181 }
else if (op == SQL_UPDATE || op == SQL_DELETE) {
10183 setstat(s, -1,
"incompatible rowset",
10184 (*s->
ov3) ?
"HY000" :
"S1000");
10191 if (!SQL_SUCCEEDED(ret)) {
10201 if (op != SQL_POSITION && op != SQL_REFRESH &&
10202 op != SQL_DELETE && op != SQL_UPDATE) {
10205 if (op == SQL_POSITION) {
10206 rowp = s->
rowp + row - 1;
10207 if (!s->
rows || row == 0 || rowp < -1 || rowp >= s->
nrows) {
10209 setstat(s, -1,
"row out of range", (*s->
ov3) ?
"HY107" :
"S1107");
10213 }
else if (op == SQL_REFRESH) {
10221 if (!SQL_SUCCEEDED(ret)) {
10228 }
else if (op == SQL_DELETE) {
10229 sql =
dsappend(sql,
"DELETE FROM ");
10235 for (i = k = 0; i < s->
ncols; i++) {
10239 sql =
dsappend(sql, (k > 0) ?
" AND " :
" WHERE ");
10248 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10255 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10256 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10262 if (rc != SQLITE_OK) {
10264 sqlite3_finalize(s3stmt);
10268 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10271 if (rc != SQLITE_OK) {
10273 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10274 sqlite3_errmsg(d->
sqlite), rc);
10277 sqlite3_finalize(s3stmt);
10286 if (ret != SQL_SUCCESS) {
10288 sqlite3_finalize(s3stmt);
10293 rc = sqlite3_step(s3stmt);
10294 if (rc != SQLITE_DONE) {
10297 sqlite3_finalize(s3stmt);
10298 if (sqlite3_changes(d->
sqlite) > 0) {
10306 return SQL_SUCCESS;
10307 }
else if (op == SQL_UPDATE) {
10309 if (ret != SQL_SUCCESS) {
10318 for (i = 0; i < s->
ncols; i++) {
10319 sql =
dsappend(sql, (i > 0) ?
", " :
" SET ");
10323 for (i = k = 0; i < s->
ncols; i++) {
10327 sql =
dsappend(sql, (k > 0) ?
" AND " :
" WHERE ");
10336 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10343 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10344 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10350 if (rc != SQLITE_OK) {
10352 sqlite3_finalize(s3stmt);
10356 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10359 if (rc != SQLITE_OK) {
10361 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10362 sqlite3_errmsg(d->
sqlite), rc);
10365 sqlite3_finalize(s3stmt);
10371 if (ret != SQL_SUCCESS) {
10373 sqlite3_finalize(s3stmt);
10383 if (ret != SQL_SUCCESS) {
10385 sqlite3_finalize(s3stmt);
10390 rc = sqlite3_step(s3stmt);
10391 if (rc != SQLITE_DONE) {
10394 sqlite3_finalize(s3stmt);
10395 if (sqlite3_changes(d->
sqlite) > 0) {
10403 return SQL_SUCCESS;
10405 return SQL_SUCCESS;
10440 int row, i, k, rc, nretry = 0;
10443 sqlite3_stmt *s3stmt = NULL;
10447 setstat(s, -1,
"incompatible statement",
10448 (*s->
ov3) ?
"HY000" :
"S1000");
10451 if (op == SQL_ADD) {
10453 setstat(s, -1,
"incompatible rowset",
10454 (*s->
ov3) ?
"HY000" :
"S1000");
10458 if (ret != SQL_SUCCESS) {
10461 sql =
dsappend(sql,
"INSERT INTO ");
10467 for (i = 0; i < s->
ncols; i++) {
10468 sql =
dsappend(sql, (i > 0) ?
"," :
"(");
10472 for (i = 0; i < s->
ncols; i++) {
10473 sql =
dsappend(sql, (i > 0) ?
",?" :
"(?");
10480 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10487 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10488 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10494 if (rc != SQLITE_OK) {
10496 sqlite3_finalize(s3stmt);
10500 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10503 if (rc != SQLITE_OK) {
10504 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10505 sqlite3_errmsg(d->
sqlite), rc);
10508 sqlite3_finalize(s3stmt);
10515 if (ret != SQL_SUCCESS) {
10524 sqlite3_finalize(s3stmt);
10529 rc = sqlite3_step(s3stmt);
10530 if (rc != SQLITE_DONE) {
10531 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10532 sqlite3_errmsg(d->
sqlite), rc);
10536 if (sqlite3_changes(d->
sqlite) > 0) {
10544 if (s->
bkmrk == SQL_UB_VARIABLE &&
10549 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10557 val = (SQLPOINTER) ((
char *) val + *s->
bind_offs);
10559 *(sqlite_int64 *) val = sqlite3_last_insert_rowid(d->
sqlite);
10563 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10572 *ival =
sizeof (sqlite_int64);
10576 sqlite3_reset(s3stmt);
10579 sqlite3_finalize(s3stmt);
10580 return SQL_SUCCESS;
10581 }
else if (op == SQL_DELETE_BY_BOOKMARK) {
10583 s->
bkmrk != SQL_UB_VARIABLE ||
10586 setstat(s, -1,
"incompatible rowset",
10587 (*s->
ov3) ?
"HY000" :
"S1000");
10590 sql =
dsappend(sql,
"DELETE FROM ");
10603 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10610 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10611 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10617 if (rc != SQLITE_OK) {
10619 sqlite3_finalize(s3stmt);
10623 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10626 if (rc != SQLITE_OK) {
10627 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10628 sqlite3_errmsg(d->
sqlite), rc);
10631 sqlite3_finalize(s3stmt);
10637 sqlite_int64 rowid;
10639 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10647 val = (SQLPOINTER) ((
char *) val + *s->
bind_offs);
10652 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10661 if (*ival !=
sizeof (sqlite_int64)) {
10665 rowid = *(sqlite_int64 *) val;
10666 sqlite3_bind_int64(s3stmt, 1, rowid);
10670 "-- parameter 1: %I64d\n",
10672 "-- parameter 1: %lld\n",
10677 rc = sqlite3_step(s3stmt);
10678 if (rc != SQLITE_DONE) {
10679 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10680 sqlite3_errmsg(d->
sqlite), rc);
10688 sqlite3_finalize(s3stmt);
10691 if (sqlite3_changes(d->
sqlite) > 0) {
10700 sqlite3_reset(s3stmt);
10703 sqlite3_finalize(s3stmt);
10704 return SQL_SUCCESS;
10705 }
else if (op == SQL_UPDATE_BY_BOOKMARK) {
10707 s->
bkmrk != SQL_UB_VARIABLE ||
10710 setstat(s, -1,
"incompatible rowset",
10711 (*s->
ov3) ?
"HY000" :
"S1000");
10715 if (ret != SQL_SUCCESS) {
10724 for (i = 0, k = 0; i < s->
ncols; i++) {
10728 sql =
dsappend(sql, (k > 0) ?
", " :
" SET ");
10740 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10747 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10748 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10754 if (rc != SQLITE_OK) {
10756 sqlite3_finalize(s3stmt);
10760 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10763 if (rc != SQLITE_OK) {
10764 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10765 sqlite3_errmsg(d->
sqlite), rc);
10768 sqlite3_finalize(s3stmt);
10774 sqlite_int64 rowid;
10776 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10784 val = (SQLPOINTER) ((
char *) val + *s->
bind_offs);
10789 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10798 if (*ival !=
sizeof (sqlite_int64)) {
10807 if (ret != SQL_SUCCESS) {
10816 sqlite3_finalize(s3stmt);
10821 rowid = *(sqlite_int64 *) val;
10822 sqlite3_bind_int64(s3stmt, k, rowid);
10826 "-- parameter %d: %I64d\n",
10828 "-- parameter %d: %lld\n",
10833 rc = sqlite3_step(s3stmt);
10834 if (rc != SQLITE_DONE) {
10835 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10836 sqlite3_errmsg(d->
sqlite), rc);
10840 if (sqlite3_changes(d->
sqlite) > 0) {
10849 sqlite3_reset(s3stmt);
10852 sqlite3_finalize(s3stmt);
10853 return SQL_SUCCESS;
10855 setstat(s, -1,
"unsupported operation", (*s->
ov3) ?
"HY000" :
"S1000");
10884 SQLUSMALLINT rowset)
10894 #define strmak(dst, src, max, lenp) { \ 10895 int len = strlen(src); \ 10896 int cnt = min(len + 1, max); \ 10897 strncpy(dst, src, cnt); \ 10898 *lenp = (cnt > len) ? len : cnt; \ 10912 drvgetinfo(SQLHDBC dbc, SQLUSMALLINT type, SQLPOINTER val, SQLSMALLINT valMax,
10913 SQLSMALLINT *valLen)
10918 #if defined(_WIN32) || defined(_WIN64) 10919 char pathbuf[301], *drvname;
10921 static char drvname[] =
"sqlite3odbc.so";
10924 if (dbc == SQL_NULL_HDBC) {
10925 return SQL_INVALID_HANDLE;
10936 valMax =
sizeof (dummyc) - 1;
10939 case SQL_MAX_USER_NAME_LEN:
10940 *((SQLSMALLINT *) val) = 16;
10941 *valLen =
sizeof (SQLSMALLINT);
10943 case SQL_USER_NAME:
10944 strmak(val,
"", valMax, valLen);
10946 case SQL_DRIVER_ODBC_VER:
10948 strmak(val, (*d->
ov3) ?
"03.00" :
"02.50", valMax, valLen);
10950 strmak(val,
"03.00", valMax, valLen);
10953 case SQL_ACTIVE_CONNECTIONS:
10954 case SQL_ACTIVE_STATEMENTS:
10955 *((SQLSMALLINT *) val) = 0;
10956 *valLen =
sizeof (SQLSMALLINT);
10958 #ifdef SQL_ASYNC_MODE 10959 case SQL_ASYNC_MODE:
10960 *((SQLUINTEGER *) val) = SQL_AM_NONE;
10961 *valLen =
sizeof (SQLUINTEGER);
10964 #ifdef SQL_CREATE_TABLE 10965 case SQL_CREATE_TABLE:
10966 *((SQLUINTEGER *) val) = SQL_CT_CREATE_TABLE |
10967 SQL_CT_COLUMN_DEFAULT |
10968 SQL_CT_COLUMN_CONSTRAINT |
10969 SQL_CT_CONSTRAINT_NON_DEFERRABLE;
10970 *valLen =
sizeof (SQLUINTEGER);
10973 #ifdef SQL_CREATE_VIEW 10974 case SQL_CREATE_VIEW:
10975 *((SQLUINTEGER *) val) = SQL_CV_CREATE_VIEW;
10976 *valLen =
sizeof (SQLUINTEGER);
10979 #ifdef SQL_DDL_INDEX 10980 case SQL_DDL_INDEX:
10981 *((SQLUINTEGER *) val) = SQL_DI_CREATE_INDEX | SQL_DI_DROP_INDEX;
10982 *valLen =
sizeof (SQLUINTEGER);
10985 #ifdef SQL_DROP_TABLE 10986 case SQL_DROP_TABLE:
10987 *((SQLUINTEGER *) val) = SQL_DT_DROP_TABLE;
10988 *valLen =
sizeof (SQLUINTEGER);
10991 #ifdef SQL_DROP_VIEW 10992 case SQL_DROP_VIEW:
10993 *((SQLUINTEGER *) val) = SQL_DV_DROP_VIEW;
10994 *valLen =
sizeof (SQLUINTEGER);
10997 #ifdef SQL_INDEX_KEYWORDS 10998 case SQL_INDEX_KEYWORDS:
10999 *((SQLUINTEGER *) val) = SQL_IK_ALL;
11000 *valLen =
sizeof (SQLUINTEGER);
11003 case SQL_DATA_SOURCE_NAME:
11006 case SQL_DRIVER_NAME:
11007 #if defined(_WIN32) || defined(_WIN64) 11008 GetModuleFileName(hModule, pathbuf,
sizeof (pathbuf));
11009 drvname = strrchr(pathbuf,
'\\');
11010 if (drvname == NULL) {
11011 drvname = strrchr(pathbuf,
'/');
11013 if (drvname == NULL) {
11019 strmak(val, drvname, valMax, valLen);
11021 case SQL_DRIVER_VER:
11024 case SQL_FETCH_DIRECTION:
11025 *((SQLUINTEGER *) val) = SQL_FD_FETCH_NEXT | SQL_FD_FETCH_FIRST |
11026 SQL_FD_FETCH_LAST | SQL_FD_FETCH_PRIOR | SQL_FD_FETCH_ABSOLUTE;
11027 *valLen =
sizeof (SQLUINTEGER);
11030 strmak(val, (*d->
ov3) ?
"03.00" :
"02.50", valMax, valLen);
11032 case SQL_ODBC_SAG_CLI_CONFORMANCE:
11033 *((SQLSMALLINT *) val) = SQL_OSCC_NOT_COMPLIANT;
11034 *valLen =
sizeof (SQLSMALLINT);
11036 case SQL_STANDARD_CLI_CONFORMANCE:
11037 *((SQLUINTEGER *) val) = SQL_SCC_XOPEN_CLI_VERSION1;
11038 *valLen =
sizeof (SQLUINTEGER);
11040 case SQL_SQL_CONFORMANCE:
11041 *((SQLUINTEGER *) val) = SQL_SC_SQL92_ENTRY;
11042 *valLen =
sizeof (SQLUINTEGER);
11044 case SQL_SERVER_NAME:
11045 case SQL_DATABASE_NAME:
11048 case SQL_SEARCH_PATTERN_ESCAPE:
11049 strmak(val,
"\\", valMax, valLen);
11051 case SQL_ODBC_SQL_CONFORMANCE:
11052 *((SQLSMALLINT *) val) = SQL_OSC_MINIMUM;
11053 *valLen =
sizeof (SQLSMALLINT);
11055 case SQL_ODBC_API_CONFORMANCE:
11056 *((SQLSMALLINT *) val) = SQL_OAC_LEVEL1;
11057 *valLen =
sizeof (SQLSMALLINT);
11059 case SQL_DBMS_NAME:
11060 strmak(val,
"SQLite", valMax, valLen);
11063 strmak(val, SQLITE_VERSION, valMax, valLen);
11065 case SQL_COLUMN_ALIAS:
11066 case SQL_NEED_LONG_DATA_LEN:
11067 strmak(val,
"Y", valMax, valLen);
11069 case SQL_ROW_UPDATES:
11070 case SQL_ACCESSIBLE_PROCEDURES:
11071 case SQL_PROCEDURES:
11072 case SQL_EXPRESSIONS_IN_ORDERBY:
11073 case SQL_ODBC_SQL_OPT_IEF:
11074 case SQL_LIKE_ESCAPE_CLAUSE:
11075 case SQL_ORDER_BY_COLUMNS_IN_SELECT:
11076 case SQL_OUTER_JOINS:
11077 case SQL_ACCESSIBLE_TABLES:
11078 case SQL_MULT_RESULT_SETS:
11079 case SQL_MULTIPLE_ACTIVE_TXN:
11080 case SQL_MAX_ROW_SIZE_INCLUDES_LONG:
11081 strmak(val,
"N", valMax, valLen);
11083 #ifdef SQL_CATALOG_NAME 11084 case SQL_CATALOG_NAME:
11085 #if defined(_WIN32) || defined(_WIN64) 11086 strmak(val, d->xcelqrx ?
"Y" :
"N", valMax, valLen);
11088 strmak(val,
"N", valMax, valLen);
11092 case SQL_DATA_SOURCE_READ_ONLY:
11093 strmak(val,
"N", valMax, valLen);
11095 #ifdef SQL_OJ_CAPABILITIES 11096 case SQL_OJ_CAPABILITIES:
11097 *((SQLUINTEGER *) val) = 0;
11098 *valLen =
sizeof (SQLUINTEGER);
11101 #ifdef SQL_MAX_IDENTIFIER_LEN 11102 case SQL_MAX_IDENTIFIER_LEN:
11103 *((SQLUSMALLINT *) val) = 255;
11104 *valLen =
sizeof (SQLUSMALLINT);
11107 case SQL_CONCAT_NULL_BEHAVIOR:
11108 *((SQLSMALLINT *) val) = SQL_CB_NULL;
11109 *valLen =
sizeof (SQLSMALLINT);
11111 case SQL_CURSOR_COMMIT_BEHAVIOR:
11112 case SQL_CURSOR_ROLLBACK_BEHAVIOR:
11113 *((SQLSMALLINT *) val) = SQL_CB_PRESERVE;
11114 *valLen =
sizeof (SQLSMALLINT);
11116 #ifdef SQL_CURSOR_SENSITIVITY 11117 case SQL_CURSOR_SENSITIVITY:
11118 *((SQLUINTEGER *) val) = SQL_UNSPECIFIED;
11119 *valLen =
sizeof (SQLUINTEGER);
11122 case SQL_DEFAULT_TXN_ISOLATION:
11123 *((SQLUINTEGER *) val) = SQL_TXN_SERIALIZABLE;
11124 *valLen =
sizeof (SQLUINTEGER);
11126 #ifdef SQL_DESCRIBE_PARAMETER 11127 case SQL_DESCRIBE_PARAMETER:
11128 strmak(val,
"Y", valMax, valLen);
11131 case SQL_TXN_ISOLATION_OPTION:
11132 *((SQLUINTEGER *) val) = SQL_TXN_SERIALIZABLE;
11133 *valLen =
sizeof (SQLUINTEGER);
11135 case SQL_IDENTIFIER_CASE:
11136 *((SQLSMALLINT *) val) = SQL_IC_SENSITIVE;
11137 *valLen =
sizeof (SQLSMALLINT);
11139 case SQL_IDENTIFIER_QUOTE_CHAR:
11140 strmak(val,
"\"", valMax, valLen);
11142 case SQL_MAX_TABLE_NAME_LEN:
11143 case SQL_MAX_COLUMN_NAME_LEN:
11144 *((SQLSMALLINT *) val) = 255;
11145 *valLen =
sizeof (SQLSMALLINT);
11147 case SQL_MAX_CURSOR_NAME_LEN:
11148 *((SQLSMALLINT *) val) = 255;
11149 *valLen =
sizeof (SQLSMALLINT);
11151 case SQL_MAX_PROCEDURE_NAME_LEN:
11152 *((SQLSMALLINT *) val) = 0;
11154 case SQL_MAX_QUALIFIER_NAME_LEN:
11155 case SQL_MAX_OWNER_NAME_LEN:
11156 *((SQLSMALLINT *) val) = 255;
11158 case SQL_OWNER_TERM:
11159 strmak(val,
"", valMax, valLen);
11161 case SQL_PROCEDURE_TERM:
11162 strmak(val,
"PROCEDURE", valMax, valLen);
11164 case SQL_QUALIFIER_NAME_SEPARATOR:
11165 strmak(val,
".", valMax, valLen);
11167 case SQL_QUALIFIER_TERM:
11168 #if defined(_WIN32) || defined(_WIN64) 11169 strmak(val, d->xcelqrx ?
"catalog" :
"", valMax, valLen);
11171 strmak(val,
"", valMax, valLen);
11174 case SQL_QUALIFIER_USAGE:
11175 #if defined(_WIN32) || defined(_WIN64) 11176 *((SQLUINTEGER *) val) = d->xcelqrx ?
11177 (SQL_CU_DML_STATEMENTS | SQL_CU_INDEX_DEFINITION |
11178 SQL_CU_TABLE_DEFINITION) : 0;
11180 *((SQLUINTEGER *) val) = 0;
11182 *valLen =
sizeof (SQLUINTEGER);
11184 case SQL_SCROLL_CONCURRENCY:
11185 *((SQLUINTEGER *) val) = SQL_SCCO_LOCK;
11186 *valLen =
sizeof (SQLUINTEGER);
11188 case SQL_SCROLL_OPTIONS:
11189 *((SQLUINTEGER *) val) = SQL_SO_STATIC | SQL_SO_FORWARD_ONLY;
11190 *valLen =
sizeof (SQLUINTEGER);
11192 case SQL_TABLE_TERM:
11193 strmak(val,
"TABLE", valMax, valLen);
11195 case SQL_TXN_CAPABLE:
11196 *((SQLSMALLINT *) val) = SQL_TC_ALL;
11197 *valLen =
sizeof (SQLSMALLINT);
11199 case SQL_CONVERT_FUNCTIONS:
11200 *((SQLUINTEGER *) val) = 0;
11201 *valLen =
sizeof (SQLUINTEGER);
11203 case SQL_SYSTEM_FUNCTIONS:
11204 case SQL_NUMERIC_FUNCTIONS:
11205 case SQL_STRING_FUNCTIONS:
11206 case SQL_TIMEDATE_FUNCTIONS:
11207 *((SQLUINTEGER *) val) = 0;
11208 *valLen =
sizeof (SQLUINTEGER);
11210 case SQL_CONVERT_BIGINT:
11211 case SQL_CONVERT_BIT:
11212 case SQL_CONVERT_CHAR:
11213 case SQL_CONVERT_DATE:
11214 case SQL_CONVERT_DECIMAL:
11215 case SQL_CONVERT_DOUBLE:
11216 case SQL_CONVERT_FLOAT:
11217 case SQL_CONVERT_INTEGER:
11218 case SQL_CONVERT_LONGVARCHAR:
11219 case SQL_CONVERT_NUMERIC:
11220 case SQL_CONVERT_REAL:
11221 case SQL_CONVERT_SMALLINT:
11222 case SQL_CONVERT_TIME:
11223 case SQL_CONVERT_TIMESTAMP:
11224 case SQL_CONVERT_TINYINT:
11225 case SQL_CONVERT_VARCHAR:
11226 *((SQLUINTEGER *) val) =
11227 SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL |
11228 SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT | SQL_CVT_REAL |
11229 SQL_CVT_DOUBLE | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR |
11230 SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_BIGINT |
11231 SQL_CVT_DATE | SQL_CVT_TIME | SQL_CVT_TIMESTAMP;
11232 *valLen =
sizeof (SQLUINTEGER);
11234 case SQL_CONVERT_BINARY:
11235 case SQL_CONVERT_VARBINARY:
11236 case SQL_CONVERT_LONGVARBINARY:
11237 *((SQLUINTEGER *) val) = 0;
11238 *valLen =
sizeof (SQLUINTEGER);
11240 case SQL_POSITIONED_STATEMENTS:
11241 *((SQLUINTEGER *) val) = 0;
11242 *valLen =
sizeof (SQLUINTEGER);
11244 case SQL_LOCK_TYPES:
11245 *((SQLUINTEGER *) val) = SQL_LCK_NO_CHANGE;
11246 *valLen =
sizeof (SQLUINTEGER);
11248 case SQL_BOOKMARK_PERSISTENCE:
11249 *((SQLUINTEGER *) val) = SQL_BP_SCROLL;
11250 *valLen =
sizeof (SQLUINTEGER);
11253 *((SQLUINTEGER *) val) = SQL_U_UNION | SQL_U_UNION_ALL;
11254 *valLen =
sizeof (SQLUINTEGER);
11256 case SQL_OWNER_USAGE:
11257 case SQL_SUBQUERIES:
11258 case SQL_TIMEDATE_ADD_INTERVALS:
11259 case SQL_TIMEDATE_DIFF_INTERVALS:
11260 *((SQLUINTEGER *) val) = 0;
11261 *valLen =
sizeof (SQLUINTEGER);
11263 case SQL_QUOTED_IDENTIFIER_CASE:
11264 *((SQLUSMALLINT *) val) = SQL_IC_SENSITIVE;
11265 *valLen =
sizeof (SQLUSMALLINT);
11267 case SQL_POS_OPERATIONS:
11268 *((SQLUINTEGER *) val) = SQL_POS_POSITION | SQL_POS_UPDATE |
11269 SQL_POS_DELETE | SQL_POS_ADD | SQL_POS_REFRESH;
11270 *valLen =
sizeof (SQLUINTEGER);
11272 case SQL_ALTER_TABLE:
11273 *((SQLUINTEGER *) val) = 0;
11274 *valLen =
sizeof (SQLUINTEGER);
11276 case SQL_CORRELATION_NAME:
11277 *((SQLSMALLINT *) val) = SQL_CN_DIFFERENT;
11278 *valLen =
sizeof (SQLSMALLINT);
11280 case SQL_NON_NULLABLE_COLUMNS:
11281 *((SQLSMALLINT *) val) = SQL_NNC_NON_NULL;
11282 *valLen =
sizeof (SQLSMALLINT);
11284 case SQL_NULL_COLLATION:
11285 *((SQLSMALLINT *) val) = SQL_NC_START;
11286 *valLen =
sizeof (SQLSMALLINT);
11288 case SQL_MAX_COLUMNS_IN_GROUP_BY:
11289 case SQL_MAX_COLUMNS_IN_ORDER_BY:
11290 case SQL_MAX_COLUMNS_IN_SELECT:
11291 case SQL_MAX_COLUMNS_IN_TABLE:
11292 case SQL_MAX_ROW_SIZE:
11293 case SQL_MAX_TABLES_IN_SELECT:
11294 *((SQLSMALLINT *) val) = 0;
11295 *valLen =
sizeof (SQLSMALLINT);
11297 case SQL_MAX_BINARY_LITERAL_LEN:
11298 case SQL_MAX_CHAR_LITERAL_LEN:
11299 *((SQLUINTEGER *) val) = 0;
11300 *valLen =
sizeof (SQLUINTEGER);
11302 case SQL_MAX_COLUMNS_IN_INDEX:
11303 *((SQLSMALLINT *) val) = 0;
11304 *valLen =
sizeof (SQLSMALLINT);
11306 case SQL_MAX_INDEX_SIZE:
11307 *((SQLUINTEGER *) val) = 0;
11308 *valLen =
sizeof (SQLUINTEGER);
11310 #ifdef SQL_MAX_IDENTIFIER_LENGTH 11311 case SQL_MAX_IDENTIFIER_LENGTH:
11312 *((SQLUINTEGER *) val) = 255;
11313 *valLen =
sizeof (SQLUINTEGER);
11316 case SQL_MAX_STATEMENT_LEN:
11317 *((SQLUINTEGER *) val) = 16384;
11318 *valLen =
sizeof (SQLUINTEGER);
11320 case SQL_QUALIFIER_LOCATION:
11321 *((SQLSMALLINT *) val) = SQL_QL_START;
11322 *valLen =
sizeof (SQLSMALLINT);
11324 case SQL_GETDATA_EXTENSIONS:
11325 *((SQLUINTEGER *) val) =
11326 SQL_GD_ANY_COLUMN | SQL_GD_ANY_ORDER | SQL_GD_BOUND;
11327 *valLen =
sizeof (SQLUINTEGER);
11329 case SQL_STATIC_SENSITIVITY:
11330 *((SQLUINTEGER *) val) = 0;
11331 *valLen =
sizeof (SQLUINTEGER);
11333 case SQL_FILE_USAGE:
11334 #if defined(_WIN32) || defined(_WIN64) 11335 *((SQLSMALLINT *) val) =
11336 d->xcelqrx ? SQL_FILE_CATALOG : SQL_FILE_NOT_SUPPORTED;
11338 *((SQLSMALLINT *) val) = SQL_FILE_NOT_SUPPORTED;
11340 *valLen =
sizeof (SQLSMALLINT);
11343 *((SQLSMALLINT *) val) = SQL_GB_GROUP_BY_EQUALS_SELECT;
11344 *valLen =
sizeof (SQLSMALLINT);
11347 strmak(val,
"CREATE,SELECT,DROP,DELETE,UPDATE,INSERT," 11348 "INTO,VALUES,TABLE,INDEX,FROM,SET,WHERE,AND,CURRENT,OF",
11351 case SQL_SPECIAL_CHARACTERS:
11352 #ifdef SQL_COLLATION_SEQ 11353 case SQL_COLLATION_SEQ:
11355 strmak(val,
"", valMax, valLen);
11357 case SQL_BATCH_SUPPORT:
11358 case SQL_BATCH_ROW_COUNT:
11359 case SQL_PARAM_ARRAY_ROW_COUNTS:
11360 *((SQLUINTEGER *) val) = 0;
11361 *valLen =
sizeof (SQLUINTEGER);
11363 case SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1:
11364 *((SQLUINTEGER *) val) = SQL_CA1_NEXT | SQL_CA1_BOOKMARK;
11365 *valLen =
sizeof (SQLUINTEGER);
11367 case SQL_STATIC_CURSOR_ATTRIBUTES1:
11368 *((SQLUINTEGER *) val) = SQL_CA1_NEXT | SQL_CA1_ABSOLUTE |
11369 SQL_CA1_RELATIVE | SQL_CA1_BOOKMARK | SQL_CA1_POS_POSITION |
11370 SQL_CA1_POS_DELETE | SQL_CA1_POS_UPDATE | SQL_CA1_POS_REFRESH |
11371 SQL_CA1_LOCK_NO_CHANGE | SQL_CA1_BULK_ADD |
11372 SQL_CA1_BULK_UPDATE_BY_BOOKMARK | SQL_CA1_BULK_DELETE_BY_BOOKMARK;
11373 *valLen =
sizeof (SQLUINTEGER);
11375 case SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2:
11376 case SQL_STATIC_CURSOR_ATTRIBUTES2:
11377 *((SQLUINTEGER *) val) = SQL_CA2_READ_ONLY_CONCURRENCY |
11378 SQL_CA2_LOCK_CONCURRENCY;
11379 *valLen =
sizeof (SQLUINTEGER);
11381 case SQL_KEYSET_CURSOR_ATTRIBUTES1:
11382 case SQL_KEYSET_CURSOR_ATTRIBUTES2:
11383 case SQL_DYNAMIC_CURSOR_ATTRIBUTES1:
11384 case SQL_DYNAMIC_CURSOR_ATTRIBUTES2:
11385 *((SQLUINTEGER *) val) = 0;
11386 *valLen =
sizeof (SQLUINTEGER);
11388 case SQL_ODBC_INTERFACE_CONFORMANCE:
11389 *((SQLUINTEGER *) val) = SQL_OIC_CORE;
11390 *valLen =
sizeof (SQLUINTEGER);
11393 setstatd(d, -1,
"unsupported info option %d",
11394 (*d->
ov3) ?
"HYC00" :
"S1C00", type);
11397 return SQL_SUCCESS;
11400 #if (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC)) || !defined(WINTERFACE) 11412 SQLGetInfo(SQLHDBC dbc, SQLUSMALLINT type, SQLPOINTER val, SQLSMALLINT valMax,
11413 SQLSMALLINT *valLen)
11418 ret =
drvgetinfo(dbc, type, val, valMax, valLen);
11436 SQLGetInfoW(SQLHDBC dbc, SQLUSMALLINT type, SQLPOINTER val, SQLSMALLINT valMax,
11437 SQLSMALLINT *valLen)
11440 SQLSMALLINT len = 0;
11443 ret =
drvgetinfo(dbc, type, val, valMax, &len);
11445 if (ret == SQL_SUCCESS) {
11446 SQLWCHAR *v = NULL;
11449 case SQL_USER_NAME:
11450 case SQL_DRIVER_ODBC_VER:
11451 case SQL_DATA_SOURCE_NAME:
11452 case SQL_DRIVER_NAME:
11453 case SQL_DRIVER_VER:
11455 case SQL_SERVER_NAME:
11456 case SQL_DATABASE_NAME:
11457 case SQL_SEARCH_PATTERN_ESCAPE:
11458 case SQL_DBMS_NAME:
11460 case SQL_NEED_LONG_DATA_LEN:
11461 case SQL_ROW_UPDATES:
11462 case SQL_ACCESSIBLE_PROCEDURES:
11463 case SQL_PROCEDURES:
11464 case SQL_EXPRESSIONS_IN_ORDERBY:
11465 case SQL_ODBC_SQL_OPT_IEF:
11466 case SQL_LIKE_ESCAPE_CLAUSE:
11467 case SQL_ORDER_BY_COLUMNS_IN_SELECT:
11468 case SQL_OUTER_JOINS:
11469 case SQL_COLUMN_ALIAS:
11470 case SQL_ACCESSIBLE_TABLES:
11471 case SQL_MULT_RESULT_SETS:
11472 case SQL_MULTIPLE_ACTIVE_TXN:
11473 case SQL_MAX_ROW_SIZE_INCLUDES_LONG:
11474 case SQL_DATA_SOURCE_READ_ONLY:
11475 #ifdef SQL_DESCRIBE_PARAMETER 11476 case SQL_DESCRIBE_PARAMETER:
11478 case SQL_IDENTIFIER_QUOTE_CHAR:
11479 case SQL_OWNER_TERM:
11480 case SQL_PROCEDURE_TERM:
11481 case SQL_QUALIFIER_NAME_SEPARATOR:
11482 case SQL_QUALIFIER_TERM:
11483 case SQL_TABLE_TERM:
11485 case SQL_SPECIAL_CHARACTERS:
11486 #ifdef SQL_CATALOG_NAME 11487 case SQL_CATALOG_NAME:
11489 #ifdef SQL_COLLATION_SEQ 11490 case SQL_COLLATION_SEQ:
11496 int vmax = valMax /
sizeof (SQLWCHAR);
11506 len *=
sizeof (SQLWCHAR);
11513 if (valMax >=
sizeof (SQLWCHAR)) {
11514 *((SQLWCHAR *)val) = 0;
11518 len *=
sizeof (SQLWCHAR);
11540 SQLUSMALLINT *flags)
11543 SQLUSMALLINT exists[100];
11545 if (dbc == SQL_NULL_HDBC) {
11546 return SQL_INVALID_HANDLE;
11549 exists[i] = SQL_FALSE;
11551 exists[SQL_API_SQLALLOCCONNECT] = SQL_TRUE;
11552 exists[SQL_API_SQLFETCH] = SQL_TRUE;
11553 exists[SQL_API_SQLALLOCENV] = SQL_TRUE;
11554 exists[SQL_API_SQLFREECONNECT] = SQL_TRUE;
11555 exists[SQL_API_SQLALLOCSTMT] = SQL_TRUE;
11556 exists[SQL_API_SQLFREEENV] = SQL_TRUE;
11557 exists[SQL_API_SQLBINDCOL] = SQL_TRUE;
11558 exists[SQL_API_SQLFREESTMT] = SQL_TRUE;
11559 exists[SQL_API_SQLCANCEL] = SQL_TRUE;
11560 exists[SQL_API_SQLGETCURSORNAME] = SQL_TRUE;
11561 exists[SQL_API_SQLCOLATTRIBUTES] = SQL_TRUE;
11562 exists[SQL_API_SQLNUMRESULTCOLS] = SQL_TRUE;
11563 exists[SQL_API_SQLCONNECT] = SQL_TRUE;
11564 exists[SQL_API_SQLPREPARE] = SQL_TRUE;
11565 exists[SQL_API_SQLDESCRIBECOL] = SQL_TRUE;
11566 exists[SQL_API_SQLROWCOUNT] = SQL_TRUE;
11567 exists[SQL_API_SQLDISCONNECT] = SQL_TRUE;
11568 exists[SQL_API_SQLSETCURSORNAME] = SQL_FALSE;
11569 exists[SQL_API_SQLERROR] = SQL_TRUE;
11570 exists[SQL_API_SQLSETPARAM] = SQL_TRUE;
11571 exists[SQL_API_SQLEXECDIRECT] = SQL_TRUE;
11572 exists[SQL_API_SQLTRANSACT] = SQL_TRUE;
11573 exists[SQL_API_SQLBULKOPERATIONS] = SQL_TRUE;
11574 exists[SQL_API_SQLEXECUTE] = SQL_TRUE;
11575 exists[SQL_API_SQLBINDPARAMETER] = SQL_TRUE;
11576 exists[SQL_API_SQLGETTYPEINFO] = SQL_TRUE;
11577 exists[SQL_API_SQLCOLUMNS] = SQL_TRUE;
11578 exists[SQL_API_SQLPARAMDATA] = SQL_TRUE;
11579 exists[SQL_API_SQLDRIVERCONNECT] = SQL_TRUE;
11580 exists[SQL_API_SQLPUTDATA] = SQL_TRUE;
11581 exists[SQL_API_SQLGETCONNECTOPTION] = SQL_TRUE;
11582 exists[SQL_API_SQLSETCONNECTOPTION] = SQL_TRUE;
11583 exists[SQL_API_SQLGETDATA] = SQL_TRUE;
11584 exists[SQL_API_SQLSETSTMTOPTION] = SQL_TRUE;
11585 exists[SQL_API_SQLGETFUNCTIONS] = SQL_TRUE;
11586 exists[SQL_API_SQLSPECIALCOLUMNS] = SQL_TRUE;
11587 exists[SQL_API_SQLGETINFO] = SQL_TRUE;
11588 exists[SQL_API_SQLSTATISTICS] = SQL_TRUE;
11589 exists[SQL_API_SQLGETSTMTOPTION] = SQL_TRUE;
11590 exists[SQL_API_SQLTABLES] = SQL_TRUE;
11591 exists[SQL_API_SQLBROWSECONNECT] = SQL_FALSE;
11592 exists[SQL_API_SQLNUMPARAMS] = SQL_TRUE;
11593 exists[SQL_API_SQLCOLUMNPRIVILEGES] = SQL_FALSE;
11594 exists[SQL_API_SQLPARAMOPTIONS] = SQL_FALSE;
11595 exists[SQL_API_SQLDATASOURCES] = SQL_TRUE;
11596 exists[SQL_API_SQLPRIMARYKEYS] = SQL_TRUE;
11597 exists[SQL_API_SQLDESCRIBEPARAM] = SQL_TRUE;
11598 exists[SQL_API_SQLPROCEDURECOLUMNS] = SQL_TRUE;
11599 exists[SQL_API_SQLDRIVERS] = SQL_FALSE;
11600 exists[SQL_API_SQLPROCEDURES] = SQL_TRUE;
11601 exists[SQL_API_SQLEXTENDEDFETCH] = SQL_TRUE;
11602 exists[SQL_API_SQLSETPOS] = SQL_TRUE;
11603 exists[SQL_API_SQLFOREIGNKEYS] = SQL_TRUE;
11604 exists[SQL_API_SQLSETSCROLLOPTIONS] = SQL_TRUE;
11605 exists[SQL_API_SQLMORERESULTS] = SQL_TRUE;
11606 exists[SQL_API_SQLTABLEPRIVILEGES] = SQL_TRUE;
11607 exists[SQL_API_SQLNATIVESQL] = SQL_TRUE;
11608 if (func == SQL_API_ALL_FUNCTIONS) {
11609 memcpy(flags, exists,
sizeof (exists));
11610 }
else if (func == SQL_API_ODBC3_ALL_FUNCTIONS) {
11612 #define SET_EXISTS(x) \ 11613 flags[(x) >> 4] |= (1 << ((x) & 0xF)) 11614 #define CLR_EXISTS(x) \ 11615 flags[(x) >> 4] &= ~(1 << ((x) & 0xF)) 11618 sizeof (SQLUSMALLINT) * SQL_API_ODBC3_ALL_FUNCTIONS_SIZE);
11621 flags[i >> 4] |= (1 << (i & 0xF));
11634 #if !defined(HAVE_UNIXODBC) || !(HAVE_UNIXODBC) 11647 *flags = exists[func];
11650 case SQL_API_SQLALLOCHANDLE:
11651 case SQL_API_SQLFREEHANDLE:
11652 case SQL_API_SQLGETSTMTATTR:
11653 case SQL_API_SQLSETSTMTATTR:
11654 case SQL_API_SQLGETCONNECTATTR:
11655 case SQL_API_SQLSETCONNECTATTR:
11656 case SQL_API_SQLGETENVATTR:
11657 case SQL_API_SQLSETENVATTR:
11658 case SQL_API_SQLCLOSECURSOR:
11659 case SQL_API_SQLBINDPARAM:
11660 #if !defined(HAVE_UNIXODBC) || !(HAVE_UNIXODBC) 11666 case SQL_API_SQLGETDIAGREC:
11668 case SQL_API_SQLGETDIAGFIELD:
11669 case SQL_API_SQLFETCHSCROLL:
11670 case SQL_API_SQLENDTRAN:
11674 *flags = SQL_FALSE;
11678 return SQL_SUCCESS;
11693 return SQL_INVALID_HANDLE;
11697 *env = SQL_NULL_HENV;
11702 #if defined(_WIN32) || defined(_WIN64) 11703 InitializeCriticalSection(&e->cs);
11705 #if defined(ENABLE_NVFS) && (ENABLE_NVFS) 11710 *env = (SQLHENV) e;
11711 return SQL_SUCCESS;
11737 if (env == SQL_NULL_HENV) {
11738 return SQL_INVALID_HANDLE;
11742 return SQL_SUCCESS;
11744 #if defined(_WIN32) || defined(_WIN64) 11745 EnterCriticalSection(&e->cs);
11748 #if defined(_WIN32) || defined(_WIN64) 11749 LeaveCriticalSection(&e->cs);
11754 #if defined(_WIN32) || defined(_WIN64) 11755 LeaveCriticalSection(&e->cs);
11756 DeleteCriticalSection(&e->cs);
11759 return SQL_SUCCESS;
11786 const char *verstr;
11787 int maj = 0,
min = 0, lev = 0;
11794 *dbc = SQL_NULL_HDBC;
11797 memset(d, 0,
sizeof (
DBC));
11798 d->
curtype = SQL_CURSOR_STATIC;
11800 verstr = sqlite3_libversion();
11801 sscanf(verstr,
"%d.%d.%d", &maj, &
min, &lev);
11804 #if defined(_WIN32) || defined(_WIN64) 11806 EnterCriticalSection(&e->cs);
11826 #if defined(_WIN32) || defined(_WIN64) 11827 InitializeCriticalSection(&d->cs);
11830 LeaveCriticalSection(&e->cs);
11836 *dbc = (SQLHDBC) d;
11838 return SQL_SUCCESS;
11865 SQLRETURN ret = SQL_ERROR;
11867 if (dbc == SQL_NULL_HDBC) {
11868 return SQL_INVALID_HANDLE;
11872 return SQL_INVALID_HANDLE;
11876 #if defined(_WIN32) || defined(_WIN64) 11877 EnterCriticalSection(&e->cs);
11884 setstatd(d, -1,
"not disconnected", (*d->
ov3) ?
"HY000" :
"S1000");
11916 #if defined(_WIN32) || defined(_WIN64) 11918 LeaveCriticalSection(&d->cs);
11919 DeleteCriticalSection(&d->cs);
11924 #if defined(_WIN32) || defined(_WIN64) 11926 LeaveCriticalSection(&e->cs);
11956 SQLINTEGER bufmax, SQLINTEGER *buflen)
11961 if (dbc == SQL_NULL_HDBC) {
11962 return SQL_INVALID_HANDLE;
11966 val = (SQLPOINTER) &dummy;
11972 case SQL_ATTR_CONNECTION_DEAD:
11973 *((SQLINTEGER *) val) = d->
sqlite ? SQL_CD_FALSE : SQL_CD_TRUE;
11974 *buflen =
sizeof (SQLINTEGER);
11976 case SQL_ATTR_ACCESS_MODE:
11977 *((SQLINTEGER *) val) = SQL_MODE_READ_WRITE;
11978 *buflen =
sizeof (SQLINTEGER);
11980 case SQL_ATTR_AUTOCOMMIT:
11981 *((SQLINTEGER *) val) =
11982 d->
autocommit ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF;
11983 *buflen =
sizeof (SQLINTEGER);
11985 case SQL_ATTR_LOGIN_TIMEOUT:
11986 *((SQLINTEGER *) val) = 100;
11987 *buflen =
sizeof (SQLINTEGER);
11989 case SQL_ATTR_ODBC_CURSORS:
11990 *((SQLINTEGER *) val) = SQL_CUR_USE_DRIVER;
11991 *buflen =
sizeof (SQLINTEGER);
11993 case SQL_ATTR_PACKET_SIZE:
11994 *((SQLINTEGER *) val) = 16384;
11995 *buflen =
sizeof (SQLINTEGER);
11997 case SQL_ATTR_TXN_ISOLATION:
11998 *((SQLINTEGER *) val) = SQL_TXN_SERIALIZABLE;
11999 *buflen =
sizeof (SQLINTEGER);
12001 case SQL_ATTR_TRACEFILE:
12002 case SQL_ATTR_TRANSLATE_LIB:
12003 *((SQLCHAR *) val) = 0;
12006 case SQL_ATTR_CURRENT_CATALOG:
12007 #if defined(_WIN32) || defined(_WIN64) 12009 if ((bufmax > 4) && (val != (SQLPOINTER) &dummy)) {
12010 strcpy((
char *) val,
"main");
12016 *((SQLCHAR *) val) = 0;
12019 case SQL_ATTR_TRACE:
12020 case SQL_ATTR_QUIET_MODE:
12021 case SQL_ATTR_TRANSLATE_OPTION:
12022 case SQL_ATTR_KEYSET_SIZE:
12023 case SQL_ATTR_QUERY_TIMEOUT:
12024 *((SQLINTEGER *) val) = 0;
12025 *buflen =
sizeof (SQLINTEGER);
12027 case SQL_ATTR_PARAM_BIND_TYPE:
12028 *((
SQLULEN *) val) = SQL_PARAM_BIND_BY_COLUMN;
12029 *buflen =
sizeof (SQLUINTEGER);
12031 case SQL_ATTR_ROW_BIND_TYPE:
12032 *((
SQLULEN *) val) = SQL_BIND_BY_COLUMN;
12035 case SQL_ATTR_USE_BOOKMARKS:
12036 *((SQLINTEGER *) val) = SQL_UB_OFF;
12037 *buflen =
sizeof (SQLINTEGER);
12039 case SQL_ATTR_ASYNC_ENABLE:
12040 *((SQLINTEGER *) val) = SQL_ASYNC_ENABLE_OFF;
12041 *buflen =
sizeof (SQLINTEGER);
12043 case SQL_ATTR_NOSCAN:
12044 *((SQLINTEGER *) val) = SQL_NOSCAN_ON;
12045 *buflen =
sizeof (SQLINTEGER);
12047 case SQL_ATTR_CONCURRENCY:
12048 *((SQLINTEGER *) val) = SQL_CONCUR_LOCK;
12049 *buflen =
sizeof (SQLINTEGER);
12051 #ifdef SQL_ATTR_CURSOR_SENSITIVITY 12052 case SQL_ATTR_CURSOR_SENSITIVITY:
12053 *((SQLINTEGER *) val) = SQL_UNSPECIFIED;
12054 *buflen =
sizeof (SQLINTEGER);
12057 case SQL_ATTR_SIMULATE_CURSOR:
12058 *((SQLINTEGER *) val) = SQL_SC_NON_UNIQUE;
12059 *buflen =
sizeof (SQLINTEGER);
12061 case SQL_ATTR_MAX_ROWS:
12062 *((SQLINTEGER *) val) = 0;
12063 *buflen =
sizeof (SQLINTEGER);
12064 case SQL_ATTR_MAX_LENGTH:
12065 *((SQLINTEGER *) val) = 1000000000;
12066 *buflen =
sizeof (SQLINTEGER);
12068 case SQL_ATTR_CURSOR_TYPE:
12069 *((SQLINTEGER *) val) = d->
curtype;
12070 *buflen =
sizeof (SQLINTEGER);
12072 case SQL_ATTR_RETRIEVE_DATA:
12073 *((SQLINTEGER *) val) = SQL_RD_ON;
12074 *buflen =
sizeof (SQLINTEGER);
12076 #ifdef SQL_ATTR_METADATA_ID 12077 case SQL_ATTR_METADATA_ID:
12078 *((
SQLULEN *) val) = SQL_FALSE;
12079 return SQL_SUCCESS;
12082 *((SQLINTEGER *) val) = 0;
12083 *buflen =
sizeof (SQLINTEGER);
12084 setstatd(d, -1,
"unsupported connect attribute %d",
12085 (*d->
ov3) ?
"HYC00" :
"S1C00", (
int) attr);
12088 return SQL_SUCCESS;
12103 SQLGetConnectAttr(SQLHDBC dbc, SQLINTEGER attr, SQLPOINTER val,
12104 SQLINTEGER bufmax, SQLINTEGER *buflen)
12128 SQLINTEGER bufmax, SQLINTEGER *buflen)
12131 SQLINTEGER len = 0;
12135 if (ret == SQL_SUCCESS) {
12136 SQLWCHAR *v = NULL;
12139 case SQL_ATTR_TRACEFILE:
12140 case SQL_ATTR_CURRENT_CATALOG:
12141 case SQL_ATTR_TRANSLATE_LIB:
12146 int vmax = bufmax /
sizeof (SQLWCHAR);
12156 len *=
sizeof (SQLWCHAR);
12163 if (bufmax >=
sizeof (SQLWCHAR)) {
12164 *((SQLWCHAR *)val) = 0;
12168 len *=
sizeof (SQLWCHAR);
12196 if (dbc == SQL_NULL_HDBC) {
12197 return SQL_INVALID_HANDLE;
12201 case SQL_AUTOCOMMIT:
12202 d->
autocommit = val == (SQLPOINTER) SQL_AUTOCOMMIT_ON;
12204 return endtran(d, SQL_COMMIT, 1);
12209 return SQL_SUCCESS;
12210 #ifdef SQL_ATTR_METADATA_ID 12211 case SQL_ATTR_METADATA_ID:
12212 if (val == (SQLPOINTER) SQL_FALSE) {
12218 setstatd(d, -1,
"option value changed",
"01S02");
12219 return SQL_SUCCESS_WITH_INFO;
12221 return SQL_SUCCESS;
12235 SQLSetConnectAttr(SQLHDBC dbc, SQLINTEGER attr, SQLPOINTER val,
12284 if (dbc == SQL_NULL_HDBC) {
12285 return SQL_INVALID_HANDLE;
12289 param = (SQLPOINTER) &dummy;
12292 case SQL_ACCESS_MODE:
12293 *((SQLINTEGER *) param) = SQL_MODE_READ_WRITE;
12295 case SQL_AUTOCOMMIT:
12296 *((SQLINTEGER *) param) =
12297 d->
autocommit ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF;
12299 case SQL_LOGIN_TIMEOUT:
12300 *((SQLINTEGER *) param) = 100;
12302 case SQL_ODBC_CURSORS:
12303 *((SQLINTEGER *) param) = SQL_CUR_USE_DRIVER;
12305 case SQL_PACKET_SIZE:
12306 *((SQLINTEGER *) param) = 16384;
12308 case SQL_TXN_ISOLATION:
12309 *((SQLINTEGER *) param) = SQL_TXN_SERIALIZABLE;
12311 case SQL_OPT_TRACE:
12312 case SQL_OPT_TRACEFILE:
12313 case SQL_QUIET_MODE:
12314 case SQL_TRANSLATE_DLL:
12315 case SQL_TRANSLATE_OPTION:
12316 case SQL_KEYSET_SIZE:
12317 case SQL_QUERY_TIMEOUT:
12318 case SQL_BIND_TYPE:
12319 case SQL_CURRENT_QUALIFIER:
12320 *((SQLINTEGER *) param) = 0;
12322 case SQL_USE_BOOKMARKS:
12323 *((SQLINTEGER *) param) = SQL_UB_OFF;
12325 case SQL_ASYNC_ENABLE:
12326 *((SQLINTEGER *) param) = SQL_ASYNC_ENABLE_OFF;
12329 *((SQLINTEGER *) param) = SQL_NOSCAN_ON;
12331 case SQL_CONCURRENCY:
12332 *((SQLINTEGER *) param) = SQL_CONCUR_LOCK;
12334 case SQL_SIMULATE_CURSOR:
12335 *((SQLINTEGER *) param) = SQL_SC_NON_UNIQUE;
12338 *((SQLINTEGER *) param) = 0;
12340 case SQL_ROWSET_SIZE:
12341 case SQL_MAX_LENGTH:
12342 *((SQLINTEGER *) param) = 1000000000;
12344 case SQL_CURSOR_TYPE:
12345 *((SQLINTEGER *) param) = d->
curtype;
12347 case SQL_RETRIEVE_DATA:
12348 *((SQLINTEGER *) param) = SQL_RD_ON;
12351 *((SQLINTEGER *) param) = 0;
12352 setstatd(d, -1,
"unsupported connect option %d",
12353 (*d->
ov3) ?
"HYC00" :
"S1C00", opt);
12356 return SQL_SUCCESS;
12369 SQLGetConnectOption(SQLHDBC dbc, SQLUSMALLINT opt, SQLPOINTER param)
12396 if (SQL_SUCCEEDED(ret)) {
12398 case SQL_OPT_TRACEFILE:
12399 case SQL_CURRENT_QUALIFIER:
12400 case SQL_TRANSLATE_DLL:
12402 *(SQLWCHAR *) param = 0;
12425 if (dbc == SQL_NULL_HDBC) {
12426 return SQL_INVALID_HANDLE;
12430 case SQL_AUTOCOMMIT:
12433 return endtran(d, SQL_COMMIT, 1);
12439 setstatd(d, -1,
"option value changed",
"01S02");
12440 return SQL_SUCCESS_WITH_INFO;
12442 return SQL_SUCCESS;
12455 SQLSetConnectOption(SQLHDBC dbc, SQLUSMALLINT opt,
SQLULEN param)
12487 #if defined(WITHOUT_DRIVERMGR) || (!defined(_WIN32) && !defined(_WIN64)) 12502 char *str = dsn, *start;
12503 int len = strlen(attr);
12506 while (*str && *str ==
';') {
12510 if ((str = strchr(str,
'=')) == NULL) {
12513 if (str - start == len && strncasecmp(start, attr, len) == 0) {
12515 while (*str && *str !=
';') {
12518 len =
min(outLen - 1, str - start);
12519 strncpy(out, start, len);
12523 while (*str && *str !=
';') {
12544 int pwdLen,
int isu)
12549 char buf[SQL_MAX_MESSAGE_LENGTH], dbname[SQL_MAX_MESSAGE_LENGTH / 4];
12550 char busy[SQL_MAX_MESSAGE_LENGTH / 4], tracef[SQL_MAX_MESSAGE_LENGTH];
12551 char loadext[SQL_MAX_MESSAGE_LENGTH];
12552 char sflag[32], spflag[32], ntflag[32], nwflag[32], biflag[32];
12553 char snflag[32], lnflag[32], ncflag[32], fkflag[32], jmode[32];
12555 #if defined(_WIN32) || defined(_WIN64) 12559 if (dbc == SQL_NULL_HDBC) {
12560 return SQL_INVALID_HANDLE;
12564 return SQL_INVALID_HANDLE;
12566 if (d->
sqlite != NULL) {
12567 setstatd(d, -1,
"connection already established",
"08002");
12571 if (dsnLen == SQL_NTS) {
12572 len =
sizeof (buf) - 1;
12574 len =
min(
sizeof (buf) - 1, dsnLen);
12577 strncpy(buf, (
char *) dsn, len);
12580 if (buf[0] ==
'\0') {
12581 setstatd(d, -1,
"invalid DSN", (*d->
ov3) ?
"HY090" :
"S1090");
12584 #if defined(_WIN32) || defined(_WIN64) 12590 char *cdsn = utf_to_wmb(buf, len);
12593 setstatd(d, -1,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
12602 #ifdef WITHOUT_DRIVERMGR 12603 getdsnattr(buf,
"database", dbname,
sizeof (dbname));
12604 if (dbname[0] ==
'\0') {
12605 strncpy(dbname, buf,
sizeof (dbname));
12606 dbname[
sizeof (dbname) - 1] =
'\0';
12608 getdsnattr(buf,
"timeout", busy,
sizeof (busy));
12610 getdsnattr(buf,
"stepapi", sflag,
sizeof (sflag));
12612 getdsnattr(buf,
"syncpragma", spflag,
sizeof (spflag));
12614 getdsnattr(buf,
"notxn", ntflag,
sizeof (ntflag));
12616 getdsnattr(buf,
"nowchar", nwflag,
sizeof (nwflag));
12618 getdsnattr(buf,
"shortnames", snflag,
sizeof (snflag));
12620 getdsnattr(buf,
"longnames", lnflag,
sizeof (lnflag));
12622 getdsnattr(buf,
"nocreat", ncflag,
sizeof (ncflag));
12624 getdsnattr(buf,
"fksupport", fkflag,
sizeof (fkflag));
12626 getdsnattr(buf,
"loadext", loadext,
sizeof (loadext));
12628 getdsnattr(buf,
"journalmode", jmode,
sizeof (jmode));
12630 getdsnattr(buf,
"jdconv", jdflag,
sizeof (jdflag));
12631 #if defined(_WIN32) || defined(_WIN64) 12633 getdsnattr(buf,
"oemcp", oemcp,
sizeof (oemcp));
12636 getdsnattr(buf,
"bigint", biflag,
sizeof (biflag));
12638 SQLGetPrivateProfileString(buf,
"timeout",
"100000",
12640 SQLGetPrivateProfileString(buf,
"database",
"",
12641 dbname,
sizeof (dbname),
ODBC_INI);
12642 #if defined(_WIN32) || defined(_WIN64) 12646 SQLGetPrivateProfileString(buf,
"stepapi",
"",
12648 SQLGetPrivateProfileString(buf,
"syncpragma",
"NORMAL",
12649 spflag,
sizeof (spflag),
ODBC_INI);
12650 SQLGetPrivateProfileString(buf,
"notxn",
"",
12651 ntflag,
sizeof (ntflag),
ODBC_INI);
12652 SQLGetPrivateProfileString(buf,
"nowchar",
"",
12653 nwflag,
sizeof (nwflag),
ODBC_INI);
12654 SQLGetPrivateProfileString(buf,
"shortnames",
"",
12655 snflag,
sizeof (snflag),
ODBC_INI);
12656 SQLGetPrivateProfileString(buf,
"longnames",
"",
12657 lnflag,
sizeof (lnflag),
ODBC_INI);
12658 SQLGetPrivateProfileString(buf,
"nocreat",
"",
12659 ncflag,
sizeof (ncflag),
ODBC_INI);
12660 SQLGetPrivateProfileString(buf,
"fksupport",
"",
12661 fkflag,
sizeof (fkflag),
ODBC_INI);
12662 SQLGetPrivateProfileString(buf,
"loadext",
"",
12663 loadext,
sizeof (loadext),
ODBC_INI);
12664 SQLGetPrivateProfileString(buf,
"journalmode",
"",
12666 SQLGetPrivateProfileString(buf,
"jdconv",
"",
12667 jdflag,
sizeof (jdflag),
ODBC_INI);
12668 #if defined(_WIN32) || defined(_WIN64) 12669 SQLGetPrivateProfileString(buf,
"oemcp",
"1",
12672 SQLGetPrivateProfileString(buf,
"bigint",
"",
12673 biflag,
sizeof (biflag),
ODBC_INI);
12676 #ifdef WITHOUT_DRIVERMGR 12677 getdsnattr(buf,
"tracefile", tracef,
sizeof (tracef));
12679 SQLGetPrivateProfileString(buf,
"tracefile",
"",
12680 tracef,
sizeof (tracef),
ODBC_INI);
12682 if (tracef[0] !=
'\0') {
12683 d->
trace = fopen(tracef,
"a");
12691 #if defined(_WIN32) || defined(_WIN64) 12700 d->
pwdLen = (pwdLen == SQL_NTS) ? strlen(d->
pwd) : pwdLen;
12702 ret =
dbopen(d, dbname, isu, (
char *) dsn, sflag, spflag, ntflag,
12704 if (ret == SQL_SUCCESS) {
12724 SQLConnect(SQLHDBC dbc, SQLCHAR *dsn, SQLSMALLINT dsnLen,
12725 SQLCHAR *uid, SQLSMALLINT uidLen,
12726 SQLCHAR *pwd, SQLSMALLINT pwdLen)
12731 ret =
drvconnect(dbc, dsn, dsnLen, (
char *) pwd, pwdLen, 0);
12752 SQLWCHAR *uid, SQLSMALLINT uidLen,
12753 SQLWCHAR *pwd, SQLSMALLINT pwdLen)
12765 setstatd(d, -1,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
12775 setstatd(d, -1,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
12780 ret =
drvconnect(dbc, (SQLCHAR *) dsna, SQL_NTS, pwda, SQL_NTS, 1);
12801 if (dbc == SQL_NULL_HDBC) {
12802 return SQL_INVALID_HANDLE;
12806 return SQL_INVALID_HANDLE;
12809 setstatd(d, -1,
"incomplete transaction",
"25000");
12817 fprintf(d->
trace,
"-- sqlite3_close: '%s'\n",
12821 rc = sqlite3_close(d->
sqlite);
12822 if (rc == SQLITE_BUSY) {
12823 setstatd(d, -1,
"unfinished statements",
"25000");
12830 return SQL_SUCCESS;
12850 #if defined(WITHOUT_DRIVERMGR) || (!defined(_WIN32) && !defined(_WIN64)) 12867 SQLCHAR *connIn, SQLSMALLINT connInLen,
12868 SQLCHAR *connOut, SQLSMALLINT connOutMax,
12869 SQLSMALLINT *connOutLen, SQLUSMALLINT drvcompl)
12874 char buf[SQL_MAX_MESSAGE_LENGTH * 6], dbname[SQL_MAX_MESSAGE_LENGTH];
12875 char dsn[SQL_MAX_MESSAGE_LENGTH / 4], busy[SQL_MAX_MESSAGE_LENGTH / 4];
12876 char tracef[SQL_MAX_MESSAGE_LENGTH], loadext[SQL_MAX_MESSAGE_LENGTH];
12877 char pwd[SQL_MAX_MESSAGE_LENGTH];
12878 char sflag[32], spflag[32], ntflag[32], snflag[32], lnflag[32];
12879 char ncflag[32], nwflag[32], fkflag[32], jmode[32], biflag[32];
12882 if (dbc == SQL_NULL_HDBC) {
12883 return SQL_INVALID_HANDLE;
12885 if (drvcompl != SQL_DRIVER_COMPLETE &&
12886 drvcompl != SQL_DRIVER_COMPLETE_REQUIRED &&
12887 drvcompl != SQL_DRIVER_PROMPT &&
12888 drvcompl != SQL_DRIVER_NOPROMPT) {
12889 return SQL_NO_DATA;
12893 setstatd(d, -1,
"connection already established",
"08002");
12897 if (connInLen == SQL_NTS) {
12898 len =
sizeof (buf) - 1;
12900 len =
min(connInLen,
sizeof (buf) - 1);
12902 if (connIn != NULL) {
12903 strncpy(buf, (
char *) connIn, len);
12907 setstatd(d, -1,
"invalid connect attributes",
12908 (*d->
ov3) ?
"HY090" :
"S1090");
12915 if (!dsn[0] && !strchr(buf,
';') && !strchr(buf,
'=')) {
12916 strncpy(dsn, buf,
sizeof (dsn) - 1);
12917 dsn[
sizeof (dsn) - 1] =
'\0';
12921 getdsnattr(buf,
"timeout", busy,
sizeof (busy));
12922 #ifndef WITHOUT_DRIVERMGR 12923 if (dsn[0] && !busy[0]) {
12924 SQLGetPrivateProfileString(dsn,
"timeout",
"100000",
12929 getdsnattr(buf,
"database", dbname,
sizeof (dbname));
12930 #ifndef WITHOUT_DRIVERMGR 12931 if (dsn[0] && !dbname[0]) {
12932 SQLGetPrivateProfileString(dsn,
"database",
"",
12933 dbname,
sizeof (dbname),
ODBC_INI);
12937 getdsnattr(buf,
"stepapi", sflag,
sizeof (sflag));
12938 #ifndef WITHOUT_DRIVERMGR 12939 if (dsn[0] && !sflag[0]) {
12940 SQLGetPrivateProfileString(dsn,
"stepapi",
"",
12945 getdsnattr(buf,
"syncpragma", spflag,
sizeof (spflag));
12946 #ifndef WITHOUT_DRIVERMGR 12947 if (dsn[0] && !spflag[0]) {
12948 SQLGetPrivateProfileString(dsn,
"syncpragma",
"NORMAL",
12949 spflag,
sizeof (spflag),
ODBC_INI);
12953 getdsnattr(buf,
"notxn", ntflag,
sizeof (ntflag));
12954 #ifndef WITHOUT_DRIVERMGR 12955 if (dsn[0] && !ntflag[0]) {
12956 SQLGetPrivateProfileString(dsn,
"notxn",
"",
12957 ntflag,
sizeof (ntflag),
ODBC_INI);
12961 getdsnattr(buf,
"shortnames", snflag,
sizeof (snflag));
12962 #ifndef WITHOUT_DRIVERMGR 12963 if (dsn[0] && !snflag[0]) {
12964 SQLGetPrivateProfileString(dsn,
"shortnames",
"",
12965 snflag,
sizeof (snflag),
ODBC_INI);
12969 getdsnattr(buf,
"longnames", lnflag,
sizeof (lnflag));
12970 #ifndef WITHOUT_DRIVERMGR 12971 if (dsn[0] && !lnflag[0]) {
12972 SQLGetPrivateProfileString(dsn,
"longnames",
"",
12973 lnflag,
sizeof (lnflag),
ODBC_INI);
12977 getdsnattr(buf,
"nocreat", ncflag,
sizeof (ncflag));
12978 #ifndef WITHOUT_DRIVERMGR 12979 if (dsn[0] && !ncflag[0]) {
12980 SQLGetPrivateProfileString(dsn,
"nocreat",
"",
12981 ncflag,
sizeof (ncflag),
ODBC_INI);
12985 getdsnattr(buf,
"nowchar", nwflag,
sizeof (nwflag));
12986 #ifndef WITHOUT_DRIVERMGR 12987 if (dsn[0] && !nwflag[0]) {
12988 SQLGetPrivateProfileString(dsn,
"nowchar",
"",
12989 nwflag,
sizeof (nwflag),
ODBC_INI);
12993 getdsnattr(buf,
"fksupport", fkflag,
sizeof (fkflag));
12994 #ifndef WITHOUT_DRIVERMGR 12995 if (dsn[0] && !fkflag[0]) {
12996 SQLGetPrivateProfileString(dsn,
"fksupport",
"",
12997 fkflag,
sizeof (fkflag),
ODBC_INI);
13001 getdsnattr(buf,
"loadext", loadext,
sizeof (loadext));
13002 #ifndef WITHOUT_DRIVERMGR 13003 if (dsn[0] && !loadext[0]) {
13004 SQLGetPrivateProfileString(dsn,
"loadext",
"",
13005 loadext,
sizeof (loadext),
ODBC_INI);
13009 getdsnattr(buf,
"journalmode", jmode,
sizeof (jmode));
13010 #ifndef WITHOUT_DRIVERMGR 13011 if (dsn[0] && !jmode[0]) {
13012 SQLGetPrivateProfileString(dsn,
"journalmode",
"",
13017 getdsnattr(buf,
"bigint", biflag,
sizeof (biflag));
13018 #ifndef WITHOUT_DRIVERMGR 13019 if (dsn[0] && !biflag[0]) {
13020 SQLGetPrivateProfileString(dsn,
"bigint",
"",
13021 biflag,
sizeof (biflag),
ODBC_INI);
13025 getdsnattr(buf,
"jdconv", jdflag,
sizeof (jdflag));
13026 #ifndef WITHOUT_DRIVERMGR 13027 if (dsn[0] && !jdflag[0]) {
13028 SQLGetPrivateProfileString(dsn,
"jdconv",
"",
13029 jdflag,
sizeof (jdflag),
ODBC_INI);
13034 #ifndef WITHOUT_DRIVERMGR 13035 if (dsn[0] && !pwd[0]) {
13036 SQLGetPrivateProfileString(dsn,
"pwd",
"",
13041 if (!dbname[0] && !dsn[0]) {
13042 strcpy(dsn,
"SQLite");
13043 strncpy(dbname, buf,
sizeof (dbname));
13044 dbname[
sizeof (dbname) - 1] =
'\0';
13047 getdsnattr(buf,
"tracefile", tracef,
sizeof (tracef));
13048 #ifndef WITHOUT_DRIVERMGR 13049 if (dsn[0] && !tracef[0]) {
13050 SQLGetPrivateProfileString(dsn,
"tracefile",
"",
13051 tracef,
sizeof (tracef),
ODBC_INI);
13054 if (connOut || connOutLen) {
13058 count = snprintf(buf,
sizeof (buf),
13059 "DSN=%s;Database=%s;StepAPI=%s;Timeout=%s;" 13060 "SyncPragma=%s;NoTXN=%s;ShortNames=%s;LongNames=%s;" 13061 "NoCreat=%s;NoWCHAR=%s;FKSupport=%s;Tracefile=%s;" 13062 "JournalMode=%s;LoadExt=%s;BigInt=%s;JDConv=%s;" 13064 dsn, dbname, sflag, busy, spflag, ntflag,
13065 snflag, lnflag, ncflag, nwflag, fkflag, tracef,
13066 jmode, loadext, biflag, jdflag, pwd);
13068 buf[
sizeof (buf) - 1] =
'\0';
13070 len =
min(connOutMax - 1, strlen(buf));
13072 strncpy((
char *) connOut, buf, len);
13073 connOut[len] =
'\0';
13079 if (tracef[0] !=
'\0') {
13080 d->
trace = fopen(tracef,
"a");
13090 d->
pwdLen = strlen(pwd);
13092 ret =
dbopen(d, dbname, 0, dsn, sflag, spflag, ntflag, jmode, busy);
13093 memset(pwd, 0,
sizeof (pwd));
13094 if (ret == SQL_SUCCESS) {
13113 if (stmt == SQL_NULL_HSTMT) {
13114 return SQL_INVALID_HANDLE;
13149 return SQL_SUCCESS;
13165 if (dbc == SQL_NULL_HDBC) {
13166 return SQL_INVALID_HANDLE;
13170 return SQL_INVALID_HANDLE;
13174 *stmt = SQL_NULL_HSTMT;
13177 *stmt = (SQLHSTMT) s;
13178 memset(s, 0,
sizeof (
STMT));
13181 s->
bkmrk = SQL_UB_OFF;
13202 sprintf((
char *) s->
cursorname,
"CUR_%I64X", (SQLUBIGINT) *stmt);
13204 sprintf((
char *) s->
cursorname,
"CUR_%016lX", (
long) *stmt);
13217 return SQL_SUCCESS;
13249 SQLRETURN ret = SQL_SUCCESS;
13252 if (stmt == SQL_NULL_HSTMT) {
13253 return SQL_INVALID_HANDLE;
13259 case SQL_RESET_PARAMS:
13274 setstat(s, -1,
"unsupported option", (*s->
ov3) ?
"HYC00" :
"S1C00");
13304 if (stmt != SQL_NULL_HSTMT) {
13306 #if defined(_WIN32) || defined(_WIN64) 13308 if (d->
magic ==
DBC_MAGIC && d->owner != GetCurrentThreadId() &&
13311 sqlite3_interrupt(d->
sqlite);
13312 return SQL_SUCCESS;
13317 sqlite3_interrupt(d->
sqlite);
13339 if (stmt == SQL_NULL_HSTMT) {
13340 return SQL_INVALID_HANDLE;
13343 if (lenp && !cursor) {
13345 return SQL_SUCCESS;
13349 strncpy((
char *) cursor, (
char *) s->
cursorname, buflen - 1);
13350 cursor[buflen - 1] =
'\0';
13356 return SQL_SUCCESS;
13370 SQLGetCursorName(SQLHSTMT stmt, SQLCHAR *cursor, SQLSMALLINT buflen,
13374 #if defined(_WIN32) || defined(_WIN64) 13375 SQLSMALLINT len = 0;
13379 #if defined(_WIN32) || defined(_WIN64) 13380 if (!((
STMT *) stmt)->oemcp[0]) {
13385 if (ret == SQL_SUCCESS) {
13389 c = utf_to_wmb((
char *) cursor, len);
13397 strncpy((
char *) cursor, c, buflen - 1);
13398 cursor[buflen - 1] = 0;
13403 *lenp =
min(len, buflen - 1);
13431 SQLSMALLINT len = 0;
13435 if (ret == SQL_SUCCESS) {
13436 SQLWCHAR *c = NULL;
13448 cursor[buflen - 1] = 0;
13453 *lenp =
min(len, buflen - 1);
13475 if (stmt == SQL_NULL_HSTMT) {
13476 return SQL_INVALID_HANDLE;
13480 !((cursor[0] >=
'A' && cursor[0] <=
'Z') ||
13481 (cursor[0] >=
'a' && cursor[0] <=
'z'))) {
13482 setstat(s, -1,
"invalid cursor name", (*s->
ov3) ?
"HYC00" :
"S1C00");
13485 if (len == SQL_NTS) {
13490 strncpy((
char *) s->
cursorname, (
char *) cursor, len);
13492 return SQL_SUCCESS;
13505 SQLSetCursorName(SQLHSTMT stmt, SQLCHAR *cursor, SQLSMALLINT len)
13507 #if defined(_WIN32) || defined(_WIN64) 13513 #if defined(_WIN32) || defined(_WIN64) 13514 if (!((
STMT *) stmt)->oemcp[0]) {
13519 c = wmb_to_utf_c((
char *) cursor, len);
13529 #if defined(_WIN32) || defined(_WIN64) 13597 case SQL_HANDLE_ENV:
13599 if (ret == SQL_SUCCESS) {
13600 ENV *e = (
ENV *) *output;
13607 case SQL_HANDLE_DBC:
13609 case SQL_HANDLE_STMT:
13611 ret =
drvallocstmt((SQLHDBC) input, (SQLHSTMT *) output);
13629 case SQL_HANDLE_ENV:
13631 case SQL_HANDLE_DBC:
13633 case SQL_HANDLE_STMT:
13650 for (i = 0; i < s->
dcols; i++) {
13741 for (i = s->
nbindcols; i < ncols; i++) {
13742 bindcols[i].
type = SQL_UNKNOWN_TYPE;
13743 bindcols[i].
max = 0;
13744 bindcols[i].
lenp = NULL;
13745 bindcols[i].
valp = NULL;
13746 bindcols[i].
index = i;
13747 bindcols[i].
offs = 0;
13752 }
else if (ncols > 0) {
13760 return SQL_SUCCESS;
13778 SQLPOINTER val, SQLINTEGER len,
SQLLEN *lenp,
int partial)
13780 char **data, valdummy[16];
13782 SQLINTEGER *ilenp = NULL;
13785 SQLRETURN sret = SQL_NO_DATA;
13791 if (((SQLINTEGER *) lenp) + 1 == (SQLINTEGER *) val) {
13792 ilenp = (SQLINTEGER *) lenp;
13795 if (col >= s->
ncols) {
13796 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009" :
"S1002");
13800 return SQL_SUCCESS;
13803 *lenp = SQL_NULL_DATA;
13807 *lenp = SQL_NULL_DATA;
13812 #if (defined(_WIN32) || defined(_WIN64)) && defined(WINTERFACE) 13814 if (type == SQL_C_WCHAR && otype == SQL_C_DEFAULT) {
13821 val = (SQLPOINTER) valdummy;
13823 if (*data == NULL) {
13824 *lenp = SQL_NULL_DATA;
13826 case SQL_C_UTINYINT:
13827 case SQL_C_TINYINT:
13828 case SQL_C_STINYINT:
13832 *((SQLCHAR *) val) = 0;
13837 *((SQLSMALLINT *) val) = 0;
13842 *((SQLINTEGER *) val) = 0;
13845 case SQL_C_SBIGINT:
13846 case SQL_C_UBIGINT:
13847 *((SQLBIGINT *) val) = 0;
13851 *((
float *) val) = 0;
13854 *((
double *) val) = 0;
13859 *((SQLCHAR *) val) =
'\0';
13862 #ifdef WCHARSUPPORT 13865 *((SQLWCHAR *) val) =
'\0';
13869 #ifdef SQL_C_TYPE_DATE 13870 case SQL_C_TYPE_DATE:
13873 memset((DATE_STRUCT *) val, 0,
sizeof (DATE_STRUCT));
13875 #ifdef SQL_C_TYPE_TIME 13876 case SQL_C_TYPE_TIME:
13879 memset((TIME_STRUCT *) val, 0,
sizeof (TIME_STRUCT));
13881 #ifdef SQL_C_TYPE_TIMESTAMP 13882 case SQL_C_TYPE_TIMESTAMP:
13884 case SQL_C_TIMESTAMP:
13885 memset((TIMESTAMP_STRUCT *) val, 0,
sizeof (TIMESTAMP_STRUCT));
13892 #if defined(_WIN32) || defined(_WIN64) 13899 case SQL_C_UTINYINT:
13900 case SQL_C_TINYINT:
13901 case SQL_C_STINYINT:
13902 *((SQLCHAR *) val) = strtol(*data, &endp, 0);
13903 if (endp && endp == *data) {
13904 *lenp = SQL_NULL_DATA;
13906 *lenp =
sizeof (SQLCHAR);
13911 *((SQLCHAR *) val) =
getbool(*data);
13912 *lenp =
sizeof (SQLCHAR);
13918 *((SQLSMALLINT *) val) = strtol(*data, &endp, 0);
13919 if (endp && endp == *data) {
13920 *lenp = SQL_NULL_DATA;
13922 *lenp =
sizeof (SQLSMALLINT);
13928 *((SQLINTEGER *) val) = strtol(*data, &endp, 0);
13929 if (endp && endp == *data) {
13930 *lenp = SQL_NULL_DATA;
13932 *lenp =
sizeof (SQLINTEGER);
13936 case SQL_C_UBIGINT:
13937 #if defined(_WIN32) || defined(_WIN64) 13938 if (sscanf(*data,
"%I64u%c", (SQLUBIGINT *) val, &endc) != 1) {
13939 *lenp = SQL_NULL_DATA;
13941 *lenp =
sizeof (SQLUBIGINT);
13945 *((SQLUBIGINT *) val) = strtoul(*data, &endp, 0);
13947 *((SQLUBIGINT *) val) = strtoull(*data, &endp, 0);
13949 if (endp && endp == *data) {
13950 *lenp = SQL_NULL_DATA;
13952 *lenp =
sizeof (SQLUBIGINT);
13956 case SQL_C_SBIGINT:
13957 #if defined(_WIN32) || defined(_WIN64) 13958 if (sscanf(*data,
"%I64d%c", (SQLBIGINT *) val, &endc) != 1) {
13959 *lenp = SQL_NULL_DATA;
13961 *lenp =
sizeof (SQLBIGINT);
13965 *((SQLBIGINT *) val) = strtol(*data, &endp, 0);
13967 *((SQLBIGINT *) val) = strtoll(*data, &endp, 0);
13969 if (endp && endp == *data) {
13970 *lenp = SQL_NULL_DATA;
13972 *lenp =
sizeof (SQLBIGINT);
13978 *((
float *) val) =
ln_strtod(*data, &endp);
13979 if (endp && endp == *data) {
13980 *lenp = SQL_NULL_DATA;
13982 *lenp =
sizeof (float);
13986 *((
double *) val) =
ln_strtod(*data, &endp);
13987 if (endp && endp == *data) {
13988 *lenp = SQL_NULL_DATA;
13990 *lenp =
sizeof (double);
13993 case SQL_C_BINARY: {
13994 int dlen, offs = 0;
14018 if (!(dp[0] ==
'x' || dp[0] ==
'X') || dp[1] !=
'\'' ||
14019 dp[dlen - 1] !=
'\'') {
14030 memset(bin, 0, dlen);
14032 for (i = 0; i < dlen; i++) {
14036 if (!*dp || !(x = strchr(
xdigits, *dp))) {
14040 bin[i] = (v >= 16) ? ((v - 6) << 4) : (v << 4);
14042 if (!*dp || !(x = strchr(xdigits, *dp))) {
14046 setstat(s, -1,
"conversion error",
14047 (*s->
ov3) ?
"HY000" :
"S1000");
14051 bin[i] |= (v >= 16) ? (v - 6) : v;
14056 if (partial && len && s->
bindcols) {
14061 sret = SQL_SUCCESS;
14065 sret = SQL_NO_DATA;
14072 memcpy(val, bin + offs,
min(len, dlen));
14077 *lenp =
min(len, dlen);
14078 if (*lenp == len && *lenp != dlen) {
14079 *lenp = SQL_NO_TOTAL;
14082 if (partial && len && s->
bindcols) {
14083 if (*lenp == SQL_NO_TOTAL) {
14086 setstat(s, -1,
"data right truncated",
"01004");
14090 sret = SQL_SUCCESS_WITH_INFO;
14095 if (*lenp == SQL_NO_TOTAL) {
14097 setstat(s, -1,
"data right truncated",
"01004");
14098 sret = SQL_SUCCESS_WITH_INFO;
14104 #ifdef WCHARSUPPORT 14108 int doz, zlen = len - 1;
14109 int dlen = strlen(*data);
14111 #ifdef WCHARSUPPORT 14112 SQLWCHAR *ucdata = NULL;
14113 SQLCHAR *cdata = (SQLCHAR *) *data;
14116 #if (defined(_WIN32) || defined(_WIN64)) && defined(WINTERFACE) 14119 (s->
cols == statSpec2P || s->
cols == statSpec3P) &&
14120 type == SQL_C_WCHAR) {
14121 if (len > 0 && len <=
sizeof (SQLWCHAR)) {
14122 ((
char *) val)[0] = data[0][0];
14123 memset((
char *) val + 1, 0, len - 1);
14125 sret = SQL_SUCCESS;
14131 #ifdef WCHARSUPPORT 14137 doz =
sizeof (SQLWCHAR);
14143 if (type == SQL_C_WCHAR) {
14148 dlen =
uc_strlen(ucdata) *
sizeof (SQLWCHAR);
14150 #if defined(_WIN32) || defined(_WIN64) 14151 else if (*s->
oemcp && type == SQL_C_CHAR) {
14152 ucdata = (SQLWCHAR *) utf_to_wmb((
char *) cdata, dlen);
14156 cdata = (SQLCHAR *) ucdata;
14157 dlen = strlen((
char *) cdata);
14161 doz = (type == SQL_C_CHAR) ? 1 : 0;
14163 if (partial && len && s->
bindcols) {
14165 #ifdef WCHARSUPPORT 14170 #ifdef WCHARSUPPORT 14171 if (type == SQL_C_WCHAR) {
14172 ((SQLWCHAR *) val)[0] = 0;
14174 ((
char *) val)[0] =
'\0';
14177 ((
char *) val)[0] =
'\0';
14182 sret = SQL_SUCCESS;
14186 sret = SQL_NO_DATA;
14192 if (val && !valnull && len) {
14193 #ifdef WCHARSUPPORT 14194 if (type == SQL_C_WCHAR) {
14195 uc_strncpy(val, ucdata + offs /
sizeof (SQLWCHAR),
14196 (len - doz) /
sizeof (SQLWCHAR));
14198 strncpy(val, (
char *) cdata + offs, len - doz);
14201 strncpy(val, *data + offs, len - doz);
14204 if (valnull || len < 1) {
14207 *lenp =
min(len - doz, dlen);
14208 if (*lenp == len - doz && *lenp != dlen) {
14209 *lenp = SQL_NO_TOTAL;
14210 }
else if (*lenp < zlen) {
14214 if (len && !valnull && doz) {
14215 #ifdef WCHARSUPPORT 14216 if (type == SQL_C_WCHAR) {
14217 ((SQLWCHAR *) val)[zlen /
sizeof (SQLWCHAR)] = 0;
14219 ((
char *) val)[zlen] =
'\0';
14222 ((
char *) val)[zlen] =
'\0';
14225 #ifdef WCHARSUPPORT 14228 if (partial && len && s->
bindcols) {
14229 if (*lenp == SQL_NO_TOTAL) {
14232 setstat(s, -1,
"data right truncated",
"01004");
14236 sret = SQL_SUCCESS_WITH_INFO;
14241 if (*lenp == SQL_NO_TOTAL) {
14243 setstat(s, -1,
"data right truncated",
"01004");
14244 sret = SQL_SUCCESS_WITH_INFO;
14249 #ifdef SQL_C_TYPE_DATE 14250 case SQL_C_TYPE_DATE:
14254 *lenp = SQL_NULL_DATA;
14256 *lenp =
sizeof (DATE_STRUCT);
14259 #ifdef SQL_C_TYPE_TIME 14260 case SQL_C_TYPE_TIME:
14264 *lenp = SQL_NULL_DATA;
14266 *lenp =
sizeof (TIME_STRUCT);
14269 #ifdef SQL_C_TYPE_TIMESTAMP 14270 case SQL_C_TYPE_TIMESTAMP:
14272 case SQL_C_TIMESTAMP:
14274 (TIMESTAMP_STRUCT *) val) < 0) {
14275 *lenp = SQL_NULL_DATA;
14277 *lenp =
sizeof (TIMESTAMP_STRUCT);
14281 ((TIMESTAMP_STRUCT *) val)->fraction = 0;
14284 ((TIMESTAMP_STRUCT *) val)->fraction /= 100000000;
14285 ((TIMESTAMP_STRUCT *) val)->fraction *= 100000000;
14288 ((TIMESTAMP_STRUCT *) val)->fraction /= 10000000;
14289 ((TIMESTAMP_STRUCT *) val)->fraction *= 10000000;
14297 sret = SQL_SUCCESS;
14323 if (stmt == SQL_NULL_HSTMT) {
14324 return SQL_INVALID_HANDLE;
14328 if (col == 0 && s->
bkmrk == SQL_UB_ON &&
14329 type == SQL_C_BOOKMARK) {
14338 return SQL_SUCCESS;
14339 }
else if (col == 0 && s->
bkmrk == SQL_UB_VARIABLE &&
14340 type == SQL_C_VARBOOKMARK &&
14341 max >= sizeof (sqlite_int64)) {
14350 return SQL_SUCCESS;
14352 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009" :
"S1002");
14359 if (type == SQL_C_DEFAULT) {
14367 sz =
sizeof (SQLINTEGER);
14369 case SQL_C_TINYINT:
14370 case SQL_C_UTINYINT:
14371 case SQL_C_STINYINT:
14372 sz =
sizeof (SQLCHAR);
14377 sz =
sizeof (SQLSMALLINT);
14380 sz =
sizeof (SQLFLOAT);
14383 sz =
sizeof (SQLDOUBLE);
14385 case SQL_C_TIMESTAMP:
14386 sz =
sizeof (SQL_TIMESTAMP_STRUCT);
14389 sz =
sizeof (SQL_TIME_STRUCT);
14392 sz =
sizeof (SQL_DATE_STRUCT);
14396 #ifdef WCHARSUPPORT 14400 #ifdef SQL_C_TYPE_DATE 14401 case SQL_C_TYPE_DATE:
14402 sz =
sizeof (SQL_DATE_STRUCT);
14405 #ifdef SQL_C_TYPE_TIME 14406 case SQL_C_TYPE_TIME:
14407 sz =
sizeof (SQL_TIME_STRUCT);
14410 #ifdef SQL_C_TYPE_TIMESTAMP 14411 case SQL_C_TYPE_TIMESTAMP:
14412 sz =
sizeof (SQL_TIMESTAMP_STRUCT);
14417 sz =
sizeof (SQLCHAR);
14423 case SQL_C_SBIGINT:
14424 case SQL_C_UBIGINT:
14425 sz =
sizeof (SQLBIGINT);
14433 setstat(s, -1,
"invalid type %d",
"HY003", type);
14444 if (sz == 0 && max < 0) {
14445 setstat(s, -1,
"invalid length",
"HY090");
14457 return SQL_SUCCESS;
14478 ret =
drvbindcol(stmt, col, type, val, max, lenp);
14488 {
"SYSTEM",
"COLUMN",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
14489 {
"SYSTEM",
"COLUMN",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
14490 {
"SYSTEM",
"COLUMN",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
14491 {
"SYSTEM",
"COLUMN",
"TABLE_TYPE",
SCOL_VARCHAR, 50 },
14496 {
"SYSTEM",
"COLUMN",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
14497 {
"SYSTEM",
"COLUMN",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
14498 {
"SYSTEM",
"COLUMN",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
14499 {
"SYSTEM",
"COLUMN",
"TABLE_TYPE",
SCOL_VARCHAR, 50 },
14519 SQLCHAR *cat, SQLSMALLINT catLen,
14520 SQLCHAR *schema, SQLSMALLINT schemaLen,
14521 SQLCHAR *table, SQLSMALLINT tableLen,
14522 SQLCHAR *type, SQLSMALLINT typeLen)
14527 int ncols, asize, rc, size, npatt;
14528 char *errp = NULL, *sql, tname[512];
14529 char *where =
"(type = 'table' or type = 'view')";
14532 tableSpec3,
array_size(tableSpec3), &asize);
14533 if (ret != SQL_SUCCESS) {
14538 if (type && (typeLen > 0 || typeLen == SQL_NTS) && type[0] ==
'%') {
14539 int size = 3 * asize;
14546 memset(s->
rows, 0, sizeof (
char *) * size);
14556 #ifdef MEMORY_DEBUG 14563 return SQL_SUCCESS;
14565 if (cat && (catLen > 0 || catLen == SQL_NTS) && cat[0] ==
'%') {
14569 if (schema && (schemaLen > 0 || schemaLen == SQL_NTS) &&
14570 schema[0] ==
'%') {
14571 if ((!cat || catLen == 0 || !cat[0]) &&
14572 (!table || tableLen == 0 || !table[0])) {
14577 if (type && (typeLen > 0 || typeLen == SQL_NTS) && type[0] !=
'\0') {
14579 int with_view = 0, with_table = 0;
14581 if (typeLen == SQL_NTS) {
14582 strncpy(tmp, (
char *) type,
sizeof (tmp));
14583 tmp[
sizeof (tmp) - 1] =
'\0';
14585 int len =
min(
sizeof (tmp) - 1, typeLen);
14587 strncpy(tmp, (
char *) type, len);
14598 if (t[0] ==
'\'') {
14601 if (strncmp(t,
"table", 5) == 0) {
14603 }
else if (strncmp(t,
"view", 4) == 0) {
14606 t = strchr(t,
',');
14611 if (with_view && with_table) {
14613 }
else if (with_view && !with_table) {
14614 where =
"type = 'view'";
14615 }
else if (!with_view && with_table) {
14616 where =
"type = 'table'";
14618 return SQL_SUCCESS;
14626 if (tableLen == SQL_NTS) {
14627 size =
sizeof (tname) - 1;
14629 size =
min(
sizeof (tname) - 1, tableLen);
14631 strncpy(tname, (
char *) table, size);
14633 tname[size] =
'\0';
14635 #if defined(_WIN32) || defined(_WIN64) 14636 sql = sqlite3_mprintf(
"select %s as 'TABLE_CAT', " 14637 "%s as 'TABLE_SCHEM', " 14638 "tbl_name as 'TABLE_NAME', " 14639 "upper(type) as 'TABLE_TYPE', " 14640 "NULL as 'REMARKS' " 14641 "from sqlite_master where %s " 14642 "and tbl_name %s %Q",
14643 d->xcelqrx ?
"'main'" :
"NULL",
14644 d->xcelqrx ?
"''" :
"NULL",
14646 npatt ?
"like" :
"=", tname);
14648 sql = sqlite3_mprintf(
"select NULL as 'TABLE_QUALIFIER', " 14649 "NULL as 'TABLE_OWNER', " 14650 "tbl_name as 'TABLE_NAME', " 14651 "upper(type) as 'TABLE_TYPE', " 14652 "NULL as 'REMARKS' " 14653 "from sqlite_master where %s " 14654 "and tbl_name %s %Q", where,
14655 npatt ?
"like" :
"=", tname);
14661 if (ret != SQL_SUCCESS) {
14666 rc = sqlite3_get_table(d->
sqlite, sql, &s->
rows, &s->
nrows, &ncols, &errp);
14668 if (rc == SQLITE_OK) {
14669 if (ncols != s->
ncols) {
14673 s->
rowfree = sqlite3_free_table;
14681 sqlite3_free(errp);
14685 return SQL_SUCCESS;
14704 SQLTables(SQLHSTMT stmt,
14705 SQLCHAR *cat, SQLSMALLINT catLen,
14706 SQLCHAR *schema, SQLSMALLINT schemaLen,
14707 SQLCHAR *table, SQLSMALLINT tableLen,
14708 SQLCHAR *type, SQLSMALLINT typeLen)
14710 #if defined(_WIN32) || defined(_WIN64) 14711 char *c = NULL, *s = NULL, *t = NULL, *y = NULL;
14716 #if defined(_WIN32) || defined(_WIN64) 14717 if (!((
STMT *) stmt)->oemcp[0]) {
14718 ret =
drvtables(stmt, cat, catLen, schema, schemaLen,
14719 table, tableLen, type, typeLen);
14723 c = wmb_to_utf_c((
char *) cat, catLen);
14730 s = wmb_to_utf_c((
char *) schema, schemaLen);
14737 t = wmb_to_utf_c((
char *) table, tableLen);
14744 y = wmb_to_utf_c((
char *) type, typeLen);
14750 ret =
drvtables(stmt, (SQLCHAR *) c, SQL_NTS, (SQLCHAR *) s, SQL_NTS,
14751 (SQLCHAR *) t, SQL_NTS, (SQLCHAR *) y, SQL_NTS);
14753 ret =
drvtables(stmt, cat, catLen, schema, schemaLen,
14754 table, tableLen, type, typeLen);
14756 #if defined(_WIN32) || defined(_WIN64) 14787 SQLWCHAR *cat, SQLSMALLINT catLen,
14788 SQLWCHAR *schema, SQLSMALLINT schemaLen,
14789 SQLWCHAR *table, SQLSMALLINT tableLen,
14790 SQLWCHAR *type, SQLSMALLINT typeLen)
14792 char *c = NULL, *s = NULL, *t = NULL, *y = NULL;
14824 ret =
drvtables(stmt, (SQLCHAR *) c, SQL_NTS, (SQLCHAR *) s, SQL_NTS,
14825 (SQLCHAR *) t, SQL_NTS, (SQLCHAR *) y, SQL_NTS);
14841 {
"SYSTEM",
"COLUMN",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
14842 {
"SYSTEM",
"COLUMN",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
14843 {
"SYSTEM",
"COLUMN",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
14844 {
"SYSTEM",
"COLUMN",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
14845 {
"SYSTEM",
"COLUMN",
"DATA_TYPE", SQL_SMALLINT, 50 },
14846 {
"SYSTEM",
"COLUMN",
"TYPE_NAME",
SCOL_VARCHAR, 50 },
14847 {
"SYSTEM",
"COLUMN",
"PRECISION", SQL_INTEGER, 50 },
14848 {
"SYSTEM",
"COLUMN",
"LENGTH", SQL_INTEGER, 50 },
14849 {
"SYSTEM",
"COLUMN",
"SCALE", SQL_SMALLINT, 50 },
14850 {
"SYSTEM",
"COLUMN",
"RADIX", SQL_SMALLINT, 50 },
14851 {
"SYSTEM",
"COLUMN",
"NULLABLE", SQL_SMALLINT, 50 },
14853 {
"SYSTEM",
"COLUMN",
"COLUMN_DEF",
SCOL_VARCHAR, 50 },
14854 {
"SYSTEM",
"COLUMN",
"SQL_DATA_TYPE", SQL_SMALLINT, 50 },
14855 {
"SYSTEM",
"COLUMN",
"SQL_DATETIME_SUB", SQL_SMALLINT, 50 },
14856 {
"SYSTEM",
"COLUMN",
"CHAR_OCTET_LENGTH", SQL_SMALLINT, 50 },
14857 {
"SYSTEM",
"COLUMN",
"ORDINAL_POSITION", SQL_SMALLINT, 50 },
14858 {
"SYSTEM",
"COLUMN",
"IS_NULLABLE",
SCOL_VARCHAR, 50 }
14862 {
"SYSTEM",
"COLUMN",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
14863 {
"SYSTEM",
"COLUMN",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
14864 {
"SYSTEM",
"COLUMN",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
14865 {
"SYSTEM",
"COLUMN",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
14866 {
"SYSTEM",
"COLUMN",
"DATA_TYPE", SQL_SMALLINT, 50 },
14867 {
"SYSTEM",
"COLUMN",
"TYPE_NAME",
SCOL_VARCHAR, 50 },
14868 {
"SYSTEM",
"COLUMN",
"COLUMN_SIZE", SQL_INTEGER, 50 },
14869 {
"SYSTEM",
"COLUMN",
"BUFFER_LENGTH", SQL_INTEGER, 50 },
14870 {
"SYSTEM",
"COLUMN",
"DECIMAL_DIGITS", SQL_SMALLINT, 50 },
14871 {
"SYSTEM",
"COLUMN",
"NUM_PREC_RADIX", SQL_SMALLINT, 50 },
14872 {
"SYSTEM",
"COLUMN",
"NULLABLE", SQL_SMALLINT, 50 },
14874 {
"SYSTEM",
"COLUMN",
"COLUMN_DEF",
SCOL_VARCHAR, 50 },
14875 {
"SYSTEM",
"COLUMN",
"SQL_DATA_TYPE", SQL_SMALLINT, 50 },
14876 {
"SYSTEM",
"COLUMN",
"SQL_DATETIME_SUB", SQL_SMALLINT, 50 },
14877 {
"SYSTEM",
"COLUMN",
"CHAR_OCTET_LENGTH", SQL_SMALLINT, 50 },
14878 {
"SYSTEM",
"COLUMN",
"ORDINAL_POSITION", SQL_SMALLINT, 50 },
14879 {
"SYSTEM",
"COLUMN",
"IS_NULLABLE",
SCOL_VARCHAR, 50 }
14898 SQLCHAR *cat, SQLSMALLINT catLen,
14899 SQLCHAR *schema, SQLSMALLINT schemaLen,
14900 SQLCHAR *table, SQLSMALLINT tableLen,
14901 SQLCHAR *col, SQLSMALLINT colLen)
14906 int ret, nrows, ncols, asize, i, k, roffs, namec;
14907 int tnrows, tncols, npatt;
14909 char *errp = NULL, *sql, tname[512], cname[512], **rowp, **trows;
14913 if (sret != SQL_SUCCESS) {
14922 if (tableLen == SQL_NTS) {
14923 size =
sizeof (tname) - 1;
14925 size =
min(
sizeof (tname) - 1, tableLen);
14927 strncpy(tname, (
char *) table, size);
14929 tname[size] =
'\0';
14933 if (colLen == SQL_NTS) {
14934 size =
sizeof (cname) - 1;
14936 size =
min(
sizeof (cname) - 1, colLen);
14938 strncpy(cname, (
char *) col, size);
14940 cname[size] =
'\0';
14941 if (!strcmp(cname,
"%")) {
14944 sql = sqlite3_mprintf(
"select tbl_name from sqlite_master where " 14945 "(type = 'table' or type = 'view') " 14946 "and tbl_name %s %Q", npatt ?
"like" :
"=", tname);
14951 if (sret != SQL_SUCCESS) {
14956 ret = sqlite3_get_table(d->
sqlite, sql, &trows, &tnrows, &tncols, &errp);
14958 if (ret != SQLITE_OK) {
14959 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
14960 errp ? errp :
"unknown error", ret);
14962 sqlite3_free(errp);
14968 sqlite3_free(errp);
14972 if (tncols * tnrows <= 0) {
14973 sqlite3_free_table(trows);
14974 return SQL_SUCCESS;
14977 for (i = 1; i <= tnrows; i++) {
14978 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", trows[i]);
14980 sqlite3_free_table(trows);
14984 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
14986 if (ret != SQLITE_OK) {
14987 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
14988 errp ? errp :
"unknown error", ret);
14990 sqlite3_free(errp);
14993 sqlite3_free_table(trows);
14997 sqlite3_free(errp);
15000 if (ncols * nrows > 0) {
15002 for (k = 0; k < ncols; k++) {
15003 if (strcmp(rowp[k],
"name") == 0) {
15010 for (k = 1; k <= nrows; k++) {
15011 if (
namematch(rowp[k * ncols + namec], cname, 1)) {
15020 sqlite3_free_table(rowp);
15024 sqlite3_free_table(trows);
15025 return SQL_SUCCESS;
15028 size = (size + 1) * asize;
15032 sqlite3_free_table(trows);
15035 s->
rows[0] = (
char *) size;
15037 memset(s->
rows, 0, sizeof (
char *) * size);
15040 for (i = 1; i <= tnrows; i++) {
15041 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", trows[i]);
15043 sqlite3_free_table(trows);
15047 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
15049 if (ret != SQLITE_OK) {
15050 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
15051 errp ? errp :
"unknown error", ret);
15053 sqlite3_free(errp);
15056 sqlite3_free_table(trows);
15060 sqlite3_free(errp);
15063 if (ncols * nrows > 0) {
15064 int m, mr, nr = nrows;
15067 for (k = 0; k < ncols; k++) {
15068 if (strcmp(rowp[k],
"name") == 0) {
15076 for (k = 1; k <= nrows; k++) {
15077 if (
namematch(rowp[k * ncols + namec], cname, 1)) {
15083 for (k = 0; k < nr; k++) {
15084 m = asize * (roffs + k);
15085 #if defined(_WIN32) || defined(_WIN64) 15086 s->
rows[m + 0] =
xstrdup(d->xcelqrx ?
"main" :
"");
15097 for (k = 0; nr && k < ncols; k++) {
15098 if (strcmp(rowp[k],
"cid") == 0) {
15099 for (mr = 0, m = 1; m <= nrows; m++) {
15104 !
namematch(rowp[m * ncols + namec], cname, 1)) {
15107 ir = asize * (roffs + mr);
15108 sscanf(rowp[m * ncols + k],
"%d", &coln);
15109 sprintf(buf,
"%d", coln + 1);
15113 }
else if (k == namec) {
15114 for (mr = 0, m = 1; m <= nrows; m++) {
15118 !
namematch(rowp[m * ncols + namec], cname, 1)) {
15121 ir = asize * (roffs + mr);
15125 }
else if (strcmp(rowp[k],
"notnull") == 0) {
15126 for (mr = 0, m = 1; m <= nrows; m++) {
15130 !
namematch(rowp[m * ncols + namec], cname, 1)) {
15133 ir = asize * (roffs + mr);
15134 if (*rowp[m * ncols + k] !=
'0') {
15140 xstrdup((*rowp[m * ncols + k] !=
'0') ?
15144 }
else if (strcmp(rowp[k],
"dflt_value") == 0) {
15145 for (mr = 0, m = 1; m <= nrows; m++) {
15146 char *dflt =
unquote(rowp[m * ncols + k]);
15150 !
namematch(rowp[m * ncols + namec], cname, 1)) {
15153 ir = asize * (roffs + mr);
15154 s->
rows[ir + 12] =
xstrdup(dflt ? dflt :
"NULL");
15157 }
else if (strcmp(rowp[k],
"type") == 0) {
15158 for (mr = 0, m = 1; m <= nrows; m++) {
15159 char *
typename = rowp[m * ncols + k];
15160 int sqltype, mm, dd, ir;
15164 !
namematch(rowp[m * ncols + namec], cname, 1)) {
15167 ir = asize * (roffs + mr);
15171 getmd(
typename, sqltype, &mm, &dd);
15172 #ifdef SQL_LONGVARCHAR 15173 if (sqltype == SQL_VARCHAR && mm > 255) {
15174 sqltype = SQL_LONGVARCHAR;
15178 #ifdef SQL_WLONGVARCHAR 15179 if (sqltype == SQL_WVARCHAR && mm > 255) {
15180 sqltype = SQL_WLONGVARCHAR;
15184 if (sqltype == SQL_VARBINARY && mm > 255) {
15185 sqltype = SQL_LONGVARBINARY;
15187 sprintf(buf,
"%d", sqltype);
15190 sprintf(buf,
"%d", mm);
15192 sprintf(buf,
"%d", dd);
15200 sqlite3_free_table(rowp);
15202 sqlite3_free_table(trows);
15203 return SQL_SUCCESS;
15222 SQLColumns(SQLHSTMT stmt,
15223 SQLCHAR *cat, SQLSMALLINT catLen,
15224 SQLCHAR *schema, SQLSMALLINT schemaLen,
15225 SQLCHAR *table, SQLSMALLINT tableLen,
15226 SQLCHAR *col, SQLSMALLINT colLen)
15228 #if defined(_WIN32) || defined(_WIN64) 15229 char *c = NULL, *s = NULL, *t = NULL, *k = NULL;
15234 #if defined(_WIN32) || defined(_WIN64) 15235 if (!((
STMT *) stmt)->oemcp[0]) {
15236 ret =
drvcolumns(stmt, cat, catLen, schema, schemaLen,
15237 table, tableLen, col, colLen);
15241 c = wmb_to_utf_c((
char *) cat, catLen);
15248 s = wmb_to_utf_c((
char *) schema, schemaLen);
15255 t = wmb_to_utf_c((
char *) table, tableLen);
15262 k = wmb_to_utf_c((
char *) col, colLen);
15268 ret =
drvcolumns(stmt, (SQLCHAR *) c, SQL_NTS, (SQLCHAR *) s, SQL_NTS,
15269 (SQLCHAR *) t, SQL_NTS, (SQLCHAR *) k, SQL_NTS);
15271 ret =
drvcolumns(stmt, cat, catLen, schema, schemaLen,
15272 table, tableLen, col, colLen);
15274 #if defined(_WIN32) || defined(_WIN64) 15305 SQLWCHAR *cat, SQLSMALLINT catLen,
15306 SQLWCHAR *schema, SQLSMALLINT schemaLen,
15307 SQLWCHAR *table, SQLSMALLINT tableLen,
15308 SQLWCHAR *col, SQLSMALLINT colLen)
15310 char *c = NULL, *s = NULL, *t = NULL, *k = NULL;
15342 ret =
drvcolumns(stmt, (SQLCHAR *) c, SQL_NTS, (SQLCHAR *) s, SQL_NTS,
15343 (SQLCHAR *) t, SQL_NTS, (SQLCHAR *) k, SQL_NTS);
15361 {
"SYSTEM",
"TYPE",
"DATA_TYPE", SQL_SMALLINT, 2 },
15362 {
"SYSTEM",
"TYPE",
"PRECISION", SQL_INTEGER, 9 },
15363 {
"SYSTEM",
"TYPE",
"LITERAL_PREFIX",
SCOL_VARCHAR, 50 },
15364 {
"SYSTEM",
"TYPE",
"LITERAL_SUFFIX",
SCOL_VARCHAR, 50 },
15365 {
"SYSTEM",
"TYPE",
"CREATE_PARAMS",
SCOL_VARCHAR, 50 },
15366 {
"SYSTEM",
"TYPE",
"NULLABLE", SQL_SMALLINT, 2 },
15367 {
"SYSTEM",
"TYPE",
"CASE_SENSITIVE", SQL_SMALLINT, 2 },
15368 {
"SYSTEM",
"TYPE",
"SEARCHABLE", SQL_SMALLINT, 2 },
15369 {
"SYSTEM",
"TYPE",
"UNSIGNED_ATTRIBUTE", SQL_SMALLINT, 2 },
15370 {
"SYSTEM",
"TYPE",
"MONEY", SQL_SMALLINT, 2 },
15371 {
"SYSTEM",
"TYPE",
"AUTO_INCREMENT", SQL_SMALLINT, 2 },
15372 {
"SYSTEM",
"TYPE",
"LOCAL_TYPE_NAME",
SCOL_VARCHAR, 50 },
15373 {
"SYSTEM",
"TYPE",
"MINIMUM_SCALE", SQL_SMALLINT, 2 },
15374 {
"SYSTEM",
"TYPE",
"MAXIMUM_SCALE", SQL_SMALLINT, 2 }
15379 {
"SYSTEM",
"TYPE",
"DATA_TYPE", SQL_SMALLINT, 2 },
15380 {
"SYSTEM",
"TYPE",
"COLUMN_SIZE", SQL_INTEGER, 9 },
15381 {
"SYSTEM",
"TYPE",
"LITERAL_PREFIX",
SCOL_VARCHAR, 50 },
15382 {
"SYSTEM",
"TYPE",
"LITERAL_SUFFIX",
SCOL_VARCHAR, 50 },
15383 {
"SYSTEM",
"TYPE",
"CREATE_PARAMS",
SCOL_VARCHAR, 50 },
15384 {
"SYSTEM",
"TYPE",
"NULLABLE", SQL_SMALLINT, 2 },
15385 {
"SYSTEM",
"TYPE",
"CASE_SENSITIVE", SQL_SMALLINT, 2 },
15386 {
"SYSTEM",
"TYPE",
"SEARCHABLE", SQL_SMALLINT, 2 },
15387 {
"SYSTEM",
"TYPE",
"UNSIGNED_ATTRIBUTE", SQL_SMALLINT, 2 },
15388 {
"SYSTEM",
"TYPE",
"FIXED_PREC_SCALE", SQL_SMALLINT, 2 },
15389 {
"SYSTEM",
"TYPE",
"AUTO_UNIQUE_VALUE", SQL_SMALLINT, 2 },
15390 {
"SYSTEM",
"TYPE",
"LOCAL_TYPE_NAME",
SCOL_VARCHAR, 50 },
15391 {
"SYSTEM",
"TYPE",
"MINIMUM_SCALE", SQL_SMALLINT, 2 },
15392 {
"SYSTEM",
"TYPE",
"MAXIMUM_SCALE", SQL_SMALLINT, 2 },
15393 {
"SYSTEM",
"TYPE",
"SQL_DATA_TYPE", SQL_SMALLINT, 2 },
15394 {
"SYSTEM",
"TYPE",
"SQL_DATETIME_SUB", SQL_SMALLINT, 2 },
15395 {
"SYSTEM",
"TYPE",
"NUM_PREC_RADIX", SQL_INTEGER, 4 },
15396 {
"SYSTEM",
"TYPE",
"INTERVAL_PRECISION", SQL_SMALLINT, 2 }
15412 int offs = row * asize;
15413 char *tcode, *crpar = NULL, *quote = NULL, *sign =
stringify(SQL_FALSE);
15414 static char tcodes[32 * 32];
15419 tcode = tcodes + tind * 32;
15420 sprintf(tcode,
"%d", type);
15421 s->
rows[offs + 0] =
typename;
15422 s->
rows[offs + 1] = tcode;
15424 s->
rows[offs + 15] = tcode;
15425 s->
rows[offs + 16] =
"0";
15429 #ifdef SQL_LONGVARCHAR 15430 case SQL_LONGVARCHAR:
15432 case SQL_WLONGVARCHAR:
15437 s->
rows[offs + 2] =
"65536";
15443 s->
rows[offs + 2] =
"1";
15452 s->
rows[offs + 2] =
"255";
15458 s->
rows[offs + 2] =
"3";
15461 s->
rows[offs + 2] =
"5";
15464 s->
rows[offs + 2] =
"9";
15468 s->
rows[offs + 2] =
"19";
15472 s->
rows[offs + 2] =
"7";
15475 s->
rows[offs + 2] =
"15";
15477 #ifdef SQL_TYPE_DATE 15478 case SQL_TYPE_DATE:
15481 s->
rows[offs + 2] =
"10";
15485 #ifdef SQL_TYPE_TIME 15486 case SQL_TYPE_TIME:
15489 s->
rows[offs + 2] =
"8";
15493 #ifdef SQL_TYPE_TIMESTAMP 15494 case SQL_TYPE_TIMESTAMP:
15496 case SQL_TIMESTAMP:
15497 s->
rows[offs + 2] =
"32";
15501 case SQL_VARBINARY:
15503 s->
rows[offs + 2] =
"255";
15505 case SQL_LONGVARBINARY:
15507 s->
rows[offs + 2] =
"65536";
15510 s->
rows[offs + 3] = s->
rows[offs + 4] = quote;
15511 s->
rows[offs + 5] = crpar;
15515 s->
rows[offs + 9] = sign;
15518 s->
rows[offs + 12] =
typename;
15522 s->
rows[offs + 13] =
"0";
15523 s->
rows[offs + 14] =
"0";
15525 #ifdef SQL_TYPE_TIMESTAMP 15526 case SQL_TYPE_TIMESTAMP:
15528 case SQL_TIMESTAMP:
15529 s->
rows[offs + 13] =
"0";
15530 s->
rows[offs + 14] =
"3";
15533 s->
rows[offs + 13] = NULL;
15534 s->
rows[offs + 14] = NULL;
15550 char **pa = (
char **) a;
15551 char **pb = (
char **) b;
15554 na = strtol(pa[1], NULL, 0);
15555 nb = strtol(pb[1], NULL, 0);
15575 if (ret != SQL_SUCCESS) {
15579 #ifdef SQL_LONGVARCHAR 15580 s->
nrows = (sqltype == SQL_ALL_TYPES) ? 13 : 1;
15582 s->
nrows = (sqltype == SQL_ALL_TYPES) ? 12 : 1;
15584 if (sqltype == SQL_ALL_TYPES) {
15587 #ifdef SQL_WLONGVARCHAR 15592 if (sqltype == SQL_ALL_TYPES) {
15606 #ifdef MEMORY_DEBUG 15611 memset(s->
rows, 0, sizeof (
char *) * (s->
nrows + 1) * asize);
15612 if (sqltype == SQL_ALL_TYPES) {
15615 mktypeinfo(s, cc++, asize,
"varchar", SQL_VARCHAR, 0);
15616 mktypeinfo(s, cc++, asize,
"tinyint", SQL_TINYINT, 0);
15617 mktypeinfo(s, cc++, asize,
"smallint", SQL_SMALLINT, 0);
15618 mktypeinfo(s, cc++, asize,
"integer", SQL_INTEGER, 0);
15619 mktypeinfo(s, cc++, asize,
"float", SQL_FLOAT, 0);
15620 mktypeinfo(s, cc++, asize,
"double", SQL_DOUBLE, 0);
15621 #ifdef SQL_TYPE_DATE 15623 (*s->
ov3) ? SQL_TYPE_DATE : SQL_DATE, 0);
15625 mktypeinfo(s, cc++, asize,
"date", SQL_DATE, 0);
15627 #ifdef SQL_TYPE_TIME 15629 (*s->
ov3) ? SQL_TYPE_TIME : SQL_TIME, 0);
15631 mktypeinfo(s, cc++, asize,
"time", SQL_TIME, 0);
15633 #ifdef SQL_TYPE_TIMESTAMP 15635 (*s->
ov3) ? SQL_TYPE_TIMESTAMP : SQL_TIMESTAMP, 0);
15637 mktypeinfo(s, cc++, asize,
"timestamp", SQL_TIMESTAMP, 0);
15639 mktypeinfo(s, cc++, asize,
"char", SQL_CHAR, 0);
15640 mktypeinfo(s, cc++, asize,
"numeric", SQL_DOUBLE, 0);
15641 #ifdef SQL_LONGVARCHAR 15642 mktypeinfo(s, cc++, asize,
"text", SQL_LONGVARCHAR, 0);
15643 mktypeinfo(s, cc++, asize,
"longvarchar", SQL_LONGVARCHAR, 0);
15645 mktypeinfo(s, cc++, asize,
"text", SQL_VARCHAR, 0);
15647 mktypeinfo(s, cc++, asize,
"varbinary", SQL_VARBINARY, 0);
15648 mktypeinfo(s, cc++, asize,
"longvarbinary", SQL_LONGVARBINARY, 0);
15650 mktypeinfo(s, cc++, asize,
"bit", SQL_BIT, 0);
15653 mktypeinfo(s, cc++, asize,
"bigint", SQL_BIGINT, 0);
15656 mktypeinfo(s, cc++, asize,
"wvarchar", SQL_WVARCHAR, 0);
15657 mktypeinfo(s, cc++, asize,
"wchar", SQL_WCHAR, 0);
15658 #ifdef SQL_WLONGVARCHAR 15659 mktypeinfo(s, cc++, asize,
"wtext", SQL_WLONGVARCHAR, 0);
15660 mktypeinfo(s, cc++, asize,
"longwvarchar", SQL_WLONGVARCHAR, 0);
15663 qsort(s->
rows + asize, s->
nrows, sizeof (
char *) * asize,
15668 mktypeinfo(s, 1, asize,
"char", SQL_CHAR, 10);
15671 mktypeinfo(s, 1, asize,
"varchar", SQL_VARCHAR, 1);
15674 mktypeinfo(s, 1, asize,
"tinyint", SQL_TINYINT, 2);
15677 mktypeinfo(s, 1, asize,
"smallint", SQL_SMALLINT, 3);
15680 mktypeinfo(s, 1, asize,
"integer", SQL_INTEGER, 4);
15683 mktypeinfo(s, 1, asize,
"float", SQL_FLOAT, 5);
15686 mktypeinfo(s, 1, asize,
"double", SQL_DOUBLE, 6);
15688 #ifdef SQL_TYPE_DATE 15689 case SQL_TYPE_DATE:
15690 mktypeinfo(s, 1, asize,
"date", SQL_TYPE_DATE, 25);
15694 mktypeinfo(s, 1, asize,
"date", SQL_DATE, 7);
15696 #ifdef SQL_TYPE_TIME 15697 case SQL_TYPE_TIME:
15698 mktypeinfo(s, 1, asize,
"time", SQL_TYPE_TIME, 26);
15702 mktypeinfo(s, 1, asize,
"time", SQL_TIME, 8);
15704 #ifdef SQL_TYPE_TIMESTAMP 15705 case SQL_TYPE_TIMESTAMP:
15706 mktypeinfo(s, 1, asize,
"timestamp", SQL_TYPE_TIMESTAMP, 27);
15709 case SQL_TIMESTAMP:
15710 mktypeinfo(s, 1, asize,
"timestamp", SQL_TIMESTAMP, 9);
15712 #ifdef SQL_LONGVARCHAR 15713 case SQL_LONGVARCHAR:
15714 mktypeinfo(s, 1, asize,
"longvarchar", SQL_LONGVARCHAR, 12);
15717 case SQL_VARBINARY:
15718 mktypeinfo(s, 1, asize,
"varbinary", SQL_VARBINARY, 30);
15720 case SQL_LONGVARBINARY:
15721 mktypeinfo(s, 1, asize,
"longvarbinary", SQL_LONGVARBINARY, 31);
15725 mktypeinfo(s, 1, asize,
"bit", SQL_BIT, 29);
15730 mktypeinfo(s, 1, asize,
"bigint", SQL_BIGINT, 28);
15736 mktypeinfo(s, 1, asize,
"wchar", SQL_WCHAR, 18);
15739 #ifdef SQL_WVARCHAR 15741 mktypeinfo(s, 1, asize,
"wvarchar", SQL_WVARCHAR, 19);
15744 #ifdef SQL_WLONGVARCHAR 15745 case SQL_WLONGVARCHAR:
15746 mktypeinfo(s, 1, asize,
"longwvarchar", SQL_WLONGVARCHAR, 20);
15754 return SQL_SUCCESS;
15766 SQLGetTypeInfo(SQLHSTMT stmt, SQLSMALLINT sqltype)
15802 {
"SYSTEM",
"STATISTICS",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
15803 {
"SYSTEM",
"STATISTICS",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
15804 {
"SYSTEM",
"STATISTICS",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
15805 {
"SYSTEM",
"STATISTICS",
"NON_UNIQUE", SQL_SMALLINT, 50 },
15806 {
"SYSTEM",
"STATISTICS",
"INDEX_QUALIFIER",
SCOL_VARCHAR, 255 },
15807 {
"SYSTEM",
"STATISTICS",
"INDEX_NAME",
SCOL_VARCHAR, 255 },
15808 {
"SYSTEM",
"STATISTICS",
"TYPE", SQL_SMALLINT, 50 },
15809 {
"SYSTEM",
"STATISTICS",
"SEQ_IN_INDEX", SQL_SMALLINT, 50 },
15810 {
"SYSTEM",
"STATISTICS",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
15811 {
"SYSTEM",
"STATISTICS",
"COLLATION",
SCOL_CHAR, 1 },
15812 {
"SYSTEM",
"STATISTICS",
"CARDINALITY", SQL_INTEGER, 50 },
15813 {
"SYSTEM",
"STATISTICS",
"PAGES", SQL_INTEGER, 50 },
15814 {
"SYSTEM",
"STATISTICS",
"FILTER_CONDITION",
SCOL_VARCHAR, 255 }
15818 {
"SYSTEM",
"STATISTICS",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
15819 {
"SYSTEM",
"STATISTICS",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
15820 {
"SYSTEM",
"STATISTICS",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
15821 {
"SYSTEM",
"STATISTICS",
"NON_UNIQUE", SQL_SMALLINT, 50 },
15822 {
"SYSTEM",
"STATISTICS",
"INDEX_QUALIFIER",
SCOL_VARCHAR, 255 },
15823 {
"SYSTEM",
"STATISTICS",
"INDEX_NAME",
SCOL_VARCHAR, 255 },
15824 {
"SYSTEM",
"STATISTICS",
"TYPE", SQL_SMALLINT, 50 },
15825 {
"SYSTEM",
"STATISTICS",
"ORDINAL_POSITION", SQL_SMALLINT, 50 },
15826 {
"SYSTEM",
"STATISTICS",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
15827 {
"SYSTEM",
"STATISTICS",
"ASC_OR_DESC",
SCOL_CHAR, 1 },
15828 {
"SYSTEM",
"STATISTICS",
"CARDINALITY", SQL_INTEGER, 50 },
15829 {
"SYSTEM",
"STATISTICS",
"PAGES", SQL_INTEGER, 50 },
15830 {
"SYSTEM",
"STATISTICS",
"FILTER_CONDITION",
SCOL_VARCHAR, 255 }
15849 SQLCHAR *schema, SQLSMALLINT schemaLen,
15850 SQLCHAR *table, SQLSMALLINT tableLen,
15851 SQLUSMALLINT itype, SQLUSMALLINT resv)
15856 int i, asize, ret, nrows, ncols, offs, namec, uniquec, addipk = 0;
15858 char **rowp, *errp = NULL, *sql, tname[512];
15862 if (sret != SQL_SUCCESS) {
15867 if (!table || table[0] ==
'\0' || table[0] ==
'%') {
15868 setstat(s, -1,
"need table name", (*s->
ov3) ?
"HY000" :
"S1000");
15871 if (tableLen == SQL_NTS) {
15872 size =
sizeof (tname) - 1;
15874 size =
min(
sizeof (tname) - 1, tableLen);
15876 strncpy(tname, (
char *) table, size);
15877 tname[size] =
'\0';
15880 if (sret != SQL_SUCCESS) {
15886 if (itype == SQL_INDEX_UNIQUE || itype == SQL_INDEX_ALL) {
15888 ret = SQLITE_ERROR;
15889 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", tname);
15892 ret = sqlite3_get_table(d->
sqlite, sql, &rowp,
15893 &nrows, &ncols, NULL);
15896 if (ret == SQLITE_OK) {
15897 int colid, typec, npk = 0, npkint = 0;
15899 namec =
findcol(rowp, ncols,
"name");
15900 uniquec =
findcol(rowp, ncols,
"pk");
15901 typec =
findcol(rowp, ncols,
"type");
15902 colid =
findcol(rowp, ncols,
"cid");
15903 if (namec < 0 || uniquec < 0 || typec < 0 || colid < 0) {
15906 for (i = 1; i <= nrows; i++) {
15907 if (*rowp[i * ncols + uniquec] !=
'0') {
15909 if (strlen(rowp[i * ncols + typec]) == 7 &&
15910 strncasecmp(rowp[i * ncols + typec],
"integer", 7)
15916 if (npkint == 1 && npk == npkint) {
15921 sqlite3_free_table(rowp);
15923 sql = sqlite3_mprintf(
"PRAGMA index_list(%Q)", tname);
15928 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
15930 if (ret != SQLITE_OK) {
15931 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
15932 errp ? errp :
"unknown error", ret);
15934 sqlite3_free(errp);
15940 sqlite3_free(errp);
15944 namec =
findcol(rowp, ncols,
"name");
15945 uniquec =
findcol(rowp, ncols,
"unique");
15946 if (namec < 0 || uniquec < 0) {
15949 for (i = 1; i <= nrows; i++) {
15950 int nnrows, nncols;
15954 isuniq = *rowp[i * ncols + uniquec] !=
'0';
15955 if (isuniq || itype == SQL_INDEX_ALL) {
15956 ret = SQLITE_ERROR;
15957 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
15958 rowp[i * ncols + namec]);
15961 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
15962 &nnrows, &nncols, NULL);
15965 if (ret == SQLITE_OK) {
15967 sqlite3_free_table(rowpp);
15976 sqlite3_free_table(rowp);
15977 return SQL_SUCCESS;
15980 size = (size + 1) * asize;
15986 s->
rows[0] = (
char *) size;
15988 memset(s->
rows, 0, sizeof (
char *) * size);
15993 int nrows2, ncols2;
15995 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", tname);
15998 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
15999 &nrows2, &ncols2, NULL);
16002 if (ret == SQLITE_OK) {
16003 int colid, typec, roffs, namecc, uniquecc;
16005 namecc =
findcol(rowpp, ncols2,
"name");
16006 uniquecc =
findcol(rowpp, ncols2,
"pk");
16007 typec =
findcol(rowpp, ncols2,
"type");
16008 colid =
findcol(rowpp, ncols2,
"cid");
16009 if (namecc < 0 || uniquecc < 0 || typec < 0 || colid < 0) {
16014 for (i = 1; i <= nrows2; i++) {
16015 if (*rowpp[i * ncols2 + uniquecc] !=
'0' &&
16016 strlen(rowpp[i * ncols2 + typec]) == 7 &&
16017 strncasecmp(rowpp[i * ncols2 + typec],
"integer", 7)
16028 #if defined(_WIN32) || defined(_WIN64) 16029 s->
rows[roffs + 0] =
xstrdup(d->xcelqrx ?
"main" :
"");
16037 s->
rows[roffs + 5] =
xstrdup(
"sqlite_autoindex_0");
16040 s->
rows[roffs + 8] =
xstrdup(rowpp[i * ncols2 + namecc]);
16044 sqlite3_free_table(rowpp);
16046 for (i = 1; i <= nrows; i++) {
16047 int nnrows, nncols;
16050 if (*rowp[i * ncols + uniquec] !=
'0' || itype == SQL_INDEX_ALL) {
16053 ret = SQLITE_ERROR;
16054 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
16055 rowp[i * ncols + namec]);
16058 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
16059 &nnrows, &nncols, NULL);
16062 if (ret != SQLITE_OK) {
16065 for (k = 0; nnrows && k < nncols; k++) {
16066 if (strcmp(rowpp[k],
"name") == 0) {
16069 for (m = 1; m <= nnrows; m++) {
16070 int roffs = (offs + addipk + m) * s->
ncols;
16073 isuniq = *rowp[i * ncols + uniquec] !=
'0';
16082 s->
rows[roffs + 5] =
xstrdup(rowp[i * ncols + namec]);
16083 s->
rows[roffs + 6] =
16085 s->
rows[roffs + 8] =
xstrdup(rowpp[m * nncols + k]);
16088 }
else if (strcmp(rowpp[k],
"seqno") == 0) {
16091 for (m = 1; m <= nnrows; m++) {
16092 int roffs = (offs + addipk + m) * s->
ncols;
16096 sscanf(rowpp[m * nncols + k],
"%d", &pos);
16097 sprintf(buf,
"%d", pos + 1);
16103 sqlite3_free_table(rowpp);
16106 sqlite3_free_table(rowp);
16107 return SQL_SUCCESS;
16126 SQLStatistics(SQLHSTMT stmt, SQLCHAR *cat, SQLSMALLINT catLen,
16127 SQLCHAR *schema, SQLSMALLINT schemaLen,
16128 SQLCHAR *table, SQLSMALLINT tableLen,
16129 SQLUSMALLINT itype, SQLUSMALLINT resv)
16131 #if defined(_WIN32) || defined(_WIN64) 16132 char *c = NULL, *s = NULL, *t = NULL;
16137 #if defined(_WIN32) || defined(_WIN64) 16138 if (!((
STMT *) stmt)->oemcp[0]) {
16140 table, tableLen, itype, resv);
16144 c = wmb_to_utf_c((
char *) cat, catLen);
16151 s = wmb_to_utf_c((
char *) schema, schemaLen);
16158 t = wmb_to_utf_c((
char *) table, tableLen);
16164 ret =
drvstatistics(stmt, (SQLCHAR *) c, SQL_NTS, (SQLCHAR *) s, SQL_NTS,
16165 (SQLCHAR *) t, SQL_NTS, itype, resv);
16168 table, tableLen, itype, resv);
16170 #if defined(_WIN32) || defined(_WIN64) 16200 SQLWCHAR *schema, SQLSMALLINT schemaLen,
16201 SQLWCHAR *table, SQLSMALLINT tableLen,
16202 SQLUSMALLINT itype, SQLUSMALLINT resv)
16204 char *c = NULL, *s = NULL, *t = NULL;
16229 ret =
drvstatistics(stmt, (SQLCHAR *) c, SQL_NTS, (SQLCHAR *) s, SQL_NTS,
16230 (SQLCHAR *) t, SQL_NTS, itype, resv);
16256 SQLRETURN ret = SQL_ERROR;
16259 if (stmt == SQL_NULL_HSTMT) {
16260 return SQL_INVALID_HANDLE;
16263 if (col == 0 && s->
bkmrk != SQL_UB_OFF) {
16264 if (s->
bkmrk == SQL_UB_ON && type == SQL_C_BOOKMARK) {
16265 *((SQLINTEGER *) val) = s->
rowp;
16267 *lenp =
sizeof (SQLINTEGER);
16271 }
else if (s->
bkmrk == SQL_UB_VARIABLE && type == SQL_C_VARBOOKMARK) {
16273 char **data, *endp = 0;
16278 *((sqlite_int64 *) val) = strtol(*data, &endp, 0);
16280 *((sqlite_int64 *) val) = strtoll(*data, &endp, 0);
16283 *((sqlite_int64 *) val) = s->
rowp;
16286 *lenp =
sizeof (sqlite_int64);
16292 if (col < 1 || col > s->
ncols) {
16293 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009" :
"S1002");
16297 ret =
getrowdata(s, col, type, val, len, lenp, 1);
16313 int ret, i, withinfo = 0;
16317 int bsize =
sizeof (SQLINTEGER);
16322 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
16330 val = (SQLPOINTER) ((
char *) val + *s->
bind_offs);
16333 char **data, *endp = 0;
16338 *(sqlite_int64 *) val = strtol(*data, &endp, 0);
16340 *(sqlite_int64 *) val = strtoll(*data, &endp, 0);
16343 *(sqlite_int64 *) val = s->
rowp;
16345 bsize =
sizeof (sqlite_int64);
16349 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
16350 val = (SQLINTEGER *)
16356 val = (SQLINTEGER *) ((
char *) val + *s->
bind_offs);
16363 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
16383 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
16386 dp = (SQLPOINTER) ((
char *) b->
valp + b->
max * rsi);
16389 dp = (SQLPOINTER) ((
char *) dp + *s->
bind_offs);
16393 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
16396 lp = b->
lenp + rsi;
16404 if (!SQL_SUCCEEDED(ret)) {
16408 if (ret != SQL_SUCCESS) {
16410 #ifdef SQL_ROW_SUCCESS_WITH_INFO 16416 if (SQL_SUCCEEDED(ret)) {
16417 ret = withinfo ? SQL_SUCCESS_WITH_INFO : SQL_SUCCESS;
16434 int i, withinfo = 0;
16437 if (stmt == SQL_NULL_HSTMT) {
16438 return SQL_INVALID_HANDLE;
16461 setstat(s, -1,
"no result set available",
"24000");
16466 if (s->
curtype == SQL_CURSOR_FORWARD_ONLY && orient != SQL_FETCH_NEXT) {
16467 setstat(s, -1,
"wrong fetch direction",
"01000");
16474 if (((
DBC *) (s->
dbc))->cur_s3stmt == s && s->
s3stmt) {
16478 ret = (i == 0) ? SQL_NO_DATA : SQL_SUCCESS;
16482 if (ret != SQL_SUCCESS) {
16486 if (s->
nrows < 1) {
16490 if (!SQL_SUCCEEDED(ret)) {
16492 }
else if (ret == SQL_SUCCESS_WITH_INFO) {
16496 }
else if (s->
rows) {
16498 case SQL_FETCH_NEXT:
16499 if (s->
nrows < 1) {
16500 return SQL_NO_DATA;
16507 return SQL_NO_DATA;
16510 case SQL_FETCH_PRIOR:
16513 return SQL_NO_DATA;
16516 if (s->
rowp < -1) {
16518 return SQL_NO_DATA;
16521 case SQL_FETCH_FIRST:
16522 if (s->
nrows < 1) {
16523 return SQL_NO_DATA;
16527 case SQL_FETCH_LAST:
16528 if (s->
nrows < 1) {
16529 return SQL_NO_DATA;
16532 if (--s->
rowp < -1) {
16536 case SQL_FETCH_ABSOLUTE:
16539 return SQL_NO_DATA;
16540 }
else if (offset < 0) {
16541 if (0 - offset <= s->nrows) {
16546 return SQL_NO_DATA;
16547 }
else if (offset > s->
nrows) {
16549 return SQL_NO_DATA;
16551 s->
rowp = offset - 1 - 1;
16553 case SQL_FETCH_RELATIVE:
16558 return SQL_NO_DATA;
16562 if (s->
rowp < -1) {
16564 return SQL_NO_DATA;
16568 case SQL_FETCH_BOOKMARK:
16570 if (offset < 0 || offset >= s->
nrows) {
16571 return SQL_NO_DATA;
16573 s->
rowp = offset - 1;
16579 if (s->
bkmrk == SQL_UB_VARIABLE) {
16581 sqlite_int64 bkmrk, rowid;
16583 bkmrk = *(sqlite_int64 *) s->
bkmrkptr;
16584 for (rowp = 0; rowp < s->
nrows; rowp++) {
16585 char **data, *endp = 0;
16590 rowid = strtol(*data, &endp, 0);
16592 rowid = strtoll(*data, &endp, 0);
16594 if (rowid == bkmrk) {
16599 rowp = *(sqlite_int64 *) s->
bkmrkptr;
16604 if (rowp + offset < 0 || rowp + offset >= s->
nrows) {
16605 return SQL_NO_DATA;
16607 s->
rowp = rowp + offset - 1;
16623 if (!SQL_SUCCEEDED(ret)) {
16625 }
else if (ret == SQL_SUCCESS_WITH_INFO) {
16632 if (SQL_SUCCEEDED(ret)) {
16633 return SQL_NO_DATA;
16637 if (SQL_SUCCEEDED(ret)) {
16638 ret = withinfo ? SQL_SUCCESS_WITH_INFO : SQL_SUCCESS;
16705 SQLINTEGER *bkmrkptr;
16708 if (stmt == SQL_NULL_HSTMT) {
16709 return SQL_INVALID_HANDLE;
16744 if (stmt == SQL_NULL_HSTMT) {
16745 return SQL_INVALID_HANDLE;
16752 return SQL_SUCCESS;
16768 if (stmt == SQL_NULL_HSTMT) {
16769 return SQL_INVALID_HANDLE;
16776 return SQL_SUCCESS;
16795 SQLSMALLINT nameMax, SQLSMALLINT *nameLen,
16796 SQLSMALLINT *type,
SQLULEN *size,
16797 SQLSMALLINT *digits, SQLSMALLINT *nullable)
16803 if (stmt == SQL_NULL_HSTMT) {
16804 return SQL_INVALID_HANDLE;
16808 setstat(s, -1,
"no columns", (*s->
ov3) ?
"07009" :
"S1002");
16811 if (col < 1 || col > s->
ncols) {
16812 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009" :
"S1002");
16815 c = s->
cols + col - 1;
16816 if (name && nameMax > 0) {
16817 strncpy((
char *) name, c->
column, nameMax);
16818 name[nameMax - 1] =
'\0';
16823 *nameLen = strlen((
char *) name);
16825 *nameLen = strlen(c->
column);
16837 *type = SQL_VARCHAR;
16839 #ifdef SQL_LONGVARCHAR 16840 case SQL_WLONGVARCHAR:
16841 *type = SQL_LONGVARCHAR;
16857 return SQL_SUCCESS;
16876 SQLDescribeCol(SQLHSTMT stmt, SQLUSMALLINT col, SQLCHAR *name,
16877 SQLSMALLINT nameMax, SQLSMALLINT *nameLen,
16878 SQLSMALLINT *type,
SQLULEN *size,
16879 SQLSMALLINT *digits, SQLSMALLINT *nullable)
16881 #if defined(_WIN32) || defined(_WIN64) 16882 SQLSMALLINT len = 0;
16887 #if defined(_WIN32) || defined(_WIN64) 16888 if (!((
STMT *) stmt)->oemcp[0]) {
16890 type, size, digits, nullable);
16894 &len, type, size, digits, nullable);
16895 if (ret == SQL_SUCCESS) {
16900 n = (SQLCHAR *) utf_to_wmb((
char *) name, len);
16902 strncpy((
char *) name, (
char *) n, nameMax);
16904 len =
min(nameMax, strlen((
char *) n));
16922 len = strlen(c->
column);
16933 type, size, digits, nullable);
16957 SQLSMALLINT nameMax, SQLSMALLINT *nameLen,
16958 SQLSMALLINT *type,
SQLULEN *size,
16959 SQLSMALLINT *digits, SQLSMALLINT *nullable)
16962 SQLSMALLINT len = 0;
16966 (SQLSMALLINT) (nameMax *
sizeof (SQLWCHAR)),
16967 &len, type, size, digits, nullable);
16968 if (ret == SQL_SUCCESS) {
16971 SQLWCHAR *n = NULL;
16995 len = strlen(c->
column);
17021 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17027 char *valc = (
char *) val;
17029 if (stmt == SQL_NULL_HSTMT) {
17030 return SQL_INVALID_HANDLE;
17039 if (
id == SQL_COLUMN_COUNT) {
17043 *valLen =
sizeof (int);
17044 return SQL_SUCCESS;
17046 if (
id == SQL_COLUMN_TYPE && col == 0) {
17048 *val2 = SQL_INTEGER;
17050 *valLen =
sizeof (int);
17051 return SQL_SUCCESS;
17053 #ifdef SQL_DESC_OCTET_LENGTH 17054 if (
id == SQL_DESC_OCTET_LENGTH && col == 0) {
17058 *valLen =
sizeof (int);
17059 return SQL_SUCCESS;
17062 if (col < 1 || col > s->
ncols) {
17063 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009":
"S1002");
17066 c = s->
cols + col - 1;
17069 case SQL_COLUMN_LABEL:
17071 if (valc && valMax > 0) {
17072 strncpy(valc, c->
label, valMax);
17073 valc[valMax - 1] =
'\0';
17075 *valLen = strlen(c->
label);
17079 case SQL_COLUMN_NAME:
17080 case SQL_DESC_NAME:
17081 if (valc && valMax > 0) {
17082 strncpy(valc, c->
column, valMax);
17083 valc[valMax - 1] =
'\0';
17085 *valLen = strlen(c->
column);
17087 if (*valLen >= valMax) {
17088 setstat(s, -1,
"data right truncated",
"01004");
17089 return SQL_SUCCESS_WITH_INFO;
17091 return SQL_SUCCESS;
17092 #ifdef SQL_DESC_BASE_COLUMN_NAME 17093 case SQL_DESC_BASE_COLUMN_NAME:
17094 if (strchr(c->
column,
'(') || strchr(c->
column,
')')) {
17095 if (valc && valMax > 0) {
17099 }
else if (valc && valMax > 0) {
17100 strncpy(valc, c->
column, valMax);
17101 valc[valMax - 1] =
'\0';
17102 *valLen = strlen(c->
column);
17106 case SQL_COLUMN_TYPE:
17107 case SQL_DESC_TYPE:
17110 int type = c->
type;
17118 type = SQL_VARCHAR;
17120 #ifdef SQL_LONGVARCHAR 17121 case SQL_WLONGVARCHAR:
17122 type = SQL_LONGVARCHAR;
17136 *valLen =
sizeof (int);
17137 return SQL_SUCCESS;
17138 case SQL_COLUMN_DISPLAY_SIZE:
17142 *valLen =
sizeof (int);
17143 return SQL_SUCCESS;
17144 case SQL_COLUMN_UNSIGNED:
17146 *val2 = c->
nosign ? SQL_TRUE : SQL_FALSE;
17148 *valLen =
sizeof (int);
17149 return SQL_SUCCESS;
17150 case SQL_COLUMN_SCALE:
17151 case SQL_DESC_SCALE:
17155 *valLen =
sizeof (int);
17156 return SQL_SUCCESS;
17157 case SQL_COLUMN_PRECISION:
17158 case SQL_DESC_PRECISION:
17178 #ifdef SQL_TYPE_TIMESTAMP 17179 case SQL_TYPE_TIMESTAMP:
17181 case SQL_TIMESTAMP:
17189 *valLen =
sizeof (int);
17190 return SQL_SUCCESS;
17191 case SQL_COLUMN_MONEY:
17195 *valLen =
sizeof (int);
17196 return SQL_SUCCESS;
17197 case SQL_COLUMN_AUTO_INCREMENT:
17201 *valLen =
sizeof (int);
17202 return SQL_SUCCESS;
17203 case SQL_COLUMN_LENGTH:
17204 case SQL_DESC_LENGTH:
17208 *valLen =
sizeof (int);
17209 return SQL_SUCCESS;
17210 case SQL_COLUMN_NULLABLE:
17211 case SQL_DESC_NULLABLE:
17215 *valLen =
sizeof (int);
17216 return SQL_SUCCESS;
17217 case SQL_COLUMN_SEARCHABLE:
17219 *val2 = SQL_SEARCHABLE;
17221 *valLen =
sizeof (int);
17222 return SQL_SUCCESS;
17223 case SQL_COLUMN_CASE_SENSITIVE:
17227 *valLen =
sizeof (int);
17228 return SQL_SUCCESS;
17229 case SQL_COLUMN_UPDATABLE:
17233 *valLen =
sizeof (int);
17234 return SQL_SUCCESS;
17235 case SQL_DESC_COUNT:
17239 *valLen =
sizeof (int);
17240 return SQL_SUCCESS;
17241 case SQL_COLUMN_TYPE_NAME: {
17245 if (c->
type == SQL_WCHAR ||
17246 c->
type == SQL_WVARCHAR ||
17247 c->
type == SQL_WLONGVARCHAR) {
17249 if (strcasecmp(tn,
"varchar") == 0) {
17255 if (valc && valMax > 0) {
17256 strncpy(valc, tn, valMax);
17257 valc[valMax - 1] =
'\0';
17258 p = strchr(valc,
'(');
17261 while (p > valc &&
ISSPACE(p[-1])) {
17266 *valLen = strlen(valc);
17268 *valLen = strlen(tn);
17269 p = strchr(tn,
'(');
17272 while (p > tn &&
ISSPACE(p[-1])) {
17280 case SQL_COLUMN_OWNER_NAME:
17281 case SQL_COLUMN_QUALIFIER_NAME: {
17284 if (valc && valMax > 0) {
17285 strncpy(valc, z, valMax);
17286 valc[valMax - 1] =
'\0';
17288 *valLen = strlen(z);
17291 case SQL_COLUMN_TABLE_NAME:
17292 #if (SQL_COLUMN_TABLE_NAME != SQL_DESC_TABLE_NAME) 17293 case SQL_DESC_TABLE_NAME:
17295 #ifdef SQL_DESC_BASE_TABLE_NAME 17296 case SQL_DESC_BASE_TABLE_NAME:
17298 if (valc && valMax > 0) {
17299 strncpy(valc, c->
table, valMax);
17300 valc[valMax - 1] =
'\0';
17302 *valLen = strlen(c->
table);
17304 #ifdef SQL_DESC_NUM_PREC_RADIX 17305 case SQL_DESC_NUM_PREC_RADIX:
17311 #ifdef SQL_LONGVARCHAR 17312 case SQL_WLONGVARCHAR:
17317 #ifdef SQL_LONGVARCHAR 17318 case SQL_LONGVARCHAR:
17321 case SQL_VARBINARY:
17322 case SQL_LONGVARBINARY:
17329 *valLen =
sizeof (int);
17330 return SQL_SUCCESS;
17333 setstat(s, -1,
"unsupported column attributes %d",
"HY091",
id);
17351 SQLColAttributes(SQLHSTMT stmt, SQLUSMALLINT col, SQLUSMALLINT
id,
17352 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17355 #if defined(_WIN32) || defined(_WIN64) 17356 SQLSMALLINT len = 0;
17361 #if defined(_WIN32) || defined(_WIN64) 17362 if (!((
STMT *) stmt)->oemcp[0]) {
17367 if (SQL_SUCCEEDED(ret)) {
17371 case SQL_COLUMN_LABEL:
17372 case SQL_COLUMN_NAME:
17373 case SQL_DESC_NAME:
17374 case SQL_COLUMN_TYPE_NAME:
17375 case SQL_COLUMN_OWNER_NAME:
17376 case SQL_COLUMN_QUALIFIER_NAME:
17377 case SQL_COLUMN_TABLE_NAME:
17378 #if (SQL_COLUMN_TABLE_NAME != SQL_DESC_TABLE_NAME) 17379 case SQL_DESC_TABLE_NAME:
17381 #ifdef SQL_DESC_BASE_COLUMN_NAME 17382 case SQL_DESC_BASE_COLUMN_NAME:
17384 #ifdef SQL_DESC_BASE_TABLE_NAME 17385 case SQL_DESC_BASE_TABLE_NAME:
17387 if (val && valMax > 0) {
17390 v = utf_to_wmb((
char *) val, SQL_NTS);
17392 strncpy(val, v, vmax);
17393 len =
min(vmax, strlen(v));
17398 v[vmax - 1] =
'\0';
17434 SQLColAttributesW(SQLHSTMT stmt, SQLUSMALLINT col, SQLUSMALLINT
id,
17435 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17439 SQLSMALLINT len = 0;
17443 if (SQL_SUCCEEDED(ret)) {
17444 SQLWCHAR *v = NULL;
17447 case SQL_COLUMN_LABEL:
17448 case SQL_COLUMN_NAME:
17449 case SQL_DESC_NAME:
17450 case SQL_COLUMN_TYPE_NAME:
17451 case SQL_COLUMN_OWNER_NAME:
17452 case SQL_COLUMN_QUALIFIER_NAME:
17453 case SQL_COLUMN_TABLE_NAME:
17454 #if (SQL_COLUMN_TABLE_NAME != SQL_DESC_TABLE_NAME) 17455 case SQL_DESC_TABLE_NAME:
17457 #ifdef SQL_DESC_BASE_COLUMN_NAME 17458 case SQL_DESC_BASE_COLUMN_NAME:
17460 #ifdef SQL_DESC_BASE_TABLE_NAME 17461 case SQL_DESC_BASE_TABLE_NAME:
17463 if (val && valMax > 0) {
17464 int vmax = valMax /
sizeof (SQLWCHAR);
17471 len *=
sizeof (SQLWCHAR);
17474 v = (SQLWCHAR *) val;
17475 v[vmax - 1] =
'\0';
17505 drvcolattribute(SQLHSTMT stmt, SQLUSMALLINT col, SQLUSMALLINT
id,
17506 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17512 char *valc = (
char *) val;
17515 if (stmt == SQL_NULL_HSTMT) {
17516 return SQL_INVALID_HANDLE;
17522 if (col < 1 || col > s->
ncols) {
17523 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009" :
"S1002");
17529 c = s->
cols + col - 1;
17531 case SQL_DESC_COUNT:
17534 case SQL_DESC_CATALOG_NAME:
17535 if (valc && valMax > 0) {
17536 strncpy(valc, c->
db, valMax);
17537 valc[valMax - 1] =
'\0';
17539 *valLen = strlen(c->
db);
17541 if (*valLen >= valMax) {
17542 setstat(s, -1,
"data right truncated",
"01004");
17543 return SQL_SUCCESS_WITH_INFO;
17546 case SQL_COLUMN_LENGTH:
17547 case SQL_DESC_LENGTH:
17550 case SQL_COLUMN_LABEL:
17552 if (valc && valMax > 0) {
17553 strncpy(valc, c->
label, valMax);
17554 valc[valMax - 1] =
'\0';
17556 *valLen = strlen(c->
label);
17560 case SQL_COLUMN_NAME:
17561 case SQL_DESC_NAME:
17562 if (valc && valMax > 0) {
17563 strncpy(valc, c->
column, valMax);
17564 valc[valMax - 1] =
'\0';
17566 *valLen = strlen(c->
column);
17568 case SQL_DESC_SCHEMA_NAME: {
17571 if (valc && valMax > 0) {
17572 strncpy(valc, z, valMax);
17573 valc[valMax - 1] =
'\0';
17575 *valLen = strlen(z);
17578 #ifdef SQL_DESC_BASE_COLUMN_NAME 17579 case SQL_DESC_BASE_COLUMN_NAME:
17580 if (strchr(c->
column,
'(') || strchr(c->
column,
')')) {
17583 }
else if (valc && valMax > 0) {
17584 strncpy(valc, c->
column, valMax);
17585 valc[valMax - 1] =
'\0';
17586 *valLen = strlen(c->
column);
17590 case SQL_DESC_TYPE_NAME: {
17594 if (c->
type == SQL_WCHAR ||
17595 c->
type == SQL_WVARCHAR ||
17596 c->
type == SQL_WLONGVARCHAR) {
17598 if (strcasecmp(tn,
"varchar") == 0) {
17604 if (valc && valMax > 0) {
17605 strncpy(valc, tn, valMax);
17606 valc[valMax - 1] =
'\0';
17607 p = strchr(valc,
'(');
17610 while (p > valc &&
ISSPACE(p[-1])) {
17615 *valLen = strlen(valc);
17617 *valLen = strlen(tn);
17618 p = strchr(tn,
'(');
17621 while (p > tn &&
ISSPACE(p[-1])) {
17629 case SQL_DESC_OCTET_LENGTH:
17632 if (c->
type == SQL_WCHAR ||
17633 c->
type == SQL_WVARCHAR ||
17634 c->
type == SQL_WLONGVARCHAR) {
17636 v *=
sizeof (SQLWCHAR);
17641 #if (SQL_COLUMN_TABLE_NAME != SQL_DESC_TABLE_NAME) 17642 case SQL_COLUMN_TABLE_NAME:
17644 #ifdef SQL_DESC_BASE_TABLE_NAME 17645 case SQL_DESC_BASE_TABLE_NAME:
17647 case SQL_DESC_TABLE_NAME:
17648 if (valc && valMax > 0) {
17649 strncpy(valc, c->
table, valMax);
17650 valc[valMax - 1] =
'\0';
17652 *valLen = strlen(c->
table);
17654 case SQL_DESC_TYPE:
17665 #ifdef SQL_LONGVARCHAR 17666 case SQL_WLONGVARCHAR:
17667 v = SQL_LONGVARCHAR;
17674 case SQL_DESC_CONCISE_TYPE:
17691 case SQL_TIMESTAMP:
17692 v = SQL_C_TIMESTAMP;
17700 #ifdef SQL_C_TYPE_TIMESTAMP 17701 case SQL_TYPE_TIMESTAMP:
17702 v = SQL_C_TYPE_TIMESTAMP;
17705 #ifdef SQL_C_TYPE_TIME 17706 case SQL_TYPE_TIME:
17707 v = SQL_C_TYPE_TIME;
17710 #ifdef SQL_C_TYPE_DATE 17711 case SQL_TYPE_DATE:
17712 v = SQL_C_TYPE_DATE;
17727 v = (s->
nowchar[0] || s->
nowchar[1]) ? SQL_C_CHAR : SQL_C_WCHAR;
17734 case SQL_DESC_UPDATABLE:
17737 case SQL_COLUMN_DISPLAY_SIZE:
17740 case SQL_COLUMN_UNSIGNED:
17741 v = c->
nosign ? SQL_TRUE : SQL_FALSE;
17743 case SQL_COLUMN_SEARCHABLE:
17744 v = SQL_SEARCHABLE;
17746 case SQL_COLUMN_SCALE:
17747 case SQL_DESC_SCALE:
17750 case SQL_COLUMN_PRECISION:
17751 case SQL_DESC_PRECISION:
17770 #ifdef SQL_TYPE_TIMESTAMP 17771 case SQL_TYPE_TIMESTAMP:
17773 case SQL_TIMESTAMP:
17781 case SQL_COLUMN_MONEY:
17784 case SQL_COLUMN_AUTO_INCREMENT:
17787 case SQL_DESC_NULLABLE:
17790 #ifdef SQL_DESC_NUM_PREC_RADIX 17791 case SQL_DESC_NUM_PREC_RADIX:
17796 #ifdef SQL_LONGVARCHAR 17797 case SQL_WLONGVARCHAR:
17802 #ifdef SQL_LONGVARCHAR 17803 case SQL_LONGVARCHAR:
17806 case SQL_VARBINARY:
17807 case SQL_LONGVARBINARY:
17816 setstat(s, -1,
"unsupported column attribute %d",
"HY091",
id);
17822 return SQL_SUCCESS;
17839 SQLColAttribute(SQLHSTMT stmt, SQLUSMALLINT col, SQLUSMALLINT
id,
17840 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17843 #if defined(_WIN32) || defined(_WIN64) 17844 SQLSMALLINT len = 0;
17849 #if defined(_WIN32) || defined(_WIN64) 17850 if (!((
STMT *) stmt)->oemcp[0]) {
17851 ret = drvcolattribute(stmt, col,
id, val, valMax, valLen,
17852 (SQLPOINTER) val2);
17855 ret = drvcolattribute(stmt, col,
id, val, valMax, &len,
17856 (SQLPOINTER) val2);
17857 if (SQL_SUCCEEDED(ret)) {
17861 case SQL_DESC_SCHEMA_NAME:
17862 case SQL_DESC_CATALOG_NAME:
17863 case SQL_COLUMN_LABEL:
17864 case SQL_DESC_NAME:
17865 case SQL_DESC_TABLE_NAME:
17866 #ifdef SQL_DESC_BASE_TABLE_NAME 17867 case SQL_DESC_BASE_TABLE_NAME:
17869 #ifdef SQL_DESC_BASE_COLUMN_NAME 17870 case SQL_DESC_BASE_COLUMN_NAME:
17872 case SQL_DESC_TYPE_NAME:
17873 if (val && valMax > 0) {
17876 v = utf_to_wmb((
char *) val, SQL_NTS);
17878 strncpy(val, v, vmax);
17879 len =
min(vmax, strlen(v));
17884 v[vmax - 1] =
'\0';
17899 ret = drvcolattribute(stmt, col,
id, val, valMax, valLen,
17900 (SQLPOINTER) val2);
17921 SQLColAttributeW(SQLHSTMT stmt, SQLUSMALLINT col, SQLUSMALLINT
id,
17922 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17926 SQLSMALLINT len = 0;
17929 ret = drvcolattribute(stmt, col,
id, val, valMax, &len,
17930 (SQLPOINTER) val2);
17931 if (SQL_SUCCEEDED(ret)) {
17932 SQLWCHAR *v = NULL;
17935 case SQL_DESC_SCHEMA_NAME:
17936 case SQL_DESC_CATALOG_NAME:
17937 case SQL_COLUMN_LABEL:
17938 case SQL_DESC_NAME:
17939 case SQL_DESC_TABLE_NAME:
17940 #ifdef SQL_DESC_BASE_TABLE_NAME 17941 case SQL_DESC_BASE_TABLE_NAME:
17943 #ifdef SQL_DESC_BASE_COLUMN_NAME 17944 case SQL_DESC_BASE_COLUMN_NAME:
17946 case SQL_DESC_TYPE_NAME:
17947 if (val && valMax > 0) {
17948 int vmax = valMax /
sizeof (SQLWCHAR);
17955 len *=
sizeof (SQLWCHAR);
17958 v = (SQLWCHAR *) val;
17959 v[vmax - 1] =
'\0';
17990 drverror(SQLHENV env, SQLHDBC dbc, SQLHSTMT stmt,
17991 SQLCHAR *sqlState, SQLINTEGER *nativeErr,
17992 SQLCHAR *errmsg, SQLSMALLINT errmax, SQLSMALLINT *errlen)
17996 SQLSMALLINT dummy2;
17998 if (env == SQL_NULL_HENV &&
17999 dbc == SQL_NULL_HDBC &&
18000 stmt == SQL_NULL_HSTMT) {
18001 return SQL_INVALID_HANDLE;
18004 sqlState[0] =
'\0';
18009 nativeErr = &dummy1;
18028 if (s->
logmsg[0] ==
'\0') {
18033 strcpy((
char *) sqlState, s->
sqlstate);
18034 if (errmax == SQL_NTS) {
18035 strcpy((
char *) errmsg,
"[SQLite]");
18036 strcat((
char *) errmsg, (
char *) s->
logmsg);
18037 *errlen = strlen((
char *) errmsg);
18039 strncpy((
char *) errmsg,
"[SQLite]", errmax);
18040 if (errmax - 8 > 0) {
18041 strncpy((
char *) errmsg + 8, (
char *) s->
logmsg, errmax - 8);
18043 *errlen =
min(strlen((
char *) s->
logmsg) + 8, errmax);
18047 return SQL_SUCCESS;
18058 strcpy((
char *) sqlState, d->
sqlstate);
18059 if (errmax == SQL_NTS) {
18060 strcpy((
char *) errmsg,
"[SQLite]");
18061 strcat((
char *) errmsg, (
char *) d->
logmsg);
18062 *errlen = strlen((
char *) errmsg);
18064 strncpy((
char *) errmsg,
"[SQLite]", errmax);
18065 if (errmax - 8 > 0) {
18066 strncpy((
char *) errmsg + 8, (
char *) d->
logmsg, errmax - 8);
18068 *errlen =
min(strlen((
char *) d->
logmsg) + 8, errmax);
18072 return SQL_SUCCESS;
18075 sqlState[0] =
'\0';
18079 return SQL_NO_DATA;
18097 SQLError(SQLHENV env, SQLHDBC dbc, SQLHSTMT stmt,
18098 SQLCHAR *sqlState, SQLINTEGER *nativeErr,
18099 SQLCHAR *errmsg, SQLSMALLINT errmax, SQLSMALLINT *errlen)
18101 return drverror(env, dbc, stmt, sqlState, nativeErr,
18102 errmsg, errmax, errlen);
18121 SQLErrorW(SQLHENV env, SQLHDBC dbc, SQLHSTMT stmt,
18122 SQLWCHAR *sqlState, SQLINTEGER *nativeErr,
18123 SQLWCHAR *errmsg, SQLSMALLINT errmax, SQLSMALLINT *errlen)
18126 SQLSMALLINT len = 0;
18129 ret = drverror(env, dbc, stmt, (SQLCHAR *) state, nativeErr,
18130 (SQLCHAR *) errmsg, errmax, &len);
18131 if (ret == SQL_SUCCESS) {
18134 6 *
sizeof (SQLWCHAR));
18138 SQLWCHAR *e = NULL;
18166 }
else if (ret == SQL_NO_DATA) {
18190 SQLMoreResults(SQLHSTMT stmt)
18193 if (stmt == SQL_NULL_HSTMT) {
18194 return SQL_INVALID_HANDLE;
18197 return SQL_NO_DATA;
18211 int ncols = *ncolsp, guessed_types = 0;
18212 SQLRETURN ret = SQL_SUCCESS;
18220 const char *colname, *
typename;
18221 #
if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME)
18225 for (i = size = 0; i < ncols; i++) {
18226 colname = sqlite3_column_name(s3stmt, i);
18227 size += 3 + 3 * strlen(colname);
18229 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME) 18230 tblname = (
char *) size;
18231 for (i = 0; i < ncols; i++) {
18232 p = (
char *) sqlite3_column_table_name(s3stmt, i);
18233 size += 2 + (p ? strlen(p) : 0);
18236 dyncols =
xmalloc(ncols *
sizeof (
COL) + size);
18242 p = (
char *) (dyncols + ncols);
18243 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME) 18246 for (i = 0; i < ncols; i++) {
18249 colname = sqlite3_column_name(s3stmt, i);
18251 fprintf(d->
trace,
"-- column %d name: '%s'\n",
18255 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME) 18256 q = (
char *) sqlite3_column_table_name(s3stmt, i);
18257 strcpy(tblname, q ? q :
"");
18259 fprintf(d->
trace,
"-- table %d name: '%s'\n",
18263 dyncols[i].
table = tblname;
18264 tblname += strlen(tblname) + 1;
18267 dyncols[i].
db = ((
DBC *) (s->
dbc))->dbname;
18268 strcpy(p, colname);
18269 dyncols[i].
label = p;
18270 p += strlen(p) + 1;
18271 q = strchr(colname,
'.');
18273 char *q2 = strchr(q + 1,
'.');
18281 #if !defined(HAVE_SQLITE3COLUMNTABLENAME) || !(HAVE_SQLITE3COLUMNTABLENAME) 18282 dyncols[i].
table = p;
18284 strncpy(p, colname, q - colname);
18285 p[q - colname] =
'\0';
18286 p += strlen(p) + 1;
18289 p += strlen(p) + 1;
18291 #if !defined(HAVE_SQLITE3COLUMNTABLENAME) || !(HAVE_SQLITE3COLUMNTABLENAME) 18292 dyncols[i].
table =
"";
18294 strcpy(p, colname);
18296 p += strlen(p) + 1;
18301 #ifdef SQL_LONGVARCHAR 18302 dyncols[i].
type = SQL_LONGVARCHAR;
18303 dyncols[i].
size = 65535;
18305 dyncols[i].
type = SQL_VARCHAR;
18306 dyncols[i].
size = 255;
18308 dyncols[i].
index = i;
18309 dyncols[i].
scale = 0;
18310 dyncols[i].
prec = 0;
18312 dyncols[i].
autoinc = SQL_FALSE;
18313 dyncols[i].
notnull = SQL_NULLABLE;
18314 dyncols[i].
ispk = -1;
18316 #ifdef FULL_METADATA 18317 s3stmt_addmeta(s3stmt, i, d, &dyncols[i]);
18340 drvprepare(SQLHSTMT stmt, SQLCHAR *query, SQLINTEGER queryLen)
18347 if (stmt == SQL_NULL_HSTMT) {
18348 return SQL_INVALID_HANDLE;
18351 if (s->
dbc == SQL_NULL_HDBC) {
18362 if (sret != SQL_SUCCESS) {
18371 setstat(s, -1,
"%s", (*s->
ov3) ?
"HY000" :
"S1000", errp);
18379 int ret, ncols, nretry = 0;
18381 sqlite3_stmt *s3stmt = NULL;
18383 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 18390 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 18391 ret = sqlite3_prepare_v2(d->
sqlite, (
char *) s->
query, -1,
18394 ret = sqlite3_prepare(d->
sqlite, (
char *) s->
query, -1,
18397 if (ret != SQLITE_OK) {
18399 sqlite3_finalize(s3stmt);
18403 }
while (ret == SQLITE_SCHEMA && (++nretry) < 2);
18405 if (ret != SQLITE_OK) {
18408 sqlite3_finalize(s3stmt);
18410 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
18411 sqlite3_errmsg(d->
sqlite), ret);
18414 if (sqlite3_bind_parameter_count(s3stmt) != s->
nparams) {
18416 sqlite3_finalize(s3stmt);
18417 setstat(s, SQLITE_ERROR,
"parameter marker count incorrect",
18418 (*s->
ov3) ?
"HY000" :
"S1000");
18421 ncols = sqlite3_column_count(s3stmt);
18429 return SQL_SUCCESS;
18445 int rc, i, ncols = 0, nrows = 0, busy_count;
18448 if (stmt == SQL_NULL_HSTMT) {
18449 return SQL_INVALID_HANDLE;
18452 if (s->
dbc == SQL_NULL_HDBC) {
18461 setstat(s, -1,
"no query prepared", (*s->
ov3) ?
"HY000" :
"S1000");
18466 setstat(s, -1,
"unbound parameters in query",
18467 (*s->
ov3) ?
"HY000" :
"S1000");
18470 for (i = 0; i < s->
nparams; i++) {
18479 if (lenp && *lenp < 0 && *lenp > SQL_LEN_DATA_AT_EXEC_OFFSET &&
18480 *lenp != SQL_NTS && *lenp != SQL_NULL_DATA &&
18481 *lenp != SQL_DATA_AT_EXEC) {
18482 setstat(s, -1,
"invalid length reference",
"HY009");
18485 if (lenp && (*lenp <= SQL_LEN_DATA_AT_EXEC_OFFSET ||
18486 *lenp == SQL_DATA_AT_EXEC)) {
18494 if (ret != SQL_SUCCESS) {
18503 for (i = 0; i < s->
nparams; i++) {
18510 if (p->
need <= 0 &&
18511 p->
lenp && (*p->
lenp <= SQL_LEN_DATA_AT_EXEC_OFFSET ||
18512 *p->
lenp == SQL_DATA_AT_EXEC)) {
18520 for (i = 0; i < s->
nparams; i++) {
18522 if (ret != SQL_SUCCESS) {
18529 s->
curtype == SQL_CURSOR_FORWARD_ONLY &&
18533 if (ret == SQL_SUCCESS) {
18540 if (rc == SQLITE_BUSY) {
18543 sqlite3_free(errp);
18546 for (i = 0; i < s->
nparams; i++) {
18553 if (!p->
lenp || (*p->
lenp > SQL_LEN_DATA_AT_EXEC_OFFSET &&
18554 *p->
lenp != SQL_DATA_AT_EXEC)) {
18563 if (rc != SQLITE_OK) {
18564 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
18565 errp ? errp :
"unknown error", rc);
18567 sqlite3_free(errp);
18574 sqlite3_free(errp);
18583 nrows += sqlite3_changes(d->
sqlite);
18587 if (s->
ncols != ncols) {
18591 setstat(s, -1,
"broken result set %d/%d",
18592 (*s->
ov3) ?
"HY000" :
"S1000", s->
ncols, ncols);
18604 for (i = 0; i < s->
nparams; i++) {
18615 }
else if (p->
lenp0 && p->
inc > 0) {
18618 if (!p->
lenp || (*p->
lenp > SQL_LEN_DATA_AT_EXEC_OFFSET &&
18619 *p->
lenp != SQL_DATA_AT_EXEC)) {
18628 }
else if (p->
lenp && (*p->
lenp <= SQL_LEN_DATA_AT_EXEC_OFFSET ||
18629 *p->
lenp == SQL_DATA_AT_EXEC)) {
18638 if (ret != SQL_NEED_DATA) {
18639 for (i = 0; i < s->
nparams; i++) {
18646 if (!p->
lenp || (*p->
lenp > SQL_LEN_DATA_AT_EXEC_OFFSET &&
18647 *p->
lenp != SQL_DATA_AT_EXEC)) {
18664 ret == SQL_SUCCESS && nrows == 0) {
18680 SQLPrepare(SQLHSTMT stmt, SQLCHAR *query, SQLINTEGER queryLen)
18683 #if defined(_WIN32) || defined(_WIN64) 18688 #if defined(_WIN32) || defined(_WIN64) 18689 if (!((
STMT *) stmt)->oemcp[0]) {
18690 ret = drvprepare(stmt, query, queryLen);
18693 q = wmb_to_utf_c((
char *) query, queryLen);
18698 query = (SQLCHAR *) q;
18699 queryLen = SQL_NTS;
18701 ret = drvprepare(stmt, query, queryLen);
18702 #if defined(_WIN32) || defined(_WIN64) 18722 SQLPrepareW(SQLHSTMT stmt, SQLWCHAR *query, SQLINTEGER queryLen)
18732 ret = drvprepare(stmt, (SQLCHAR *) q, SQL_NTS);
18747 SQLExecute(SQLHSTMT stmt)
18767 SQLExecDirect(SQLHSTMT stmt, SQLCHAR *query, SQLINTEGER queryLen)
18770 #if defined(_WIN32) || defined(_WIN64) 18775 #if defined(_WIN32) || defined(_WIN64) 18776 if (!((
STMT *) stmt)->oemcp[0]) {
18777 ret = drvprepare(stmt, query, queryLen);
18778 if (ret == SQL_SUCCESS) {
18783 q = wmb_to_utf_c((
char *) query, queryLen);
18788 query = (SQLCHAR *) q;
18789 queryLen = SQL_NTS;
18791 ret = drvprepare(stmt, query, queryLen);
18792 if (ret == SQL_SUCCESS) {
18795 #if defined(_WIN32) || defined(_WIN64) 18815 SQLExecDirectW(SQLHSTMT stmt, SQLWCHAR *query, SQLINTEGER queryLen)
18825 ret = drvprepare(stmt, (SQLCHAR *) q, SQL_NTS);
18827 if (ret == SQL_SUCCESS) {
18837 #if defined(_WIN32) || defined(_WIN64) 18838 #ifndef WITHOUT_DRIVERMGR 18844 #include <windowsx.h> 18845 #include <winuser.h> 18847 #define MAXPATHLEN (259+1) 18848 #define MAXKEYLEN (15+1) 18849 #define MAXDESC (255+1) 18850 #define MAXDSNAME (255+1) 18851 #define MAXTONAME (32+1) 18852 #define MAXDBNAME MAXPATHLEN 18858 #define KEY_DBNAME 2 18860 #define KEY_DRIVER 4 18861 #define KEY_STEPAPI 5 18862 #define KEY_SYNCP 6 18863 #define KEY_NOTXN 7 18864 #define KEY_SHORTNAM 8 18865 #define KEY_LONGNAM 9 18866 #define KEY_NOCREAT 10 18867 #define KEY_NOWCHAR 11 18868 #define KEY_LOADEXT 12 18869 #define KEY_JMODE 13 18870 #define KEY_FKSUPPORT 14 18871 #define KEY_OEMCP 15 18872 #define KEY_BIGINT 16 18873 #define KEY_PASSWD 17 18874 #define KEY_JDCONV 18 18875 #define NUMOFKEYS 19 18879 char attr[MAXPATHLEN*4];
18885 ATTR attr[NUMOFKEYS];
18886 char DSN[MAXDSNAME];
18895 {
"DSN", KEY_DSN },
18896 {
"DESC", KEY_DESC },
18897 {
"Description", KEY_DESC},
18898 {
"Database", KEY_DBNAME },
18899 {
"Timeout", KEY_BUSY },
18900 {
"Driver", KEY_DRIVER },
18901 {
"StepAPI", KEY_STEPAPI },
18902 {
"SyncPragma", KEY_SYNCP },
18903 {
"NoTXN", KEY_NOTXN },
18904 {
"ShortNames", KEY_SHORTNAM },
18905 {
"LongNames", KEY_LONGNAM },
18906 {
"NoCreat", KEY_NOCREAT },
18907 {
"NoWCHAR", KEY_NOWCHAR },
18908 {
"LoadExt", KEY_LOADEXT },
18909 {
"JournalMode", KEY_JMODE },
18910 {
"FKSupport", KEY_FKSUPPORT },
18911 {
"OEMCP", KEY_OEMCP },
18912 {
"BigInt", KEY_BIGINT },
18913 {
"PWD", KEY_PASSWD },
18914 {
"JDConv", KEY_JDCONV },
18925 ParseAttributes(LPCSTR attribs, SETUPDLG *setupdlg)
18927 char *str = (
char *) attribs, *start, key[MAXKEYLEN];
18932 if ((str = strchr(str,
'=')) == NULL) {
18936 nkey = str - start;
18937 if (nkey <
sizeof (key)) {
18940 memcpy(key, start, nkey);
18942 for (i = 0; attrLookup[i].key; i++) {
18943 if (strcasecmp(attrLookup[i].key, key) == 0) {
18944 elem = attrLookup[i].ikey;
18950 while (*str && *str !=
';') {
18954 int end =
min(str - start,
sizeof (setupdlg->attr[elem].attr) - 1);
18956 setupdlg->attr[elem].supplied = TRUE;
18957 memcpy(setupdlg->attr[elem].attr, start, end);
18958 setupdlg->attr[elem].attr[end] =
'\0';
18972 SetDSNAttributes(HWND parent, SETUPDLG *setupdlg)
18974 char *dsn = setupdlg->attr[KEY_DSN].attr;
18976 if (setupdlg->newDSN && strlen(dsn) == 0) {
18979 if (!SQLWriteDSNToIni(dsn, setupdlg->driver)) {
18981 char buf[MAXPATHLEN], msg[MAXPATHLEN];
18983 LoadString(hModule, IDS_BADDSN, buf,
sizeof (buf));
18984 wsprintf(msg, buf, dsn);
18985 LoadString(hModule, IDS_MSGTITLE, buf,
sizeof (buf));
18986 MessageBox(parent, msg, buf,
18987 MB_ICONEXCLAMATION | MB_OK | MB_TASKMODAL |
18992 if (parent || setupdlg->attr[KEY_DESC].supplied) {
18993 SQLWritePrivateProfileString(dsn,
"Description",
18994 setupdlg->attr[KEY_DESC].attr,
18997 if (parent || setupdlg->attr[KEY_DBNAME].supplied) {
18998 SQLWritePrivateProfileString(dsn,
"Database",
18999 setupdlg->attr[KEY_DBNAME].attr,
19002 if (parent || setupdlg->attr[KEY_BUSY].supplied) {
19003 SQLWritePrivateProfileString(dsn,
"Timeout",
19004 setupdlg->attr[KEY_BUSY].attr,
19007 if (parent || setupdlg->attr[KEY_STEPAPI].supplied) {
19008 SQLWritePrivateProfileString(dsn,
"StepAPI",
19009 setupdlg->attr[KEY_STEPAPI].attr,
19012 if (parent || setupdlg->attr[KEY_SYNCP].supplied) {
19013 SQLWritePrivateProfileString(dsn,
"SyncPragma",
19014 setupdlg->attr[KEY_SYNCP].attr,
19017 if (parent || setupdlg->attr[KEY_NOTXN].supplied) {
19018 SQLWritePrivateProfileString(dsn,
"NoTXN",
19019 setupdlg->attr[KEY_NOTXN].attr,
19022 if (parent || setupdlg->attr[KEY_SHORTNAM].supplied) {
19023 SQLWritePrivateProfileString(dsn,
"ShortNames",
19024 setupdlg->attr[KEY_SHORTNAM].attr,
19027 if (parent || setupdlg->attr[KEY_LONGNAM].supplied) {
19028 SQLWritePrivateProfileString(dsn,
"LongNames",
19029 setupdlg->attr[KEY_LONGNAM].attr,
19032 if (parent || setupdlg->attr[KEY_NOCREAT].supplied) {
19033 SQLWritePrivateProfileString(dsn,
"NoCreat",
19034 setupdlg->attr[KEY_NOCREAT].attr,
19037 if (parent || setupdlg->attr[KEY_NOWCHAR].supplied) {
19038 SQLWritePrivateProfileString(dsn,
"NoWCHAR",
19039 setupdlg->attr[KEY_NOWCHAR].attr,
19042 if (parent || setupdlg->attr[KEY_FKSUPPORT].supplied) {
19043 SQLWritePrivateProfileString(dsn,
"FKSupport",
19044 setupdlg->attr[KEY_FKSUPPORT].attr,
19047 if (parent || setupdlg->attr[KEY_OEMCP].supplied) {
19048 SQLWritePrivateProfileString(dsn,
"OEMCP",
19049 setupdlg->attr[KEY_OEMCP].attr,
19052 if (parent || setupdlg->attr[KEY_LOADEXT].supplied) {
19053 SQLWritePrivateProfileString(dsn,
"LoadExt",
19054 setupdlg->attr[KEY_LOADEXT].attr,
19057 if (parent || setupdlg->attr[KEY_BIGINT].supplied) {
19058 SQLWritePrivateProfileString(dsn,
"BigInt",
19059 setupdlg->attr[KEY_BIGINT].attr,
19062 if (parent || setupdlg->attr[KEY_JDCONV].supplied) {
19063 SQLWritePrivateProfileString(dsn,
"JDConv",
19064 setupdlg->attr[KEY_JDCONV].attr,
19067 if (parent || setupdlg->attr[KEY_PASSWD].supplied) {
19068 SQLWritePrivateProfileString(dsn,
"PWD",
19069 setupdlg->attr[KEY_PASSWD].attr,
19072 if (setupdlg->attr[KEY_DSN].supplied &&
19073 strcasecmp(setupdlg->DSN, setupdlg->attr[KEY_DSN].attr)) {
19074 SQLRemoveDSNFromIni(setupdlg->DSN);
19085 GetAttributes(SETUPDLG *setupdlg)
19087 char *dsn = setupdlg->attr[KEY_DSN].attr;
19089 if (!setupdlg->attr[KEY_DESC].supplied) {
19090 SQLGetPrivateProfileString(dsn,
"Description",
"",
19091 setupdlg->attr[KEY_DESC].attr,
19092 sizeof (setupdlg->attr[KEY_DESC].attr),
19095 if (!setupdlg->attr[KEY_DBNAME].supplied) {
19096 SQLGetPrivateProfileString(dsn,
"Database",
"",
19097 setupdlg->attr[KEY_DBNAME].attr,
19098 sizeof (setupdlg->attr[KEY_DBNAME].attr),
19101 if (!setupdlg->attr[KEY_BUSY].supplied) {
19102 SQLGetPrivateProfileString(dsn,
"Timeout",
"100000",
19103 setupdlg->attr[KEY_BUSY].attr,
19104 sizeof (setupdlg->attr[KEY_BUSY].attr),
19107 if (!setupdlg->attr[KEY_STEPAPI].supplied) {
19108 SQLGetPrivateProfileString(dsn,
"StepAPI",
"0",
19109 setupdlg->attr[KEY_STEPAPI].attr,
19110 sizeof (setupdlg->attr[KEY_STEPAPI].attr),
19113 if (!setupdlg->attr[KEY_SYNCP].supplied) {
19114 SQLGetPrivateProfileString(dsn,
"SyncPragma",
"NORMAL",
19115 setupdlg->attr[KEY_SYNCP].attr,
19116 sizeof (setupdlg->attr[KEY_SYNCP].attr),
19119 if (!setupdlg->attr[KEY_NOTXN].supplied) {
19120 SQLGetPrivateProfileString(dsn,
"NoTXN",
"",
19121 setupdlg->attr[KEY_NOTXN].attr,
19122 sizeof (setupdlg->attr[KEY_NOTXN].attr),
19125 if (!setupdlg->attr[KEY_SHORTNAM].supplied) {
19126 SQLGetPrivateProfileString(dsn,
"ShortNames",
"",
19127 setupdlg->attr[KEY_SHORTNAM].attr,
19128 sizeof (setupdlg->attr[KEY_SHORTNAM].attr),
19131 if (!setupdlg->attr[KEY_LONGNAM].supplied) {
19132 SQLGetPrivateProfileString(dsn,
"LongNames",
"",
19133 setupdlg->attr[KEY_LONGNAM].attr,
19134 sizeof (setupdlg->attr[KEY_LONGNAM].attr),
19137 if (!setupdlg->attr[KEY_NOCREAT].supplied) {
19138 SQLGetPrivateProfileString(dsn,
"NoCreat",
"",
19139 setupdlg->attr[KEY_NOCREAT].attr,
19140 sizeof (setupdlg->attr[KEY_NOCREAT].attr),
19143 if (!setupdlg->attr[KEY_NOWCHAR].supplied) {
19144 SQLGetPrivateProfileString(dsn,
"NoWCHAR",
"",
19145 setupdlg->attr[KEY_NOWCHAR].attr,
19146 sizeof (setupdlg->attr[KEY_NOWCHAR].attr),
19149 if (!setupdlg->attr[KEY_FKSUPPORT].supplied) {
19150 SQLGetPrivateProfileString(dsn,
"FKSupport",
"",
19151 setupdlg->attr[KEY_FKSUPPORT].attr,
19152 sizeof (setupdlg->attr[KEY_FKSUPPORT].attr),
19155 if (!setupdlg->attr[KEY_OEMCP].supplied) {
19156 SQLGetPrivateProfileString(dsn,
"OEMCP",
"",
19157 setupdlg->attr[KEY_OEMCP].attr,
19158 sizeof (setupdlg->attr[KEY_OEMCP].attr),
19161 if (!setupdlg->attr[KEY_LOADEXT].supplied) {
19162 SQLGetPrivateProfileString(dsn,
"LoadExt",
"",
19163 setupdlg->attr[KEY_LOADEXT].attr,
19164 sizeof (setupdlg->attr[KEY_LOADEXT].attr),
19167 if (!setupdlg->attr[KEY_JMODE].supplied) {
19168 SQLGetPrivateProfileString(dsn,
"JournalMode",
"",
19169 setupdlg->attr[KEY_JMODE].attr,
19170 sizeof (setupdlg->attr[KEY_JMODE].attr),
19173 if (!setupdlg->attr[KEY_BIGINT].supplied) {
19174 SQLGetPrivateProfileString(dsn,
"BigInt",
"",
19175 setupdlg->attr[KEY_BIGINT].attr,
19176 sizeof (setupdlg->attr[KEY_BIGINT].attr),
19179 if (!setupdlg->attr[KEY_PASSWD].supplied) {
19180 SQLGetPrivateProfileString(dsn,
"PWD",
"",
19181 setupdlg->attr[KEY_PASSWD].attr,
19182 sizeof (setupdlg->attr[KEY_PASSWD].attr),
19185 if (!setupdlg->attr[KEY_JDCONV].supplied) {
19186 SQLGetPrivateProfileString(dsn,
"JDConv",
"",
19187 setupdlg->attr[KEY_JDCONV].attr,
19188 sizeof (setupdlg->attr[KEY_JDCONV].attr),
19199 GetDBFile(HWND hdlg)
19202 SETUPDLG *setupdlg = (SETUPDLG *) GetWindowLongPtr(hdlg, DWLP_USER);
19204 SETUPDLG *setupdlg = (SETUPDLG *) GetWindowLong(hdlg, DWL_USER);
19208 memset(&ofn, 0,
sizeof (ofn));
19209 ofn.lStructSize =
sizeof (ofn);
19210 ofn.hwndOwner = hdlg;
19212 ofn.hInstance = (HINSTANCE) GetWindowLongPtr(hdlg, GWLP_HINSTANCE);
19214 ofn.hInstance = (HINSTANCE) GetWindowLong(hdlg, GWL_HINSTANCE);
19216 ofn.lpstrFile = (LPTSTR) setupdlg->attr[KEY_DBNAME].attr;
19217 ofn.nMaxFile = MAXPATHLEN;
19218 ofn.Flags = OFN_HIDEREADONLY | OFN_PATHMUSTEXIST |
19219 OFN_NOCHANGEDIR | OFN_EXPLORER | OFN_FILEMUSTEXIST;
19220 if (GetOpenFileName(&ofn)) {
19221 SetDlgItemText(hdlg, IDC_DBNAME, setupdlg->attr[KEY_DBNAME].attr);
19222 setupdlg->attr[KEY_DBNAME].supplied = TRUE;
19235 static BOOL CALLBACK
19236 ConfigDlgProc(HWND hdlg, WORD wmsg, WPARAM wparam, LPARAM lparam)
19238 SETUPDLG *setupdlg = NULL;
19242 case WM_INITDIALOG:
19244 SetWindowLongPtr(hdlg, DWLP_USER, lparam);
19246 SetWindowLong(hdlg, DWL_USER, lparam);
19248 setupdlg = (SETUPDLG *) lparam;
19249 GetAttributes(setupdlg);
19250 SetDlgItemText(hdlg, IDC_DSNAME, setupdlg->attr[KEY_DSN].attr);
19251 SetDlgItemText(hdlg, IDC_DESC, setupdlg->attr[KEY_DESC].attr);
19252 SetDlgItemText(hdlg, IDC_DBNAME, setupdlg->attr[KEY_DBNAME].attr);
19253 SetDlgItemText(hdlg, IDC_TONAME, setupdlg->attr[KEY_BUSY].attr);
19254 SetDlgItemText(hdlg, IDC_LOADEXT, setupdlg->attr[KEY_LOADEXT].attr);
19255 SendDlgItemMessage(hdlg, IDC_DSNAME, EM_LIMITTEXT,
19256 (WPARAM) (MAXDSNAME - 1), (LPARAM) 0);
19257 SendDlgItemMessage(hdlg, IDC_DESC, EM_LIMITTEXT,
19258 (WPARAM) (MAXDESC - 1), (LPARAM) 0);
19259 SendDlgItemMessage(hdlg, IDC_DBNAME, EM_LIMITTEXT,
19260 (WPARAM) (MAXDBNAME - 1), (LPARAM) 0);
19261 SendDlgItemMessage(hdlg, IDC_TONAME, EM_LIMITTEXT,
19262 (WPARAM) (MAXTONAME - 1), (LPARAM) 0);
19263 SendDlgItemMessage(hdlg, IDC_LOADEXT, EM_LIMITTEXT,
19264 (WPARAM) (MAXPATHLEN*4 - 1), (LPARAM) 0);
19265 CheckDlgButton(hdlg, IDC_STEPAPI,
19266 getbool(setupdlg->attr[KEY_STEPAPI].attr) ?
19267 BST_CHECKED : BST_UNCHECKED);
19268 CheckDlgButton(hdlg, IDC_NOTXN,
19269 getbool(setupdlg->attr[KEY_NOTXN].attr) ?
19270 BST_CHECKED : BST_UNCHECKED);
19271 CheckDlgButton(hdlg, IDC_SHORTNAM,
19272 getbool(setupdlg->attr[KEY_SHORTNAM].attr) ?
19273 BST_CHECKED : BST_UNCHECKED);
19274 CheckDlgButton(hdlg, IDC_LONGNAM,
19275 getbool(setupdlg->attr[KEY_LONGNAM].attr) ?
19276 BST_CHECKED : BST_UNCHECKED);
19277 CheckDlgButton(hdlg, IDC_NOCREAT,
19278 getbool(setupdlg->attr[KEY_NOCREAT].attr) ?
19279 BST_CHECKED : BST_UNCHECKED);
19280 CheckDlgButton(hdlg, IDC_NOWCHAR,
19281 getbool(setupdlg->attr[KEY_NOWCHAR].attr) ?
19282 BST_CHECKED : BST_UNCHECKED);
19283 CheckDlgButton(hdlg, IDC_FKSUPPORT,
19284 getbool(setupdlg->attr[KEY_FKSUPPORT].attr) ?
19285 BST_CHECKED : BST_UNCHECKED);
19286 CheckDlgButton(hdlg, IDC_OEMCP,
19287 getbool(setupdlg->attr[KEY_OEMCP].attr) ?
19288 BST_CHECKED : BST_UNCHECKED);
19289 CheckDlgButton(hdlg, IDC_BIGINT,
19290 getbool(setupdlg->attr[KEY_BIGINT].attr) ?
19291 BST_CHECKED : BST_UNCHECKED);
19292 CheckDlgButton(hdlg, IDC_JDCONV,
19293 getbool(setupdlg->attr[KEY_JDCONV].attr) ?
19294 BST_CHECKED : BST_UNCHECKED);
19295 SendDlgItemMessage(hdlg, IDC_SYNCP,
19296 CB_LIMITTEXT, (WPARAM) 10, (LPARAM) 0);
19297 SendDlgItemMessage(hdlg, IDC_SYNCP,
19298 CB_ADDSTRING, 0, (LPARAM)
"NORMAL");
19299 SendDlgItemMessage(hdlg, IDC_SYNCP,
19300 CB_ADDSTRING, 0, (LPARAM)
"OFF");
19301 SendDlgItemMessage(hdlg, IDC_SYNCP,
19302 CB_ADDSTRING, 0, (LPARAM)
"FULL");
19303 SendDlgItemMessage(hdlg, IDC_SYNCP,
19304 CB_SELECTSTRING, (WPARAM) -1,
19305 (LPARAM) setupdlg->attr[KEY_SYNCP].attr);
19306 if (setupdlg->defDSN) {
19307 EnableWindow(GetDlgItem(hdlg, IDC_DSNAME), FALSE);
19308 EnableWindow(GetDlgItem(hdlg, IDC_DSNAMETEXT), FALSE);
19312 switch (GET_WM_COMMAND_ID(wparam, lparam)) {
19314 if (GET_WM_COMMAND_CMD(wparam, lparam) == EN_CHANGE) {
19315 char item[MAXDSNAME];
19317 EnableWindow(GetDlgItem(hdlg, IDOK),
19318 GetDlgItemText(hdlg, IDC_DSNAME,
19319 item,
sizeof (item)));
19328 setupdlg = (SETUPDLG *) GetWindowLongPtr(hdlg, DWLP_USER);
19330 setupdlg = (SETUPDLG *) GetWindowLong(hdlg, DWL_USER);
19332 if (!setupdlg->defDSN) {
19333 GetDlgItemText(hdlg, IDC_DSNAME,
19334 setupdlg->attr[KEY_DSN].attr,
19335 sizeof (setupdlg->attr[KEY_DSN].attr));
19337 GetDlgItemText(hdlg, IDC_DESC,
19338 setupdlg->attr[KEY_DESC].attr,
19339 sizeof (setupdlg->attr[KEY_DESC].attr));
19340 GetDlgItemText(hdlg, IDC_DBNAME,
19341 setupdlg->attr[KEY_DBNAME].attr,
19342 sizeof (setupdlg->attr[KEY_DBNAME].attr));
19343 GetDlgItemText(hdlg, IDC_TONAME,
19344 setupdlg->attr[KEY_BUSY].attr,
19345 sizeof (setupdlg->attr[KEY_BUSY].attr));
19346 GetDlgItemText(hdlg, IDC_LOADEXT,
19347 setupdlg->attr[KEY_LOADEXT].attr,
19348 sizeof (setupdlg->attr[KEY_LOADEXT].attr));
19349 index = SendDlgItemMessage(hdlg, IDC_SYNCP,
19350 CB_GETCURSEL, (WPARAM) 0, (LPARAM) 0);
19351 if (index != (WORD) CB_ERR) {
19352 SendDlgItemMessage(hdlg, IDC_SYNCP,
19353 CB_GETLBTEXT, index,
19354 (LPARAM) setupdlg->attr[KEY_SYNCP].attr);
19356 strcpy(setupdlg->attr[KEY_STEPAPI].attr,
19357 (IsDlgButtonChecked(hdlg, IDC_STEPAPI) == BST_CHECKED) ?
19359 strcpy(setupdlg->attr[KEY_NOTXN].attr,
19360 (IsDlgButtonChecked(hdlg, IDC_NOTXN) == BST_CHECKED) ?
19362 strcpy(setupdlg->attr[KEY_SHORTNAM].attr,
19363 (IsDlgButtonChecked(hdlg, IDC_SHORTNAM) == BST_CHECKED) ?
19365 strcpy(setupdlg->attr[KEY_LONGNAM].attr,
19366 (IsDlgButtonChecked(hdlg, IDC_LONGNAM) == BST_CHECKED) ?
19368 strcpy(setupdlg->attr[KEY_NOCREAT].attr,
19369 (IsDlgButtonChecked(hdlg, IDC_NOCREAT) == BST_CHECKED) ?
19371 strcpy(setupdlg->attr[KEY_NOWCHAR].attr,
19372 (IsDlgButtonChecked(hdlg, IDC_NOWCHAR) == BST_CHECKED) ?
19374 strcpy(setupdlg->attr[KEY_FKSUPPORT].attr,
19375 (IsDlgButtonChecked(hdlg, IDC_FKSUPPORT) == BST_CHECKED) ?
19377 strcpy(setupdlg->attr[KEY_OEMCP].attr,
19378 (IsDlgButtonChecked(hdlg, IDC_OEMCP) == BST_CHECKED) ?
19380 strcpy(setupdlg->attr[KEY_BIGINT].attr,
19381 (IsDlgButtonChecked(hdlg, IDC_BIGINT) == BST_CHECKED) ?
19383 strcpy(setupdlg->attr[KEY_JDCONV].attr,
19384 (IsDlgButtonChecked(hdlg, IDC_JDCONV) == BST_CHECKED) ?
19386 SetDSNAttributes(hdlg, setupdlg);
19389 EndDialog(hdlg, wparam);
19407 ConfigDSN(HWND hwnd, WORD request, LPCSTR driver, LPCSTR attribs)
19410 SETUPDLG *setupdlg;
19412 setupdlg = (SETUPDLG *)
xmalloc(
sizeof (SETUPDLG));
19413 if (setupdlg == NULL) {
19416 memset(setupdlg, 0,
sizeof (SETUPDLG));
19418 ParseAttributes(attribs, setupdlg);
19420 if (setupdlg->attr[KEY_DSN].supplied) {
19421 strcpy(setupdlg->DSN, setupdlg->attr[KEY_DSN].attr);
19423 setupdlg->DSN[0] =
'\0';
19425 if (request == ODBC_REMOVE_DSN) {
19426 if (!setupdlg->attr[KEY_DSN].supplied) {
19429 success = SQLRemoveDSNFromIni(setupdlg->attr[KEY_DSN].attr);
19432 setupdlg->parent = hwnd;
19433 setupdlg->driver = driver;
19434 setupdlg->newDSN = request == ODBC_ADD_DSN;
19435 setupdlg->defDSN = strcasecmp(setupdlg->attr[KEY_DSN].attr,
19438 success = DialogBoxParam(hModule, MAKEINTRESOURCE(CONFIGDSN),
19439 hwnd, (DLGPROC) ConfigDlgProc,
19440 (LPARAM) setupdlg) == IDOK;
19441 }
else if (setupdlg->attr[KEY_DSN].supplied) {
19442 success = SetDSNAttributes(hwnd, setupdlg);
19460 static BOOL CALLBACK
19461 DriverConnectProc(HWND hdlg, WORD wmsg, WPARAM wparam, LPARAM lparam)
19463 SETUPDLG *setupdlg;
19467 case WM_INITDIALOG:
19469 SetWindowLongPtr(hdlg, DWLP_USER, lparam);
19471 SetWindowLong(hdlg, DWL_USER, lparam);
19473 setupdlg = (SETUPDLG *) lparam;
19474 SetDlgItemText(hdlg, IDC_DSNAME, setupdlg->attr[KEY_DSN].attr);
19475 SetDlgItemText(hdlg, IDC_DESC, setupdlg->attr[KEY_DESC].attr);
19476 SetDlgItemText(hdlg, IDC_DBNAME, setupdlg->attr[KEY_DBNAME].attr);
19477 SetDlgItemText(hdlg, IDC_TONAME, setupdlg->attr[KEY_BUSY].attr);
19478 SetDlgItemText(hdlg, IDC_LOADEXT, setupdlg->attr[KEY_LOADEXT].attr);
19479 SendDlgItemMessage(hdlg, IDC_DSNAME, EM_LIMITTEXT,
19480 (WPARAM) (MAXDSNAME - 1), (LPARAM) 0);
19481 SendDlgItemMessage(hdlg, IDC_DESC, EM_LIMITTEXT,
19482 (WPARAM) (MAXDESC - 1), (LPARAM) 0);
19483 SendDlgItemMessage(hdlg, IDC_DBNAME, EM_LIMITTEXT,
19484 (WPARAM) (MAXDBNAME - 1), (LPARAM) 0);
19485 SendDlgItemMessage(hdlg, IDC_TONAME, EM_LIMITTEXT,
19486 (WPARAM) (MAXTONAME - 1), (LPARAM) 0);
19487 SendDlgItemMessage(hdlg, IDC_LOADEXT, EM_LIMITTEXT,
19488 (WPARAM) (MAXPATHLEN*4 - 1), (LPARAM) 0);
19489 CheckDlgButton(hdlg, IDC_STEPAPI,
19490 getbool(setupdlg->attr[KEY_STEPAPI].attr) ?
19491 BST_CHECKED : BST_UNCHECKED);
19492 CheckDlgButton(hdlg, IDC_NOTXN,
19493 getbool(setupdlg->attr[KEY_NOTXN].attr) ?
19494 BST_CHECKED : BST_UNCHECKED);
19495 CheckDlgButton(hdlg, IDC_SHORTNAM,
19496 getbool(setupdlg->attr[KEY_SHORTNAM].attr) ?
19497 BST_CHECKED : BST_UNCHECKED);
19498 CheckDlgButton(hdlg, IDC_LONGNAM,
19499 getbool(setupdlg->attr[KEY_LONGNAM].attr) ?
19500 BST_CHECKED : BST_UNCHECKED);
19501 CheckDlgButton(hdlg, IDC_NOCREAT,
19502 getbool(setupdlg->attr[KEY_NOCREAT].attr) ?
19503 BST_CHECKED : BST_UNCHECKED);
19504 CheckDlgButton(hdlg, IDC_NOWCHAR,
19505 getbool(setupdlg->attr[KEY_NOWCHAR].attr) ?
19506 BST_CHECKED : BST_UNCHECKED);
19507 CheckDlgButton(hdlg, IDC_FKSUPPORT,
19508 getbool(setupdlg->attr[KEY_FKSUPPORT].attr) ?
19509 BST_CHECKED : BST_UNCHECKED);
19510 CheckDlgButton(hdlg, IDC_OEMCP,
19511 getbool(setupdlg->attr[KEY_OEMCP].attr) ?
19512 BST_CHECKED : BST_UNCHECKED);
19513 CheckDlgButton(hdlg, IDC_BIGINT,
19514 getbool(setupdlg->attr[KEY_BIGINT].attr) ?
19515 BST_CHECKED : BST_UNCHECKED);
19516 CheckDlgButton(hdlg, IDC_JDCONV,
19517 getbool(setupdlg->attr[KEY_JDCONV].attr) ?
19518 BST_CHECKED : BST_UNCHECKED);
19519 SendDlgItemMessage(hdlg, IDC_SYNCP,
19520 CB_LIMITTEXT, (WPARAM) 10, (LPARAM) 0);
19521 SendDlgItemMessage(hdlg, IDC_SYNCP,
19522 CB_ADDSTRING, 0, (LPARAM)
"NORMAL");
19523 SendDlgItemMessage(hdlg, IDC_SYNCP,
19524 CB_ADDSTRING, 0, (LPARAM)
"OFF");
19525 SendDlgItemMessage(hdlg, IDC_SYNCP,
19526 CB_ADDSTRING, 0, (LPARAM)
"FULL");
19527 SendDlgItemMessage(hdlg, IDC_SYNCP,
19528 CB_SELECTSTRING, (WORD) -1,
19529 (LPARAM) setupdlg->attr[KEY_SYNCP].attr);
19530 if (setupdlg->defDSN) {
19531 EnableWindow(GetDlgItem(hdlg, IDC_DSNAME), FALSE);
19532 EnableWindow(GetDlgItem(hdlg, IDC_DSNAMETEXT), FALSE);
19536 switch (GET_WM_COMMAND_ID(wparam, lparam)) {
19542 setupdlg = (SETUPDLG *) GetWindowLongPtr(hdlg, DWLP_USER);
19544 setupdlg = (SETUPDLG *) GetWindowLong(hdlg, DWL_USER);
19546 GetDlgItemText(hdlg, IDC_DSNAME,
19547 setupdlg->attr[KEY_DSN].attr,
19548 sizeof (setupdlg->attr[KEY_DSN].attr));
19549 GetDlgItemText(hdlg, IDC_DBNAME,
19550 setupdlg->attr[KEY_DBNAME].attr,
19551 sizeof (setupdlg->attr[KEY_DBNAME].attr));
19552 GetDlgItemText(hdlg, IDC_TONAME,
19553 setupdlg->attr[KEY_BUSY].attr,
19554 sizeof (setupdlg->attr[KEY_BUSY].attr));
19555 GetDlgItemText(hdlg, IDC_LOADEXT,
19556 setupdlg->attr[KEY_LOADEXT].attr,
19557 sizeof (setupdlg->attr[KEY_LOADEXT].attr));
19558 index = SendDlgItemMessage(hdlg, IDC_SYNCP,
19559 CB_GETCURSEL, (WPARAM) 0, (LPARAM) 0);
19560 if (index != (WORD) CB_ERR) {
19561 SendDlgItemMessage(hdlg, IDC_SYNCP,
19562 CB_GETLBTEXT, index,
19563 (LPARAM) setupdlg->attr[KEY_SYNCP].attr);
19565 strcpy(setupdlg->attr[KEY_STEPAPI].attr,
19566 (IsDlgButtonChecked(hdlg, IDC_STEPAPI) == BST_CHECKED) ?
19568 strcpy(setupdlg->attr[KEY_NOTXN].attr,
19569 (IsDlgButtonChecked(hdlg, IDC_NOTXN) == BST_CHECKED) ?
19571 strcpy(setupdlg->attr[KEY_SHORTNAM].attr,
19572 (IsDlgButtonChecked(hdlg, IDC_SHORTNAM) == BST_CHECKED) ?
19574 strcpy(setupdlg->attr[KEY_LONGNAM].attr,
19575 (IsDlgButtonChecked(hdlg, IDC_LONGNAM) == BST_CHECKED) ?
19577 strcpy(setupdlg->attr[KEY_NOCREAT].attr,
19578 (IsDlgButtonChecked(hdlg, IDC_NOCREAT) == BST_CHECKED) ?
19580 strcpy(setupdlg->attr[KEY_NOWCHAR].attr,
19581 (IsDlgButtonChecked(hdlg, IDC_NOWCHAR) == BST_CHECKED) ?
19583 strcpy(setupdlg->attr[KEY_FKSUPPORT].attr,
19584 (IsDlgButtonChecked(hdlg, IDC_FKSUPPORT) == BST_CHECKED) ?
19586 strcpy(setupdlg->attr[KEY_OEMCP].attr,
19587 (IsDlgButtonChecked(hdlg, IDC_OEMCP) == BST_CHECKED) ?
19589 strcpy(setupdlg->attr[KEY_BIGINT].attr,
19590 (IsDlgButtonChecked(hdlg, IDC_BIGINT) == BST_CHECKED) ?
19592 strcpy(setupdlg->attr[KEY_JDCONV].attr,
19593 (IsDlgButtonChecked(hdlg, IDC_JDCONV) == BST_CHECKED) ?
19597 EndDialog(hdlg, GET_WM_COMMAND_ID(wparam, lparam) == IDOK);
19619 SQLCHAR *connIn, SQLSMALLINT connInLen,
19620 SQLCHAR *connOut, SQLSMALLINT connOutMax,
19621 SQLSMALLINT *connOutLen, SQLUSMALLINT drvcompl)
19623 BOOL maybeprompt, prompt = FALSE, defaultdsn = FALSE;
19625 SETUPDLG *setupdlg;
19627 char *dsn = NULL, *driver = NULL, *dbname = NULL;
19629 if (dbc == SQL_NULL_HDBC) {
19630 return SQL_INVALID_HANDLE;
19634 setstatd(d, -1,
"connection already established",
"08002");
19637 setupdlg = (SETUPDLG *)
xmalloc(
sizeof (SETUPDLG));
19638 if (setupdlg == NULL) {
19641 memset(setupdlg, 0,
sizeof (SETUPDLG));
19642 maybeprompt = drvcompl == SQL_DRIVER_COMPLETE ||
19643 drvcompl == SQL_DRIVER_COMPLETE_REQUIRED;
19644 if (connIn == NULL || !connInLen ||
19645 (connInLen == SQL_NTS && !connIn[0])) {
19648 ParseAttributes((LPCSTR) connIn, setupdlg);
19649 if (!setupdlg->attr[KEY_DSN].attr[0] &&
19650 drvcompl == SQL_DRIVER_COMPLETE_REQUIRED) {
19651 strcpy(setupdlg->attr[KEY_DSN].attr,
"DEFAULT");
19654 GetAttributes(setupdlg);
19655 if (drvcompl == SQL_DRIVER_PROMPT ||
19657 !setupdlg->attr[KEY_DBNAME].attr[0])) {
19665 setupdlg->defDSN = setupdlg->attr[KEY_DRIVER].attr[0] !=
'\0';
19666 dlgret = DialogBoxParam(hModule, MAKEINTRESOURCE(DRIVERCONNECT),
19667 hwnd, (DLGPROC) DriverConnectProc,
19668 (LPARAM) setupdlg);
19670 if (!dlgret || dlgret == -1) {
19672 return SQL_NO_DATA;
19675 dsn = setupdlg->attr[KEY_DSN].attr;
19676 driver = setupdlg->attr[KEY_DRIVER].attr;
19677 dbname = setupdlg->attr[KEY_DBNAME].attr;
19678 if (connOut || connOutLen) {
19679 char buf[SQL_MAX_MESSAGE_LENGTH * 4];
19681 char dsn_0 = (dsn && !defaultdsn) ? dsn[0] :
'\0';
19682 char drv_0 = driver ? driver[0] :
'\0';
19685 count = snprintf(buf,
sizeof (buf),
19686 "%s%s%s%s%s%sDatabase=%s;StepAPI=%s;" 19687 "SyncPragma=%s;NoTXN=%s;Timeout=%s;" 19688 "ShortNames=%s;LongNames=%s;" 19689 "NoCreat=%s;NoWCHAR=%s;" 19690 "FKSupport=%s;JournalMode=%s;OEMCP=%s;LoadExt=%s;" 19691 "BigInt=%s;JDConv=%s;PWD=%s",
19692 dsn_0 ?
"DSN=" :
"",
19695 drv_0 ?
"Driver=" :
"",
19696 drv_0 ? driver :
"",
19698 dbname ? dbname :
"",
19699 setupdlg->attr[KEY_STEPAPI].attr,
19700 setupdlg->attr[KEY_SYNCP].attr,
19701 setupdlg->attr[KEY_NOTXN].attr,
19702 setupdlg->attr[KEY_BUSY].attr,
19703 setupdlg->attr[KEY_SHORTNAM].attr,
19704 setupdlg->attr[KEY_LONGNAM].attr,
19705 setupdlg->attr[KEY_NOCREAT].attr,
19706 setupdlg->attr[KEY_NOWCHAR].attr,
19707 setupdlg->attr[KEY_FKSUPPORT].attr,
19708 setupdlg->attr[KEY_JMODE].attr,
19709 setupdlg->attr[KEY_OEMCP].attr,
19710 setupdlg->attr[KEY_LOADEXT].attr,
19711 setupdlg->attr[KEY_BIGINT].attr,
19712 setupdlg->attr[KEY_JDCONV].attr,
19713 setupdlg->attr[KEY_PASSWD].attr);
19715 buf[
sizeof (buf) - 1] =
'\0';
19717 len =
min(connOutMax - 1, strlen(buf));
19719 strncpy((
char *) connOut, buf, len);
19720 connOut[len] =
'\0';
19727 char tracef[SQL_MAX_MESSAGE_LENGTH];
19730 SQLGetPrivateProfileString(setupdlg->attr[KEY_DSN].attr,
19731 "tracefile",
"", tracef,
19733 if (tracef[0] !=
'\0') {
19734 d->
trace = fopen(tracef,
"a");
19745 d->
pwdLen = strlen(setupdlg->attr[KEY_PASSWD].attr);
19746 d->
pwd = (d->
pwdLen > 0) ? setupdlg->attr[KEY_PASSWD].attr : NULL;
19747 ret =
dbopen(d, dbname ? dbname :
"", 0,
19749 setupdlg->attr[KEY_STEPAPI].attr,
19750 setupdlg->attr[KEY_SYNCP].attr,
19751 setupdlg->attr[KEY_NOTXN].attr,
19752 setupdlg->attr[KEY_JMODE].attr,
19753 setupdlg->attr[KEY_BUSY].attr);
19754 if (ret != SQL_SUCCESS) {
19755 if (maybeprompt && !prompt) {
19760 memset(setupdlg->attr[KEY_PASSWD].attr, 0,
19761 sizeof (setupdlg->attr[KEY_PASSWD].attr));
19762 if (ret == SQL_SUCCESS) {
19763 dbloadext(d, setupdlg->attr[KEY_LOADEXT].attr);
19787 SQLDriverConnect(SQLHDBC dbc, SQLHWND hwnd,
19788 SQLCHAR *connIn, SQLSMALLINT connInLen,
19789 SQLCHAR *connOut, SQLSMALLINT connOutMax,
19790 SQLSMALLINT *connOutLen, SQLUSMALLINT drvcompl)
19796 connOut, connOutMax, connOutLen, drvcompl);
19817 SQLDriverConnectW(SQLHDBC dbc, SQLHWND hwnd,
19818 SQLWCHAR *connIn, SQLSMALLINT connInLen,
19819 SQLWCHAR *connOut, SQLSMALLINT connOutMax,
19820 SQLSMALLINT *connOutLen, SQLUSMALLINT drvcompl)
19824 SQLSMALLINT len = 0;
19828 #if defined(_WIN32) || defined(_WIN64) 19829 if (connInLen == SQL_NTS) {
19832 ci = uc_to_wmb(connIn, connInLen);
19839 setstatd(d, -1,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
19845 (SQLCHAR *) connOut, connOutMax, &len, drvcompl);
19848 if (ret == SQL_SUCCESS) {
19849 SQLWCHAR *co = NULL;
19853 #if defined(_WIN32) || defined(_WIN64) 19854 co = wmb_to_uc((
char *) connOut, len);
19859 uc_strncpy(connOut, co, connOutMax /
sizeof (SQLWCHAR));
19860 len =
min(connOutMax /
sizeof (SQLWCHAR),
uc_strlen(co));
19881 #if defined(_WIN32) || defined(_WIN64) 19892 LibMain(HANDLE hinst, DWORD reason, LPVOID reserved)
19897 case DLL_PROCESS_ATTACH:
19898 if (!initialized++) {
19905 #ifdef SQLITE_DYNLOAD 19908 #ifdef SQLITE_HAS_CODEC 19909 sqlite3_activate_see(SQLITE_ACTIVATION_KEY);
19912 #if defined(ENABLE_NVFS) && (ENABLE_NVFS) 19916 case DLL_THREAD_ATTACH:
19918 case DLL_PROCESS_DETACH:
19919 if (--initialized <= 0) {
19920 #ifdef SQLITE_DYNLOAD 19925 case DLL_THREAD_DETACH:
19942 DllMain(HANDLE hinst, DWORD reason, LPVOID reserved)
19944 return LibMain(hinst, reason, reserved);
19947 #ifndef WITHOUT_INSTALLER 19956 InUnError(
char *name)
19961 WORD errlen, errmax =
sizeof (errmsg) - 1;
19967 sqlret = SQLInstallerError(err, &code, errmsg, errmax, &errlen);
19968 if (SQL_SUCCEEDED(sqlret)) {
19969 MessageBox(NULL, errmsg, name,
19970 MB_ICONSTOP | MB_OK | MB_TASKMODAL | MB_SETFOREGROUND);
19974 }
while (sqlret != SQL_NO_DATA);
19985 InUn(
int remove,
char *cmdline)
19987 #ifdef SQLITE_HAS_CODEC 19988 static char *drivername =
"SQLite3 ODBC Driver (SEE)";
19989 static char *dsname =
"SQLite3 SEE Datasource";
19991 static char *drivername =
"SQLite3 ODBC Driver";
19992 static char *dsname =
"SQLite3 Datasource";
19995 char dllbuf[301], path[301], driver[300], attr[300], inst[400];
19996 WORD pathmax =
sizeof (path) - 1, pathlen;
19997 DWORD usecnt, mincnt;
20001 GetModuleFileName(hModule, dllbuf,
sizeof (dllbuf));
20002 p = strrchr(dllbuf,
'\\');
20003 dllname = p ? (p + 1) : dllbuf;
20004 quiet = cmdline && strstr(cmdline,
"quiet");
20005 if (SQLInstallDriverManager(path, pathmax, &pathlen)) {
20006 sprintf(driver,
"%s;Driver=%s;Setup=%s;",
20007 drivername, dllname, dllname);
20017 SQLInstallDriverEx(driver, NULL, path, pathmax, NULL,
20018 ODBC_INSTALL_INQUIRY, &usecnt);
20019 pathlen = strlen(path);
20020 while (pathlen > 0 && path[pathlen - 1] ==
'\\') {
20022 path[pathlen] =
'\0';
20024 sprintf(driver,
"%s;Driver=%s\\%s;Setup=%s\\%s;",
20025 drivername, path, dllname, path, dllname);
20033 sprintf(inst,
"%s\\%s", path, dllname);
20034 if (!
remove && usecnt > 0) {
20036 if (GetFileAttributesA(dllbuf) != INVALID_FILE_ATTRIBUTES &&
20037 CopyFile(dllbuf, inst, 0)) {
20041 sprintf(buf,
"%s replaced.", drivername);
20042 MessageBox(NULL, buf,
"Info",
20043 MB_ICONINFORMATION | MB_OK | MB_TASKMODAL |
20049 mincnt =
remove ? 1 : 0;
20050 while (usecnt != mincnt) {
20051 if (!SQLRemoveDriver(driver, TRUE, &usecnt)) {
20056 if (usecnt && !SQLRemoveDriver(driver, TRUE, &usecnt)) {
20057 InUnError(
"SQLRemoveDriver");
20065 sprintf(buf,
"%s uninstalled.", drivername);
20066 MessageBox(NULL, buf,
"Info",
20067 MB_ICONINFORMATION |MB_OK | MB_TASKMODAL |
20071 sprintf(attr,
"DSN=%s;Database=;", dsname);
20079 SQLConfigDataSource(NULL, ODBC_REMOVE_SYS_DSN, drivername, attr);
20082 if (GetFileAttributesA(dllbuf) == INVALID_FILE_ATTRIBUTES) {
20085 if (strcasecmp(dllbuf, inst) != 0 && !CopyFile(dllbuf, inst, 0)) {
20088 sprintf(buf,
"Copy %s to %s failed.", dllbuf, inst);
20089 MessageBox(NULL, buf,
"CopyFile",
20090 MB_ICONSTOP |MB_OK | MB_TASKMODAL | MB_SETFOREGROUND);
20093 if (!SQLInstallDriverEx(driver, path, path, pathmax, &pathlen,
20094 ODBC_INSTALL_COMPLETE, &usecnt)) {
20095 InUnError(
"SQLInstallDriverEx");
20098 sprintf(attr,
"DSN=%s;Database=;", dsname);
20106 SQLConfigDataSource(NULL, ODBC_REMOVE_SYS_DSN, drivername, attr);
20107 if (!SQLConfigDataSource(NULL, ODBC_ADD_SYS_DSN, drivername, attr)) {
20108 InUnError(
"SQLConfigDataSource");
20114 sprintf(buf,
"%s installed.", drivername);
20115 MessageBox(NULL, buf,
"Info",
20116 MB_ICONINFORMATION | MB_OK | MB_TASKMODAL |
20120 InUnError(
"SQLInstallDriverManager");
20135 install(HWND hwnd, HINSTANCE hinst, LPSTR lpszCmdLine,
int nCmdShow)
20137 InUn(0, lpszCmdLine);
20149 uninstall(HWND hwnd, HINSTANCE hinst, LPSTR lpszCmdLine,
int nCmdShow)
20151 InUn(1, lpszCmdLine);
20156 #ifndef WITHOUT_SHELL 20167 setargv(
int *argcp,
char ***argvp,
char *cmdline,
char *argv0)
20169 char *p, *arg, *argspace, **argv;
20170 int argc, size, inquote, copy, slashes;
20172 size = 2 + (argv0 ? 1 : 0);
20173 for (p = cmdline; *p !=
'\0'; p++) {
20184 argspace = malloc(size *
sizeof (
char *) + strlen(cmdline) + 1);
20185 argv = (
char **) argspace;
20186 argspace += size *
sizeof (
char *);
20190 argv[argc++] = argv0;
20193 for (; argc < size; argc++) {
20194 argv[argc] = arg = argspace;
20205 while (*p ==
'\\') {
20210 if ((slashes & 1) == 0) {
20212 if (inquote && p[1] ==
'"') {
20216 inquote = !inquote;
20226 if (*p ==
'\0' || (!inquote &&
ISSPACE(*p))) {
20236 argspace = arg + 1;
20252 shell(HWND hwnd, HINSTANCE hinst, LPSTR lpszCmdLine,
int nCmdShow)
20254 int argc, needcon = 0;
20256 extern int sqlite3_main(
int,
char **);
20257 static const char *name =
"SQLite3 Shell";
20258 DWORD ftype0, ftype1, ftype2;
20260 ftype0 = GetFileType(GetStdHandle(STD_INPUT_HANDLE));
20261 ftype1 = GetFileType(GetStdHandle(STD_OUTPUT_HANDLE));
20262 ftype2 = GetFileType(GetStdHandle(STD_ERROR_HANDLE));
20263 if (ftype0 != FILE_TYPE_DISK && ftype0 != FILE_TYPE_CHAR &&
20264 ftype0 != FILE_TYPE_PIPE) {
20267 ftype0 = FILE_TYPE_UNKNOWN;
20269 if (ftype1 != FILE_TYPE_DISK && ftype1 != FILE_TYPE_CHAR &&
20270 ftype1 != FILE_TYPE_PIPE) {
20273 ftype1 = FILE_TYPE_UNKNOWN;
20275 if (ftype2 != FILE_TYPE_DISK && ftype2 != FILE_TYPE_CHAR &&
20276 ftype2 != FILE_TYPE_PIPE) {
20279 ftype2 = FILE_TYPE_UNKNOWN;
20283 SetConsoleTitle(name);
20285 if (ftype0 == FILE_TYPE_UNKNOWN) {
20286 freopen(
"CONIN$",
"r", stdin);
20288 if (ftype1 == FILE_TYPE_UNKNOWN) {
20289 freopen(
"CONOUT$",
"w", stdout);
20291 if (ftype2 == FILE_TYPE_UNKNOWN) {
20292 freopen(
"CONOUT$",
"w", stderr);
20294 setargv(&argc, &argv, lpszCmdLine, (
char *) name);
20295 #if defined(ENABLE_NVFS) && (ENABLE_NVFS) 20298 sqlite3_main(argc, argv);
20305 #if defined(HAVE_ODBCINSTEXT_H) && (HAVE_ODBCINSTEXT_H) 20312 #include <odbcinstext.h> 20315 ODBCINSTGetProperties(HODBCINSTPROPERTY prop)
20317 static const char *instYN[] = {
"No",
"Yes", NULL };
20318 static const char *syncPragma[] = {
"NORMAL",
"OFF",
"FULL", NULL };
20319 static const char *jmPragma[] = {
20320 "DELETE",
"PERSIST",
"OFF",
"TRUNCATE",
"MEMORY",
"WAL", NULL
20323 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20324 prop = prop->pNext;
20325 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20326 prop->nPromptType = ODBCINST_PROMPTTYPE_FILENAME;
20327 strncpy(prop->szName,
"Database", INI_MAX_PROPERTY_NAME);
20328 strncpy(prop->szValue,
"", INI_MAX_PROPERTY_VALUE);
20329 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20330 prop = prop->pNext;
20331 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20332 prop->nPromptType = ODBCINST_PROMPTTYPE_TEXTEDIT;
20333 strncpy(prop->szName,
"Timeout", INI_MAX_PROPERTY_NAME);
20334 strncpy(prop->szValue,
"100000", INI_MAX_PROPERTY_VALUE);
20335 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20336 prop = prop->pNext;
20337 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20338 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20339 prop->aPromptData = malloc(
sizeof (instYN));
20340 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20341 strncpy(prop->szName,
"StepAPI", INI_MAX_PROPERTY_NAME);
20342 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20343 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20344 prop = prop->pNext;
20345 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20346 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20347 prop->aPromptData = malloc(
sizeof (instYN));
20348 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20349 strncpy(prop->szName,
"ShortNames", INI_MAX_PROPERTY_NAME);
20350 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20351 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20352 prop = prop->pNext;
20353 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20354 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20355 prop->aPromptData = malloc(
sizeof (instYN));
20356 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20357 strncpy(prop->szName,
"LongNames", INI_MAX_PROPERTY_NAME);
20358 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20359 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20360 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20361 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20362 prop->aPromptData = malloc(
sizeof (instYN));
20363 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20364 strncpy(prop->szName,
"NoCreat", INI_MAX_PROPERTY_NAME);
20365 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20367 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20368 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20369 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20370 prop->aPromptData = malloc(
sizeof (instYN));
20371 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20372 strncpy(prop->szName,
"NoWCHAR", INI_MAX_PROPERTY_NAME);
20373 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20375 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20376 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20377 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20378 prop->aPromptData = malloc(
sizeof (instYN));
20379 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20380 strncpy(prop->szName,
"FKSupport", INI_MAX_PROPERTY_NAME);
20381 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20382 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20383 prop = prop->pNext;
20384 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20385 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20386 prop->aPromptData = malloc(
sizeof (syncPragma));
20387 memcpy(prop->aPromptData, syncPragma, sizeof (syncPragma));
20388 strncpy(prop->szName,
"SyncPragma", INI_MAX_PROPERTY_NAME);
20389 strncpy(prop->szValue,
"NORMAL", INI_MAX_PROPERTY_VALUE);
20390 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20391 prop = prop->pNext;
20392 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20393 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20394 prop->aPromptData = malloc(
sizeof (jmPragma));
20395 memcpy(prop->aPromptData, jmPragma, sizeof (jmPragma));
20396 strncpy(prop->szName,
"JournalMode", INI_MAX_PROPERTY_NAME);
20397 strncpy(prop->szValue,
"DELETE", INI_MAX_PROPERTY_VALUE);
20398 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20399 prop = prop->pNext;
20400 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20401 prop->nPromptType = ODBCINST_PROMPTTYPE_TEXTEDIT;
20402 strncpy(prop->szName,
"LoadExt", INI_MAX_PROPERTY_NAME);
20403 strncpy(prop->szValue,
"", INI_MAX_PROPERTY_VALUE);
20404 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20405 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20406 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20407 prop->aPromptData = malloc(
sizeof (instYN));
20408 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20409 strncpy(prop->szName,
"BigInt", INI_MAX_PROPERTY_NAME);
20410 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20416 #ifdef SQLITE_DYNLOAD 20430 return SQLITE_ERROR;
20439 static sqlite_int64
20457 static const char *
20466 return SQLITE_NULL;
20469 #define DLS_ENT(name, func) \ 20470 { "sqlite3_" #name, offsetof(struct dl_sqlite3_funcs, name), \ 20473 #define DLS_ENT3(name, off, func) \ 20474 { "sqlite3_" #name, offsetof(struct dl_sqlite3_funcs, off), \ 20477 #define DLS_END { NULL, 0, NULL } 20483 } dls_nametab[] = {
20484 DLS_ENT(activate_see, dls_void),
20485 DLS_ENT(bind_blob, dls_error),
20486 DLS_ENT(bind_double, dls_error),
20487 DLS_ENT(bind_int, dls_error),
20488 DLS_ENT(bind_int64, dls_error),
20489 DLS_ENT(bind_null, dls_error),
20490 DLS_ENT(bind_parameter_count, dls_0),
20491 DLS_ENT(bind_text, dls_error),
20493 DLS_ENT(changes, dls_0),
20494 DLS_ENT(close, dls_error),
20495 DLS_ENT(column_blob, dls_null),
20496 DLS_ENT(column_bytes, dls_0),
20497 DLS_ENT(column_count, dls_0),
20498 DLS_ENT(column_database_name, dls_empty),
20499 DLS_ENT(column_decltype, dls_empty),
20500 DLS_ENT(column_double, dls_00),
20501 DLS_ENT(column_name, dls_empty),
20502 DLS_ENT(column_origin_name, dls_null),
20503 DLS_ENT(column_table_name, dls_null),
20504 DLS_ENT(column_text, dls_null),
20505 DLS_ENT(column_type, dls_snull),
20506 DLS_ENT(create_function, dls_error),
20507 DLS_ENT(enable_load_extension, dls_error),
20508 DLS_ENT(errcode, dls_error),
20509 DLS_ENT(errmsg, dls_empty),
20510 DLS_ENT(exec, dls_error),
20511 DLS_ENT(finalize, dls_error),
20512 DLS_ENT(free, free),
20513 DLS_ENT(free_table, dls_void),
20514 DLS_ENT(get_table, dls_error),
20515 DLS_ENT(interrupt, dls_void),
20516 DLS_ENT(key, dls_error),
20517 DLS_ENT(last_insert_rowid, dls_0LL),
20518 DLS_ENT(libversion, dls_empty),
20519 DLS_ENT(load_extension, dls_error),
20520 DLS_ENT(malloc, malloc),
20521 DLS_ENT(mprintf, dls_null),
20522 DLS_ENT(open, dls_error),
20523 DLS_ENT(open16, dls_error),
20524 DLS_ENT(open_v2, dls_error),
20525 DLS_ENT(prepare, dls_error),
20526 DLS_ENT(prepare_v2, dls_error),
20527 DLS_ENT(profile, dls_null),
20528 DLS_ENT(realloc, realloc),
20529 DLS_ENT(rekey, dls_error),
20530 DLS_ENT(reset, dls_error),
20531 DLS_ENT(result_blob, dls_void),
20532 DLS_ENT(result_error, dls_void),
20533 DLS_ENT(result_int, dls_void),
20534 DLS_ENT(result_null, dls_void),
20535 DLS_ENT(step, dls_error),
20536 #if defined(_WIN32) || defined(_WIN64) 20537 DLS_ENT3(strnicmp, xstrnicmp, _strnicmp),
20539 DLS_ENT3(strnicmp, xstrnicmp, strncasecmp),
20541 DLS_ENT(table_column_metadata, dls_error),
20542 DLS_ENT(trace, dls_null),
20543 DLS_ENT(user_data, dls_null),
20544 DLS_ENT(value_blob, dls_null),
20545 DLS_ENT(value_bytes, dls_0),
20546 DLS_ENT(value_text, dls_empty),
20547 DLS_ENT(value_type, dls_snull),
20551 #if defined(_WIN32) || defined(_WIN64) 20553 static HMODULE sqlite3_dll = 0;
20559 static const char *dll_names[] = {
20560 "System.Data.SQLite.dll",
20566 while (dll_names[i]) {
20567 sqlite3_dll = LoadLibrary(dll_names[i]);
20574 while (dls_nametab[i].name) {
20575 void *func = 0, **loc;
20578 func = (
void *) GetProcAddress(sqlite3_dll, dls_nametab[i].name);
20581 func = dls_nametab[i].func;
20583 loc = (
void **) ((
char *) &dls_funcs + dls_nametab[i].offset);
20587 if (!sqlite3_dll) {
20588 char buf[MAXPATHLEN], msg[MAXPATHLEN];
20590 LoadString(hModule, IDS_DRVTITLE, buf,
sizeof (buf));
20591 LoadString(hModule, IDS_DLLERR, msg,
sizeof (msg));
20592 MessageBox(NULL, msg, buf,
20593 MB_ICONEXCLAMATION | MB_OK | MB_TASKMODAL |
20602 FreeLibrary(sqlite3_dll);
20611 static void *libsqlite3_so = 0;
20618 libsqlite3_so = dlopen(
"libsqlite3.so.0", RTLD_NOW | RTLD_GLOBAL);
20620 while (dls_nametab[i].name) {
20621 void *func = 0, **loc;
20623 if (libsqlite3_so) {
20624 func = dlsym(libsqlite3_so, dls_nametab[i].name);
20627 func = dls_nametab[i].func;
20629 loc = (
void **) ((
char *) &dls_funcs + dls_nametab[i].offset);
20633 if (!libsqlite3_so) {
20634 const char errmsg[] =
"SQLite3 shared library not found.\n";
20636 write(2, errmsg,
sizeof (errmsg) - 1);
20643 if (libsqlite3_so) {
20644 dlclose(libsqlite3_so);
sqlite3_stmt * s3stmt
SQLite statement handle or NULL.
SQLULEN paramset_size
SQL_ATTR_PARAMSET_SIZE.
sqlite_int64 s3lival
SQLite3 64bit integer value.
int busyint
Interrupt busy handler from SQLCancel()
static SQLRETURN setupparbuf(STMT *s, BINDPARM *p)
Setup parameter buffer for deferred parameter.
void * parbuf
Buffer for SQL_LEN_DATA_AT_EXEC etc.
SQLRETURN SQL_API SQLSetConnectAttrW(SQLHDBC dbc, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER len)
Set connect attribute of HDBC (UNICODE version).
Internal dynamic string buffer.
SQLRETURN SQL_API SQLSetDescRec(SQLHDESC handle, SQLSMALLINT recno, SQLSMALLINT type, SQLSMALLINT subtype, SQLLEN len, SQLSMALLINT prec, SQLSMALLINT scale, SQLPOINTER data, SQLLEN *strlen, SQLLEN *indicator)
Function not implemented.
SQLRETURN SQL_API SQLRowCount(SQLHSTMT stmt, SQLLEN *nrows)
Return number of affected rows of HSTMT.
static SQLRETURN setposbind(STMT *s, sqlite3_stmt *stmt, int i, int si, int rsi)
Internal handler to setup parameters for positional updates from bound user buffers.
static SQLRETURN nomem(STMT *s)
Report S1000 (out of memory) SQL error given STMT.
static const char lower_chars[]
static int findcol(char **cols, int ncols, char *name)
Find column given name in string array.
int longnames
Don't shorten column names.
int nocreat
Don't auto create database file.
static void freerows(char **rowp)
Free counted array of char pointers.
SQLRETURN SQL_API SQLDisconnect(SQLHDBC dbc)
Disconnect given HDBC.
static void setstatd(DBC *d, int naterr, char *msg, char *st,...)
Set error message and SQL state on DBC.
struct dbc * dbcs
Pointer to first DBC.
void * param0
Parameter buffer, initial value.
int * ov3
True for SQL_OV_ODBC3.
static SQLRETURN freeparams(STMT *s)
Clear out parameter bindings, if any.
int dobigint
Force SQL_BIGINT for INTEGER columns.
SQLCHAR * query
Current query, raw string.
sqlite3 * sqlite
SQLITE database handle.
static SQLRETURN drvgettypeinfo(SQLHSTMT stmt, SQLSMALLINT sqltype)
Internal return data type information.
SQLRETURN SQL_API SQLConnectW(SQLHDBC dbc, SQLWCHAR *dsn, SQLSMALLINT dsnLen, SQLWCHAR *uid, SQLSMALLINT uidLen, SQLWCHAR *pwd, SQLSMALLINT pwdLen)
Connect to SQLite database.
int guessed_types
Flag for drvprepare()/drvexecute()
SQLRETURN SQL_API SQLForeignKeysW(SQLHSTMT stmt, SQLWCHAR *PKcatalog, SQLSMALLINT PKcatalogLen, SQLWCHAR *PKschema, SQLSMALLINT PKschemaLen, SQLWCHAR *PKtable, SQLSMALLINT PKtableLen, SQLWCHAR *FKcatalog, SQLSMALLINT FKcatalogLen, SQLWCHAR *FKschema, SQLSMALLINT FKschemaLen, SQLWCHAR *FKtable, SQLSMALLINT FKtableLen)
Retrieve information about primary/foreign keys (UNICODE version).
static SQLRETURN drvfetchscroll(SQLHSTMT stmt, SQLSMALLINT orient, SQLINTEGER offset)
Internal fetch function for SQLFetchScroll() and SQLExtendedFetch().
SQLRETURN SQL_API SQLParamData(SQLHSTMT stmt, SQLPOINTER *pind)
Retrieve next parameter for sending data to executing query.
static SQLRETURN drvfreeconnect(SQLHDBC dbc)
Internal free connection (HDBC).
SQLCHAR logmsg[1024]
Message for SQLError()
static dstr * dsappend(dstr *dsp, const char *str)
Append string to dynamic string.
static SQLRETURN drvgetcursorname(SQLHSTMT stmt, SQLCHAR *cursor, SQLSMALLINT buflen, SQLSMALLINT *lenp)
Internal function to get cursor name of STMT.
char ** rows
2-dim array, result set
int step_enable
True for sqlite_compile/step/finalize.
SQLRETURN SQL_API SQLColumnsW(SQLHSTMT stmt, SQLWCHAR *cat, SQLSMALLINT catLen, SQLWCHAR *schema, SQLSMALLINT schemaLen, SQLWCHAR *table, SQLSMALLINT tableLen, SQLWCHAR *col, SQLSMALLINT colLen)
Retrieve column information on table (UNICODE version).
static int drvgettable_row(TBLRES *t, int ncol, int rc)
static void blob_import(sqlite3_context *ctx, int nargs, sqlite3_value **args)
SQLite function to import a BLOB from a file.
SQLRETURN SQL_API SQLFetchScroll(SQLHSTMT stmt, SQLSMALLINT orient, SQLLEN offset)
Fetch result row with scrolling.
static void s3bind(DBC *d, sqlite3_stmt *stmt, int nparams, BINDPARM *p)
int ispk
Flag for primary key (> 0)
static SQLRETURN dofetchbind(STMT *s, int rsi)
Internal: fetch and bind from statement's current row.
PTRDIFF_T ndata
index into result array
SQLRETURN SQL_API SQLSetConnectOptionW(SQLHDBC dbc, SQLUSMALLINT opt, SQLULEN param)
Set option on HDBC (UNICODE version).
int intrans
True when transaction started.
int shortnames
Always use short column names.
static SQLRETURN drvgetconnectoption(SQLHDBC dbc, SQLUSMALLINT opt, SQLPOINTER param)
Internal get connect option of HDBC.
static SQLRETURN drvallocconnect(SQLHENV env, SQLHDBC *dbc)
Internal allocate HDBC.
SQLULEN * parm_bind_offs
SQL_ATTR_PARAM_BIND_OFFSET_PTR.
void * s3val
SQLite3 value buffer.
static int str2time(int jdconv, char *str, TIME_STRUCT *ts)
Convert string to ODBC TIME_STRUCT.
Internal structure for bound column (SQLBindCol).
static COL pkeySpec2[]
Columns for result set of SQLPrimaryKeys().
SQLRETURN SQL_API SQLGetInfoW(SQLHDBC dbc, SQLUSMALLINT type, SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen)
Return information about what this ODBC driver supports.
static COL fkeySpec2[]
Columns for result set of SQLForeignKeys().
static void freedyncols(STMT *s)
Free dynamically allocated column descriptions of STMT.
int nrows
Number of result rows.
static int mapsqltype(const char *typename, int *nosign, int ov3, int nowchar, int dobigint)
Map SQL field type from string to ODBC integer type code.
SQLRETURN SQL_API SQLCancel(SQLHSTMT stmt)
Cancel HSTMT closing cursor.
static void getmd(const char *typename, int sqltype, int *mp, int *dp)
Get maximum display size and number of digits after decimal point from field type specification...
SQLRETURN SQL_API SQLAllocEnv(SQLHENV *env)
Allocate HENV.
Driver internal structure for database connection (HDBC).
SQLRETURN SQL_API SQLFreeConnect(SQLHDBC dbc)
Free connection (HDBC).
SQLRETURN SQL_API SQLExtendedFetch(SQLHSTMT stmt, SQLUSMALLINT orient, SQLROWOFFSET offset, SQLROWSETSIZE *rowcount, SQLUSMALLINT *rowstatus)
Fetch result row with scrolling and row status.
SQLULEN row_count0
Row count.
int s3ival
SQLite3 integer value.
struct stmt * cur_s3stmt
Current STMT executing sqlite statement.
int need
True when SQL_LEN_DATA_AT_EXEC.
static const char digit_chars[]
static SQLRETURN drvgetdiagfield(SQLSMALLINT htype, SQLHANDLE handle, SQLSMALLINT recno, SQLSMALLINT id, SQLPOINTER info, SQLSMALLINT buflen, SQLSMALLINT *stringlen)
Get error record given handle (HDBC or HSTMT).
SQLULEN parm_bind_type
SQL_ATTR_PARAM_BIND_TYPE.
int * ov3
True for SQL_OV_ODBC3.
static SQLRETURN drvfreestmt(SQLHSTMT stmt, SQLUSMALLINT opt)
Internal function to perform certain kinds of free/close on STMT.
SQLULEN * row_count
Row count pointer.
SQLRETURN SQL_API SQLNativeSqlW(SQLHSTMT stmt, SQLWCHAR *sqlin, SQLINTEGER sqlinLen, SQLWCHAR *sql, SQLINTEGER sqlMax, SQLINTEGER *sqlLen)
Translate SQL string (UNICODE version).
static SQLRETURN drvallocenv(SQLHENV *env)
Internal allocate HENV.
static COL procSpec2[]
Columns for result set of SQLProcedures().
char sqlstate[6]
SQL state for SQLError()
static SQLRETURN drvprimarykeys(SQLHSTMT stmt, SQLCHAR *cat, SQLSMALLINT catLen, SQLCHAR *schema, SQLSMALLINT schemaLen, SQLCHAR *table, SQLSMALLINT tableLen)
Internal retrieve information about indexed columns.
int inc
Increment for paramset size > 1.
static int getdsnattr(char *dsn, char *attr, char *out, int outLen)
Handling of SQLConnect() connection attributes for standalone operation without driver manager...
static void s3stmt_end(STMT *s)
Stop running sqlite statement.
SQLRETURN SQL_API SQLSetDescFieldW(SQLHDESC handle, SQLSMALLINT recno, SQLSMALLINT fieldid, SQLPOINTER value, SQLINTEGER buflen)
Function not implemented.
char * column
Column name.
int version
SQLITE version number.
char * dsn
ODBC data source name.
static const char space_chars[]
SQLRETURN SQL_API SQLDescribeColW(SQLHSTMT stmt, SQLUSMALLINT col, SQLWCHAR *name, SQLSMALLINT nameMax, SQLSMALLINT *nameLen, SQLSMALLINT *type, SQLULEN *size, SQLSMALLINT *digits, SQLSMALLINT *nullable)
Describe column information (UNICODE version).
static SQLRETURN drvdisconnect(SQLHDBC dbc)
Internal disconnect given HDBC.
static SQLRETURN drvsetconnectoption(SQLHDBC dbc, SQLUSMALLINT opt, SQLUINTEGER param)
Internal set option on HDBC.
int curtype
Default cursor type.
Driver internal structure representing SQL statement (HSTMT).
SQLRETURN SQL_API SQLGetEnvAttr(SQLHENV env, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER len, SQLINTEGER *lenp)
Get information of HENV.
SQLUINTEGER paramset_nrows
Row count for paramset handling.
static int typeinfosort(const void *a, const void *b)
Helper function to sort type information.
int autocommit
Auto commit state.
SQLCHAR logmsg[1024]
Message for SQLError()
static SQLRETURN drvsetpos(SQLHSTMT stmt, SQLSETPOSIROW row, SQLUSMALLINT op, SQLUSMALLINT lock)
Internal set position on result in HSTMT.
static SQLRETURN drvgetstmtoption(SQLHSTMT stmt, SQLUSMALLINT opt, SQLPOINTER param)
Internal get option of HSTMT.
int isrowid
Flag for ROWID column (> 0)
SQLRETURN SQL_API SQLGetStmtOptionW(SQLHSTMT stmt, SQLUSMALLINT opt, SQLPOINTER param)
Get option of HSTMT (UNICODE version).
int prec
Precision of column.
ENV * env
Pointer to environment.
char buffer[1]
String buffer.
SQLRETURN SQL_API SQLProcedureColumnsW(SQLHSTMT stmt, SQLWCHAR *catalog, SQLSMALLINT catalogLen, SQLWCHAR *schema, SQLSMALLINT schemaLen, SQLWCHAR *proc, SQLSMALLINT procLen, SQLWCHAR *column, SQLSMALLINT columnLen)
Retrieve information about columns in result set of stored procedures (UNICODE version).
static void dbtrace(void *arg, const char *msg, sqlite_uint64 et)
SQLite trace or profile callback.
static void mktypeinfo(STMT *s, int row, int asize, char *typename, int type, int tind)
Internal function to build up data type information as row in result set.
SQLRETURN SQL_API SQLGetConnectOptionW(SQLHDBC dbc, SQLUSMALLINT opt, SQLPOINTER param)
Get connect option of HDBC (UNICODE version).
SQLRETURN SQL_API SQLTransact(SQLHENV env, SQLHDBC dbc, SQLUSMALLINT type)
Commit or rollback transaction.
static void blob_export(sqlite3_context *ctx, int nargs, sqlite3_value **args)
SQLite function to export a BLOB to a file.
static SQLRETURN drvgetinfo(SQLHDBC dbc, SQLUSMALLINT type, SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen)
Internal return information about what this ODBC driver supports.
int nrow
number of rows in result array
static COL procColSpec3[]
static double ln_strtod(const char *data, char **endp)
Internal locale neutral strtod function.
static SQLRETURN drvcolumns(SQLHSTMT stmt, SQLCHAR *cat, SQLSMALLINT catLen, SQLCHAR *schema, SQLSMALLINT schemaLen, SQLCHAR *table, SQLSMALLINT tableLen, SQLCHAR *col, SQLSMALLINT colLen)
Internal retrieve column information on table.
static SQLRETURN drvputdata(SQLHSTMT stmt, SQLPOINTER data, SQLLEN len)
Internal put (partial) parameter data into executing statement.
static int mapdeftype(int type, int stype, int nosign, int nowchar)
Map SQL_C_DEFAULT to proper C type.
static SQLRETURN SQL_API drvforeignkeys(SQLHSTMT stmt, SQLCHAR *PKcatalog, SQLSMALLINT PKcatalogLen, SQLCHAR *PKschema, SQLSMALLINT PKschemaLen, SQLCHAR *PKtable, SQLSMALLINT PKtableLen, SQLCHAR *FKcatalog, SQLSMALLINT FKcatalogLen, SQLCHAR *FKschema, SQLSMALLINT FKschemaLen, SQLCHAR *FKtable, SQLSMALLINT FKtableLen)
Internal retrieve information about primary/foreign keys.
BINDPARM * bindparms
Array of bound parameters.
#define SETSTMTOPTION_LAST_ARG_TYPE
COL * cols
Result column array.
static SQLRETURN noconn(STMT *s)
Report S1000 (not connected) SQL error given STMT.
SQLULEN bind_type
SQL_ATTR_ROW_BIND_TYPE.
SQLRETURN SQL_API SQLPutData(SQLHSTMT stmt, SQLPOINTER data, SQLLEN len)
Put (partial) parameter data into executing statement.
SQLRETURN SQL_API SQLBindParam(SQLHSTMT stmt, SQLUSMALLINT pnum, SQLSMALLINT vtype, SQLSMALLINT ptype, SQLULEN lenprec, SQLSMALLINT scale, SQLPOINTER val, SQLLEN *lenp)
Bind parameter on HSTMT.
SQLRETURN SQL_API SQLCopyDesc(SQLHDESC source, SQLHDESC target)
Function not implemented.
static SQLRETURN mkresultset(HSTMT stmt, COL *colspec, int ncols, COL *colspec3, int ncols3, int *nret)
Setup empty result set from constant column specification.
SQLPOINTER valp
Value buffer.
SQLRETURN SQL_API SQLFreeStmt(SQLHSTMT stmt, SQLUSMALLINT opt)
Free HSTMT.
SQLRETURN SQL_API SQLBulkOperations(SQLHSTMT stmt, SQLSMALLINT oper)
Perform bulk operation on HSTMT.
int ov3
True for SQL_OV_ODBC3.
SQLRETURN SQL_API SQLGetDiagFieldW(SQLSMALLINT htype, SQLHANDLE handle, SQLSMALLINT recno, SQLSMALLINT id, SQLPOINTER info, SQLSMALLINT buflen, SQLSMALLINT *stringlen)
Get error record given handle (HDBC or HSTMT).
static int namematch(char *str, char *pat, int esc)
SQL LIKE string match with optional backslash escape handling.
SQLUSMALLINT * parm_oper
SQL_ATTR_PARAM_OPERATION_PTR.
static SQLWCHAR * uc_strncpy(SQLWCHAR *dest, SQLWCHAR *src, int len)
Copy UNICODE string like strncpy().
static SQLWCHAR * uc_from_utf(unsigned char *str, int len)
Make UNICODE string from UTF8 string.
char * dbname
SQLITE database name.
SQLRETURN SQL_API SQLEndTran(SQLSMALLINT type, SQLHANDLE handle, SQLSMALLINT comptype)
Commit or rollback transaction.
SQLRETURN SQL_API SQLFetch(SQLHSTMT stmt)
Fetch next result row.
static SQLRETURN mkbindcols(STMT *s, int ncols)
Reallocate space for bound columns.
int fksupport
Foreign keys on or off.
SQLRETURN SQL_API SQLSetCursorNameW(SQLHSTMT stmt, SQLWCHAR *cursor, SQLSMALLINT len)
Set cursor name on STMT (UNICODE version).
int s3stmt_needmeta
True to get meta data in s3stmt_step().
int rowprs
Current start row of rowset.
SQLRETURN SQL_API SQLDescribeParam(SQLHSTMT stmt, SQLUSMALLINT pnum, SQLSMALLINT *dtype, SQLULEN *size, SQLSMALLINT *decdigits, SQLSMALLINT *nullable)
Return information about parameter.
static SQLRETURN drvdriverconnect(SQLHDBC dbc, SQLHWND hwnd, SQLCHAR *connIn, SQLSMALLINT connInLen, SQLCHAR *connOut, SQLSMALLINT connOutMax, SQLSMALLINT *connOutLen, SQLUSMALLINT drvcompl)
Internal standalone (w/o driver manager) database connect.
static SQLRETURN drvallocstmt(SQLHDBC dbc, SQLHSTMT *stmt)
Allocate HSTMT given HDBC (driver internal version).
#define strmak(dst, src, max, lenp)
int rc
SQLite return code.
SQLRETURN SQL_API SQLCloseCursor(SQLHSTMT stmt)
Close open cursor.
int s3stmt_rownum
Current row number.
static COL tablePrivSpec2[]
Columns for result set of SQLTablePrivileges().
static SQLRETURN drvtableprivileges(SQLHSTMT stmt, SQLCHAR *cat, SQLSMALLINT catLen, SQLCHAR *schema, SQLSMALLINT schemaLen, SQLCHAR *table, SQLSMALLINT tableLen)
Retrieve privileges on tables and/or views.
int * jdconv
True for julian day conversion.
SQLRETURN SQL_API SQLFreeHandle(SQLSMALLINT type, SQLHANDLE h)
Free a HENV, HDBC, or HSTMT handle.
static SQLRETURN drvsetcursorname(SQLHSTMT stmt, SQLCHAR *cursor, SQLSMALLINT len)
Internal function to set cursor name on STMT.
SQLRETURN SQL_API SQLTablePrivilegesW(SQLHSTMT stmt, SQLWCHAR *catalog, SQLSMALLINT catalogLen, SQLWCHAR *schema, SQLSMALLINT schemaLen, SQLWCHAR *table, SQLSMALLINT tableLen)
Retrieve privileges on tables and/or views (UNICODE version).
SQLUSMALLINT row_status1
Internal status array for 1 row rowsets.
SQLLEN * lenp
Value return, actual size of value buffer.
SQLULEN retr_data
SQL_ATTR_RETRIEVE_DATA.
int longnames
Don't shorten column names.
int index
Index of column in result.
static SQLRETURN chkunbound(STMT *s)
Check for unbound result columns.
static void freep(void *x)
Free memory given pointer to memory pointer.
static void fixupdyncols(STMT *s, DBC *d)
Fixup column information for a running statement.
static char * uc_to_utf(SQLWCHAR *str, int len)
Make UTF8 string from UNICODE string.
static int getmdays(int year, int month)
Return number of month days.
static COL tablePrivSpec3[]
SQLSMALLINT type
ODBC type.
SQLRETURN SQL_API SQLPrimaryKeysW(SQLHSTMT stmt, SQLWCHAR *cat, SQLSMALLINT catLen, SQLWCHAR *schema, SQLSMALLINT schemaLen, SQLWCHAR *table, SQLSMALLINT tableLen)
Retrieve information about indexed columns (UNICODE version).
SQLRETURN SQL_API SQLSpecialColumnsW(SQLHSTMT stmt, SQLUSMALLINT id, SQLWCHAR *cat, SQLSMALLINT catLen, SQLWCHAR *schema, SQLSMALLINT schemaLen, SQLWCHAR *table, SQLSMALLINT tableLen, SQLUSMALLINT scope, SQLUSMALLINT nullable)
Retrieve information about indexed columns (UNICODE version).
static int str2date(int jdconv, char *str, DATE_STRUCT *ds)
Convert string to ODBC DATE_STRUCT.
struct dbc * next
Pointer to next DBC.
static SQLRETURN setposibind(STMT *s, sqlite3_stmt *stmt, int i, int si, int rsi)
Internal handler to setup parameters for positional updates from driver side result set...
static COL colPrivSpec3[]
static SQLRETURN drvtables(SQLHSTMT stmt, SQLCHAR *cat, SQLSMALLINT catLen, SQLCHAR *schema, SQLSMALLINT schemaLen, SQLCHAR *table, SQLSMALLINT tableLen, SQLCHAR *type, SQLSMALLINT typeLen)
Retrieve information on tables and/or views.
static COL statSpec2[]
Columns for result set of SQLStatistics().
int nowchar
Don't try to use WCHAR.
#define HSTMT_UNLOCK(hdbc)
SQLRETURN SQL_API SQLGetCursorNameW(SQLHSTMT stmt, SQLWCHAR *cursor, SQLSMALLINT buflen, SQLSMALLINT *lenp)
Get cursor name of STMT (UNICODE version).
SQLRETURN SQL_API SQLSetStmtOption(SQLHSTMT stmt, SQLUSMALLINT opt, SETSTMTOPTION_LAST_ARG_TYPE param)
Set option on HSTMT.
SQLRETURN SQL_API SQLSetStmtOptionW(SQLHSTMT stmt, SQLUSMALLINT opt, SETSTMTOPTION_LAST_ARG_TYPE param)
Set option on HSTMT (UNICODE version).
double s3dval
SQLite3 float value.
static int drvgettable(STMT *s, const char *sql, char ***resp, int *nrowp, int *ncolp, char **errp, int nparam, BINDPARM *p)
Internal structure for managing driver's sqlite3_get_table() implementation.
int pwdLen
Length of password.
static void unbindcols(STMT *s)
Reset bound columns to unbound state.
static COL scolSpec2[]
Columns for result set of SQLSpecialColumns().
SQLRETURN SQL_API SQLGetConnectAttrW(SQLHDBC dbc, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER bufmax, SQLINTEGER *buflen)
Get connect attribute of HDBC (UNICODE version).
int ncols
Number of result columns.
SQLUSMALLINT * row_status
Row status pointer.
SQLRETURN SQL_API SQLNumResultCols(SQLHSTMT stmt, SQLSMALLINT *ncols)
Return number of columns of result set given HSTMT.
static int busy_handler(void *udata, int count)
Busy callback for SQLite.
static char * uc_to_utf_c(SQLWCHAR *str, int len)
Make UTF8 string from UNICODE string.
SQLCHAR cursorname[32]
Cursor name.
static int str2timestamp(int jdconv, char *str, TIMESTAMP_STRUCT *tss)
Convert string to ODBC TIMESTAMP_STRUCT.
static SQLRETURN starttran(STMT *s)
Start transaction when autocommit off.
static int s3stmt_step(STMT *s)
Do one sqlite statement step gathering one result row.
static COL tableSpec2[]
Columns for result set of SQLTables().
static SQLRETURN drvexecute(SQLHSTMT stmt, int initial)
struct stmt * next
Linkage for STMT list in DBC.
static SQLRETURN drvbulkoperations(SQLHSTMT stmt, SQLSMALLINT op)
Internal perform bulk operation on HSTMT.
SQLRETURN SQL_API SQLSetPos(SQLHSTMT stmt, SQLSETPOSIROW row, SQLUSMALLINT op, SQLUSMALLINT lock)
Set position on result in HSTMT.
#define COLATTRIBUTE_LAST_ARG_TYPE
char * bincache
Cache for blob data.
static SQLRETURN setupdyncols(STMT *s, sqlite3_stmt *s3stmt, int *ncolsp)
static COL procColSpec2[]
Columns for result set of SQLProcedureColumns().
static SQLRETURN drvsetstmtattr(SQLHSTMT stmt, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER buflen)
Internal set option on HSTMT.
SQLINTEGER * bkmrkptr
SQL_ATTR_FETCH_BOOKMARK_PTR.
int notnull
NOT NULL constraint on column.
int timeout
Lock timeout value.
SQLULEN max_rows
SQL_ATTR_MAX_ROWS.
int nalloc
alloc'ed size of result array
static void dbtraceapi(DBC *d, char *fn, const char *sql)
Trace function for SQLite API calls.
SQLRETURN SQL_API SQLDriversW(SQLHENV env, SQLUSMALLINT dir, SQLWCHAR *drvdesc, SQLSMALLINT descmax, SQLSMALLINT *desclenp, SQLWCHAR *drvattr, SQLSMALLINT attrmax, SQLSMALLINT *attrlenp)
Function not implemented.
static int getbool(char *string)
Get boolean flag from string.
SQLRETURN SQL_API SQLGetStmtAttrW(SQLHSTMT stmt, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER bufmax, SQLINTEGER *buflen)
Get option of HSTMT (UNICODE version).
char * label
Column label or NULL.
SQLRETURN SQL_API SQLFreeEnv(SQLHENV env)
Free HENV.
int type
Data type of column.
SQLRETURN SQL_API SQLGetDescRecW(SQLHDESC handle, SQLSMALLINT recno, SQLWCHAR *name, SQLSMALLINT buflen, SQLSMALLINT *strlen, SQLSMALLINT *type, SQLSMALLINT *subtype, SQLLEN *len, SQLSMALLINT *prec, SQLSMALLINT *scale, SQLSMALLINT *nullable)
Function not implemented.
int nowchar[2]
Don't try to use WCHAR.
static const char upper_chars[]
static SQLRETURN setupparam(STMT *s, char *sql, int pnum)
Setup SQLite3 parameter for statement parameter.
int binlen
Length of blob data.
SQLLEN * lenp0
Actual size of parameter buffer, initial value.
int * oemcp
True for Win32 OEM CP translation.
static SQLRETURN drvunimpldbc(HDBC dbc)
Report IM001 (not implemented) SQL error code for HDBC.
SQLUSMALLINT * row_status0
Internal status array.
static void s3stmt_end_if(STMT *s)
Conditionally stop running sqlite statement.
SQLRETURN SQL_API SQLStatisticsW(SQLHSTMT stmt, SQLWCHAR *cat, SQLSMALLINT catLen, SQLWCHAR *schema, SQLSMALLINT schemaLen, SQLWCHAR *table, SQLSMALLINT tableLen, SQLUSMALLINT itype, SQLUSMALLINT resv)
Return statistic information on table indices (UNICODE version).
static int setsqliteopts(sqlite3 *x, DBC *d)
Set SQLite options (PRAGMAs) given SQLite handle.
int nbindcols
Number of entries in bindcols.
int isselect
0 if query is a SELECT statement
SQLLEN * lenp
Actual size of parameter buffer.
SQLRETURN SQL_API SQLGetStmtOption(SQLHSTMT stmt, SQLUSMALLINT opt, SQLPOINTER param)
Get option of HSTMT.
static SQLRETURN drvsetstmtoption(SQLHSTMT stmt, SQLUSMALLINT opt, SQLUINTEGER param)
Internal set option on HSTMT.
char * pwd
Password or NULL.
Driver internal structure for environment (HENV).
static SQLRETURN drvfreeenv(SQLHENV env)
Internal free HENV.
static char * strdup_(const char *str)
Duplicate string using xmalloc().
FILE * trace
sqlite3_trace() file pointer or NULL
Internal structure representing dynamic strings.
static void freeresult(STMT *s, int clrcols)
Free statement's result.
SQLRETURN SQL_API SQLSetStmtAttrW(SQLHSTMT stmt, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER buflen)
Set option on HSTMT (UNICODE version).
static void uc_from_utf_buf(unsigned char *str, int len, SQLWCHAR *uc, int ucLen)
Make UNICODE string from UTF8 string into buffer.
sqlite3_stmt * stmt
SQLite3 statement pointer.
static void uc_free(void *str)
Free converted UTF8 or UNICODE string.
int autoinc
AUTO_INCREMENT column.
SQLRETURN SQL_API SQLSetScrollOptions(SQLHSTMT stmt, SQLUSMALLINT concur, SQLLEN rowkeyset, SQLUSMALLINT rowset)
Function not implemented.
static SQLRETURN endtran(DBC *d, SQLSMALLINT comptype, int force)
Internal commit or rollback transaction.
int oom
True when out of memory.
SQLRETURN SQL_API SQLTablesW(SQLHSTMT stmt, SQLWCHAR *cat, SQLSMALLINT catLen, SQLWCHAR *schema, SQLSMALLINT schemaLen, SQLWCHAR *table, SQLSMALLINT tableLen, SQLWCHAR *type, SQLSMALLINT typeLen)
Retrieve information on tables and/or views.
static SQLRETURN drvsetconnectattr(SQLHDBC dbc, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER len)
Internal set connect attribute of HDBC.
SQLRETURN SQL_API SQLGetFunctions(SQLHDBC dbc, SQLUSMALLINT func, SQLUSMALLINT *flags)
Return information about supported ODBC API functions.
SQLRETURN SQL_API SQLBrowseConnectW(SQLHDBC dbc, SQLWCHAR *connin, SQLSMALLINT conninLen, SQLWCHAR *connout, SQLSMALLINT connoutMax, SQLSMALLINT *connoutLen)
Function not implemented.
static const char * xdigits
long t0
Start time for SQLITE busy handler.
int naterr
Native error code.
SQLRETURN SQL_API SQLGetDiagRecW(SQLSMALLINT htype, SQLHANDLE handle, SQLSMALLINT recno, SQLWCHAR *sqlstate, SQLINTEGER *nativeerr, SQLWCHAR *msg, SQLSMALLINT buflen, SQLSMALLINT *msglen)
Get error message given handle (HENV, HDBC, or HSTMT) (UNICODE version).
char sqlstate[6]
SQL state for SQLError()
int bound
True when SQLBindParameter() called.
static void dbloadext(DBC *d, char *exts)
Load SQLite extension modules, if any.
static BOOL InUn(int remove, char *drivername, char *dllname, char *dll2name, char *dsname)
Driver installer/uninstaller.
void * param
Parameter buffer.
int one_tbl
Flag for single table (> 0)
SQLRETURN SQL_API SQLGetData(SQLHSTMT stmt, SQLUSMALLINT col, SQLSMALLINT type, SQLPOINTER val, SQLLEN len, SQLLEN *lenp)
Retrieve row data after fetch.
void(* rowfree)()
Free function for rows.
static int TOLOWER(int c)
static SQLRETURN drvgetconnectattr(SQLHDBC dbc, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER bufmax, SQLINTEGER *buflen)
Internal get connect attribute of HDBC.
STMT * s
Driver statement pointer.
static COL colSpec2[]
Columns for result set of SQLColumns().
int ncol
number of columns in result array
int scale
from SQLBindParameter()
COL * dyncols
Column array, but malloc()ed.
int dobigint
Force SQL_BIGINT for INTEGER columns.
SQLRETURN SQL_API SQLBindParameter(SQLHSTMT stmt, SQLUSMALLINT pnum, SQLSMALLINT iotype, SQLSMALLINT buftype, SQLSMALLINT ptype, SQLULEN coldef, SQLSMALLINT scale, SQLPOINTER data, SQLLEN buflen, SQLLEN *len)
Bind parameter on HSTMT.
int index
Index of column in result.
int bkmrk
True when bookmarks used.
SQLULEN * parm_proc
SQL_ATTR_PARAMS_PROCESSED_PTR.
SQLULEN * bind_offs
SQL_ATTR_ROW_BIND_OFFSET_PTR.
static SQLRETURN getrowdata(STMT *s, SQLUSMALLINT col, SQLSMALLINT otype, SQLPOINTER val, SQLINTEGER len, SQLLEN *lenp, int partial)
Internal function to retrieve row data, used by SQLFetch() and friends and SQLGetData().
static SQLRETURN setposrefr(STMT *s, int rsi)
Internal handler to refresh user buffers from driver side result set.
static int dserr(dstr *dsp)
Check error on dynamic string.
static SQLRETURN drvconnect(SQLHDBC dbc, SQLCHAR *dsn, SQLSMALLINT dsnLen, char *pwd, int pwdLen, int isu)
Internal connect to SQLite database.
static void convJD2YMD(double jd, DATE_STRUCT *ds)
Convert julian day to year/month/day.
static dstr * dsappendq(dstr *dsp, const char *str)
Append string quoted to dynamic string.
SQLRETURN SQL_API SQLSetParam(SQLHSTMT stmt, SQLUSMALLINT par, SQLSMALLINT type, SQLSMALLINT sqltype, SQLULEN coldef, SQLSMALLINT scale, SQLPOINTER val, SQLLEN *nval)
Set information on parameter.
static COL colPrivSpec2[]
Columns for result set of SQLColumnPrivileges().
static SQLRETURN drvunimplstmt(HSTMT stmt)
Report IM001 (not implemented) SQL error code for HSTMT.
SQLRETURN SQL_API SQLSetEnvAttr(SQLHENV env, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER len)
Set information in HENV.
static char * s3stmt_coltype(sqlite3_stmt *s3stmt, int col, DBC *d, int *guessed_types)
Find out column type.
SQLRETURN SQL_API SQLDataSourcesW(SQLHENV env, SQLUSMALLINT dir, SQLWCHAR *srvname, SQLSMALLINT buflen1, SQLSMALLINT *lenp1, SQLWCHAR *desc, SQLSMALLINT buflen2, SQLSMALLINT *lenp2)
Function not implemented.
BINDCOL * bindcols
Array of bound columns.
int rowp
Current result row.
SQLRETURN SQL_API SQLGetDescFieldW(SQLHDESC handle, SQLSMALLINT recno, SQLSMALLINT fieldid, SQLPOINTER value, SQLINTEGER buflen, SQLINTEGER *strlen)
Function not implemented.
int ov3val
True for SQL_OV_ODBC3.
int scale
Scale of column.
static void dsfree(dstr *dsp)
Free dynamic string.
SQLRETURN SQL_API SQLAllocConnect(SQLHENV env, SQLHDBC *dbc)
Allocate HDBC.
static SQLRETURN freestmt(HSTMT stmt)
char * typename
Column type name or NULL.
SQLUSMALLINT * parm_status
SQL_ATTR_PARAMS_STATUS_PTR.
static SQLRETURN s3stmt_start(STMT *s)
Start sqlite statement for execution of SELECT statement.
int jdconv
True for julian day conversion.
int has_rowid
Flag for ROWID (>= 0 or -1)
BINDCOL bkmrkcol
Bookmark bound column.
SQLULEN rowset_size
Size of rowset.
static SQLRETURN drvstatistics(SQLHSTMT stmt, SQLCHAR *cat, SQLSMALLINT catLen, SQLCHAR *schema, SQLSMALLINT schemaLen, SQLCHAR *table, SQLSMALLINT tableLen, SQLUSMALLINT itype, SQLUSMALLINT resv)
Internal return statistic information on table indices.
static SQLRETURN drvcolattributes(SQLHSTMT stmt, SQLUSMALLINT col, SQLUSMALLINT id, SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen, SQLLEN *val2)
Internal retrieve column attributes.
SQLRETURN SQL_API SQLNumParams(SQLHSTMT stmt, SQLSMALLINT *nparam)
Return number of parameters.
char strbuf[64]
String buffer for scalar data.
int oemcp
True for Win32 OEM CP translation.
SQLRETURN SQL_API SQLGetTypeInfoW(SQLHSTMT stmt, SQLSMALLINT sqltype)
Return data type information (UNICODE version).
static SQLRETURN drvendtran(SQLSMALLINT type, SQLHANDLE handle, SQLSMALLINT comptype)
Internal commit or rollback transaction.
char * bincell
Cache for blob data.
int nparams
Number of parameters in query.
static void setstat(STMT *s, int naterr, char *msg, char *st,...)
Set error message and SQL state on statement.
int stype
ODBC and SQL types.
Internal structure for bound parameter (SQLBindParameter).
static void s3stmt_drop(STMT *s)
Drop running sqlite statement in STMT.
int nbindparms
Number bound parameters.
static COL typeSpec2[]
Columns for result set of SQLGetTypeInfo().
SQLRETURN SQL_API SQLBindCol(SQLHSTMT stmt, SQLUSMALLINT col, SQLSMALLINT type, SQLPOINTER val, SQLLEN max, SQLLEN *lenp)
Bind C variable to column of result set.
Internal structure to describe a column in a result set.
char * errmsg
error message or NULL
SQLRETURN SQL_API SQLAllocStmt(SQLHDBC dbc, SQLHSTMT *stmt)
Allocate HSTMT given HDBC.
int has_pk
Flag for primary key (> 0)
static SQLRETURN drvgetstmtattr(SQLHSTMT stmt, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER bufmax, SQLINTEGER *buflen)
Internal get option of HSTMT.
static SQLRETURN dbopen(DBC *d, char *name, int isu, char *dsn, char *sflag, char *spflag, char *ntflag, char *jmode, char *busy)
Open SQLite database file given file name and flags.
static int uc_strlen(SQLWCHAR *str)
Return length of UNICODE string.
int offs
Byte offset for SQLGetData()
SQLULEN paramset_count
Internal for paramset.
int pdcount
SQLParamData() counter.
struct stmt * stmt
STMT list of this DBC.
#define HDBC_UNLOCK(hdbc)
static SQLRETURN drvdescribecol(SQLHSTMT stmt, SQLUSMALLINT col, SQLCHAR *name, SQLSMALLINT nameMax, SQLSMALLINT *nameLen, SQLSMALLINT *type, SQLULEN *size, SQLSMALLINT *digits, SQLSMALLINT *nullable)
Internal describe column information.
static char * unquote(char *str)
Strip quotes from quoted string in-place.
static SQLRETURN drvbindcol(SQLHSTMT stmt, SQLUSMALLINT col, SQLSMALLINT type, SQLPOINTER val, SQLLEN max, SQLLEN *lenp)
Internal bind C variable to column of result set.
SQLRETURN SQL_API SQLAllocHandle(SQLSMALLINT type, SQLHANDLE input, SQLHANDLE *output)
Allocate a HENV, HDBC, or HSTMT handle.
SQLRETURN SQL_API SQLColumnPrivilegesW(SQLHSTMT stmt, SQLWCHAR *catalog, SQLSMALLINT catalogLen, SQLWCHAR *schema, SQLSMALLINT schemaLen, SQLWCHAR *table, SQLSMALLINT tableLen, SQLWCHAR *column, SQLSMALLINT columnLen)
Retrieve privileges on columns (UNICODE version).
static void convJD2HMS(double jd, TIME_STRUCT *ts, int *fp)
Convert julian day to hour/minute/second.
char ** resarr
result array
#define verinfo(maj, min, lev)
int s3stmt_noreset
False when sqlite3_reset() needed.
static void dbtracerc(DBC *d, int rc, char *err)
Trace function for SQLite return codes.
int trans_disable
True for no transaction support.
static SQLRETURN drvspecialcolumns(SQLHSTMT stmt, SQLUSMALLINT id, SQLCHAR *cat, SQLSMALLINT catLen, SQLCHAR *schema, SQLSMALLINT schemaLen, SQLCHAR *table, SQLSMALLINT tableLen, SQLUSMALLINT scope, SQLUSMALLINT nullable)
Internal retrieve information about indexed columns.
static const char * dsval(dstr *dsp)
Return dynamic string's value.
int dcols
Number of entries in dyncols.
static SQLRETURN drvbindparam(SQLHSTMT stmt, SQLUSMALLINT pnum, SQLSMALLINT iotype, SQLSMALLINT buftype, SQLSMALLINT ptype, SQLUINTEGER coldef, SQLSMALLINT scale, SQLPOINTER data, SQLINTEGER buflen, SQLLEN *len)
Internal bind parameter on HSTMT.
SQLRETURN SQL_API SQLProceduresW(SQLHSTMT stmt, SQLWCHAR *catalog, SQLSMALLINT catalogLen, SQLWCHAR *schema, SQLSMALLINT schemaLen, SQLWCHAR *proc, SQLSMALLINT procLen)
Retrieve information about stored procedures (UNICODE version).
static char * fixupsql(char *sql, int sqlLen, int cte, int *nparam, int *isselect, char **errmsg)
Fixup query string with optional parameter markers.
SQLRETURN SQL_API SQLParamOptions(SQLHSTMT stmt, SQLULEN rows, SQLULEN *rowp)
Function not implemented.
int naterr
Native error code.
int len
Offset/length for SQLParamData()/SQLPutData()
static SQLRETURN drvgetdiagrec(SQLSMALLINT htype, SQLHANDLE handle, SQLSMALLINT recno, SQLCHAR *sqlstate, SQLINTEGER *nativeerr, SQLCHAR *msg, SQLSMALLINT buflen, SQLSMALLINT *msglen)
Internal get error message given handle (HENV, HDBC, or HSTMT).
Header file for SQLite3 ODBC driver.
int max
Maximum length of buffer.
static int unescpat(char *str)
Unescape search pattern for e.g.