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 *);
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) {
723 if (dsp->
len + len > dsp->
max) {
724 int max = dsp->
max + len + 256;
728 strcpy(dsp->
buffer,
"OUT OF MEMORY");
739 for (p = str; *p; ++p) {
761 return (
const char *) dsp->
buffer;
775 return !dsp || dsp->
oom;
850 ucLen = ucLen /
sizeof (SQLWCHAR);
851 if (!uc || ucLen < 0) {
861 while (i < len && *str && i < ucLen) {
862 unsigned char c = str[0];
867 }
else if (c <= 0xc1 || c >= 0xf5) {
870 }
else if (c < 0xe0) {
871 if ((str[1] & 0xc0) == 0x80) {
872 unsigned long t = ((c & 0x1f) << 6) | (str[1] & 0x3f);
880 }
else if (c < 0xf0) {
881 if ((str[1] & 0xc0) == 0x80 && (str[2] & 0xc0) == 0x80) {
882 unsigned long t = ((c & 0x0f) << 12) |
883 ((str[1] & 0x3f) << 6) | (str[2] & 0x3f);
891 }
else if (c < 0xf8) {
892 if ((str[1] & 0xc0) == 0x80 && (str[2] & 0xc0) == 0x80 &&
893 (str[3] & 0xc0) == 0x80) {
894 unsigned long t = ((c & 0x03) << 18) |
895 ((str[1] & 0x3f) << 12) | ((str[2] & 0x3f) << 6) |
898 if (
sizeof (SQLWCHAR) == 2 *
sizeof (char) &&
901 uc[i++] = 0xd800 | ((t >> 10) & 0x3ff);
905 t = 0xdc00 | (t & 0x3ff);
913 }
else if (c < 0xfc) {
914 if ((str[1] & 0xc0) == 0x80 && (str[2] & 0xc0) == 0x80 &&
915 (str[3] & 0xc0) == 0x80 && (str[4] & 0xc0) == 0x80) {
916 unsigned long t = ((c & 0x01) << 24) |
917 ((str[1] & 0x3f) << 18) | ((str[2] & 0x3f) << 12) |
918 ((str[3] & 0x3f) << 6) | (str[4] & 0x3f);
920 if (
sizeof (SQLWCHAR) == 2 *
sizeof (char) &&
923 uc[i++] = 0xd800 | ((t >> 10) & 0x3ff);
927 t = 0xdc00 | (t & 0x3ff);
960 if (len == SQL_NTS) {
961 len = strlen((
char *) str);
963 ucLen =
sizeof (SQLWCHAR) * (len + 1);
983 char *cp, *ret = NULL;
988 if (len == SQL_NTS) {
991 len = len /
sizeof (SQLWCHAR);
998 for (i = 0; i < len; i++) {
999 unsigned long c = str[i];
1001 if (
sizeof (SQLWCHAR) == 2 *
sizeof (
char)) {
1006 }
else if (c < 0x800) {
1007 *cp++ = 0xc0 | ((c >> 6) & 0x1f);
1008 *cp++ = 0x80 | (c & 0x3f);
1009 }
else if (c < 0x10000) {
1010 if (
sizeof (SQLWCHAR) == 2 *
sizeof (char) &&
1011 c >= 0xd800 && c <= 0xdbff && i + 1 < len) {
1012 unsigned long c2 = str[i + 1] & 0xffff;
1014 if (c2 >= 0xdc00 && c2 <= 0xdfff) {
1015 c = (((c & 0x3ff) << 10) | (c2 & 0x3ff)) + 0x10000;
1016 *cp++ = 0xf0 | ((c >> 18) & 0x07);
1017 *cp++ = 0x80 | ((c >> 12) & 0x3f);
1018 *cp++ = 0x80 | ((c >> 6) & 0x3f);
1019 *cp++ = 0x80 | (c & 0x3f);
1024 *cp++ = 0xe0 | ((c >> 12) & 0x0f);
1025 *cp++ = 0x80 | ((c >> 6) & 0x3f);
1026 *cp++ = 0x80 | (c & 0x3f);
1027 }
else if (c < 0x200000) {
1028 *cp++ = 0xf0 | ((c >> 18) & 0x07);
1029 *cp++ = 0x80 | ((c >> 12) & 0x3f);
1030 *cp++ = 0x80 | ((c >> 6) & 0x3f);
1031 *cp++ = 0x80 | (c & 0x3f);
1032 }
else if (c < 0x4000000) {
1033 *cp++ = 0xf8 | ((c >> 24) & 0x03);
1034 *cp++ = 0x80 | ((c >> 18) & 0x3f);
1035 *cp++ = 0x80 | ((c >> 12) & 0x3f);
1036 *cp++ = 0x80 | ((c >> 6) & 0x3f);
1037 *cp++ = 0x80 | (c & 0x3f);
1038 }
else if (c < 0x80000000) {
1039 *cp++ = 0xfc | ((c >> 31) & 0x01);
1040 *cp++ = 0x80 | ((c >> 24) & 0x3f);
1041 *cp++ = 0x80 | ((c >> 18) & 0x3f);
1042 *cp++ = 0x80 | ((c >> 12) & 0x3f);
1043 *cp++ = 0x80 | ((c >> 6) & 0x3f);
1044 *cp++ = 0x80 | (c & 0x3f);
1065 if (len != SQL_NTS) {
1066 len = len *
sizeof (SQLWCHAR);
1073 #if defined(WCHARSUPPORT) || defined(_WIN32) || defined(_WIN64) 1090 #if defined(_WIN32) || defined(_WIN64) 1100 wmb_to_utf(
char *str,
int len)
1104 int nchar, is2k, cp = CP_OEMCP;
1106 ovi.dwOSVersionInfoSize =
sizeof (ovi);
1108 is2k = ovi.dwPlatformId == VER_PLATFORM_WIN32_NT && ovi.dwMajorVersion > 4;
1109 if (AreFileApisANSI()) {
1110 cp = is2k ? CP_THREAD_ACP : CP_ACP;
1112 nchar = MultiByteToWideChar(cp, 0, str, len, NULL, 0);
1113 wstr =
xmalloc((nchar + 1) *
sizeof (WCHAR));
1118 nchar = MultiByteToWideChar(cp, 0, str, len, wstr, nchar);
1120 str =
xmalloc((nchar + 1) * 7);
1126 nchar = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, str, nchar * 7, 0, 0);
1142 wmb_to_utf_c(
char *str,
int len)
1144 if (len == SQL_NTS) {
1147 return wmb_to_utf(str, len);
1160 utf_to_wmb(
char *str,
int len)
1164 int nchar, is2k, cp = CP_OEMCP;
1166 ovi.dwOSVersionInfoSize =
sizeof (ovi);
1168 is2k = ovi.dwPlatformId == VER_PLATFORM_WIN32_NT && ovi.dwMajorVersion > 4;
1169 if (AreFileApisANSI()) {
1170 cp = is2k ? CP_THREAD_ACP : CP_ACP;
1172 nchar = MultiByteToWideChar(CP_UTF8, 0, str, len, NULL, 0);
1173 wstr =
xmalloc((nchar + 1) *
sizeof (WCHAR));
1178 nchar = MultiByteToWideChar(CP_UTF8, 0, str, len, wstr, nchar);
1180 str =
xmalloc((nchar + 1) * 7);
1186 nchar = WideCharToMultiByte(cp, 0, wstr, -1, str, nchar * 7, 0, 0);
1202 wmb_to_uc(
char *str,
int len)
1206 int nchar, is2k, cp = CP_OEMCP;
1208 ovi.dwOSVersionInfoSize =
sizeof (ovi);
1210 is2k = ovi.dwPlatformId == VER_PLATFORM_WIN32_NT && ovi.dwMajorVersion > 4;
1211 if (AreFileApisANSI()) {
1212 cp = is2k ? CP_THREAD_ACP : CP_ACP;
1214 nchar = MultiByteToWideChar(cp, 0, str, len, NULL, 0);
1215 wstr =
xmalloc((nchar + 1) *
sizeof (WCHAR));
1220 nchar = MultiByteToWideChar(cp, 0, str, len, wstr, nchar);
1233 uc_to_wmb(WCHAR *wstr,
int len)
1237 int nchar, is2k, cp = CP_OEMCP;
1239 ovi.dwOSVersionInfoSize =
sizeof (ovi);
1241 is2k = ovi.dwPlatformId == VER_PLATFORM_WIN32_NT && ovi.dwMajorVersion > 4;
1242 if (AreFileApisANSI()) {
1243 cp = is2k ? CP_THREAD_ACP : CP_ACP;
1245 nchar = WideCharToMultiByte(cp, 0, wstr, len, NULL, 0, 0, 0);
1246 str =
xmalloc((nchar + 1) * 2);
1251 nchar = WideCharToMultiByte(cp, 0, wstr, len, str, nchar * 2, 0, 0);
1261 #ifdef USE_DLOPEN_FOR_GPPS 1265 #define SQLGetPrivateProfileString(A,B,C,D,E,F) drvgpps(d,A,B,C,D,E,F) 1280 lib = dlopen(
"libodbcinst.so.2", RTLD_LAZY);
1282 lib = dlopen(
"libodbcinst.so.1", RTLD_LAZY);
1285 lib = dlopen(
"libodbcinst.so", RTLD_LAZY);
1288 lib = dlopen(
"libiodbcinst.so.2", RTLD_LAZY);
1291 lib = dlopen(
"libiodbcinst.so", RTLD_LAZY);
1294 gpps = (int (*)()) dlsym(lib,
"SQLGetPrivateProfileString");
1308 dlclose(d->instlib);
1314 drvgpps(
DBC *d,
char *sect,
char *ent,
char *def,
char *buf,
1315 int bufsiz,
char *fname)
1318 return d->gpps(sect, ent, def, buf, bufsiz, fname);
1320 strncpy(buf, def, bufsiz);
1321 buf[bufsiz - 1] =
'\0';
1325 #include <odbcinst.h> 1326 #define drvgetgpps(d) 1327 #define drvrelgpps(d) 1339 if (
stmt && p && nparams > 0) {
1340 for (i = 0; i < nparams; i++, p++) {
1344 sqlite3_bind_null(
stmt, i + 1);
1346 fprintf(d->
trace,
"-- parameter %d: NULL\n", i + 1);
1354 fprintf(d->
trace,
"-- parameter %d: '%*s'\n", i + 1,
1363 fprintf(d->
trace,
"-- parameter %d: [BLOB]'\n", i + 1);
1370 fprintf(d->
trace,
"-- parameter %d: %g\n",
1375 case SQLITE_INTEGER:
1376 if (p->
s3size > sizeof (
int)) {
1381 "-- parameter %d: %I64d\n",
1383 "-- parameter %d: %lld\n",
1391 fprintf(d->
trace,
"-- parameter %d: %d\n",
1433 if (t->
nrow == 0 && rc == SQLITE_ROW) {
1440 int nalloc = t->
nalloc * 2 + need + 1;
1445 t->
rc = SQLITE_NOMEM;
1454 for (i = 0; i < ncol; i++) {
1455 p = (
char *) sqlite3_column_name(t->
stmt, i);
1457 char *q =
xmalloc(strlen(p) + 1);
1474 }
else if (t->
ncol != ncol) {
1475 t->
errmsg = sqlite3_mprintf(
"drvgettable() called with two or" 1476 " more incompatible queries");
1477 t->
rc = SQLITE_ERROR;
1481 if (rc == SQLITE_ROW) {
1482 for (i = 0; i < ncol; i++) {
1483 int coltype = sqlite3_column_type(t->
stmt, i);
1486 if (coltype == SQLITE_BLOB) {
1487 int k, nbytes = sqlite3_column_bytes(t->
stmt, i);
1489 unsigned const char *bp;
1491 bp = sqlite3_column_blob(t->
stmt, i);
1499 for (k = 0; k < nbytes; k++) {
1500 *qp++ =
xdigits[(bp[k] >> 4)];
1501 *qp++ =
xdigits[(bp[k] & 0xF)];
1506 }
else if (coltype == SQLITE_FLOAT) {
1507 struct lconv *lc = 0;
1508 double val = sqlite3_column_double(t->
stmt, i);
1516 snprintf(buffer,
sizeof (buffer),
"%.15g", val);
1518 if (lc && lc->decimal_point && lc->decimal_point[0] &&
1519 lc->decimal_point[0] !=
'.') {
1520 p = strchr(buffer, lc->decimal_point[0]);
1530 }
else if (coltype != SQLITE_NULL) {
1531 p =
xstrdup((
char *) sqlite3_column_text(t->
stmt, i));
1545 int *ncolp,
char **errp,
int nparam,
BINDPARM *p)
1548 int rc = SQLITE_OK, keep = sql == NULL;
1550 const char *sqlleft = 0;
1551 int nretry = 0, haveerr = 0;
1554 return SQLITE_ERROR;
1568 tres.rc = SQLITE_OK;
1569 tres.resarr =
xmalloc(
sizeof (
char *) * tres.nalloc);
1573 return SQLITE_NOMEM;
1578 if (tres.stmt == NULL) {
1579 return SQLITE_NOMEM;
1583 while (sql && *sql && (rc == SQLITE_OK ||
1584 (rc == SQLITE_SCHEMA && (++nretry) < 2))) {
1588 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 1590 rc = sqlite3_prepare_v2(d->
sqlite, sql, -1, &tres.stmt, &sqlleft);
1593 rc = sqlite3_prepare(d->
sqlite, sql, -1, &tres.stmt, &sqlleft);
1595 if (rc != SQLITE_OK) {
1598 sqlite3_finalize(tres.stmt);
1609 if (sqlite3_bind_parameter_count(tres.stmt) != nparam) {
1612 sqlite3_mprintf(
"%s",
"parameter marker count incorrect");
1619 ncol = sqlite3_column_count(tres.stmt);
1625 rc = sqlite3_step(tres.stmt);
1626 if (rc == SQLITE_ROW || rc == SQLITE_DONE) {
1632 if (rc != SQLITE_ROW) {
1635 rc = sqlite3_reset(tres.stmt);
1639 rc = sqlite3_finalize(tres.stmt);
1642 if (rc != SQLITE_SCHEMA) {
1645 while (sql &&
ISSPACE(*sql)) {
1649 if (rc == SQLITE_DONE) {
1661 sqlite3_reset(tres.stmt);
1666 sqlite3_finalize(tres.stmt);
1671 }
else if (rc != SQLITE_OK && rc == sqlite3_errcode(d->
sqlite) && errp) {
1672 *errp = sqlite3_mprintf(
"%s", sqlite3_errmsg(d->
sqlite));
1677 tres.resarr[0] = (
char *) (tres.ndata - 1);
1679 if (rc == SQLITE_ABORT) {
1684 sqlite3_free(*errp);
1686 *errp = tres.errmsg;
1688 sqlite3_free(tres.errmsg);
1693 sqlite3_free(tres.errmsg);
1694 if (rc != SQLITE_OK) {
1698 *resp = &tres.resarr[1];
1716 #if defined(__GNUC__) && (__GNUC__ >= 2) 1717 static void setstatd(
DBC *,
int,
char *,
char *, ...)
1718 __attribute__((format (printf, 3, 5)));
1735 count = vsnprintf((
char *) d->
logmsg, sizeof (d->
logmsg), msg, ap);
1756 #if defined(__GNUC__) && (__GNUC__ >= 2) 1757 static void setstat(
STMT *,
int,
char *,
char *, ...)
1758 __attribute__((format (printf, 3, 5)));
1775 count = vsnprintf((
char *) s->
logmsg, sizeof (s->
logmsg), msg, ap);
1799 if (
dbc == SQL_NULL_HDBC) {
1800 return SQL_INVALID_HANDLE;
1803 setstatd(d, -1,
"not supported",
"IM001");
1818 if (
stmt == SQL_NULL_HSTMT) {
1819 return SQL_INVALID_HANDLE;
1822 setstat(s, -1,
"not supported",
"IM001");
1834 if (x && ((
char **) x)[0]) {
1835 xfree(((
char **) x)[0]);
1836 ((
char **) x)[0] = NULL;
1849 setstat(s, -1,
"out of memory", (*s->
ov3) ?
"HY000" :
"S1000");
1862 setstat(s, -1,
"not connected", (*s->
ov3) ?
"HY000" :
"S1000");
1873 #if defined(HAVE_LOCALECONV) || defined(_WIN32) || defined(_WIN64) 1878 struct lconv *lc = 0;
1879 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[SQL_MAX_MESSAGE_LENGTH * 2];
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) 4167 ((q[1] ==
':' && (q[2] ==
'\\' || q[2] ==
'/')) ||
4168 q[0] ==
'\\' || q[0] ==
'/' || q[0] ==
'.'))) {
4172 for (i = 0; q[i] !=
'\0'; i++) {
4177 rc = sqlite3_load_extension(d->
sqlite, q, 0, &errmsg);
4179 rc = sqlite3_load_extension(d->
sqlite, path, 0, &errmsg);
4181 if (rc != SQLITE_OK) {
4182 #if defined(_WIN32) || defined(_WIN64) 4183 char buf[512], msg[512];
4185 LoadString(hModule, IDS_EXTERR, buf,
sizeof (buf));
4186 wsprintf(msg, buf, q, errmsg ?
4187 errmsg :
"no error info available");
4188 LoadString(hModule, IDS_EXTTITLE, buf,
sizeof (buf));
4189 MessageBox(NULL, msg, buf,
4190 MB_ICONEXCLAMATION | MB_OK | MB_TASKMODAL |
4193 fprintf(stderr,
"extension '%s' did not load%s%s\n",
4194 path, errmsg ?
": " :
"", errmsg ? errmsg :
"");
4217 char *
typename = (
char *) sqlite3_column_decltype(s3stmt, col);
4222 int coltype = sqlite3_column_type(s3stmt, col);
4224 if (guessed_types) {
4228 sprintf(guess,
" (guessed from %d)", coltype);
4231 case SQLITE_INTEGER:
typename =
"integer";
break;
4232 case SQLITE_FLOAT:
typename =
"double";
break;
4234 case SQLITE_TEXT:
typename =
"varchar";
break;
4235 case SQLITE_BLOB:
typename =
"blob";
break;
4237 case SQLITE_NULL:
typename =
"null";
break;
4242 fprintf(d->
trace,
"-- column %d type%s: '%s'\n", col + 1,
4249 #ifdef FULL_METADATA 4260 s3stmt_addmeta(sqlite3_stmt *s3stmt,
int col,
DBC *d,
COL *ci)
4262 int nn = 0, pk = 0, ai = 0;
4263 const char *dn = NULL, *tn = NULL, *cn = NULL, *dummy[4];
4265 dn = sqlite3_column_database_name(s3stmt, col);
4266 tn = sqlite3_column_table_name(s3stmt, col);
4267 cn = sqlite3_column_origin_name(s3stmt, col);
4268 dummy[0] = dummy[1] = 0;
4270 sqlite3_table_column_metadata(d->
sqlite, dn, tn, cn,
4274 ci->
autoinc = ai ? SQL_TRUE: SQL_FALSE;
4275 ci->
notnull = nn ? SQL_NO_NULLS : SQL_NULLABLE;
4276 ci->
ispk = pk ? 1 : 0;
4278 fprintf(d->
trace,
"-- column %d %s\n",
4279 col + 1, nn ?
"notnull" :
"nullable");
4281 fprintf(d->
trace,
"-- column %d autoincrement\n", col + 1);
4286 if (ci->
ispk && tn) {
4288 dummy[2] = dummy[3] = 0;
4290 sqlite3_table_column_metadata(d->
sqlite, dn, tn,
"rowid",
4291 dummy + 2, dummy + 3,
4293 if (pk && dummy[0] && dummy[0] == dummy[2]) {
4312 const char *errp = NULL;
4316 setstat(s, -1,
"stale statement", (*s->
ov3) ?
"HY000" :
"S1000");
4319 rc = sqlite3_step(s->
s3stmt);
4320 if (rc == SQLITE_ROW || rc == SQLITE_DONE) {
4322 ncols = sqlite3_column_count(s->
s3stmt);
4327 const char *colname, *
typename;
4328 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME) 4332 for (i = size = 0; i < ncols; i++) {
4333 colname = sqlite3_column_name(s->
s3stmt, i);
4334 size += 3 + 3 * strlen(colname);
4336 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME) 4337 tblname = (
char *) size;
4338 for (i = 0; i < ncols; i++) {
4339 p = (
char *) sqlite3_column_table_name(s->
s3stmt, i);
4340 size += 2 + (p ? strlen(p) : 0);
4343 dyncols =
xmalloc(ncols *
sizeof (
COL) + size);
4348 sqlite3_finalize(s->
s3stmt);
4353 p = (
char *) (dyncols + ncols);
4354 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME) 4357 for (i = 0; i < ncols; i++) {
4360 colname = sqlite3_column_name(s->
s3stmt, i);
4362 fprintf(d->
trace,
"-- column %d name: '%s'\n",
4366 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME) 4367 q = (
char *) sqlite3_column_table_name(s->
s3stmt, i);
4368 strcpy(tblname, q ? q :
"");
4370 fprintf(d->
trace,
"-- table %d name: '%s'\n",
4374 dyncols[i].
table = tblname;
4375 tblname += strlen(tblname) + 1;
4378 dyncols[i].
db = ((
DBC *) (s->
dbc))->dbname;
4380 dyncols[i].
label = p;
4382 q = strchr(colname,
'.');
4384 char *q2 = strchr(q + 1,
'.');
4392 #if !defined(HAVE_SQLITE3COLUMNTABLENAME) || !(HAVE_SQLITE3COLUMNTABLENAME) 4393 dyncols[i].
table = p;
4395 strncpy(p, colname, q - colname);
4396 p[q - colname] =
'\0';
4402 #if !defined(HAVE_SQLITE3COLUMNTABLENAME) || !(HAVE_SQLITE3COLUMNTABLENAME) 4403 dyncols[i].
table =
"";
4412 #ifdef SQL_LONGVARCHAR 4413 dyncols[i].
type = SQL_LONGVARCHAR;
4414 dyncols[i].
size = 65535;
4416 dyncols[i].
type = SQL_VARCHAR;
4417 dyncols[i].
size = 255;
4419 dyncols[i].
index = i;
4420 dyncols[i].
scale = 0;
4421 dyncols[i].
prec = 0;
4423 dyncols[i].
autoinc = SQL_FALSE;
4424 dyncols[i].
notnull = SQL_NULLABLE;
4425 dyncols[i].
ispk = -1;
4427 #ifdef FULL_METADATA 4428 s3stmt_addmeta(s->
s3stmt, i, d, &dyncols[i]);
4442 if (rc == SQLITE_DONE) {
4446 sqlite3_finalize(s->
s3stmt);
4451 rowd =
xmalloc((1 + 2 * ncols) *
sizeof (
char *));
4453 const unsigned char *value;
4455 rowd[0] = (
char *) ((
PTRDIFF_T) (ncols * 2));
4457 for (i = 0; i < ncols; i++) {
4458 int coltype = sqlite3_column_type(s->
s3stmt, i);
4460 rowd[i] = rowd[i + ncols] = NULL;
4461 if (coltype == SQLITE_BLOB) {
4462 int k, nbytes = sqlite3_column_bytes(s->
s3stmt, i);
4464 unsigned const char *bp;
4466 bp = sqlite3_column_blob(s->
s3stmt, i);
4469 rowd[i + ncols] = qp;
4472 for (k = 0; k < nbytes; k++) {
4473 *qp++ =
xdigits[(bp[k] >> 4)];
4474 *qp++ =
xdigits[(bp[k] & 0xF)];
4480 }
else if (coltype == SQLITE_FLOAT) {
4481 struct lconv *lc = 0;
4482 double d = sqlite3_column_double(s->
s3stmt, i);
4483 char *p, buffer[128];
4490 snprintf(buffer,
sizeof (buffer),
"%.15g", d);
4492 if (lc && lc->decimal_point && lc->decimal_point[0] &&
4493 lc->decimal_point[0] !=
'.') {
4494 p = strchr(buffer, lc->decimal_point[0]);
4499 rowd[i + ncols] =
xstrdup(buffer);
4501 }
else if (coltype != SQLITE_NULL) {
4502 value = sqlite3_column_text(s->
s3stmt, i);
4503 rowd[i + ncols] =
xstrdup((
char *) value);
4506 for (i = 0; i < ncols; i++) {
4507 int coltype = sqlite3_column_type(s->
s3stmt, i);
4510 if (coltype == SQLITE_BLOB) {
4511 value = sqlite3_column_blob(s->
s3stmt, i);
4512 }
else if (coltype != SQLITE_NULL) {
4513 value = sqlite3_column_text(s->
s3stmt, i);
4515 if (value && !rowd[i + ncols]) {
4527 if (rc == SQLITE_DONE) {
4529 sqlite3_finalize(s->
s3stmt);
4538 rc = sqlite3_reset(s->
s3stmt);
4540 errp = sqlite3_errmsg(d->
sqlite);
4544 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
4545 errp ? errp :
"unknown error", rc);
4568 sqlite3_reset(s->
s3stmt);
4609 sqlite3_finalize(s->
s3stmt);
4626 sqlite3_stmt *s3stmt = NULL;
4631 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 4638 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 4639 rc = sqlite3_prepare_v2(d->
sqlite, (
char *) s->
query, -1,
4642 rc = sqlite3_prepare(d->
sqlite, (
char *) s->
query, -1,
4645 if (rc != SQLITE_OK) {
4647 sqlite3_finalize(s3stmt);
4651 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
4653 if (rc != SQLITE_OK) {
4656 sqlite3_finalize(s3stmt);
4658 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
4659 sqlite3_errmsg(d->
sqlite), rc);
4662 if (sqlite3_bind_parameter_count(s3stmt) != s->
nparams) {
4664 sqlite3_finalize(s3stmt);
4665 setstat(s, SQLITE_ERROR,
"parameter marker count incorrect",
4666 (*s->
ov3) ?
"HY000" :
"S1000");
4685 SQLDataSources(SQLHENV env, SQLUSMALLINT dir, SQLCHAR *srvname,
4686 SQLSMALLINT buflen1, SQLSMALLINT *lenp1,
4687 SQLCHAR *desc, SQLSMALLINT buflen2, SQLSMALLINT *lenp2)
4689 if (env == SQL_NULL_HENV) {
4690 return SQL_INVALID_HANDLE;
4703 SQLSMALLINT buflen1, SQLSMALLINT *lenp1,
4704 SQLWCHAR *desc, SQLSMALLINT buflen2, SQLSMALLINT *lenp2)
4706 if (env == SQL_NULL_HENV) {
4707 return SQL_INVALID_HANDLE;
4719 SQLDrivers(SQLHENV env, SQLUSMALLINT dir, SQLCHAR *drvdesc,
4720 SQLSMALLINT descmax, SQLSMALLINT *desclenp,
4721 SQLCHAR *drvattr, SQLSMALLINT attrmax, SQLSMALLINT *attrlenp)
4723 if (env == SQL_NULL_HENV) {
4724 return SQL_INVALID_HANDLE;
4737 SQLSMALLINT descmax, SQLSMALLINT *desclenp,
4738 SQLWCHAR *drvattr, SQLSMALLINT attrmax, SQLSMALLINT *attrlenp)
4740 if (env == SQL_NULL_HENV) {
4741 return SQL_INVALID_HANDLE;
4753 SQLBrowseConnect(SQLHDBC
dbc, SQLCHAR *connin, SQLSMALLINT conninLen,
4754 SQLCHAR *connout, SQLSMALLINT connoutMax,
4755 SQLSMALLINT *connoutLen)
4773 SQLWCHAR *connout, SQLSMALLINT connoutMax,
4774 SQLSMALLINT *connoutLen)
4797 int i, dlen, done = 0;
4800 if (
stmt == SQL_NULL_HSTMT) {
4801 return SQL_INVALID_HANDLE;
4806 setstat(s, -1,
"sequence error",
"HY010");
4809 for (i = (s->
pdcount < 0) ? 0 : s->
pdcount; i < s->nparams; i++) {
4814 if (len == SQL_NULL_DATA) {
4817 p->
len = SQL_NULL_DATA;
4819 }
else if (type != SQL_C_CHAR
4821 && type != SQL_C_WCHAR
4823 && type != SQL_C_BINARY) {
4828 case SQL_C_UTINYINT:
4829 case SQL_C_STINYINT:
4833 size =
sizeof (SQLCHAR);
4838 size =
sizeof (SQLSMALLINT);
4843 size =
sizeof (SQLINTEGER);
4848 size =
sizeof (SQLBIGINT);
4852 size =
sizeof (float);
4855 size =
sizeof (double);
4857 #ifdef SQL_C_TYPE_DATE 4858 case SQL_C_TYPE_DATE:
4861 size =
sizeof (DATE_STRUCT);
4863 #ifdef SQL_C_TYPE_DATE 4864 case SQL_C_TYPE_TIME:
4867 size =
sizeof (TIME_STRUCT);
4869 #ifdef SQL_C_TYPE_DATE 4870 case SQL_C_TYPE_TIMESTAMP:
4872 case SQL_C_TIMESTAMP:
4873 size =
sizeof (TIMESTAMP_STRUCT);
4882 memcpy(p->
param, data, size);
4885 }
else if (len == SQL_NTS && (
4888 || type == SQL_C_WCHAR
4894 if (type == SQL_C_WCHAR) {
4901 #if defined(_WIN32) || defined(_WIN64) 4903 dp = wmb_to_utf(data, strlen (data));
4919 strcpy(p->
param, dp);
4925 }
else if (len < 0) {
4926 setstat(s, -1,
"invalid length",
"HY090");
4931 setstat(s, -1,
"no memory for parameter",
"HY013");
4934 memcpy((
char *) p->
param + p->
offs, data, dlen);
4938 if (type == SQL_C_WCHAR) {
4960 *((
char *) p->
param + p->
len) =
'\0';
4962 p->
need = (type == SQL_C_CHAR || type == SQL_C_WCHAR)
4965 *((
char *) p->
param + p->
len) =
'\0';
4966 p->
need = (type == SQL_C_CHAR) ? -1 : 0;
4968 #if defined(_WIN32) || defined(_WIN64) 4969 if (type == SQL_C_CHAR && *s->
oemcp &&
4970 !(p->
stype == SQL_BINARY ||
4971 p->
stype == SQL_VARBINARY ||
4972 p->
stype == SQL_LONGVARBINARY)) {
4973 char *dp = wmb_to_utf(p->
param, p->
len);
4982 p->
len = strlen(dp);
4984 if (p->
type == SQL_C_WCHAR &&
4985 (p->
stype == SQL_VARCHAR ||
4986 p->
stype == SQL_LONGVARCHAR) &&
4987 p->
len == p->
coldef * sizeof (SQLWCHAR)) {
5056 int type, len = 0, needalloc = 0;
5064 #if (defined(_WIN32) || defined(_WIN64)) && defined(WINTERFACE) 5066 if (type == SQL_C_WCHAR && p->
type == SQL_C_DEFAULT) {
5079 if (type == SQL_C_CHAR &&
5080 (p->
stype == SQL_BINARY ||
5081 p->
stype == SQL_VARBINARY ||
5082 p->
stype == SQL_LONGVARBINARY)) {
5083 type = SQL_C_BINARY;
5095 }
else if (*p->
lenp == SQL_DATA_AT_EXEC) {
5099 if (len <= SQL_LEN_DATA_AT_EXEC_OFFSET) {
5100 len = SQL_LEN_DATA_AT_EXEC(len);
5104 setstat(s, -1,
"invalid length",
"HY009");
5121 if (type == SQL_C_WCHAR) {
5122 if (!p->
lenp || *p->
lenp == SQL_NTS) {
5124 }
else if (*p->
lenp >= 0) {
5129 if (type == SQL_C_CHAR) {
5130 if (!p->
lenp || *p->
lenp == SQL_NTS) {
5132 #if defined(_WIN32) || defined(_WIN64) 5135 }
else if (*p->
lenp >= 0) {
5145 if (type == SQL_C_WCHAR) {
5161 if (type == SQL_C_CHAR) {
5166 #if defined(_WIN32) || defined(_WIN64) 5178 #if defined(_WIN32) || defined(_WIN64) 5180 p->
len = strlen(dp);
5199 case SQL_C_UTINYINT:
5201 case SQL_C_STINYINT:
5202 p->
s3type = SQLITE_INTEGER;
5203 p->
s3size =
sizeof (int);
5207 p->
s3type = SQLITE_INTEGER;
5208 p->
s3size =
sizeof (int);
5213 p->
s3type = SQLITE_INTEGER;
5214 p->
s3size =
sizeof (int);
5218 p->
s3type = SQLITE_INTEGER;
5219 p->
s3size =
sizeof (int);
5224 p->
s3type = SQLITE_INTEGER;
5225 p->
s3size =
sizeof (int);
5230 p->
s3type = SQLITE_INTEGER;
5231 p->
s3size =
sizeof (int);
5237 p->
s3type = SQLITE_INTEGER;
5238 p->
s3size =
sizeof (sqlite_int64);
5242 p->
s3type = SQLITE_INTEGER;
5243 p->
s3size =
sizeof (sqlite_int64);
5248 p->
s3type = SQLITE_FLOAT;
5249 p->
s3size =
sizeof (double);
5253 p->
s3type = SQLITE_FLOAT;
5254 p->
s3size =
sizeof (double);
5257 #ifdef SQL_C_TYPE_DATE 5258 case SQL_C_TYPE_DATE:
5262 int a, b, x1, x2, y, m, d;
5264 p->
s3type = SQLITE_FLOAT;
5265 p->
s3size =
sizeof (double);
5266 y = ((DATE_STRUCT *) p->
param)->year;
5267 m = ((DATE_STRUCT *) p->
param)->month;
5268 d = ((DATE_STRUCT *) p->
param)->day;
5274 b = 2 - a + (a / 4);
5275 x1 = 36525 * (y + 4716) / 100;
5276 x2 = 306001 * (m + 1) / 10000;
5277 p->
s3dval = x1 + x2 + d + b - 1524.5;
5280 sprintf(p->
strbuf,
"%04d-%02d-%02d",
5281 ((DATE_STRUCT *) p->
param)->year,
5282 ((DATE_STRUCT *) p->
param)->month,
5283 ((DATE_STRUCT *) p->
param)->day);
5288 #ifdef SQL_C_TYPE_TIME 5289 case SQL_C_TYPE_TIME:
5293 p->
s3type = SQLITE_FLOAT;
5294 p->
s3size =
sizeof (double);
5296 (((TIME_STRUCT *) p->
param)->hour * 3600000.0 +
5297 ((TIME_STRUCT *) p->
param)->minute * 60000.0 +
5298 ((TIME_STRUCT *) p->
param)->second * 1000.0) / 86400000.0;
5301 sprintf(p->
strbuf,
"%02d:%02d:%02d",
5302 ((TIME_STRUCT *) p->
param)->hour,
5303 ((TIME_STRUCT *) p->
param)->minute,
5304 ((TIME_STRUCT *) p->
param)->second);
5309 #ifdef SQL_C_TYPE_TIMESTAMP 5310 case SQL_C_TYPE_TIMESTAMP:
5312 case SQL_C_TIMESTAMP:
5314 int a, b, x1, x2, y, m, d;
5316 p->
s3type = SQLITE_FLOAT;
5317 p->
s3size =
sizeof (double);
5318 y = ((TIMESTAMP_STRUCT *) p->
param)->year;
5319 m = ((TIMESTAMP_STRUCT *) p->
param)->month;
5320 d = ((TIMESTAMP_STRUCT *) p->
param)->day;
5326 b = 2 - a + (a / 4);
5327 x1 = 36525 * (y + 4716) / 100;
5328 x2 = 306001 * (m + 1) / 10000;
5329 p->
s3dval = x1 + x2 + d + b - 1524.5 +
5330 (((TIMESTAMP_STRUCT *) p->
param)->hour * 3600000.0 +
5331 ((TIMESTAMP_STRUCT *) p->
param)->minute * 60000.0 +
5332 ((TIMESTAMP_STRUCT *) p->
param)->second * 1000.0 +
5333 ((TIMESTAMP_STRUCT *) p->
param)->fraction / 1.0E6)
5337 len = (int) ((TIMESTAMP_STRUCT *) p->
param)->fraction;
5344 sprintf(p->
strbuf,
"%04d-%02d-%02d %02d:%02d:00.000",
5345 ((TIMESTAMP_STRUCT *) p->
param)->year,
5346 ((TIMESTAMP_STRUCT *) p->
param)->month,
5347 ((TIMESTAMP_STRUCT *) p->
param)->day,
5348 ((TIMESTAMP_STRUCT *) p->
param)->hour,
5349 ((TIMESTAMP_STRUCT *) p->
param)->minute);
5351 sprintf(p->
strbuf,
"%04d-%02d-%02d %02d:%02d:%02d.000",
5352 ((TIMESTAMP_STRUCT *) p->
param)->year,
5353 ((TIMESTAMP_STRUCT *) p->
param)->month,
5354 ((TIMESTAMP_STRUCT *) p->
param)->day,
5355 ((TIMESTAMP_STRUCT *) p->
param)->hour,
5356 ((TIMESTAMP_STRUCT *) p->
param)->minute,
5357 ((TIMESTAMP_STRUCT *) p->
param)->second);
5359 sprintf(p->
strbuf,
"%04d-%02d-%02d %02d:%02d:%02d.%03d",
5360 ((TIMESTAMP_STRUCT *) p->
param)->year,
5361 ((TIMESTAMP_STRUCT *) p->
param)->month,
5362 ((TIMESTAMP_STRUCT *) p->
param)->day,
5363 ((TIMESTAMP_STRUCT *) p->
param)->hour,
5364 ((TIMESTAMP_STRUCT *) p->
param)->minute,
5365 ((TIMESTAMP_STRUCT *) p->
param)->second,
5374 setstat(s, -1,
"unsupported parameter type",
5375 (*s->
ov3) ?
"07009" :
"S1093");
5398 SQLSMALLINT buftype, SQLSMALLINT ptype, SQLUINTEGER coldef,
5400 SQLPOINTER data, SQLINTEGER buflen,
SQLLEN *len)
5405 if (
stmt == SQL_NULL_HSTMT) {
5406 return SQL_INVALID_HANDLE;
5410 setstat(s, -1,
"invalid parameter", (*s->
ov3) ?
"07009" :
"S1093");
5413 if (!data && !len) {
5414 setstat(s, -1,
"invalid buffer",
"HY003");
5434 int npar =
max(10, pnum + 1);
5444 case SQL_C_STINYINT:
5445 case SQL_C_UTINYINT:
5450 buflen =
sizeof (SQLCHAR);
5455 buflen =
sizeof (SQLSMALLINT);
5460 buflen =
sizeof (SQLINTEGER);
5463 buflen =
sizeof (float);
5466 buflen =
sizeof (double);
5468 case SQL_C_TIMESTAMP:
5469 #ifdef SQL_C_TYPE_TIMESTAMP 5470 case SQL_C_TYPE_TIMESTAMP:
5472 buflen =
sizeof (TIMESTAMP_STRUCT);
5475 #ifdef SQL_C_TYPE_TIME 5476 case SQL_C_TYPE_TIME:
5478 buflen =
sizeof (TIME_STRUCT);
5481 #ifdef SQL_C_TYPE_DATE 5482 case SQL_C_TYPE_DATE:
5484 buflen =
sizeof (DATE_STRUCT);
5486 #ifdef SQL_C_UBIGINT 5488 buflen =
sizeof (SQLBIGINT);
5491 #ifdef SQL_C_SBIGINT 5493 buflen =
sizeof (SQLBIGINT);
5498 buflen =
sizeof (SQLBIGINT);
5537 SQLSMALLINT buftype, SQLSMALLINT ptype,
SQLULEN coldef,
5545 scale, data, buflen, len);
5566 SQLSMALLINT ptype,
SQLULEN lenprec,
5567 SQLSMALLINT scale, SQLPOINTER val,
5574 lenprec, scale, val, 0, lenp);
5594 if (
stmt == SQL_NULL_HSTMT) {
5595 return SQL_INVALID_HANDLE;
5617 if (*p->
lenp == SQL_DATA_AT_EXEC) {
5620 p->
len = SQL_LEN_DATA_AT_EXEC(*p->
lenp);
5622 if (p->
len < 0 && p->
len != SQL_NTS &&
5623 p->
len != SQL_NULL_DATA) {
5624 setstat(s, -1,
"invalid length",
"HY009");
5637 return SQL_NEED_DATA;
5657 if (
stmt == SQL_NULL_HSTMT) {
5658 return SQL_INVALID_HANDLE;
5667 for (i = 0; i < s->
pdcount; i++) {
5672 p->
need = (type == SQL_C_CHAR || type == SQL_C_WCHAR) ? -1 : 0;
5678 *pind = (SQLPOINTER) p->
param0;
5703 SQLULEN *size, SQLSMALLINT *decdigits, SQLSMALLINT *nullable)
5706 SQLRETURN ret = SQL_ERROR;
5709 if (
stmt == SQL_NULL_HSTMT) {
5710 return SQL_INVALID_HANDLE;
5715 setstat(s, -1,
"invalid parameter index",
5716 (*s->
ov3) ?
"HY000" :
"S1000");
5720 #ifdef SQL_LONGVARCHAR 5722 *dtype = s->
nowchar[0] ? SQL_LONGVARCHAR : SQL_WLONGVARCHAR;
5724 *dtype = SQL_LONGVARCHAR;
5728 *dtype = s->
nowchar[0] ? SQL_VARCHAR : SQL_WVARCHAR;
5730 *dtype = SQL_VARCHAR;
5735 #ifdef SQL_LONGVARCHAR 5745 *nullable = SQL_NULLABLE;
5768 SQLSMALLINT sqltype,
SQLULEN coldef,
5769 SQLSMALLINT scale, SQLPOINTER val,
SQLLEN *nval)
5775 type, sqltype, coldef, scale, val,
5776 SQL_SETPARAM_VALUE_MAX, nval);
5802 SQLGetDescField(SQLHDESC handle, SQLSMALLINT recno,
5803 SQLSMALLINT fieldid, SQLPOINTER value,
5804 SQLINTEGER buflen, SQLINTEGER *strlen)
5817 SQLSMALLINT fieldid, SQLPOINTER value,
5818 SQLINTEGER buflen, SQLINTEGER *strlen)
5830 SQLSetDescField(SQLHDESC handle, SQLSMALLINT recno,
5831 SQLSMALLINT fieldid, SQLPOINTER value,
5845 SQLSMALLINT fieldid, SQLPOINTER value,
5858 SQLGetDescRec(SQLHDESC handle, SQLSMALLINT recno,
5859 SQLCHAR *name, SQLSMALLINT buflen,
5860 SQLSMALLINT *strlen, SQLSMALLINT *type,
5861 SQLSMALLINT *subtype,
SQLLEN *len,
5862 SQLSMALLINT *prec, SQLSMALLINT *scale,
5863 SQLSMALLINT *nullable)
5876 SQLWCHAR *name, SQLSMALLINT buflen,
5877 SQLSMALLINT *strlen, SQLSMALLINT *type,
5878 SQLSMALLINT *subtype,
SQLLEN *len,
5879 SQLSMALLINT *prec, SQLSMALLINT *scale,
5880 SQLSMALLINT *nullable)
5892 SQLSMALLINT type, SQLSMALLINT subtype,
5893 SQLLEN len, SQLSMALLINT prec,
5894 SQLSMALLINT scale, SQLPOINTER data,
5913 int ncols3,
int *nret)
5918 if (
stmt == SQL_NULL_HSTMT) {
5919 return SQL_INVALID_HANDLE;
5922 if (s->
dbc == SQL_NULL_HDBC) {
5932 if (colspec3 && *s->
ov3) {
5955 {
"SYSTEM",
"TABLEPRIV",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
5956 {
"SYSTEM",
"TABLEPRIV",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
5957 {
"SYSTEM",
"TABLEPRIV",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
5958 {
"SYSTEM",
"TABLEPRIV",
"GRANTOR",
SCOL_VARCHAR, 50 },
5959 {
"SYSTEM",
"TABLEPRIV",
"GRANTEE",
SCOL_VARCHAR, 50 },
5960 {
"SYSTEM",
"TABLEPRIV",
"PRIVILEGE",
SCOL_VARCHAR, 50 },
5961 {
"SYSTEM",
"TABLEPRIV",
"IS_GRANTABLE",
SCOL_VARCHAR, 50 }
5965 {
"SYSTEM",
"TABLEPRIV",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
5966 {
"SYSTEM",
"TABLEPRIV",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
5967 {
"SYSTEM",
"TABLEPRIV",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
5968 {
"SYSTEM",
"TABLEPRIV",
"GRANTOR",
SCOL_VARCHAR, 50 },
5969 {
"SYSTEM",
"TABLEPRIV",
"GRANTEE",
SCOL_VARCHAR, 50 },
5970 {
"SYSTEM",
"TABLEPRIV",
"PRIVILEGE",
SCOL_VARCHAR, 50 },
5971 {
"SYSTEM",
"TABLEPRIV",
"IS_GRANTABLE",
SCOL_VARCHAR, 50 }
5988 SQLCHAR *cat, SQLSMALLINT catLen,
5989 SQLCHAR *schema, SQLSMALLINT schemaLen,
5990 SQLCHAR *table, SQLSMALLINT tableLen)
5995 int ncols, rc, size, npatt;
5996 char *errp = NULL, *sql, tname[512];
6000 if (ret != SQL_SUCCESS) {
6005 if (cat && (catLen > 0 || catLen == SQL_NTS) && cat[0] ==
'%') {
6009 if (schema && (schemaLen > 0 || schemaLen == SQL_NTS) &&
6011 if ((!cat || catLen == 0 || !cat[0]) &&
6012 (!table || tableLen == 0 || !table[0])) {
6022 if (tableLen == SQL_NTS) {
6023 size =
sizeof (tname) - 1;
6025 size =
min(
sizeof (tname) - 1, tableLen);
6027 strncpy(tname, (
char *) table, size);
6031 #if defined(_WIN32) || defined(_WIN64) 6032 sql = sqlite3_mprintf(
"select %s as 'TABLE_QUALIFIER', " 6033 "%s as 'TABLE_OWNER', " 6034 "tbl_name as 'TABLE_NAME', " 6037 "'SELECT' AS 'PRIVILEGE', " 6038 "NULL as 'IS_GRANTABLE' " 6039 "from sqlite_master where " 6040 "(type = 'table' or type = 'view') " 6041 "and tbl_name %s %Q " 6043 "select %s as 'TABLE_QUALIFIER', " 6044 "%s as 'TABLE_OWNER', " 6045 "tbl_name as 'TABLE_NAME', " 6048 "'UPDATE' AS 'PRIVILEGE', " 6049 "NULL as 'IS_GRANTABLE' " 6050 "from sqlite_master where " 6051 "(type = 'table' or type = 'view') " 6052 "and tbl_name %s %Q " 6054 "select %s as 'TABLE_QUALIFIER', " 6055 "%s as 'TABLE_OWNER', " 6056 "tbl_name as 'TABLE_NAME', " 6059 "'DELETE' AS 'PRIVILEGE', " 6060 "NULL as 'IS_GRANTABLE' " 6061 "from sqlite_master where " 6062 "(type = 'table' or type = 'view') " 6063 "and tbl_name %s %Q " 6065 "select %s as 'TABLE_QUALIFIER', " 6066 "%s as 'TABLE_OWNER', " 6067 "tbl_name as 'TABLE_NAME', " 6070 "'INSERT' AS 'PRIVILEGE', " 6071 "NULL as 'IS_GRANTABLE' " 6072 "from sqlite_master where " 6073 "(type = 'table' or type = 'view') " 6074 "and tbl_name %s %Q " 6076 "select %s as 'TABLE_QUALIFIER', " 6077 "%s as 'TABLE_OWNER', " 6078 "tbl_name as 'TABLE_NAME', " 6081 "'REFERENCES' AS 'PRIVILEGE', " 6082 "NULL as 'IS_GRANTABLE' " 6083 "from sqlite_master where " 6084 "(type = 'table' or type = 'view') " 6085 "and tbl_name %s %Q",
6086 d->xcelqrx ?
"'main'" :
"NULL",
6087 d->xcelqrx ?
"''" :
"NULL",
6088 npatt ?
"like" :
"=", tname,
6089 d->xcelqrx ?
"'main'" :
"NULL",
6090 d->xcelqrx ?
"''" :
"NULL",
6091 npatt ?
"like" :
"=", tname,
6092 d->xcelqrx ?
"'main'" :
"NULL",
6093 d->xcelqrx ?
"''" :
"NULL",
6094 npatt ?
"like" :
"=", tname,
6095 d->xcelqrx ?
"'main'" :
"NULL",
6096 d->xcelqrx ?
"''" :
"NULL",
6097 npatt ?
"like" :
"=", tname,
6098 d->xcelqrx ?
"'main'" :
"NULL",
6099 d->xcelqrx ?
"''" :
"NULL",
6100 npatt ?
"like" :
"=", tname);
6102 sql = sqlite3_mprintf(
"select NULL as 'TABLE_QUALIFIER', " 6103 "NULL as 'TABLE_OWNER', " 6104 "tbl_name as 'TABLE_NAME', " 6107 "'SELECT' AS 'PRIVILEGE', " 6108 "NULL as 'IS_GRANTABLE' " 6109 "from sqlite_master where " 6110 "(type = 'table' or type = 'view') " 6111 "and tbl_name %s %Q " 6113 "select NULL as 'TABLE_QUALIFIER', " 6114 "NULL as 'TABLE_OWNER', " 6115 "tbl_name as 'TABLE_NAME', " 6118 "'UPDATE' AS 'PRIVILEGE', " 6119 "NULL as 'IS_GRANTABLE' " 6120 "from sqlite_master where " 6121 "(type = 'table' or type = 'view') " 6122 "and tbl_name %s %Q " 6124 "select NULL as 'TABLE_QUALIFIER', " 6125 "NULL as 'TABLE_OWNER', " 6126 "tbl_name as 'TABLE_NAME', " 6129 "'DELETE' AS 'PRIVILEGE', " 6130 "NULL as 'IS_GRANTABLE' " 6131 "from sqlite_master where " 6132 "(type = 'table' or type = 'view') " 6133 "and tbl_name %s %Q " 6135 "select NULL as 'TABLE_QUALIFIER', " 6136 "NULL as 'TABLE_OWNER', " 6137 "tbl_name as 'TABLE_NAME', " 6140 "'INSERT' AS 'PRIVILEGE', " 6141 "NULL as 'IS_GRANTABLE' " 6142 "from sqlite_master where " 6143 "(type = 'table' or type = 'view') " 6144 "and tbl_name %s %Q " 6146 "select NULL as 'TABLE_QUALIFIER', " 6147 "NULL as 'TABLE_OWNER', " 6148 "tbl_name as 'TABLE_NAME', " 6151 "'REFERENCES' AS 'PRIVILEGE', " 6152 "NULL as 'IS_GRANTABLE' " 6153 "from sqlite_master where " 6154 "(type = 'table' or type = 'view') " 6155 "and tbl_name %s %Q",
6156 npatt ?
"like" :
"=", tname,
6157 npatt ?
"like" :
"=", tname,
6158 npatt ?
"like" :
"=", tname,
6159 npatt ?
"like" :
"=", tname,
6160 npatt ?
"like" :
"=", tname);
6166 if (ret != SQL_SUCCESS) {
6171 rc = sqlite3_get_table(d->
sqlite, sql, &s->
rows, &s->
nrows, &ncols, &errp);
6173 if (rc == SQLITE_OK) {
6174 if (ncols != s->
ncols) {
6178 s->
rowfree = sqlite3_free_table;
6194 #if !defined(WINTERFACE) || (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC)) 6208 SQLTablePrivileges(SQLHSTMT
stmt,
6209 SQLCHAR *catalog, SQLSMALLINT catalogLen,
6210 SQLCHAR *schema, SQLSMALLINT schemaLen,
6211 SQLCHAR *table, SQLSMALLINT tableLen)
6213 #if defined(_WIN32) || defined(_WIN64) 6214 char *c = NULL, *s = NULL, *t = NULL;
6219 #if defined(_WIN32) || defined(_WIN64) 6226 c = wmb_to_utf_c((
char *) catalog, catalogLen);
6233 s = wmb_to_utf_c((
char *) schema, schemaLen);
6240 t = wmb_to_utf_c((
char *) table, tableLen);
6247 (SQLCHAR *) s, SQL_NTS,
6248 (SQLCHAR *) t, SQL_NTS);
6253 #if defined(_WIN32) || defined(_WIN64) 6266 #if !defined(HAVE_UNIXODBC) || !(HAVE_UNIXODBC) 6282 SQLWCHAR *catalog, SQLSMALLINT catalogLen,
6283 SQLWCHAR *schema, SQLSMALLINT schemaLen,
6284 SQLWCHAR *table, SQLSMALLINT tableLen)
6286 char *c = NULL, *s = NULL, *t = NULL;
6312 (SQLCHAR *) s, SQL_NTS,
6313 (SQLCHAR *) t, SQL_NTS);
6329 {
"SYSTEM",
"COLPRIV",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
6330 {
"SYSTEM",
"COLPRIV",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
6331 {
"SYSTEM",
"COLPRIV",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
6332 {
"SYSTEM",
"COLPRIV",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6339 {
"SYSTEM",
"COLPRIV",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
6340 {
"SYSTEM",
"COLPRIV",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
6341 {
"SYSTEM",
"COLPRIV",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
6342 {
"SYSTEM",
"COLPRIV",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6348 #if !defined(WINTERFACE) || (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC)) 6364 SQLColumnPrivileges(SQLHSTMT
stmt,
6365 SQLCHAR *catalog, SQLSMALLINT catalogLen,
6366 SQLCHAR *schema, SQLSMALLINT schemaLen,
6367 SQLCHAR *table, SQLSMALLINT tableLen,
6368 SQLCHAR *column, SQLSMALLINT columnLen)
6380 #if !defined(HAVE_UNIXODBC) || !(HAVE_UNIXODBC) 6398 SQLWCHAR *catalog, SQLSMALLINT catalogLen,
6399 SQLWCHAR *schema, SQLSMALLINT schemaLen,
6400 SQLWCHAR *table, SQLSMALLINT tableLen,
6401 SQLWCHAR *column, SQLSMALLINT columnLen)
6419 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
6420 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
6421 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
6422 {
"SYSTEM",
"PRIMARYKEY",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6423 {
"SYSTEM",
"PRIMARYKEY",
"KEY_SEQ", SQL_SMALLINT, 50 },
6424 {
"SYSTEM",
"PRIMARYKEY",
"PK_NAME",
SCOL_VARCHAR, 50 }
6428 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
6429 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
6430 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
6431 {
"SYSTEM",
"PRIMARYKEY",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6432 {
"SYSTEM",
"PRIMARYKEY",
"KEY_SEQ", SQL_SMALLINT, 50 },
6433 {
"SYSTEM",
"PRIMARYKEY",
"PK_NAME",
SCOL_VARCHAR, 50 }
6450 SQLCHAR *cat, SQLSMALLINT catLen,
6451 SQLCHAR *schema, SQLSMALLINT schemaLen,
6452 SQLCHAR *table, SQLSMALLINT tableLen)
6457 int i, asize, ret, nrows, ncols, nrows2 = 0, ncols2 = 0;
6458 int namec = -1, uniquec = -1, namec2 = -1, uniquec2 = -1, offs, seq = 1;
6460 char **rowp = NULL, **rowp2 = NULL, *errp = NULL, *sql, tname[512];
6464 if (sret != SQL_SUCCESS) {
6469 if (!table || table[0] ==
'\0' || table[0] ==
'%') {
6470 setstat(s, -1,
"need table name", (*s->
ov3) ?
"HY000" :
"S1000");
6473 if (tableLen == SQL_NTS) {
6474 size =
sizeof (tname) - 1;
6476 size =
min(
sizeof (tname) - 1, tableLen);
6478 strncpy(tname, (
char *) table, size);
6481 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", tname);
6486 if (sret != SQL_SUCCESS) {
6491 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
6493 if (ret != SQLITE_OK) {
6494 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
6495 errp ? errp :
"unknown error", ret);
6507 if (ncols * nrows > 0) {
6510 namec =
findcol(rowp, ncols,
"name");
6511 uniquec =
findcol(rowp, ncols,
"pk");
6512 typec =
findcol(rowp, ncols,
"type");
6513 if (namec >= 0 && uniquec >= 0 && typec >= 0) {
6514 for (i = 1; i <= nrows; i++) {
6515 if (*rowp[i * ncols + uniquec] !=
'0') {
6522 sql = sqlite3_mprintf(
"PRAGMA index_list(%Q)", tname);
6524 sqlite3_free_table(rowp);
6528 ret = sqlite3_get_table(d->
sqlite, sql, &rowp2, &nrows2, &ncols2,
6531 if (ret != SQLITE_OK) {
6532 sqlite3_free_table(rowp);
6533 sqlite3_free_table(rowp2);
6534 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
6535 errp ? errp :
"unknown error", ret);
6547 if (ncols2 * nrows2 > 0) {
6548 namec2 =
findcol(rowp2, ncols2,
"name");
6549 uniquec2 =
findcol(rowp2, ncols2,
"unique");
6550 if (namec2 >= 0 && uniquec2 >= 0) {
6551 for (i = 1; i <= nrows2; i++) {
6552 int nnrows, nncols, nlen = 0;
6555 if (rowp2[i * ncols2 + namec2]) {
6556 nlen = strlen(rowp2[i * ncols2 + namec2]);
6559 strncmp(rowp2[i * ncols2 + namec2],
6560 "sqlite_autoindex_", 17)) {
6563 if (*rowp2[i * ncols2 + uniquec2] !=
'0') {
6565 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
6566 rowp2[i * ncols2 + namec2]);
6569 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
6570 &nnrows, &nncols, NULL);
6573 if (ret == SQLITE_OK) {
6575 sqlite3_free_table(rowpp);
6582 sqlite3_free_table(rowp);
6583 sqlite3_free_table(rowp2);
6587 size = (size + 1) * asize;
6591 sqlite3_free_table(rowp);
6592 sqlite3_free_table(rowp2);
6595 s->
rows[0] = (
char *) size;
6597 memset(s->
rows, 0, sizeof (
char *) * size);
6601 for (i = 1; i <= nrows; i++) {
6602 if (*rowp[i * ncols + uniquec] !=
'0') {
6605 #if defined(_WIN32) || defined(_WIN64) 6606 s->
rows[offs + 0] =
xstrdup(d->xcelqrx ?
"main" :
"");
6613 s->
rows[offs + 3] =
xstrdup(rowp[i * ncols + namec]);
6614 sprintf(buf,
"%d", seq++);
6621 for (i = 1; i <= nrows2; i++) {
6622 int nnrows, nncols, nlen = 0;
6625 if (rowp2[i * ncols2 + namec2]) {
6626 nlen = strlen(rowp2[i * ncols2 + namec2]);
6629 strncmp(rowp2[i * ncols2 + namec2],
"sqlite_autoindex_", 17)) {
6632 if (*rowp2[i * ncols2 + uniquec2] !=
'0') {
6636 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
6637 rowp2[i * ncols2 + namec2]);
6640 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
6641 &nnrows, &nncols, NULL);
6644 if (ret != SQLITE_OK) {
6647 for (k = 0; nnrows && k < nncols; k++) {
6648 if (strcmp(rowpp[k],
"name") == 0) {
6651 for (m = 1; m <= nnrows; m++) {
6652 int roffs = offs + (m - 1) * s->
ncols;
6654 #
if defined(_WIN32) || defined(_WIN64)
6655 s->
rows[roffs + 0] =
6656 xstrdup(d->xcelqrx ?
"main" :
"");
6663 s->
rows[roffs + 3] =
6664 xstrdup(rowpp[m * nncols + k]);
6665 s->
rows[roffs + 5] =
6666 xstrdup(rowp2[i * ncols2 + namec2]);
6668 }
else if (strcmp(rowpp[k],
"seqno") == 0) {
6671 for (m = 1; m <= nnrows; m++) {
6672 int roffs = offs + (m - 1) * s->
ncols;
6676 sscanf(rowpp[m * nncols + k],
"%d", &pos);
6677 sprintf(buf,
"%d", pos + 1);
6682 offs += nnrows * s->
ncols;
6683 sqlite3_free_table(rowpp);
6687 sqlite3_free_table(rowp);
6688 sqlite3_free_table(rowp2);
6706 SQLPrimaryKeys(SQLHSTMT
stmt,
6707 SQLCHAR *cat, SQLSMALLINT catLen,
6708 SQLCHAR *schema, SQLSMALLINT schemaLen,
6709 SQLCHAR *table, SQLSMALLINT tableLen)
6711 #if defined(_WIN32) || defined(_WIN64) 6712 char *c = NULL, *s = NULL, *t = NULL;
6717 #if defined(_WIN32) || defined(_WIN64) 6724 c = wmb_to_utf_c((
char *) cat, catLen);
6731 s = wmb_to_utf_c((
char *) schema, schemaLen);
6738 t = wmb_to_utf_c((
char *) table, tableLen);
6745 (SQLCHAR *) s, SQL_NTS, (SQLCHAR *) t, SQL_NTS);
6750 #if defined(_WIN32) || defined(_WIN64) 6778 SQLWCHAR *cat, SQLSMALLINT catLen,
6779 SQLWCHAR *schema, SQLSMALLINT schemaLen,
6780 SQLWCHAR *table, SQLSMALLINT tableLen)
6782 char *c = NULL, *s = NULL, *t = NULL;
6808 (SQLCHAR *) s, SQL_NTS, (SQLCHAR *) t, SQL_NTS);
6823 {
"SYSTEM",
"COLUMN",
"SCOPE", SQL_SMALLINT, 1 },
6824 {
"SYSTEM",
"COLUMN",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6825 {
"SYSTEM",
"COLUMN",
"DATA_TYPE", SQL_SMALLINT, 50 },
6827 {
"SYSTEM",
"COLUMN",
"PRECISION", SQL_INTEGER, 50 },
6828 {
"SYSTEM",
"COLUMN",
"LENGTH", SQL_INTEGER, 50 },
6829 {
"SYSTEM",
"COLUMN",
"DECIMAL_DIGITS", SQL_INTEGER, 50 },
6830 {
"SYSTEM",
"COLUMN",
"PSEUDO_COLUMN", SQL_SMALLINT, 1 },
6831 {
"SYSTEM",
"COLUMN",
"NULLABLE", SQL_SMALLINT, 1 }
6835 {
"SYSTEM",
"COLUMN",
"SCOPE", SQL_SMALLINT, 1 },
6836 {
"SYSTEM",
"COLUMN",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6837 {
"SYSTEM",
"COLUMN",
"DATA_TYPE", SQL_SMALLINT, 50 },
6839 {
"SYSTEM",
"COLUMN",
"COLUMN_SIZE", SQL_INTEGER, 50 },
6840 {
"SYSTEM",
"COLUMN",
"BUFFER_LENGTH", SQL_INTEGER, 50 },
6841 {
"SYSTEM",
"COLUMN",
"DECIMAL_DIGITS", SQL_INTEGER, 50 },
6842 {
"SYSTEM",
"COLUMN",
"PSEUDO_COLUMN", SQL_SMALLINT, 1 },
6843 {
"SYSTEM",
"COLUMN",
"NULLABLE", SQL_SMALLINT, 1 }
6863 SQLCHAR *cat, SQLSMALLINT catLen,
6864 SQLCHAR *schema, SQLSMALLINT schemaLen,
6865 SQLCHAR *table, SQLSMALLINT tableLen,
6866 SQLUSMALLINT scope, SQLUSMALLINT nullable)
6871 int i, asize, ret, nrows, ncols, nnnrows, nnncols, offs;
6873 int namec = -1, uniquec = -1, namecc = -1, typecc = -1;
6874 int notnullcc = -1, mkrowid = 0;
6875 char *errp = NULL, *sql, tname[512];
6876 char **rowp = NULL, **rowppp = NULL;
6880 if (sret != SQL_SUCCESS) {
6885 if (!table || table[0] ==
'\0' || table[0] ==
'%') {
6886 setstat(s, -1,
"need table name", (*s->
ov3) ?
"HY000" :
"S1000");
6889 if (tableLen == SQL_NTS) {
6890 size =
sizeof (tname) - 1;
6892 size =
min(
sizeof (tname) - 1, tableLen);
6894 strncpy(tname, (
char *) table, size);
6897 if (
id != SQL_BEST_ROWID) {
6900 sql = sqlite3_mprintf(
"PRAGMA index_list(%Q)", tname);
6905 if (sret != SQL_SUCCESS) {
6910 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
6912 if (ret != SQLITE_OK) {
6914 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
6915 errp ? errp :
"unknown error", ret);
6927 if (ncols * nrows <= 0) {
6928 goto nodata_but_rowid;
6930 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", tname);
6935 ret = sqlite3_get_table(d->
sqlite, sql, &rowppp, &nnnrows, &nnncols,
6938 if (ret != SQLITE_OK) {
6939 sqlite3_free_table(rowp);
6946 namec =
findcol(rowp, ncols,
"name");
6947 uniquec =
findcol(rowp, ncols,
"unique");
6948 if (namec < 0 || uniquec < 0) {
6949 goto nodata_but_rowid;
6951 namecc =
findcol(rowppp, nnncols,
"name");
6952 typecc =
findcol(rowppp, nnncols,
"type");
6953 notnullcc =
findcol(rowppp, nnncols,
"notnull");
6954 for (i = 1; i <= nrows; i++) {
6956 char **rowpp = NULL;
6958 if (*rowp[i * ncols + uniquec] !=
'0') {
6960 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
6961 rowp[i * ncols + namec]);
6964 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
6965 &nnrows, &nncols, NULL);
6968 if (ret == SQLITE_OK) {
6970 sqlite3_free_table(rowpp);
6980 size = (size + 1) * asize;
6984 sqlite3_free_table(rowp);
6985 sqlite3_free_table(rowppp);
6988 s->
rows[0] = (
char *) size;
6990 memset(s->
rows, 0, sizeof (
char *) * size);
6997 for (i = 1; i <= nrows; i++) {
6999 char **rowpp = NULL;
7001 if (*rowp[i * ncols + uniquec] !=
'0') {
7005 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
7006 rowp[i * ncols + namec]);
7009 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
7010 &nnrows, &nncols, NULL);
7013 if (ret != SQLITE_OK) {
7016 for (k = 0; nnrows && k < nncols; k++) {
7017 if (strcmp(rowpp[k],
"name") == 0) {
7020 for (m = 1; m <= nnrows; m++) {
7021 int roffs = (offs + m) * s->
ncols;
7023 s->
rows[roffs + 0] =
7025 s->
rows[roffs + 1] =
xstrdup(rowpp[m * nncols + k]);
7027 s->
rows[roffs + 7] =
7029 if (namecc >= 0 && typecc >= 0) {
7032 for (ii = 1; ii <= nnnrows; ii++) {
7033 if (strcmp(rowppp[ii * nnncols + namecc],
7034 rowpp[m * nncols + k]) == 0) {
7035 char *typen = rowppp[ii * nnncols + typecc];
7036 int sqltype, mm, dd, isnullable = 0;
7043 getmd(typen, sqltype, &mm, &dd);
7044 #ifdef SQL_LONGVARCHAR 7045 if (sqltype == SQL_VARCHAR && mm > 255) {
7046 sqltype = SQL_LONGVARCHAR;
7050 #ifdef SQL_WLONGVARCHAR 7051 if (sqltype == SQL_WVARCHAR && mm > 255) {
7052 sqltype = SQL_WLONGVARCHAR;
7056 if (sqltype == SQL_VARBINARY && mm > 255) {
7057 sqltype = SQL_LONGVARBINARY;
7059 sprintf(buf,
"%d", sqltype);
7061 sprintf(buf,
"%d", mm);
7063 sprintf(buf,
"%d", dd);
7065 if (notnullcc >= 0) {
7067 rowppp[ii * nnncols + notnullcc];
7069 isnullable = inp[0] !=
'0';
7071 sprintf(buf,
"%d", isnullable);
7080 sqlite3_free_table(rowpp);
7083 if (nullable == SQL_NO_NULLS) {
7084 for (i = 1; i < s->
nrows; i++) {
7085 if (s->
rows[i * s->
ncols + 8][0] ==
'0') {
7088 for (m = 0; m < s->
ncols; m++) {
7091 size = s->
ncols *
sizeof (
char *) * (s->
nrows - i1);
7097 s->
ncols * sizeof (
char *));
7105 sqlite3_free_table(rowp);
7106 sqlite3_free_table(rowppp);
7107 if (s->
nrows == 0) {
7139 SQLSpecialColumns(SQLHSTMT
stmt, SQLUSMALLINT
id,
7140 SQLCHAR *cat, SQLSMALLINT catLen,
7141 SQLCHAR *schema, SQLSMALLINT schemaLen,
7142 SQLCHAR *table, SQLSMALLINT tableLen,
7143 SQLUSMALLINT scope, SQLUSMALLINT nullable)
7145 #if defined(_WIN32) || defined(_WIN64) 7146 char *c = NULL, *s = NULL, *t = NULL;
7151 #if defined(_WIN32) || defined(_WIN64) 7154 table, tableLen, scope, nullable);
7158 c = wmb_to_utf_c((
char *) cat, catLen);
7165 s = wmb_to_utf_c((
char *) schema, schemaLen);
7172 t = wmb_to_utf_c((
char *) table, tableLen);
7179 (SQLCHAR *) s, SQL_NTS, (SQLCHAR *) t, SQL_NTS,
7183 table, tableLen, scope, nullable);
7185 #if defined(_WIN32) || defined(_WIN64) 7216 SQLWCHAR *cat, SQLSMALLINT catLen,
7217 SQLWCHAR *schema, SQLSMALLINT schemaLen,
7218 SQLWCHAR *table, SQLSMALLINT tableLen,
7219 SQLUSMALLINT scope, SQLUSMALLINT nullable)
7221 char *c = NULL, *s = NULL, *t = NULL;
7247 (SQLCHAR *) s, SQL_NTS, (SQLCHAR *) t, SQL_NTS,
7263 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
7264 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_OWNER",
SCOL_VARCHAR, 50 },
7265 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_NAME",
SCOL_VARCHAR, 255 },
7266 {
"SYSTEM",
"FOREIGNKEY",
"PKCOLUMN_NAME",
SCOL_VARCHAR, 255 },
7267 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
7268 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_OWNER",
SCOL_VARCHAR, 50 },
7269 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_NAME",
SCOL_VARCHAR, 255 },
7270 {
"SYSTEM",
"FOREIGNKEY",
"FKCOLUMN_NAME",
SCOL_VARCHAR, 255 },
7271 {
"SYSTEM",
"FOREIGNKEY",
"KEY_SEQ", SQL_SMALLINT, 5 },
7272 {
"SYSTEM",
"FOREIGNKEY",
"UPDATE_RULE", SQL_SMALLINT, 5 },
7273 {
"SYSTEM",
"FOREIGNKEY",
"DELETE_RULE", SQL_SMALLINT, 5 },
7274 {
"SYSTEM",
"FOREIGNKEY",
"FK_NAME",
SCOL_VARCHAR, 255 },
7275 {
"SYSTEM",
"FOREIGNKEY",
"PK_NAME",
SCOL_VARCHAR, 255 },
7276 {
"SYSTEM",
"FOREIGNKEY",
"DEFERRABILITY", SQL_SMALLINT, 5 }
7280 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_CAT",
SCOL_VARCHAR, 50 },
7281 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_SCHEM",
SCOL_VARCHAR, 50 },
7282 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_NAME",
SCOL_VARCHAR, 255 },
7283 {
"SYSTEM",
"FOREIGNKEY",
"PKCOLUMN_NAME",
SCOL_VARCHAR, 255 },
7284 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_CAT",
SCOL_VARCHAR, 50 },
7285 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_SCHEM",
SCOL_VARCHAR, 50 },
7286 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_NAME",
SCOL_VARCHAR, 255 },
7287 {
"SYSTEM",
"FOREIGNKEY",
"FKCOLUMN_NAME",
SCOL_VARCHAR, 255 },
7288 {
"SYSTEM",
"FOREIGNKEY",
"KEY_SEQ", SQL_SMALLINT, 5 },
7289 {
"SYSTEM",
"FOREIGNKEY",
"UPDATE_RULE", SQL_SMALLINT, 5 },
7290 {
"SYSTEM",
"FOREIGNKEY",
"DELETE_RULE", SQL_SMALLINT, 5 },
7291 {
"SYSTEM",
"FOREIGNKEY",
"FK_NAME",
SCOL_VARCHAR, 255 },
7292 {
"SYSTEM",
"FOREIGNKEY",
"PK_NAME",
SCOL_VARCHAR, 255 },
7293 {
"SYSTEM",
"FOREIGNKEY",
"DEFERRABILITY", SQL_SMALLINT, 5 }
7316 SQLCHAR *PKcatalog, SQLSMALLINT PKcatalogLen,
7317 SQLCHAR *PKschema, SQLSMALLINT PKschemaLen,
7318 SQLCHAR *PKtable, SQLSMALLINT PKtableLen,
7319 SQLCHAR *FKcatalog, SQLSMALLINT FKcatalogLen,
7320 SQLCHAR *FKschema, SQLSMALLINT FKschemaLen,
7321 SQLCHAR *FKtable, SQLSMALLINT FKtableLen)
7326 int i, asize, ret, nrows, ncols, offs, namec, seqc, fromc, toc;
7329 char **rowp, *errp = NULL, *sql, pname[512], fname[512];
7333 if (sret != SQL_SUCCESS) {
7338 if (sret != SQL_SUCCESS) {
7342 if ((!PKtable || PKtable[0] ==
'\0' || PKtable[0] ==
'%') &&
7343 (!FKtable || FKtable[0] ==
'\0' || FKtable[0] ==
'%')) {
7344 setstat(s, -1,
"need table name", (*s->
ov3) ?
"HY000" :
"S1000");
7349 if (PKtableLen == SQL_NTS) {
7350 size =
sizeof (pname) - 1;
7352 size =
min(
sizeof (pname) - 1, PKtableLen);
7354 strncpy(pname, (
char *) PKtable, size);
7360 if (FKtableLen == SQL_NTS) {
7361 size =
sizeof (fname) - 1;
7363 size =
min(
sizeof (fname) - 1, FKtableLen);
7365 strncpy(fname, (
char *) FKtable, size);
7368 if (fname[0] !=
'\0') {
7372 sql = sqlite3_mprintf(
"PRAGMA foreign_key_list(%Q)", fname);
7375 ret = sqlite3_get_table(d->
sqlite, sql, &rowp,
7376 &nrows, &ncols, &errp);
7379 if (ret != SQLITE_OK) {
7380 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
7381 errp ? errp :
"unknown error", ret);
7392 if (ncols * nrows <= 0) {
7394 sqlite3_free_table(rowp);
7398 namec =
findcol(rowp, ncols,
"table");
7399 seqc =
findcol(rowp, ncols,
"seq");
7400 fromc =
findcol(rowp, ncols,
"from");
7401 toc =
findcol(rowp, ncols,
"to");
7402 onu =
findcol(rowp, ncols,
"on_update");
7403 ond =
findcol(rowp, ncols,
"on_delete");
7404 if (namec < 0 || seqc < 0 || fromc < 0 || toc < 0) {
7407 plen = strlen(pname);
7408 for (i = 1; i <= nrows; i++) {
7409 char *ptab =
unquote(rowp[i * ncols + namec]);
7412 int len = strlen(ptab);
7414 if (plen != len || strncasecmp(pname, ptab, plen) != 0) {
7424 size = (size + 1) * asize;
7430 s->
rows[0] = (
char *) size;
7432 memset(s->
rows, 0, sizeof (
char *) * size);
7435 for (i = 1; i <= nrows; i++) {
7436 int pos = 0, roffs = (offs + 1) * s->
ncols;
7437 char *ptab = rowp[i * ncols + namec];
7441 int len = strlen(ptab);
7443 if (plen != len || strncasecmp(pname, ptab, plen) != 0) {
7447 #if defined(_WIN32) || defined(_WIN64) 7448 s->
rows[roffs + 0] =
xstrdup(d->xcelqrx ?
"main" :
"");
7455 s->
rows[roffs + 3] =
xstrdup(rowp[i * ncols + toc]);
7459 s->
rows[roffs + 7] =
xstrdup(rowp[i * ncols + fromc]);
7460 sscanf(rowp[i * ncols + seqc],
"%d", &pos);
7461 sprintf(buf,
"%d", pos + 1);
7466 if (strcmp(rowp[i * ncols + onu],
"SET NULL") == 0) {
7468 }
else if (strcmp(rowp[i * ncols + onu],
"SET DEFAULT") == 0) {
7470 }
else if (strcmp(rowp[i * ncols + onu],
"CASCADE") == 0) {
7472 }
else if (strcmp(rowp[i * ncols + onu],
"RESTRICT") == 0) {
7481 if (strcmp(rowp[i * ncols + ond],
"SET NULL") == 0) {
7483 }
else if (strcmp(rowp[i * ncols + ond],
"SET DEFAULT") == 0) {
7485 }
else if (strcmp(rowp[i * ncols + ond],
"CASCADE") == 0) {
7487 }
else if (strcmp(rowp[i * ncols + ond],
"RESTRICT") == 0) {
7493 s->
rows[roffs + 11] = NULL;
7494 s->
rows[roffs + 12] = NULL;
7498 sqlite3_free_table(rowp);
7500 int nnrows, nncols, plen = strlen(pname);
7503 sql =
"select name from sqlite_master where type='table'";
7505 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
7506 if (ret != SQLITE_OK) {
7507 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
7508 errp ? errp :
"unknown error", ret);
7519 if (ncols * nrows <= 0) {
7523 for (i = 1; i <= nrows; i++) {
7531 sql = sqlite3_mprintf(
"PRAGMA foreign_key_list(%Q)", rowp[i]);
7534 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
7535 &nnrows, &nncols, NULL);
7538 if (ret != SQLITE_OK || nncols * nnrows <= 0) {
7539 sqlite3_free_table(rowpp);
7542 namec =
findcol(rowpp, nncols,
"table");
7543 seqc =
findcol(rowpp, nncols,
"seq");
7544 fromc =
findcol(rowpp, nncols,
"from");
7545 toc =
findcol(rowpp, nncols,
"to");
7546 if (namec < 0 || seqc < 0 || fromc < 0 || toc < 0) {
7547 sqlite3_free_table(rowpp);
7550 for (k = 1; k <= nnrows; k++) {
7551 char *ptab =
unquote(rowpp[k * nncols + namec]);
7554 int len = strlen(ptab);
7556 if (len != plen || strncasecmp(pname, ptab, plen) != 0) {
7562 sqlite3_free_table(rowpp);
7568 size = (size + 1) * asize;
7574 s->
rows[0] = (
char *) size;
7576 memset(s->
rows, 0, sizeof (
char *) * size);
7579 for (i = 1; i <= nrows; i++) {
7587 sql = sqlite3_mprintf(
"PRAGMA foreign_key_list(%Q)", rowp[i]);
7590 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
7591 &nnrows, &nncols, NULL);
7594 if (ret != SQLITE_OK || nncols * nnrows <= 0) {
7595 sqlite3_free_table(rowpp);
7598 namec =
findcol(rowpp, nncols,
"table");
7599 seqc =
findcol(rowpp, nncols,
"seq");
7600 fromc =
findcol(rowpp, nncols,
"from");
7601 toc =
findcol(rowpp, nncols,
"to");
7602 onu =
findcol(rowpp, nncols,
"on_update");
7603 ond =
findcol(rowpp, nncols,
"on_delete");
7604 if (namec < 0 || seqc < 0 || fromc < 0 || toc < 0) {
7605 sqlite3_free_table(rowpp);
7608 for (k = 1; k <= nnrows; k++) {
7609 int pos = 0, roffs = (offs + 1) * s->
ncols;
7610 char *ptab =
unquote(rowpp[k * nncols + namec]);
7614 int len = strlen(ptab);
7616 if (len != plen || strncasecmp(pname, ptab, plen) != 0) {
7620 #if defined(_WIN32) || defined(_WIN64) 7621 s->
rows[roffs + 0] =
xstrdup(d->xcelqrx ?
"main" :
"");
7628 s->
rows[roffs + 3] =
xstrdup(rowpp[k * nncols + toc]);
7632 s->
rows[roffs + 7] =
xstrdup(rowpp[k * nncols + fromc]);
7633 sscanf(rowpp[k * nncols + seqc],
"%d", &pos);
7634 sprintf(buf,
"%d", pos + 1);
7639 if (strcmp(rowpp[k * nncols + onu],
"SET NULL") == 0) {
7641 }
else if (strcmp(rowpp[k * nncols + onu],
"SET DEFAULT")
7643 s->
rows[roffs + 9] =
7645 }
else if (strcmp(rowpp[k * nncols + onu],
"CASCADE")
7648 }
else if (strcmp(rowpp[k * nncols + onu],
"RESTRICT")
7652 s->
rows[roffs + 9] =
7659 if (strcmp(rowpp[k * nncols + ond],
"SET NULL") == 0) {
7661 }
else if (strcmp(rowpp[k * nncols + ond],
"SET DEFAULT")
7663 s->
rows[roffs + 10] =
7665 }
else if (strcmp(rowpp[k * nncols + ond],
"CASCADE")
7668 }
else if (strcmp(rowpp[k * nncols + ond],
"RESTRICT")
7672 s->
rows[roffs + 10] =
7676 s->
rows[roffs + 11] = NULL;
7677 s->
rows[roffs + 12] = NULL;
7681 sqlite3_free_table(rowpp);
7683 sqlite3_free_table(rowp);
7708 SQLForeignKeys(SQLHSTMT
stmt,
7709 SQLCHAR *PKcatalog, SQLSMALLINT PKcatalogLen,
7710 SQLCHAR *PKschema, SQLSMALLINT PKschemaLen,
7711 SQLCHAR *PKtable, SQLSMALLINT PKtableLen,
7712 SQLCHAR *FKcatalog, SQLSMALLINT FKcatalogLen,
7713 SQLCHAR *FKschema, SQLSMALLINT FKschemaLen,
7714 SQLCHAR *FKtable, SQLSMALLINT FKtableLen)
7716 #if defined(_WIN32) || defined(_WIN64) 7717 char *pc = NULL, *ps = NULL, *pt = NULL;
7718 char *fc = NULL, *fs = NULL, *ft = NULL;
7723 #if defined(_WIN32) || defined(_WIN64) 7726 PKcatalog, PKcatalogLen,
7727 PKschema, PKschemaLen, PKtable, PKtableLen,
7728 FKcatalog, FKcatalogLen,
7729 FKschema, FKschemaLen,
7730 FKtable, FKtableLen);
7734 pc = wmb_to_utf_c((
char *) PKcatalog, PKcatalogLen);
7741 ps = wmb_to_utf_c((
char *) PKschema, PKschemaLen);
7748 pt = wmb_to_utf_c((
char *) PKtable, PKtableLen);
7755 fc = wmb_to_utf_c((
char *) FKcatalog, FKcatalogLen);
7762 fs = wmb_to_utf_c((
char *) FKschema, FKschemaLen);
7769 ft = wmb_to_utf_c((
char *) FKtable, FKtableLen);
7776 (SQLCHAR *) ps, SQL_NTS, (SQLCHAR *) pt, SQL_NTS,
7777 (SQLCHAR *) fc, SQL_NTS, (SQLCHAR *) fs, SQL_NTS,
7778 (SQLCHAR *) ft, SQL_NTS);
7781 PKcatalog, PKcatalogLen,
7782 PKschema, PKschemaLen, PKtable, PKtableLen,
7783 FKcatalog, FKcatalogLen,
7784 FKschema, FKschemaLen,
7785 FKtable, FKtableLen);
7787 #if defined(_WIN32) || defined(_WIN64) 7824 SQLWCHAR *PKcatalog, SQLSMALLINT PKcatalogLen,
7825 SQLWCHAR *PKschema, SQLSMALLINT PKschemaLen,
7826 SQLWCHAR *PKtable, SQLSMALLINT PKtableLen,
7827 SQLWCHAR *FKcatalog, SQLSMALLINT FKcatalogLen,
7828 SQLWCHAR *FKschema, SQLSMALLINT FKschemaLen,
7829 SQLWCHAR *FKtable, SQLSMALLINT FKtableLen)
7831 char *pc = NULL, *ps = NULL, *pt = NULL;
7832 char *fc = NULL, *fs = NULL, *ft = NULL;
7879 (SQLCHAR *) ps, SQL_NTS, (SQLCHAR *) pt, SQL_NTS,
7880 (SQLCHAR *) fc, SQL_NTS, (SQLCHAR *) fs, SQL_NTS,
7881 (SQLCHAR *) ft, SQL_NTS);
7903 int ret = SQL_SUCCESS, rc, busy_count = 0;
7909 rc = sqlite3_exec(d->
sqlite,
"BEGIN TRANSACTION", NULL, NULL, &errp);
7910 if (rc == SQLITE_BUSY) {
7920 if (rc != SQLITE_OK) {
7921 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
7922 errp ? errp :
"unknown error", rc);
7946 int ret, busy_count = 0;
7947 char *sql, *errp = NULL;
7950 setstatd(d, -1,
"not connected", (*d->
ov3) ?
"HY000" :
"S1000");
7958 sql =
"COMMIT TRANSACTION";
7961 sql =
"ROLLBACK TRANSACTION";
7963 ret = sqlite3_exec(d->
sqlite, sql, NULL, NULL, &errp);
7965 if (ret == SQLITE_BUSY && busy_count < 10) {
7974 if (ret != SQLITE_OK) {
7975 setstatd(d, ret,
"%s", (*d->
ov3) ?
"HY000" :
"S1000",
7976 errp ? errp :
"transaction failed");
7990 setstatd(d, -1,
"invalid completion type", (*d->
ov3) ?
"HY000" :
"S1000");
8003 drvendtran(SQLSMALLINT type, SQLHANDLE handle, SQLSMALLINT comptype)
8008 #if defined(_WIN32) || defined(_WIN64) 8013 case SQL_HANDLE_DBC:
8015 if (handle == SQL_NULL_HDBC) {
8016 return SQL_INVALID_HANDLE;
8022 case SQL_HANDLE_ENV:
8023 if (handle == SQL_NULL_HENV) {
8024 return SQL_INVALID_HANDLE;
8026 #if defined(_WIN32) || defined(_WIN64) 8027 env = (
ENV *) handle;
8029 return SQL_INVALID_HANDLE;
8031 EnterCriticalSection(&env->cs);
8033 dbc = ((
ENV *) handle)->dbcs;
8038 if (ret != SQL_SUCCESS) {
8043 #if defined(_WIN32) || defined(_WIN64) 8044 LeaveCriticalSection(&env->cs);
8046 return fail ? SQL_ERROR : SQL_SUCCESS;
8048 return SQL_INVALID_HANDLE;
8060 SQLEndTran(SQLSMALLINT type, SQLHANDLE handle, SQLSMALLINT comptype)
8076 if (
dbc != SQL_NULL_HDBC) {
8079 return drvendtran(SQL_HANDLE_ENV, (SQLHANDLE) env, type);
8105 SQLNativeSql(SQLHSTMT
stmt, SQLCHAR *sqlin, SQLINTEGER sqlinLen,
8106 SQLCHAR *sql, SQLINTEGER sqlMax, SQLINTEGER *sqlLen)
8109 SQLRETURN ret = SQL_SUCCESS;
8112 if (sqlinLen == SQL_NTS) {
8113 sqlinLen = strlen((
char *) sqlin);
8117 strncpy((
char *) sql, (
char *) sqlin, sqlMax - 1);
8118 sqlin[sqlMax - 1] =
'\0';
8119 outLen =
min(sqlMax - 1, sqlinLen);
8127 if (sql && outLen < sqlinLen) {
8129 ret = SQL_SUCCESS_WITH_INFO;
8150 SQLWCHAR *sql, SQLINTEGER sqlMax, SQLINTEGER *sqlLen)
8153 SQLRETURN ret = SQL_SUCCESS;
8156 if (sqlinLen == SQL_NTS) {
8162 sqlin[sqlMax - 1] = 0;
8163 outLen =
min(sqlMax - 1, sqlinLen);
8171 if (sql && outLen < sqlinLen) {
8173 ret = SQL_SUCCESS_WITH_INFO;
8185 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_QUALIFIER",
SCOL_VARCHAR, 50 },
8186 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_OWNER",
SCOL_VARCHAR, 50 },
8187 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_NAME",
SCOL_VARCHAR, 255 },
8188 {
"SYSTEM",
"PROCEDURE",
"NUM_INPUT_PARAMS", SQL_SMALLINT, 5 },
8189 {
"SYSTEM",
"PROCEDURE",
"NUM_OUTPUT_PARAMS", SQL_SMALLINT, 5 },
8190 {
"SYSTEM",
"PROCEDURE",
"NUM_RESULT_SETS", SQL_SMALLINT, 5 },
8191 {
"SYSTEM",
"PROCEDURE",
"REMARKS",
SCOL_VARCHAR, 255 },
8192 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_TYPE", SQL_SMALLINT, 5 }
8196 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_CAT",
SCOL_VARCHAR, 50 },
8197 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_SCHEM",
SCOL_VARCHAR, 50 },
8198 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_NAME",
SCOL_VARCHAR, 255 },
8199 {
"SYSTEM",
"PROCEDURE",
"NUM_INPUT_PARAMS", SQL_SMALLINT, 5 },
8200 {
"SYSTEM",
"PROCEDURE",
"NUM_OUTPUT_PARAMS", SQL_SMALLINT, 5 },
8201 {
"SYSTEM",
"PROCEDURE",
"NUM_RESULT_SETS", SQL_SMALLINT, 5 },
8202 {
"SYSTEM",
"PROCEDURE",
"REMARKS",
SCOL_VARCHAR, 255 },
8203 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_TYPE", SQL_SMALLINT, 5 }
8220 SQLProcedures(SQLHSTMT
stmt,
8221 SQLCHAR *catalog, SQLSMALLINT catalogLen,
8222 SQLCHAR *schema, SQLSMALLINT schemaLen,
8223 SQLCHAR *proc, SQLSMALLINT procLen)
8250 SQLWCHAR *catalog, SQLSMALLINT catalogLen,
8251 SQLWCHAR *schema, SQLSMALLINT schemaLen,
8252 SQLWCHAR *proc, SQLSMALLINT procLen)
8269 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_QUALIFIER",
SCOL_VARCHAR, 50 },
8270 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_OWNER",
SCOL_VARCHAR, 50 },
8271 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_NAME",
SCOL_VARCHAR, 255 },
8272 {
"SYSTEM",
"PROCCOL",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
8273 {
"SYSTEM",
"PROCCOL",
"COLUMN_TYPE", SQL_SMALLINT, 5 },
8274 {
"SYSTEM",
"PROCCOL",
"DATA_TYPE", SQL_SMALLINT, 5 },
8275 {
"SYSTEM",
"PROCCOL",
"TYPE_NAME",
SCOL_VARCHAR, 50 },
8276 {
"SYSTEM",
"PROCCOL",
"PRECISION", SQL_INTEGER, 10 },
8277 {
"SYSTEM",
"PROCCOL",
"LENGTH", SQL_INTEGER, 10 },
8278 {
"SYSTEM",
"PROCCOL",
"SCALE", SQL_SMALLINT, 5 },
8279 {
"SYSTEM",
"PROCCOL",
"RADIX", SQL_SMALLINT, 5 },
8280 {
"SYSTEM",
"PROCCOL",
"NULLABLE", SQL_SMALLINT, 5 },
8282 {
"SYSTEM",
"PROCCOL",
"COLUMN_DEF",
SCOL_VARCHAR, 50 },
8283 {
"SYSTEM",
"PROCCOL",
"SQL_DATA_TYPE", SQL_SMALLINT, 5 },
8284 {
"SYSTEM",
"PROCCOL",
"SQL_DATETIME_SUB", SQL_SMALLINT, 5 },
8285 {
"SYSTEM",
"PROCCOL",
"CHAR_OCTET_LENGTH", SQL_SMALLINT, 5 },
8286 {
"SYSTEM",
"PROCCOL",
"ORDINAL_POSITION", SQL_SMALLINT, 5 },
8287 {
"SYSTEM",
"PROCCOL",
"IS_NULLABLE",
SCOL_VARCHAR, 50 }
8291 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_CAT",
SCOL_VARCHAR, 50 },
8292 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_SCHEM",
SCOL_VARCHAR, 50 },
8293 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_NAME",
SCOL_VARCHAR, 255 },
8294 {
"SYSTEM",
"PROCCOL",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
8295 {
"SYSTEM",
"PROCCOL",
"COLUMN_TYPE", SQL_SMALLINT, 5 },
8296 {
"SYSTEM",
"PROCCOL",
"DATA_TYPE", SQL_SMALLINT, 5 },
8297 {
"SYSTEM",
"PROCCOL",
"TYPE_NAME",
SCOL_VARCHAR, 50 },
8298 {
"SYSTEM",
"PROCCOL",
"COLUMN_SIZE", SQL_INTEGER, 10 },
8299 {
"SYSTEM",
"PROCCOL",
"BUFFER_LENGTH", SQL_INTEGER, 10 },
8300 {
"SYSTEM",
"PROCCOL",
"DECIMAL_DIGITS", SQL_SMALLINT, 5 },
8301 {
"SYSTEM",
"PROCCOL",
"NUM_PREC_RADIX", SQL_SMALLINT, 5 },
8302 {
"SYSTEM",
"PROCCOL",
"NULLABLE", SQL_SMALLINT, 5 },
8304 {
"SYSTEM",
"PROCCOL",
"COLUMN_DEF",
SCOL_VARCHAR, 50 },
8305 {
"SYSTEM",
"PROCCOL",
"SQL_DATA_TYPE", SQL_SMALLINT, 5 },
8306 {
"SYSTEM",
"PROCCOL",
"SQL_DATETIME_SUB", SQL_SMALLINT, 5 },
8307 {
"SYSTEM",
"PROCCOL",
"CHAR_OCTET_LENGTH", SQL_SMALLINT, 5 },
8308 {
"SYSTEM",
"PROCCOL",
"ORDINAL_POSITION", SQL_SMALLINT, 5 },
8309 {
"SYSTEM",
"PROCCOL",
"IS_NULLABLE",
SCOL_VARCHAR, 50 }
8328 SQLProcedureColumns(SQLHSTMT
stmt,
8329 SQLCHAR *catalog, SQLSMALLINT catalogLen,
8330 SQLCHAR *schema, SQLSMALLINT schemaLen,
8331 SQLCHAR *proc, SQLSMALLINT procLen,
8332 SQLCHAR *column, SQLSMALLINT columnLen)
8362 SQLWCHAR *catalog, SQLSMALLINT catalogLen,
8363 SQLWCHAR *schema, SQLSMALLINT schemaLen,
8364 SQLWCHAR *proc, SQLSMALLINT procLen,
8365 SQLWCHAR *column, SQLSMALLINT columnLen)
8389 SQLINTEGER len, SQLINTEGER *lenp)
8392 SQLRETURN ret = SQL_ERROR;
8394 if (env == SQL_NULL_HENV) {
8395 return SQL_INVALID_HANDLE;
8399 return SQL_INVALID_HANDLE;
8401 #if defined(_WIN32) || defined(_WIN64) 8402 EnterCriticalSection(&e->cs);
8405 case SQL_ATTR_CONNECTION_POOLING:
8408 case SQL_ATTR_CP_MATCH:
8411 case SQL_ATTR_OUTPUT_NTS:
8413 *((SQLINTEGER *) val) = SQL_TRUE;
8416 *lenp =
sizeof (SQLINTEGER);
8420 case SQL_ATTR_ODBC_VERSION:
8422 *((SQLINTEGER *) val) = e->
ov3 ? SQL_OV_ODBC3 : SQL_OV_ODBC2;
8425 *lenp =
sizeof (SQLINTEGER);
8430 #if defined(_WIN32) || defined(_WIN64) 8431 LeaveCriticalSection(&e->cs);
8449 SQLRETURN ret = SQL_ERROR;
8451 if (env == SQL_NULL_HENV) {
8452 return SQL_INVALID_HANDLE;
8456 return SQL_INVALID_HANDLE;
8458 #if defined(_WIN32) || defined(_WIN64) 8459 EnterCriticalSection(&e->cs);
8462 case SQL_ATTR_CONNECTION_POOLING:
8465 case SQL_ATTR_CP_MATCH:
8468 case SQL_ATTR_OUTPUT_NTS:
8469 if (val == (SQLPOINTER) SQL_TRUE) {
8473 case SQL_ATTR_ODBC_VERSION:
8477 if (val == (SQLPOINTER) SQL_OV_ODBC2) {
8481 if (val == (SQLPOINTER) SQL_OV_ODBC3) {
8487 #if defined(_WIN32) || defined(_WIN64) 8488 LeaveCriticalSection(&e->cs);
8508 SQLCHAR *sqlstate, SQLINTEGER *nativeerr, SQLCHAR *msg,
8509 SQLSMALLINT buflen, SQLSMALLINT *msglen)
8514 char *logmsg, *sqlst;
8515 SQLRETURN ret = SQL_ERROR;
8517 if (handle == SQL_NULL_HANDLE) {
8518 return SQL_INVALID_HANDLE;
8523 if (msg && buflen > 0) {
8533 case SQL_HANDLE_ENV:
8534 case SQL_HANDLE_DESC:
8536 case SQL_HANDLE_DBC:
8539 logmsg = (
char *) d->
logmsg;
8543 case SQL_HANDLE_STMT:
8545 s = (
STMT *) handle;
8546 logmsg = (
char *) s->
logmsg;
8551 return SQL_INVALID_HANDLE;
8560 len = strlen(logmsg);
8566 *nativeerr = naterr;
8569 strcpy((
char *) sqlstate, sqlst);
8574 if (len >= buflen) {
8575 if (msg && buflen > 0) {
8576 strncpy((
char *) msg, logmsg, buflen);
8577 msg[buflen - 1] =
'\0';
8581 strcpy((
char *) msg, logmsg);
8587 case SQL_HANDLE_DBC:
8590 case SQL_HANDLE_STMT:
8597 #if !defined(WINTERFACE) || (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC)) 8612 SQLGetDiagRec(SQLSMALLINT htype, SQLHANDLE handle, SQLSMALLINT recno,
8613 SQLCHAR *sqlstate, SQLINTEGER *nativeerr, SQLCHAR *msg,
8614 SQLSMALLINT buflen, SQLSMALLINT *msglen)
8617 nativeerr, msg, buflen, msglen);
8621 #if !defined(HAVE_UNIXODBC) || !(HAVE_UNIXODBC) 8639 SQLWCHAR *sqlstate, SQLINTEGER *nativeerr, SQLWCHAR *msg,
8640 SQLSMALLINT buflen, SQLSMALLINT *msglen)
8646 ret =
drvgetdiagrec(htype, handle, recno, (SQLCHAR *) state,
8647 nativeerr, (SQLCHAR *) msg, buflen, &len);
8648 if (ret == SQL_SUCCESS) {
8651 6 *
sizeof (SQLWCHAR));
8660 buflen /=
sizeof (SQLWCHAR);
8680 len *=
sizeof (SQLWCHAR);
8685 }
else if (ret == SQL_NO_DATA) {
8717 SQLSMALLINT
id, SQLPOINTER info,
8718 SQLSMALLINT buflen, SQLSMALLINT *stringlen)
8722 int len, naterr,
strbuf = 1;
8723 char *logmsg, *sqlst, *clrmsg = NULL;
8724 SQLRETURN ret = SQL_ERROR;
8726 if (handle == SQL_NULL_HANDLE) {
8727 return SQL_INVALID_HANDLE;
8733 case SQL_HANDLE_ENV:
8734 case SQL_HANDLE_DESC:
8736 case SQL_HANDLE_DBC:
8739 logmsg = (
char *) d->
logmsg;
8743 case SQL_HANDLE_STMT:
8745 s = (
STMT *) handle;
8747 logmsg = (
char *) s->
logmsg;
8752 return SQL_INVALID_HANDLE;
8756 case SQL_IS_POINTER:
8757 case SQL_IS_UINTEGER:
8758 case SQL_IS_INTEGER:
8759 case SQL_IS_USMALLINT:
8760 case SQL_IS_SMALLINT:
8773 case SQL_DIAG_CLASS_ORIGIN:
8774 logmsg =
"ISO 9075";
8775 if (sqlst[0] ==
'I' && sqlst[1] ==
'M') {
8776 logmsg =
"ODBC 3.0";
8779 case SQL_DIAG_SUBCLASS_ORIGIN:
8780 logmsg =
"ISO 9075";
8781 if (sqlst[0] ==
'I' && sqlst[1] ==
'M') {
8782 logmsg =
"ODBC 3.0";
8783 }
else if (sqlst[0] ==
'H' && sqlst[1] ==
'Y') {
8784 logmsg =
"ODBC 3.0";
8785 }
else if (sqlst[0] ==
'2' || sqlst[0] ==
'0' || sqlst[0] ==
'4') {
8786 logmsg =
"ODBC 3.0";
8789 case SQL_DIAG_CONNECTION_NAME:
8790 case SQL_DIAG_SERVER_NAME:
8791 logmsg = d->
dsn ? d->
dsn :
"No DSN";
8793 case SQL_DIAG_SQLSTATE:
8796 case SQL_DIAG_MESSAGE_TEXT:
8801 case SQL_DIAG_NUMBER:
8804 case SQL_DIAG_NATIVE:
8805 len = strlen(logmsg);
8811 *((SQLINTEGER *) info) = naterr;
8815 case SQL_DIAG_DYNAMIC_FUNCTION:
8818 case SQL_DIAG_CURSOR_ROW_COUNT:
8819 if (htype == SQL_HANDLE_STMT) {
8827 case SQL_DIAG_ROW_COUNT:
8828 if (htype == SQL_HANDLE_STMT) {
8839 if (info && buflen > 0) {
8840 ((
char *) info)[0] =
'\0';
8842 len = strlen(logmsg);
8851 if (len >= buflen) {
8852 if (info && buflen > 0) {
8854 *stringlen = buflen - 1;
8856 strncpy((
char *) info, logmsg, buflen);
8857 ((
char *) info)[buflen - 1] =
'\0';
8860 strcpy((
char *) info, logmsg);
8869 case SQL_HANDLE_DBC:
8872 case SQL_HANDLE_STMT:
8893 SQLGetDiagField(SQLSMALLINT htype, SQLHANDLE handle, SQLSMALLINT recno,
8894 SQLSMALLINT
id, SQLPOINTER info,
8895 SQLSMALLINT buflen, SQLSMALLINT *stringlen)
8897 return drvgetdiagfield(htype, handle, recno,
id, info, buflen, stringlen);
8916 SQLSMALLINT
id, SQLPOINTER info,
8917 SQLSMALLINT buflen, SQLSMALLINT *stringlen)
8923 if (ret == SQL_SUCCESS) {
8926 case SQL_DIAG_CLASS_ORIGIN:
8927 case SQL_DIAG_SUBCLASS_ORIGIN:
8928 case SQL_DIAG_CONNECTION_NAME:
8929 case SQL_DIAG_SERVER_NAME:
8930 case SQL_DIAG_SQLSTATE:
8931 case SQL_DIAG_MESSAGE_TEXT:
8932 case SQL_DIAG_DYNAMIC_FUNCTION:
8939 buflen /=
sizeof (SQLWCHAR);
8947 len *=
sizeof (SQLWCHAR);
8955 ((SQLWCHAR *) info)[0] = 0;
8961 case SQL_DIAG_CLASS_ORIGIN:
8962 case SQL_DIAG_SUBCLASS_ORIGIN:
8963 case SQL_DIAG_CONNECTION_NAME:
8964 case SQL_DIAG_SERVER_NAME:
8965 case SQL_DIAG_SQLSTATE:
8966 case SQL_DIAG_MESSAGE_TEXT:
8967 case SQL_DIAG_DYNAMIC_FUNCTION:
8968 len *=
sizeof (SQLWCHAR);
8992 SQLINTEGER bufmax, SQLINTEGER *buflen)
9003 uval = (SQLPOINTER) dummybuf;
9006 case SQL_QUERY_TIMEOUT:
9010 case SQL_ATTR_CURSOR_TYPE:
9014 case SQL_ATTR_CURSOR_SCROLLABLE:
9015 *uval = (s->
curtype != SQL_CURSOR_FORWARD_ONLY) ?
9016 SQL_SCROLLABLE : SQL_NONSCROLLABLE;
9019 #ifdef SQL_ATTR_CURSOR_SENSITIVITY 9020 case SQL_ATTR_CURSOR_SENSITIVITY:
9021 *uval = SQL_UNSPECIFIED;
9025 case SQL_ATTR_ROW_NUMBER:
9030 *uval = (s->
rowp < 0) ? SQL_ROW_NUMBER_UNKNOWN : (s->
rowp + 1);
9034 case SQL_ATTR_ASYNC_ENABLE:
9035 *uval = SQL_ASYNC_ENABLE_OFF;
9038 case SQL_CONCURRENCY:
9039 *uval = SQL_CONCUR_LOCK;
9042 case SQL_ATTR_RETRIEVE_DATA:
9046 case SQL_ROWSET_SIZE:
9047 case SQL_ATTR_ROW_ARRAY_SIZE:
9052 case SQL_ATTR_IMP_ROW_DESC:
9053 case SQL_ATTR_APP_ROW_DESC:
9054 case SQL_ATTR_IMP_PARAM_DESC:
9055 case SQL_ATTR_APP_PARAM_DESC:
9056 *((SQLHDESC *) uval) = (SQLHDESC)
DEAD_MAGIC;
9057 *buflen =
sizeof (SQLHDESC);
9059 case SQL_ATTR_ROW_STATUS_PTR:
9061 *buflen =
sizeof (SQLUSMALLINT *);
9063 case SQL_ATTR_ROWS_FETCHED_PTR:
9067 case SQL_ATTR_USE_BOOKMARKS: {
9070 *(SQLUINTEGER *) uval = s->
bkmrk;
9071 *buflen = sizeof (SQLUINTEGER);
9074 case SQL_ATTR_FETCH_BOOKMARK_PTR:
9075 *(SQLPOINTER *) uval = s->
bkmrkptr;
9076 *buflen = sizeof (SQLPOINTER);
9078 case SQL_ATTR_PARAM_BIND_OFFSET_PTR:
9082 case SQL_ATTR_PARAM_BIND_TYPE:
9086 case SQL_ATTR_PARAM_OPERATION_PTR:
9087 *((SQLUSMALLINT **) uval) = s->
parm_oper;
9088 *buflen =
sizeof (SQLUSMALLINT *);
9090 case SQL_ATTR_PARAM_STATUS_PTR:
9092 *buflen =
sizeof (SQLUSMALLINT *);
9094 case SQL_ATTR_PARAMS_PROCESSED_PTR:
9098 case SQL_ATTR_PARAMSET_SIZE:
9102 case SQL_ATTR_ROW_BIND_TYPE:
9106 case SQL_ATTR_ROW_BIND_OFFSET_PTR:
9110 case SQL_ATTR_MAX_ROWS:
9114 case SQL_ATTR_MAX_LENGTH:
9115 *((
SQLULEN *) uval) = 1000000000;
9118 #ifdef SQL_ATTR_METADATA_ID 9119 case SQL_ATTR_METADATA_ID:
9120 *((
SQLULEN *) uval) = SQL_FALSE;
9128 #if (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC)) || !defined(WINTERFACE) 9140 SQLGetStmtAttr(SQLHSTMT
stmt, SQLINTEGER attr, SQLPOINTER val,
9141 SQLINTEGER bufmax, SQLINTEGER *buflen)
9165 SQLINTEGER bufmax, SQLINTEGER *buflen)
9190 #if defined(SQL_BIGINT) && defined(__WORDSIZE) && (__WORDSIZE == 64) 9193 uval = (SQLBIGINT) val;
9200 case SQL_ATTR_CURSOR_TYPE:
9201 if (val == (SQLPOINTER) SQL_CURSOR_FORWARD_ONLY) {
9202 s->
curtype = SQL_CURSOR_FORWARD_ONLY;
9204 s->
curtype = SQL_CURSOR_STATIC;
9206 if (val != (SQLPOINTER) SQL_CURSOR_FORWARD_ONLY &&
9207 val != (SQLPOINTER) SQL_CURSOR_STATIC) {
9211 case SQL_ATTR_CURSOR_SCROLLABLE:
9212 if (val == (SQLPOINTER) SQL_NONSCROLLABLE) {
9213 s->
curtype = SQL_CURSOR_FORWARD_ONLY;
9215 s->
curtype = SQL_CURSOR_STATIC;
9218 case SQL_ATTR_ASYNC_ENABLE:
9219 if (val != (SQLPOINTER) SQL_ASYNC_ENABLE_OFF) {
9221 setstat(s, -1,
"option value changed",
"01S02");
9222 return SQL_SUCCESS_WITH_INFO;
9225 case SQL_CONCURRENCY:
9226 if (val != (SQLPOINTER) SQL_CONCUR_LOCK) {
9230 #ifdef SQL_ATTR_CURSOR_SENSITIVITY 9231 case SQL_ATTR_CURSOR_SENSITIVITY:
9232 if (val != (SQLPOINTER) SQL_UNSPECIFIED) {
9237 case SQL_ATTR_QUERY_TIMEOUT:
9239 case SQL_ATTR_RETRIEVE_DATA:
9240 if (val != (SQLPOINTER) SQL_RD_ON &&
9241 val != (SQLPOINTER) SQL_RD_OFF) {
9246 case SQL_ROWSET_SIZE:
9247 case SQL_ATTR_ROW_ARRAY_SIZE:
9249 setstat(s, -1,
"invalid rowset size",
"HY000");
9255 rst =
xmalloc(
sizeof (SQLUSMALLINT) * uval);
9267 case SQL_ATTR_ROW_STATUS_PTR:
9270 case SQL_ATTR_ROWS_FETCHED_PTR:
9273 case SQL_ATTR_PARAM_BIND_OFFSET_PTR:
9276 case SQL_ATTR_PARAM_BIND_TYPE:
9279 case SQL_ATTR_PARAM_OPERATION_PTR:
9282 case SQL_ATTR_PARAM_STATUS_PTR:
9285 case SQL_ATTR_PARAMS_PROCESSED_PTR:
9288 case SQL_ATTR_PARAMSET_SIZE:
9295 case SQL_ATTR_ROW_BIND_TYPE:
9298 case SQL_ATTR_ROW_BIND_OFFSET_PTR:
9301 case SQL_ATTR_USE_BOOKMARKS:
9302 if (val != (SQLPOINTER) SQL_UB_OFF &&
9303 val != (SQLPOINTER) SQL_UB_ON &&
9304 val != (SQLPOINTER) SQL_UB_VARIABLE) {
9307 if (*s->
ov3 && val == (SQLPOINTER) SQL_UB_VARIABLE) {
9308 s->
bkmrk = SQL_UB_VARIABLE;
9311 if (val == (SQLPOINTER) SQL_UB_VARIABLE) {
9312 s->
bkmrk = SQL_UB_ON;
9315 s->
bkmrk = (val == (SQLPOINTER) SQL_UB_ON) ? SQL_UB_ON : SQL_UB_OFF;
9317 case SQL_ATTR_FETCH_BOOKMARK_PTR:
9320 case SQL_ATTR_MAX_ROWS:
9323 case SQL_ATTR_MAX_LENGTH:
9324 if (val != (SQLPOINTER) 1000000000) {
9328 #ifdef SQL_ATTR_METADATA_ID 9329 case SQL_ATTR_METADATA_ID:
9330 if (val != (SQLPOINTER) SQL_FALSE) {
9339 #if (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC)) || !defined(WINTERFACE) 9350 SQLSetStmtAttr(SQLHSTMT
stmt, SQLINTEGER attr, SQLPOINTER val,
9397 SQLUINTEGER *ret = (SQLUINTEGER *) param;
9400 case SQL_QUERY_TIMEOUT:
9403 case SQL_CURSOR_TYPE:
9406 case SQL_ROW_NUMBER:
9411 *ret = (s->
rowp < 0) ? SQL_ROW_NUMBER_UNKNOWN : (s->
rowp + 1);
9414 case SQL_ASYNC_ENABLE:
9415 *ret = SQL_ASYNC_ENABLE_OFF;
9417 case SQL_CONCURRENCY:
9418 *ret = SQL_CONCUR_LOCK;
9420 case SQL_ATTR_RETRIEVE_DATA:
9423 case SQL_ROWSET_SIZE:
9424 case SQL_ATTR_ROW_ARRAY_SIZE:
9427 case SQL_ATTR_MAX_ROWS:
9430 case SQL_ATTR_MAX_LENGTH:
9491 case SQL_CURSOR_TYPE:
9492 if (param == SQL_CURSOR_FORWARD_ONLY) {
9495 s->
curtype = SQL_CURSOR_STATIC;
9497 if (param != SQL_CURSOR_FORWARD_ONLY &&
9498 param != SQL_CURSOR_STATIC) {
9502 case SQL_ASYNC_ENABLE:
9503 if (param != SQL_ASYNC_ENABLE_OFF) {
9507 case SQL_CONCURRENCY:
9508 if (param != SQL_CONCUR_LOCK) {
9512 case SQL_QUERY_TIMEOUT:
9514 case SQL_RETRIEVE_DATA:
9515 if (param != SQL_RD_ON && param != SQL_RD_OFF) {
9517 setstat(s, -1,
"option value changed",
"01S02");
9518 return SQL_SUCCESS_WITH_INFO;
9522 case SQL_ROWSET_SIZE:
9523 case SQL_ATTR_ROW_ARRAY_SIZE:
9525 setstat(s, -1,
"invalid rowset size",
"HY000");
9531 rst =
xmalloc(
sizeof (SQLUSMALLINT) * param);
9543 case SQL_ATTR_MAX_ROWS:
9546 case SQL_ATTR_MAX_LENGTH:
9547 if (param != 1000000000) {
9610 setstat(s, -1,
"unbound columns", (*s->
ov3) ?
"HY000" :
"S1000");
9613 for (i = 0; i < s->
ncols; i++) {
9616 if (b->
type == SQL_UNKNOWN_TYPE || !b->
valp) {
9645 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
9646 dp = (SQLPOINTER) ((
char *) b->valp + s->
bind_type * rsi);
9648 dp = (SQLPOINTER) ((
char *) b->valp + b->max * rsi);
9651 dp = (SQLPOINTER) ((
char *) dp + *s->
bind_offs);
9655 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
9665 setstat(s, -1,
"unbound column in positional update",
9666 (*s->
ov3) ?
"HY000" :
"S1000");
9669 if (*lp == SQL_NULL_DATA) {
9670 sqlite3_bind_null(
stmt, si);
9672 fprintf(d->
trace,
"-- parameter %d: NULL\n", si);
9678 case SQL_C_UTINYINT:
9680 case SQL_C_STINYINT:
9681 sqlite3_bind_int(
stmt, si, *(SQLCHAR *) dp);
9683 fprintf(d->
trace,
"-- parameter %d: %d\n", si, *(SQLCHAR *) dp);
9689 sqlite3_bind_int(
stmt, si, (*(SQLCHAR *) dp) ? 1 : 0);
9691 fprintf(d->
trace,
"-- parameter %d: %d\n", si,
9692 (*(SQLCHAR *) dp) ? 1 : 0);
9698 sqlite3_bind_int(
stmt, si, *(SQLUSMALLINT *) dp);
9700 fprintf(d->
trace,
"-- parameter %d: %d\n", si,
9701 *(SQLUSMALLINT *) dp);
9707 sqlite3_bind_int(
stmt, si, *(SQLSMALLINT *) dp);
9709 fprintf(d->
trace,
"-- parameter %d: %d\n", si,
9710 *(SQLSMALLINT *) dp);
9715 sqlite3_bind_int(
stmt, si, *(SQLUINTEGER *) dp);
9717 fprintf(d->
trace,
"-- parameter %d: %ld\n", si,
9718 (
long) *(SQLUINTEGER *) dp);
9724 sqlite3_bind_int(
stmt, si, *(SQLINTEGER *) dp);
9726 fprintf(d->
trace,
"-- parameter %d: %ld\n", si,
9727 (
long) *(SQLINTEGER *) dp);
9734 sqlite3_bind_int64(
stmt, si, *(SQLBIGINT *) dp);
9738 "-- parameter %d: %I64d\n",
9740 "-- parameter %d: %lld\n",
9742 si, (sqlite_int64) *(SQLBIGINT *) dp);
9748 sqlite3_bind_double(
stmt, si, *(
float *) dp);
9750 fprintf(d->
trace,
"-- parameter %d: %g\n", si,
9756 sqlite3_bind_double(
stmt, si, *(
double *) dp);
9758 fprintf(d->
trace,
"-- parameter %d: %g\n", si,
9764 sqlite3_bind_blob(
stmt, si, (
char *) dp, *lp, SQLITE_STATIC);
9766 fprintf(d->
trace,
"-- parameter %d: [BLOB]\n", si);
9776 sqlite3_bind_text(
stmt, si, cp, -1, SQLITE_TRANSIENT);
9778 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si, cp);
9785 #if defined(_WIN32) || defined(_WIN64) 9787 cp = wmb_to_utf((
char *) dp, *lp);
9791 sqlite3_bind_text(
stmt, si, cp, -1, SQLITE_TRANSIENT);
9793 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si, cp);
9800 if (*lp == SQL_NTS) {
9801 sqlite3_bind_text(
stmt, si, (
char *) dp, -1,
9804 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si,
9809 sqlite3_bind_text(
stmt, si, (
char *) dp, *lp,
9812 fprintf(d->
trace,
"-- parameter %d: '%*s'\n", si,
9813 (
int) *lp, (
char *) dp);
9819 #ifdef SQL_C_TYPE_DATE 9820 case SQL_C_TYPE_DATE:
9824 int a, b, x1, x2, y, m, dd;
9827 y = ((DATE_STRUCT *) dp)->year;
9828 m = ((DATE_STRUCT *) dp)->month;
9829 dd = ((DATE_STRUCT *) dp)->day;
9835 b = 2 - a + (a / 4);
9836 x1 = 36525 * (y + 4716) / 100;
9837 x2 = 306001 * (m + 1) / 10000;
9838 v = x1 + x2 + dd + b - 1524.5;
9839 sqlite3_bind_double(
stmt, si, v);
9841 fprintf(d->
trace,
"-- parameter %d: %g\n", si, v);
9845 sprintf(
strbuf,
"%04d-%02d-%02d",
9846 ((DATE_STRUCT *) dp)->year,
9847 ((DATE_STRUCT *) dp)->month,
9848 ((DATE_STRUCT *) dp)->day);
9849 sqlite3_bind_text(
stmt, si,
strbuf, -1, SQLITE_TRANSIENT);
9851 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si,
strbuf);
9856 #ifdef SQL_C_TYPE_TIME 9857 case SQL_C_TYPE_TIME:
9864 (((TIME_STRUCT *) dp)->hour * 3600000.0 +
9865 ((TIME_STRUCT *) dp)->minute * 60000.0 +
9866 ((TIME_STRUCT *) dp)->second * 1000.0) / 86400000.0;
9867 sqlite3_bind_double(
stmt, si, v);
9869 fprintf(d->
trace,
"-- parameter %d: %g\n", si, v);
9873 sprintf(
strbuf,
"%02d:%02d:%02d",
9874 ((TIME_STRUCT *) dp)->hour,
9875 ((TIME_STRUCT *) dp)->minute,
9876 ((TIME_STRUCT *) dp)->second);
9877 sqlite3_bind_text(
stmt, si,
strbuf, -1, SQLITE_TRANSIENT);
9879 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si,
strbuf);
9884 #ifdef SQL_C_TYPE_TIMESTAMP 9885 case SQL_C_TYPE_TIMESTAMP:
9887 case SQL_C_TIMESTAMP:
9889 int a, b, x1, x2, y, m, dd;
9892 y = ((TIMESTAMP_STRUCT *) dp)->year;
9893 m = ((TIMESTAMP_STRUCT *) dp)->month;
9894 dd = ((TIMESTAMP_STRUCT *) dp)->day;
9900 b = 2 - a + (a / 4);
9901 x1 = 36525 * (y + 4716) / 100;
9902 x2 = 306001 * (m + 1) / 10000;
9903 v = x1 + x2 + dd + b - 1524.5 +
9904 (((TIMESTAMP_STRUCT *) dp)->hour * 3600000.0 +
9905 ((TIMESTAMP_STRUCT *) dp)->minute * 60000.0 +
9906 ((TIMESTAMP_STRUCT *) dp)->second * 1000.0 +
9907 ((TIMESTAMP_STRUCT *) dp)->fraction / 1.0E6)
9909 sqlite3_bind_double(
stmt, si, v);
9911 fprintf(d->
trace,
"-- parameter %d: %g\n", si, v);
9917 frac = (int) ((TIMESTAMP_STRUCT *) dp)->fraction;
9923 if (c->prec && c->prec <= 16) {
9924 sprintf(
strbuf,
"%04d-%02d-%02d %02d:%02d:00.000",
9925 ((TIMESTAMP_STRUCT *) dp)->year,
9926 ((TIMESTAMP_STRUCT *) dp)->month,
9927 ((TIMESTAMP_STRUCT *) dp)->day,
9928 ((TIMESTAMP_STRUCT *) dp)->hour,
9929 ((TIMESTAMP_STRUCT *) dp)->minute);
9930 }
else if (c->prec && c->prec <= 19) {
9931 sprintf(
strbuf,
"%04d-%02d-%02d %02d:%02d:%02d.000",
9932 ((TIMESTAMP_STRUCT *) dp)->year,
9933 ((TIMESTAMP_STRUCT *) dp)->month,
9934 ((TIMESTAMP_STRUCT *) dp)->day,
9935 ((TIMESTAMP_STRUCT *) dp)->hour,
9936 ((TIMESTAMP_STRUCT *) dp)->minute,
9937 ((TIMESTAMP_STRUCT *) dp)->second);
9939 sprintf(
strbuf,
"%04d-%02d-%02d %02d:%02d:%02d.%03d",
9940 ((TIMESTAMP_STRUCT *) dp)->year,
9941 ((TIMESTAMP_STRUCT *) dp)->month,
9942 ((TIMESTAMP_STRUCT *) dp)->day,
9943 ((TIMESTAMP_STRUCT *) dp)->hour,
9944 ((TIMESTAMP_STRUCT *) dp)->minute,
9945 ((TIMESTAMP_STRUCT *) dp)->second,
9948 sqlite3_bind_text(
stmt, si,
strbuf, -1, SQLITE_TRANSIENT);
9950 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si,
strbuf);
9956 setstat(s, -1,
"unsupported column type in positional update",
9957 (*s->
ov3) ?
"HY000" :
"S1000");
9983 setstat(s, -1,
"row out of range", (*s->
ov3) ?
"HY107" :
"S1107");
9988 if (*data == NULL) {
9989 sqlite3_bind_null(
stmt, si);
9991 fprintf(d->
trace,
"-- parameter %d: NULL\n", si);
9995 sqlite3_bind_text(
stmt, si, *data, -1, SQLITE_STATIC);
9997 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si, *data);
10001 return SQL_SUCCESS;
10014 int i, withinfo = 0;
10015 SQLRETURN ret = SQL_SUCCESS;
10024 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10027 dp = (SQLPOINTER) ((
char *) b->
valp + b->
max * rsi);
10030 dp = (SQLPOINTER) ((
char *) dp + *s->
bind_offs);
10034 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10037 lp = b->
lenp + rsi;
10044 int rowp = s->
rowp;
10050 if (!SQL_SUCCEEDED(ret)) {
10054 if (ret != SQL_SUCCESS) {
10056 #ifdef SQL_ROW_SUCCESS_WITH_INFO 10062 if (SQL_SUCCEEDED(ret)) {
10063 ret = withinfo ? SQL_SUCCESS_WITH_INFO : SQL_SUCCESS;
10082 int rowp, i, k, rc, nretry = 0;
10085 sqlite3_stmt *s3stmt = NULL;
10088 if (lock != SQL_LOCK_NO_CHANGE) {
10089 setstat(s, -1,
"unsupported locking mode",
10090 (*s->
ov3) ?
"HY000" :
"S1000");
10094 setstat(s, -1,
"incompatible statement",
10095 (*s->
ov3) ?
"HY000" :
"S1000");
10098 if (op == SQL_ADD) {
10100 setstat(s, -1,
"incompatible rowset",
10101 (*s->
ov3) ?
"HY000" :
"S1000");
10108 if (ret != SQL_SUCCESS) {
10111 sql =
dsappend(sql,
"INSERT INTO ");
10117 for (i = 0; i < s->
ncols; i++) {
10118 sql =
dsappend(sql, (i > 0) ?
"," :
"(");
10122 for (i = 0; i < s->
ncols; i++) {
10123 sql =
dsappend(sql, (i > 0) ?
",?" :
"(?");
10130 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10137 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10138 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10144 if (rc != SQLITE_OK) {
10146 sqlite3_finalize(s3stmt);
10150 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10153 if (rc != SQLITE_OK) {
10155 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10156 sqlite3_errmsg(d->
sqlite), rc);
10159 sqlite3_finalize(s3stmt);
10165 if (ret != SQL_SUCCESS) {
10167 sqlite3_finalize(s3stmt);
10172 rc = sqlite3_step(s3stmt);
10173 if (rc != SQLITE_DONE) {
10176 sqlite3_finalize(s3stmt);
10177 if (sqlite3_changes(d->
sqlite) > 0 && row <= s->rowset_size) {
10185 return SQL_SUCCESS;
10186 }
else if (op == SQL_UPDATE || op == SQL_DELETE) {
10188 setstat(s, -1,
"incompatible rowset",
10189 (*s->
ov3) ?
"HY000" :
"S1000");
10196 if (!SQL_SUCCEEDED(ret)) {
10206 if (op != SQL_POSITION && op != SQL_REFRESH &&
10207 op != SQL_DELETE && op != SQL_UPDATE) {
10210 if (op == SQL_POSITION) {
10211 rowp = s->
rowp + row - 1;
10212 if (!s->
rows || row == 0 || rowp < -1 || rowp >= s->
nrows) {
10214 setstat(s, -1,
"row out of range", (*s->
ov3) ?
"HY107" :
"S1107");
10218 }
else if (op == SQL_REFRESH) {
10226 if (!SQL_SUCCEEDED(ret)) {
10233 }
else if (op == SQL_DELETE) {
10234 sql =
dsappend(sql,
"DELETE FROM ");
10240 for (i = k = 0; i < s->
ncols; i++) {
10244 sql =
dsappend(sql, (k > 0) ?
" AND " :
" WHERE ");
10253 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10260 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10261 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10267 if (rc != SQLITE_OK) {
10269 sqlite3_finalize(s3stmt);
10273 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10276 if (rc != SQLITE_OK) {
10278 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10279 sqlite3_errmsg(d->
sqlite), rc);
10282 sqlite3_finalize(s3stmt);
10291 if (ret != SQL_SUCCESS) {
10293 sqlite3_finalize(s3stmt);
10298 rc = sqlite3_step(s3stmt);
10299 if (rc != SQLITE_DONE) {
10302 sqlite3_finalize(s3stmt);
10303 if (sqlite3_changes(d->
sqlite) > 0) {
10311 return SQL_SUCCESS;
10312 }
else if (op == SQL_UPDATE) {
10314 if (ret != SQL_SUCCESS) {
10323 for (i = 0; i < s->
ncols; i++) {
10324 sql =
dsappend(sql, (i > 0) ?
", " :
" SET ");
10328 for (i = k = 0; i < s->
ncols; i++) {
10332 sql =
dsappend(sql, (k > 0) ?
" AND " :
" WHERE ");
10341 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10348 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10349 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10355 if (rc != SQLITE_OK) {
10357 sqlite3_finalize(s3stmt);
10361 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10364 if (rc != SQLITE_OK) {
10366 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10367 sqlite3_errmsg(d->
sqlite), rc);
10370 sqlite3_finalize(s3stmt);
10376 if (ret != SQL_SUCCESS) {
10378 sqlite3_finalize(s3stmt);
10388 if (ret != SQL_SUCCESS) {
10390 sqlite3_finalize(s3stmt);
10395 rc = sqlite3_step(s3stmt);
10396 if (rc != SQLITE_DONE) {
10399 sqlite3_finalize(s3stmt);
10400 if (sqlite3_changes(d->
sqlite) > 0) {
10408 return SQL_SUCCESS;
10410 return SQL_SUCCESS;
10445 int row, i, k, rc, nretry = 0;
10448 sqlite3_stmt *s3stmt = NULL;
10452 setstat(s, -1,
"incompatible statement",
10453 (*s->
ov3) ?
"HY000" :
"S1000");
10456 if (op == SQL_ADD) {
10458 setstat(s, -1,
"incompatible rowset",
10459 (*s->
ov3) ?
"HY000" :
"S1000");
10463 if (ret != SQL_SUCCESS) {
10466 sql =
dsappend(sql,
"INSERT INTO ");
10472 for (i = 0; i < s->
ncols; i++) {
10473 sql =
dsappend(sql, (i > 0) ?
"," :
"(");
10477 for (i = 0; i < s->
ncols; i++) {
10478 sql =
dsappend(sql, (i > 0) ?
",?" :
"(?");
10485 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10492 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10493 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10499 if (rc != SQLITE_OK) {
10501 sqlite3_finalize(s3stmt);
10505 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10508 if (rc != SQLITE_OK) {
10509 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10510 sqlite3_errmsg(d->
sqlite), rc);
10513 sqlite3_finalize(s3stmt);
10520 if (ret != SQL_SUCCESS) {
10529 sqlite3_finalize(s3stmt);
10534 rc = sqlite3_step(s3stmt);
10535 if (rc != SQLITE_DONE) {
10536 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10537 sqlite3_errmsg(d->
sqlite), rc);
10541 if (sqlite3_changes(d->
sqlite) > 0) {
10549 if (s->
bkmrk == SQL_UB_VARIABLE &&
10554 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10562 val = (SQLPOINTER) ((
char *) val + *s->
bind_offs);
10564 *(sqlite_int64 *) val = sqlite3_last_insert_rowid(d->
sqlite);
10568 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10577 *ival =
sizeof (sqlite_int64);
10581 sqlite3_reset(s3stmt);
10584 sqlite3_finalize(s3stmt);
10585 return SQL_SUCCESS;
10586 }
else if (op == SQL_DELETE_BY_BOOKMARK) {
10588 s->
bkmrk != SQL_UB_VARIABLE ||
10591 setstat(s, -1,
"incompatible rowset",
10592 (*s->
ov3) ?
"HY000" :
"S1000");
10595 sql =
dsappend(sql,
"DELETE FROM ");
10608 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10615 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10616 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10622 if (rc != SQLITE_OK) {
10624 sqlite3_finalize(s3stmt);
10628 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10631 if (rc != SQLITE_OK) {
10632 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10633 sqlite3_errmsg(d->
sqlite), rc);
10636 sqlite3_finalize(s3stmt);
10642 sqlite_int64 rowid;
10644 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10652 val = (SQLPOINTER) ((
char *) val + *s->
bind_offs);
10657 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10666 if (*ival !=
sizeof (sqlite_int64)) {
10670 rowid = *(sqlite_int64 *) val;
10671 sqlite3_bind_int64(s3stmt, 1, rowid);
10675 "-- parameter 1: %I64d\n",
10677 "-- parameter 1: %lld\n",
10682 rc = sqlite3_step(s3stmt);
10683 if (rc != SQLITE_DONE) {
10684 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10685 sqlite3_errmsg(d->
sqlite), rc);
10693 sqlite3_finalize(s3stmt);
10696 if (sqlite3_changes(d->
sqlite) > 0) {
10705 sqlite3_reset(s3stmt);
10708 sqlite3_finalize(s3stmt);
10709 return SQL_SUCCESS;
10710 }
else if (op == SQL_UPDATE_BY_BOOKMARK) {
10712 s->
bkmrk != SQL_UB_VARIABLE ||
10715 setstat(s, -1,
"incompatible rowset",
10716 (*s->
ov3) ?
"HY000" :
"S1000");
10720 if (ret != SQL_SUCCESS) {
10729 for (i = 0, k = 0; i < s->
ncols; i++) {
10733 sql =
dsappend(sql, (k > 0) ?
", " :
" SET ");
10745 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10752 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10753 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10759 if (rc != SQLITE_OK) {
10761 sqlite3_finalize(s3stmt);
10765 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10768 if (rc != SQLITE_OK) {
10769 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10770 sqlite3_errmsg(d->
sqlite), rc);
10773 sqlite3_finalize(s3stmt);
10779 sqlite_int64 rowid;
10781 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10789 val = (SQLPOINTER) ((
char *) val + *s->
bind_offs);
10794 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10803 if (*ival !=
sizeof (sqlite_int64)) {
10812 if (ret != SQL_SUCCESS) {
10821 sqlite3_finalize(s3stmt);
10826 rowid = *(sqlite_int64 *) val;
10827 sqlite3_bind_int64(s3stmt, k, rowid);
10831 "-- parameter %d: %I64d\n",
10833 "-- parameter %d: %lld\n",
10838 rc = sqlite3_step(s3stmt);
10839 if (rc != SQLITE_DONE) {
10840 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10841 sqlite3_errmsg(d->
sqlite), rc);
10845 if (sqlite3_changes(d->
sqlite) > 0) {
10854 sqlite3_reset(s3stmt);
10857 sqlite3_finalize(s3stmt);
10858 return SQL_SUCCESS;
10860 setstat(s, -1,
"unsupported operation", (*s->
ov3) ?
"HY000" :
"S1000");
10889 SQLUSMALLINT rowset)
10899 #define strmak(dst, src, max, lenp) { \ 10900 int len = strlen(src); \ 10901 int cnt = min(len + 1, max); \ 10902 strncpy(dst, src, cnt); \ 10903 *lenp = (cnt > len) ? len : cnt; \ 10918 SQLSMALLINT *valLen)
10923 #if defined(_WIN32) || defined(_WIN64) 10924 char pathbuf[301], *drvname;
10926 static char drvname[] =
"sqlite3odbc.so";
10929 if (
dbc == SQL_NULL_HDBC) {
10930 return SQL_INVALID_HANDLE;
10941 valMax =
sizeof (dummyc) - 1;
10944 case SQL_MAX_USER_NAME_LEN:
10945 *((SQLSMALLINT *) val) = 16;
10946 *valLen =
sizeof (SQLSMALLINT);
10948 case SQL_USER_NAME:
10949 strmak(val,
"", valMax, valLen);
10951 case SQL_DRIVER_ODBC_VER:
10953 strmak(val, (*d->
ov3) ?
"03.00" :
"02.50", valMax, valLen);
10955 strmak(val,
"03.00", valMax, valLen);
10958 case SQL_ACTIVE_CONNECTIONS:
10959 case SQL_ACTIVE_STATEMENTS:
10960 *((SQLSMALLINT *) val) = 0;
10961 *valLen =
sizeof (SQLSMALLINT);
10963 #ifdef SQL_ASYNC_MODE 10964 case SQL_ASYNC_MODE:
10965 *((SQLUINTEGER *) val) = SQL_AM_NONE;
10966 *valLen =
sizeof (SQLUINTEGER);
10969 #ifdef SQL_CREATE_TABLE 10970 case SQL_CREATE_TABLE:
10971 *((SQLUINTEGER *) val) = SQL_CT_CREATE_TABLE |
10972 SQL_CT_COLUMN_DEFAULT |
10973 SQL_CT_COLUMN_CONSTRAINT |
10974 SQL_CT_CONSTRAINT_NON_DEFERRABLE;
10975 *valLen =
sizeof (SQLUINTEGER);
10978 #ifdef SQL_CREATE_VIEW 10979 case SQL_CREATE_VIEW:
10980 *((SQLUINTEGER *) val) = SQL_CV_CREATE_VIEW;
10981 *valLen =
sizeof (SQLUINTEGER);
10984 #ifdef SQL_DDL_INDEX 10985 case SQL_DDL_INDEX:
10986 *((SQLUINTEGER *) val) = SQL_DI_CREATE_INDEX | SQL_DI_DROP_INDEX;
10987 *valLen =
sizeof (SQLUINTEGER);
10990 #ifdef SQL_DROP_TABLE 10991 case SQL_DROP_TABLE:
10992 *((SQLUINTEGER *) val) = SQL_DT_DROP_TABLE;
10993 *valLen =
sizeof (SQLUINTEGER);
10996 #ifdef SQL_DROP_VIEW 10997 case SQL_DROP_VIEW:
10998 *((SQLUINTEGER *) val) = SQL_DV_DROP_VIEW;
10999 *valLen =
sizeof (SQLUINTEGER);
11002 #ifdef SQL_INDEX_KEYWORDS 11003 case SQL_INDEX_KEYWORDS:
11004 *((SQLUINTEGER *) val) = SQL_IK_ALL;
11005 *valLen =
sizeof (SQLUINTEGER);
11008 case SQL_DATA_SOURCE_NAME:
11011 case SQL_DRIVER_NAME:
11012 #if defined(_WIN32) || defined(_WIN64) 11013 GetModuleFileName(hModule, pathbuf,
sizeof (pathbuf));
11014 drvname = strrchr(pathbuf,
'\\');
11015 if (drvname == NULL) {
11016 drvname = strrchr(pathbuf,
'/');
11018 if (drvname == NULL) {
11024 strmak(val, drvname, valMax, valLen);
11026 case SQL_DRIVER_VER:
11029 case SQL_FETCH_DIRECTION:
11030 *((SQLUINTEGER *) val) = SQL_FD_FETCH_NEXT | SQL_FD_FETCH_FIRST |
11031 SQL_FD_FETCH_LAST | SQL_FD_FETCH_PRIOR | SQL_FD_FETCH_ABSOLUTE;
11032 *valLen =
sizeof (SQLUINTEGER);
11035 strmak(val, (*d->
ov3) ?
"03.00" :
"02.50", valMax, valLen);
11037 case SQL_ODBC_SAG_CLI_CONFORMANCE:
11038 *((SQLSMALLINT *) val) = SQL_OSCC_NOT_COMPLIANT;
11039 *valLen =
sizeof (SQLSMALLINT);
11041 case SQL_STANDARD_CLI_CONFORMANCE:
11042 *((SQLUINTEGER *) val) = SQL_SCC_XOPEN_CLI_VERSION1;
11043 *valLen =
sizeof (SQLUINTEGER);
11045 case SQL_SQL_CONFORMANCE:
11046 *((SQLUINTEGER *) val) = SQL_SC_SQL92_ENTRY;
11047 *valLen =
sizeof (SQLUINTEGER);
11049 case SQL_SERVER_NAME:
11050 case SQL_DATABASE_NAME:
11053 case SQL_SEARCH_PATTERN_ESCAPE:
11054 strmak(val,
"\\", valMax, valLen);
11056 case SQL_ODBC_SQL_CONFORMANCE:
11057 *((SQLSMALLINT *) val) = SQL_OSC_MINIMUM;
11058 *valLen =
sizeof (SQLSMALLINT);
11060 case SQL_ODBC_API_CONFORMANCE:
11061 *((SQLSMALLINT *) val) = SQL_OAC_LEVEL1;
11062 *valLen =
sizeof (SQLSMALLINT);
11064 case SQL_DBMS_NAME:
11065 strmak(val,
"SQLite", valMax, valLen);
11068 strmak(val, SQLITE_VERSION, valMax, valLen);
11070 case SQL_COLUMN_ALIAS:
11071 case SQL_NEED_LONG_DATA_LEN:
11072 strmak(val,
"Y", valMax, valLen);
11074 case SQL_ROW_UPDATES:
11075 case SQL_ACCESSIBLE_PROCEDURES:
11076 case SQL_PROCEDURES:
11077 case SQL_EXPRESSIONS_IN_ORDERBY:
11078 case SQL_ODBC_SQL_OPT_IEF:
11079 case SQL_LIKE_ESCAPE_CLAUSE:
11080 case SQL_ORDER_BY_COLUMNS_IN_SELECT:
11081 case SQL_OUTER_JOINS:
11082 case SQL_ACCESSIBLE_TABLES:
11083 case SQL_MULT_RESULT_SETS:
11084 case SQL_MULTIPLE_ACTIVE_TXN:
11085 case SQL_MAX_ROW_SIZE_INCLUDES_LONG:
11086 strmak(val,
"N", valMax, valLen);
11088 #ifdef SQL_CATALOG_NAME 11089 case SQL_CATALOG_NAME:
11090 #if defined(_WIN32) || defined(_WIN64) 11091 strmak(val, d->xcelqrx ?
"Y" :
"N", valMax, valLen);
11093 strmak(val,
"N", valMax, valLen);
11097 case SQL_DATA_SOURCE_READ_ONLY:
11098 strmak(val,
"N", valMax, valLen);
11100 #ifdef SQL_OJ_CAPABILITIES 11101 case SQL_OJ_CAPABILITIES:
11102 *((SQLUINTEGER *) val) = 0;
11103 *valLen =
sizeof (SQLUINTEGER);
11106 #ifdef SQL_MAX_IDENTIFIER_LEN 11107 case SQL_MAX_IDENTIFIER_LEN:
11108 *((SQLUSMALLINT *) val) = 255;
11109 *valLen =
sizeof (SQLUSMALLINT);
11112 case SQL_CONCAT_NULL_BEHAVIOR:
11113 *((SQLSMALLINT *) val) = SQL_CB_NULL;
11114 *valLen =
sizeof (SQLSMALLINT);
11116 case SQL_CURSOR_COMMIT_BEHAVIOR:
11117 case SQL_CURSOR_ROLLBACK_BEHAVIOR:
11118 *((SQLSMALLINT *) val) = SQL_CB_PRESERVE;
11119 *valLen =
sizeof (SQLSMALLINT);
11121 #ifdef SQL_CURSOR_SENSITIVITY 11122 case SQL_CURSOR_SENSITIVITY:
11123 *((SQLUINTEGER *) val) = SQL_UNSPECIFIED;
11124 *valLen =
sizeof (SQLUINTEGER);
11127 case SQL_DEFAULT_TXN_ISOLATION:
11128 *((SQLUINTEGER *) val) = SQL_TXN_SERIALIZABLE;
11129 *valLen =
sizeof (SQLUINTEGER);
11131 #ifdef SQL_DESCRIBE_PARAMETER 11132 case SQL_DESCRIBE_PARAMETER:
11133 strmak(val,
"Y", valMax, valLen);
11136 case SQL_TXN_ISOLATION_OPTION:
11137 *((SQLUINTEGER *) val) = SQL_TXN_SERIALIZABLE;
11138 *valLen =
sizeof (SQLUINTEGER);
11140 case SQL_IDENTIFIER_CASE:
11141 *((SQLSMALLINT *) val) = SQL_IC_SENSITIVE;
11142 *valLen =
sizeof (SQLSMALLINT);
11144 case SQL_IDENTIFIER_QUOTE_CHAR:
11145 strmak(val,
"\"", valMax, valLen);
11147 case SQL_MAX_TABLE_NAME_LEN:
11148 case SQL_MAX_COLUMN_NAME_LEN:
11149 *((SQLSMALLINT *) val) = 255;
11150 *valLen =
sizeof (SQLSMALLINT);
11152 case SQL_MAX_CURSOR_NAME_LEN:
11153 *((SQLSMALLINT *) val) = 255;
11154 *valLen =
sizeof (SQLSMALLINT);
11156 case SQL_MAX_PROCEDURE_NAME_LEN:
11157 *((SQLSMALLINT *) val) = 0;
11159 case SQL_MAX_QUALIFIER_NAME_LEN:
11160 case SQL_MAX_OWNER_NAME_LEN:
11161 *((SQLSMALLINT *) val) = 255;
11163 case SQL_OWNER_TERM:
11164 strmak(val,
"", valMax, valLen);
11166 case SQL_PROCEDURE_TERM:
11167 strmak(val,
"PROCEDURE", valMax, valLen);
11169 case SQL_QUALIFIER_NAME_SEPARATOR:
11170 strmak(val,
".", valMax, valLen);
11172 case SQL_QUALIFIER_TERM:
11173 #if defined(_WIN32) || defined(_WIN64) 11174 strmak(val, d->xcelqrx ?
"catalog" :
"", valMax, valLen);
11176 strmak(val,
"", valMax, valLen);
11179 case SQL_QUALIFIER_USAGE:
11180 #if defined(_WIN32) || defined(_WIN64) 11181 *((SQLUINTEGER *) val) = d->xcelqrx ?
11182 (SQL_CU_DML_STATEMENTS | SQL_CU_INDEX_DEFINITION |
11183 SQL_CU_TABLE_DEFINITION) : 0;
11185 *((SQLUINTEGER *) val) = 0;
11187 *valLen =
sizeof (SQLUINTEGER);
11189 case SQL_SCROLL_CONCURRENCY:
11190 *((SQLUINTEGER *) val) = SQL_SCCO_LOCK;
11191 *valLen =
sizeof (SQLUINTEGER);
11193 case SQL_SCROLL_OPTIONS:
11194 *((SQLUINTEGER *) val) = SQL_SO_STATIC | SQL_SO_FORWARD_ONLY;
11195 *valLen =
sizeof (SQLUINTEGER);
11197 case SQL_TABLE_TERM:
11198 strmak(val,
"TABLE", valMax, valLen);
11200 case SQL_TXN_CAPABLE:
11201 *((SQLSMALLINT *) val) = SQL_TC_ALL;
11202 *valLen =
sizeof (SQLSMALLINT);
11204 case SQL_CONVERT_FUNCTIONS:
11205 *((SQLUINTEGER *) val) = 0;
11206 *valLen =
sizeof (SQLUINTEGER);
11208 case SQL_SYSTEM_FUNCTIONS:
11209 case SQL_NUMERIC_FUNCTIONS:
11210 case SQL_STRING_FUNCTIONS:
11211 case SQL_TIMEDATE_FUNCTIONS:
11212 *((SQLUINTEGER *) val) = 0;
11213 *valLen =
sizeof (SQLUINTEGER);
11215 case SQL_CONVERT_BIGINT:
11216 case SQL_CONVERT_BIT:
11217 case SQL_CONVERT_CHAR:
11218 case SQL_CONVERT_DATE:
11219 case SQL_CONVERT_DECIMAL:
11220 case SQL_CONVERT_DOUBLE:
11221 case SQL_CONVERT_FLOAT:
11222 case SQL_CONVERT_INTEGER:
11223 case SQL_CONVERT_LONGVARCHAR:
11224 case SQL_CONVERT_NUMERIC:
11225 case SQL_CONVERT_REAL:
11226 case SQL_CONVERT_SMALLINT:
11227 case SQL_CONVERT_TIME:
11228 case SQL_CONVERT_TIMESTAMP:
11229 case SQL_CONVERT_TINYINT:
11230 case SQL_CONVERT_VARCHAR:
11231 *((SQLUINTEGER *) val) =
11232 SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL |
11233 SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT | SQL_CVT_REAL |
11234 SQL_CVT_DOUBLE | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR |
11235 SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_BIGINT |
11236 SQL_CVT_DATE | SQL_CVT_TIME | SQL_CVT_TIMESTAMP;
11237 *valLen =
sizeof (SQLUINTEGER);
11239 case SQL_CONVERT_BINARY:
11240 case SQL_CONVERT_VARBINARY:
11241 case SQL_CONVERT_LONGVARBINARY:
11242 *((SQLUINTEGER *) val) = 0;
11243 *valLen =
sizeof (SQLUINTEGER);
11245 case SQL_POSITIONED_STATEMENTS:
11246 *((SQLUINTEGER *) val) = 0;
11247 *valLen =
sizeof (SQLUINTEGER);
11249 case SQL_LOCK_TYPES:
11250 *((SQLUINTEGER *) val) = SQL_LCK_NO_CHANGE;
11251 *valLen =
sizeof (SQLUINTEGER);
11253 case SQL_BOOKMARK_PERSISTENCE:
11254 *((SQLUINTEGER *) val) = SQL_BP_SCROLL;
11255 *valLen =
sizeof (SQLUINTEGER);
11258 *((SQLUINTEGER *) val) = SQL_U_UNION | SQL_U_UNION_ALL;
11259 *valLen =
sizeof (SQLUINTEGER);
11261 case SQL_OWNER_USAGE:
11262 case SQL_SUBQUERIES:
11263 case SQL_TIMEDATE_ADD_INTERVALS:
11264 case SQL_TIMEDATE_DIFF_INTERVALS:
11265 *((SQLUINTEGER *) val) = 0;
11266 *valLen =
sizeof (SQLUINTEGER);
11268 case SQL_QUOTED_IDENTIFIER_CASE:
11269 *((SQLUSMALLINT *) val) = SQL_IC_SENSITIVE;
11270 *valLen =
sizeof (SQLUSMALLINT);
11272 case SQL_POS_OPERATIONS:
11273 *((SQLUINTEGER *) val) = SQL_POS_POSITION | SQL_POS_UPDATE |
11274 SQL_POS_DELETE | SQL_POS_ADD | SQL_POS_REFRESH;
11275 *valLen =
sizeof (SQLUINTEGER);
11277 case SQL_ALTER_TABLE:
11278 *((SQLUINTEGER *) val) = 0;
11279 *valLen =
sizeof (SQLUINTEGER);
11281 case SQL_CORRELATION_NAME:
11282 *((SQLSMALLINT *) val) = SQL_CN_DIFFERENT;
11283 *valLen =
sizeof (SQLSMALLINT);
11285 case SQL_NON_NULLABLE_COLUMNS:
11286 *((SQLSMALLINT *) val) = SQL_NNC_NON_NULL;
11287 *valLen =
sizeof (SQLSMALLINT);
11289 case SQL_NULL_COLLATION:
11290 *((SQLSMALLINT *) val) = SQL_NC_START;
11291 *valLen =
sizeof (SQLSMALLINT);
11293 case SQL_MAX_COLUMNS_IN_GROUP_BY:
11294 case SQL_MAX_COLUMNS_IN_ORDER_BY:
11295 case SQL_MAX_COLUMNS_IN_SELECT:
11296 case SQL_MAX_COLUMNS_IN_TABLE:
11297 case SQL_MAX_ROW_SIZE:
11298 case SQL_MAX_TABLES_IN_SELECT:
11299 *((SQLSMALLINT *) val) = 0;
11300 *valLen =
sizeof (SQLSMALLINT);
11302 case SQL_MAX_BINARY_LITERAL_LEN:
11303 case SQL_MAX_CHAR_LITERAL_LEN:
11304 *((SQLUINTEGER *) val) = 0;
11305 *valLen =
sizeof (SQLUINTEGER);
11307 case SQL_MAX_COLUMNS_IN_INDEX:
11308 *((SQLSMALLINT *) val) = 0;
11309 *valLen =
sizeof (SQLSMALLINT);
11311 case SQL_MAX_INDEX_SIZE:
11312 *((SQLUINTEGER *) val) = 0;
11313 *valLen =
sizeof (SQLUINTEGER);
11315 #ifdef SQL_MAX_IDENTIFIER_LENGTH 11316 case SQL_MAX_IDENTIFIER_LENGTH:
11317 *((SQLUINTEGER *) val) = 255;
11318 *valLen =
sizeof (SQLUINTEGER);
11321 case SQL_MAX_STATEMENT_LEN:
11322 *((SQLUINTEGER *) val) = 16384;
11323 *valLen =
sizeof (SQLUINTEGER);
11325 case SQL_QUALIFIER_LOCATION:
11326 *((SQLSMALLINT *) val) = SQL_QL_START;
11327 *valLen =
sizeof (SQLSMALLINT);
11329 case SQL_GETDATA_EXTENSIONS:
11330 *((SQLUINTEGER *) val) =
11331 SQL_GD_ANY_COLUMN | SQL_GD_ANY_ORDER | SQL_GD_BOUND;
11332 *valLen =
sizeof (SQLUINTEGER);
11334 case SQL_STATIC_SENSITIVITY:
11335 *((SQLUINTEGER *) val) = 0;
11336 *valLen =
sizeof (SQLUINTEGER);
11338 case SQL_FILE_USAGE:
11339 #if defined(_WIN32) || defined(_WIN64) 11340 *((SQLSMALLINT *) val) =
11341 d->xcelqrx ? SQL_FILE_CATALOG : SQL_FILE_NOT_SUPPORTED;
11343 *((SQLSMALLINT *) val) = SQL_FILE_NOT_SUPPORTED;
11345 *valLen =
sizeof (SQLSMALLINT);
11348 *((SQLSMALLINT *) val) = SQL_GB_GROUP_BY_EQUALS_SELECT;
11349 *valLen =
sizeof (SQLSMALLINT);
11352 strmak(val,
"CREATE,SELECT,DROP,DELETE,UPDATE,INSERT," 11353 "INTO,VALUES,TABLE,INDEX,FROM,SET,WHERE,AND,CURRENT,OF",
11356 case SQL_SPECIAL_CHARACTERS:
11357 #ifdef SQL_COLLATION_SEQ 11358 case SQL_COLLATION_SEQ:
11360 strmak(val,
"", valMax, valLen);
11362 case SQL_BATCH_SUPPORT:
11363 case SQL_BATCH_ROW_COUNT:
11364 case SQL_PARAM_ARRAY_ROW_COUNTS:
11365 *((SQLUINTEGER *) val) = 0;
11366 *valLen =
sizeof (SQLUINTEGER);
11368 case SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1:
11369 *((SQLUINTEGER *) val) = SQL_CA1_NEXT | SQL_CA1_BOOKMARK;
11370 *valLen =
sizeof (SQLUINTEGER);
11372 case SQL_STATIC_CURSOR_ATTRIBUTES1:
11373 *((SQLUINTEGER *) val) = SQL_CA1_NEXT | SQL_CA1_ABSOLUTE |
11374 SQL_CA1_RELATIVE | SQL_CA1_BOOKMARK | SQL_CA1_POS_POSITION |
11375 SQL_CA1_POS_DELETE | SQL_CA1_POS_UPDATE | SQL_CA1_POS_REFRESH |
11376 SQL_CA1_LOCK_NO_CHANGE | SQL_CA1_BULK_ADD |
11377 SQL_CA1_BULK_UPDATE_BY_BOOKMARK | SQL_CA1_BULK_DELETE_BY_BOOKMARK;
11378 *valLen =
sizeof (SQLUINTEGER);
11380 case SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2:
11381 case SQL_STATIC_CURSOR_ATTRIBUTES2:
11382 *((SQLUINTEGER *) val) = SQL_CA2_READ_ONLY_CONCURRENCY |
11383 SQL_CA2_LOCK_CONCURRENCY;
11384 *valLen =
sizeof (SQLUINTEGER);
11386 case SQL_KEYSET_CURSOR_ATTRIBUTES1:
11387 case SQL_KEYSET_CURSOR_ATTRIBUTES2:
11388 case SQL_DYNAMIC_CURSOR_ATTRIBUTES1:
11389 case SQL_DYNAMIC_CURSOR_ATTRIBUTES2:
11390 *((SQLUINTEGER *) val) = 0;
11391 *valLen =
sizeof (SQLUINTEGER);
11393 case SQL_ODBC_INTERFACE_CONFORMANCE:
11394 *((SQLUINTEGER *) val) = SQL_OIC_CORE;
11395 *valLen =
sizeof (SQLUINTEGER);
11398 setstatd(d, -1,
"unsupported info option %d",
11399 (*d->
ov3) ?
"HYC00" :
"S1C00", type);
11402 return SQL_SUCCESS;
11405 #if (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC)) || !defined(WINTERFACE) 11417 SQLGetInfo(SQLHDBC
dbc, SQLUSMALLINT type, SQLPOINTER val, SQLSMALLINT valMax,
11418 SQLSMALLINT *valLen)
11442 SQLSMALLINT *valLen)
11445 SQLSMALLINT len = 0;
11450 if (ret == SQL_SUCCESS) {
11451 SQLWCHAR *v = NULL;
11454 case SQL_USER_NAME:
11455 case SQL_DRIVER_ODBC_VER:
11456 case SQL_DATA_SOURCE_NAME:
11457 case SQL_DRIVER_NAME:
11458 case SQL_DRIVER_VER:
11460 case SQL_SERVER_NAME:
11461 case SQL_DATABASE_NAME:
11462 case SQL_SEARCH_PATTERN_ESCAPE:
11463 case SQL_DBMS_NAME:
11465 case SQL_NEED_LONG_DATA_LEN:
11466 case SQL_ROW_UPDATES:
11467 case SQL_ACCESSIBLE_PROCEDURES:
11468 case SQL_PROCEDURES:
11469 case SQL_EXPRESSIONS_IN_ORDERBY:
11470 case SQL_ODBC_SQL_OPT_IEF:
11471 case SQL_LIKE_ESCAPE_CLAUSE:
11472 case SQL_ORDER_BY_COLUMNS_IN_SELECT:
11473 case SQL_OUTER_JOINS:
11474 case SQL_COLUMN_ALIAS:
11475 case SQL_ACCESSIBLE_TABLES:
11476 case SQL_MULT_RESULT_SETS:
11477 case SQL_MULTIPLE_ACTIVE_TXN:
11478 case SQL_MAX_ROW_SIZE_INCLUDES_LONG:
11479 case SQL_DATA_SOURCE_READ_ONLY:
11480 #ifdef SQL_DESCRIBE_PARAMETER 11481 case SQL_DESCRIBE_PARAMETER:
11483 case SQL_IDENTIFIER_QUOTE_CHAR:
11484 case SQL_OWNER_TERM:
11485 case SQL_PROCEDURE_TERM:
11486 case SQL_QUALIFIER_NAME_SEPARATOR:
11487 case SQL_QUALIFIER_TERM:
11488 case SQL_TABLE_TERM:
11490 case SQL_SPECIAL_CHARACTERS:
11491 #ifdef SQL_CATALOG_NAME 11492 case SQL_CATALOG_NAME:
11494 #ifdef SQL_COLLATION_SEQ 11495 case SQL_COLLATION_SEQ:
11501 int vmax = valMax /
sizeof (SQLWCHAR);
11511 len *=
sizeof (SQLWCHAR);
11518 if (valMax >=
sizeof (SQLWCHAR)) {
11519 *((SQLWCHAR *)val) = 0;
11523 len *=
sizeof (SQLWCHAR);
11545 SQLUSMALLINT *flags)
11548 SQLUSMALLINT exists[100];
11550 if (
dbc == SQL_NULL_HDBC) {
11551 return SQL_INVALID_HANDLE;
11554 exists[i] = SQL_FALSE;
11556 exists[SQL_API_SQLALLOCCONNECT] = SQL_TRUE;
11557 exists[SQL_API_SQLFETCH] = SQL_TRUE;
11558 exists[SQL_API_SQLALLOCENV] = SQL_TRUE;
11559 exists[SQL_API_SQLFREECONNECT] = SQL_TRUE;
11560 exists[SQL_API_SQLALLOCSTMT] = SQL_TRUE;
11561 exists[SQL_API_SQLFREEENV] = SQL_TRUE;
11562 exists[SQL_API_SQLBINDCOL] = SQL_TRUE;
11563 exists[SQL_API_SQLFREESTMT] = SQL_TRUE;
11564 exists[SQL_API_SQLCANCEL] = SQL_TRUE;
11565 exists[SQL_API_SQLGETCURSORNAME] = SQL_TRUE;
11566 exists[SQL_API_SQLCOLATTRIBUTES] = SQL_TRUE;
11567 exists[SQL_API_SQLNUMRESULTCOLS] = SQL_TRUE;
11568 exists[SQL_API_SQLCONNECT] = SQL_TRUE;
11569 exists[SQL_API_SQLPREPARE] = SQL_TRUE;
11570 exists[SQL_API_SQLDESCRIBECOL] = SQL_TRUE;
11571 exists[SQL_API_SQLROWCOUNT] = SQL_TRUE;
11572 exists[SQL_API_SQLDISCONNECT] = SQL_TRUE;
11573 exists[SQL_API_SQLSETCURSORNAME] = SQL_FALSE;
11574 exists[SQL_API_SQLERROR] = SQL_TRUE;
11575 exists[SQL_API_SQLSETPARAM] = SQL_TRUE;
11576 exists[SQL_API_SQLEXECDIRECT] = SQL_TRUE;
11577 exists[SQL_API_SQLTRANSACT] = SQL_TRUE;
11578 exists[SQL_API_SQLBULKOPERATIONS] = SQL_TRUE;
11579 exists[SQL_API_SQLEXECUTE] = SQL_TRUE;
11580 exists[SQL_API_SQLBINDPARAMETER] = SQL_TRUE;
11581 exists[SQL_API_SQLGETTYPEINFO] = SQL_TRUE;
11582 exists[SQL_API_SQLCOLUMNS] = SQL_TRUE;
11583 exists[SQL_API_SQLPARAMDATA] = SQL_TRUE;
11584 exists[SQL_API_SQLDRIVERCONNECT] = SQL_TRUE;
11585 exists[SQL_API_SQLPUTDATA] = SQL_TRUE;
11586 exists[SQL_API_SQLGETCONNECTOPTION] = SQL_TRUE;
11587 exists[SQL_API_SQLSETCONNECTOPTION] = SQL_TRUE;
11588 exists[SQL_API_SQLGETDATA] = SQL_TRUE;
11589 exists[SQL_API_SQLSETSTMTOPTION] = SQL_TRUE;
11590 exists[SQL_API_SQLGETFUNCTIONS] = SQL_TRUE;
11591 exists[SQL_API_SQLSPECIALCOLUMNS] = SQL_TRUE;
11592 exists[SQL_API_SQLGETINFO] = SQL_TRUE;
11593 exists[SQL_API_SQLSTATISTICS] = SQL_TRUE;
11594 exists[SQL_API_SQLGETSTMTOPTION] = SQL_TRUE;
11595 exists[SQL_API_SQLTABLES] = SQL_TRUE;
11596 exists[SQL_API_SQLBROWSECONNECT] = SQL_FALSE;
11597 exists[SQL_API_SQLNUMPARAMS] = SQL_TRUE;
11598 exists[SQL_API_SQLCOLUMNPRIVILEGES] = SQL_FALSE;
11599 exists[SQL_API_SQLPARAMOPTIONS] = SQL_FALSE;
11600 exists[SQL_API_SQLDATASOURCES] = SQL_TRUE;
11601 exists[SQL_API_SQLPRIMARYKEYS] = SQL_TRUE;
11602 exists[SQL_API_SQLDESCRIBEPARAM] = SQL_TRUE;
11603 exists[SQL_API_SQLPROCEDURECOLUMNS] = SQL_TRUE;
11604 exists[SQL_API_SQLDRIVERS] = SQL_FALSE;
11605 exists[SQL_API_SQLPROCEDURES] = SQL_TRUE;
11606 exists[SQL_API_SQLEXTENDEDFETCH] = SQL_TRUE;
11607 exists[SQL_API_SQLSETPOS] = SQL_TRUE;
11608 exists[SQL_API_SQLFOREIGNKEYS] = SQL_TRUE;
11609 exists[SQL_API_SQLSETSCROLLOPTIONS] = SQL_TRUE;
11610 exists[SQL_API_SQLMORERESULTS] = SQL_TRUE;
11611 exists[SQL_API_SQLTABLEPRIVILEGES] = SQL_TRUE;
11612 exists[SQL_API_SQLNATIVESQL] = SQL_TRUE;
11613 if (func == SQL_API_ALL_FUNCTIONS) {
11614 memcpy(flags, exists,
sizeof (exists));
11615 }
else if (func == SQL_API_ODBC3_ALL_FUNCTIONS) {
11617 #define SET_EXISTS(x) \ 11618 flags[(x) >> 4] |= (1 << ((x) & 0xF)) 11619 #define CLR_EXISTS(x) \ 11620 flags[(x) >> 4] &= ~(1 << ((x) & 0xF)) 11623 sizeof (SQLUSMALLINT) * SQL_API_ODBC3_ALL_FUNCTIONS_SIZE);
11626 flags[i >> 4] |= (1 << (i & 0xF));
11639 #if !defined(HAVE_UNIXODBC) || !(HAVE_UNIXODBC) 11652 *flags = exists[func];
11655 case SQL_API_SQLALLOCHANDLE:
11656 case SQL_API_SQLFREEHANDLE:
11657 case SQL_API_SQLGETSTMTATTR:
11658 case SQL_API_SQLSETSTMTATTR:
11659 case SQL_API_SQLGETCONNECTATTR:
11660 case SQL_API_SQLSETCONNECTATTR:
11661 case SQL_API_SQLGETENVATTR:
11662 case SQL_API_SQLSETENVATTR:
11663 case SQL_API_SQLCLOSECURSOR:
11664 case SQL_API_SQLBINDPARAM:
11665 #if !defined(HAVE_UNIXODBC) || !(HAVE_UNIXODBC) 11671 case SQL_API_SQLGETDIAGREC:
11673 case SQL_API_SQLGETDIAGFIELD:
11674 case SQL_API_SQLFETCHSCROLL:
11675 case SQL_API_SQLENDTRAN:
11679 *flags = SQL_FALSE;
11683 return SQL_SUCCESS;
11698 return SQL_INVALID_HANDLE;
11702 *env = SQL_NULL_HENV;
11707 #if defined(_WIN32) || defined(_WIN64) 11708 InitializeCriticalSection(&e->cs);
11710 #if defined(ENABLE_NVFS) && (ENABLE_NVFS) 11715 *env = (SQLHENV) e;
11716 return SQL_SUCCESS;
11742 if (env == SQL_NULL_HENV) {
11743 return SQL_INVALID_HANDLE;
11747 return SQL_SUCCESS;
11749 #if defined(_WIN32) || defined(_WIN64) 11750 EnterCriticalSection(&e->cs);
11753 #if defined(_WIN32) || defined(_WIN64) 11754 LeaveCriticalSection(&e->cs);
11759 #if defined(_WIN32) || defined(_WIN64) 11760 LeaveCriticalSection(&e->cs);
11761 DeleteCriticalSection(&e->cs);
11764 return SQL_SUCCESS;
11791 const char *verstr;
11792 int maj = 0,
min = 0, lev = 0;
11799 *
dbc = SQL_NULL_HDBC;
11802 memset(d, 0,
sizeof (
DBC));
11803 d->
curtype = SQL_CURSOR_STATIC;
11805 verstr = sqlite3_libversion();
11806 sscanf(verstr,
"%d.%d.%d", &maj, &
min, &lev);
11809 #if defined(_WIN32) || defined(_WIN64) 11811 EnterCriticalSection(&e->cs);
11831 #if defined(_WIN32) || defined(_WIN64) 11832 InitializeCriticalSection(&d->cs);
11835 LeaveCriticalSection(&e->cs);
11841 *
dbc = (SQLHDBC) d;
11843 return SQL_SUCCESS;
11870 SQLRETURN ret = SQL_ERROR;
11872 if (
dbc == SQL_NULL_HDBC) {
11873 return SQL_INVALID_HANDLE;
11877 return SQL_INVALID_HANDLE;
11881 #if defined(_WIN32) || defined(_WIN64) 11882 EnterCriticalSection(&e->cs);
11889 setstatd(d, -1,
"not disconnected", (*d->
ov3) ?
"HY000" :
"S1000");
11921 #if defined(_WIN32) || defined(_WIN64) 11923 LeaveCriticalSection(&d->cs);
11924 DeleteCriticalSection(&d->cs);
11929 #if defined(_WIN32) || defined(_WIN64) 11931 LeaveCriticalSection(&e->cs);
11961 SQLINTEGER bufmax, SQLINTEGER *buflen)
11966 if (
dbc == SQL_NULL_HDBC) {
11967 return SQL_INVALID_HANDLE;
11971 val = (SQLPOINTER) &dummy;
11977 case SQL_ATTR_CONNECTION_DEAD:
11978 *((SQLINTEGER *) val) = d->
sqlite ? SQL_CD_FALSE : SQL_CD_TRUE;
11979 *buflen =
sizeof (SQLINTEGER);
11981 case SQL_ATTR_ACCESS_MODE:
11982 *((SQLINTEGER *) val) = SQL_MODE_READ_WRITE;
11983 *buflen =
sizeof (SQLINTEGER);
11985 case SQL_ATTR_AUTOCOMMIT:
11986 *((SQLINTEGER *) val) =
11987 d->
autocommit ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF;
11988 *buflen =
sizeof (SQLINTEGER);
11990 case SQL_ATTR_LOGIN_TIMEOUT:
11991 *((SQLINTEGER *) val) = 100;
11992 *buflen =
sizeof (SQLINTEGER);
11994 case SQL_ATTR_ODBC_CURSORS:
11995 *((SQLINTEGER *) val) = SQL_CUR_USE_DRIVER;
11996 *buflen =
sizeof (SQLINTEGER);
11998 case SQL_ATTR_PACKET_SIZE:
11999 *((SQLINTEGER *) val) = 16384;
12000 *buflen =
sizeof (SQLINTEGER);
12002 case SQL_ATTR_TXN_ISOLATION:
12003 *((SQLINTEGER *) val) = SQL_TXN_SERIALIZABLE;
12004 *buflen =
sizeof (SQLINTEGER);
12006 case SQL_ATTR_TRACEFILE:
12007 case SQL_ATTR_TRANSLATE_LIB:
12008 *((SQLCHAR *) val) = 0;
12011 case SQL_ATTR_CURRENT_CATALOG:
12012 #if defined(_WIN32) || defined(_WIN64) 12014 if ((bufmax > 4) && (val != (SQLPOINTER) &dummy)) {
12015 strcpy((
char *) val,
"main");
12021 *((SQLCHAR *) val) = 0;
12024 case SQL_ATTR_TRACE:
12025 case SQL_ATTR_QUIET_MODE:
12026 case SQL_ATTR_TRANSLATE_OPTION:
12027 case SQL_ATTR_KEYSET_SIZE:
12028 case SQL_ATTR_QUERY_TIMEOUT:
12029 *((SQLINTEGER *) val) = 0;
12030 *buflen =
sizeof (SQLINTEGER);
12032 case SQL_ATTR_PARAM_BIND_TYPE:
12033 *((
SQLULEN *) val) = SQL_PARAM_BIND_BY_COLUMN;
12034 *buflen =
sizeof (SQLUINTEGER);
12036 case SQL_ATTR_ROW_BIND_TYPE:
12037 *((
SQLULEN *) val) = SQL_BIND_BY_COLUMN;
12040 case SQL_ATTR_USE_BOOKMARKS:
12041 *((SQLINTEGER *) val) = SQL_UB_OFF;
12042 *buflen =
sizeof (SQLINTEGER);
12044 case SQL_ATTR_ASYNC_ENABLE:
12045 *((SQLINTEGER *) val) = SQL_ASYNC_ENABLE_OFF;
12046 *buflen =
sizeof (SQLINTEGER);
12048 case SQL_ATTR_NOSCAN:
12049 *((SQLINTEGER *) val) = SQL_NOSCAN_ON;
12050 *buflen =
sizeof (SQLINTEGER);
12052 case SQL_ATTR_CONCURRENCY:
12053 *((SQLINTEGER *) val) = SQL_CONCUR_LOCK;
12054 *buflen =
sizeof (SQLINTEGER);
12056 #ifdef SQL_ATTR_CURSOR_SENSITIVITY 12057 case SQL_ATTR_CURSOR_SENSITIVITY:
12058 *((SQLINTEGER *) val) = SQL_UNSPECIFIED;
12059 *buflen =
sizeof (SQLINTEGER);
12062 case SQL_ATTR_SIMULATE_CURSOR:
12063 *((SQLINTEGER *) val) = SQL_SC_NON_UNIQUE;
12064 *buflen =
sizeof (SQLINTEGER);
12066 case SQL_ATTR_MAX_ROWS:
12067 *((SQLINTEGER *) val) = 0;
12068 *buflen =
sizeof (SQLINTEGER);
12069 case SQL_ATTR_MAX_LENGTH:
12070 *((SQLINTEGER *) val) = 1000000000;
12071 *buflen =
sizeof (SQLINTEGER);
12073 case SQL_ATTR_CURSOR_TYPE:
12074 *((SQLINTEGER *) val) = d->
curtype;
12075 *buflen =
sizeof (SQLINTEGER);
12077 case SQL_ATTR_RETRIEVE_DATA:
12078 *((SQLINTEGER *) val) = SQL_RD_ON;
12079 *buflen =
sizeof (SQLINTEGER);
12081 #ifdef SQL_ATTR_METADATA_ID 12082 case SQL_ATTR_METADATA_ID:
12083 *((
SQLULEN *) val) = SQL_FALSE;
12084 return SQL_SUCCESS;
12087 *((SQLINTEGER *) val) = 0;
12088 *buflen =
sizeof (SQLINTEGER);
12089 setstatd(d, -1,
"unsupported connect attribute %d",
12090 (*d->
ov3) ?
"HYC00" :
"S1C00", (
int) attr);
12093 return SQL_SUCCESS;
12108 SQLGetConnectAttr(SQLHDBC
dbc, SQLINTEGER attr, SQLPOINTER val,
12109 SQLINTEGER bufmax, SQLINTEGER *buflen)
12133 SQLINTEGER bufmax, SQLINTEGER *buflen)
12136 SQLINTEGER len = 0;
12140 if (ret == SQL_SUCCESS) {
12141 SQLWCHAR *v = NULL;
12144 case SQL_ATTR_TRACEFILE:
12145 case SQL_ATTR_CURRENT_CATALOG:
12146 case SQL_ATTR_TRANSLATE_LIB:
12151 int vmax = bufmax /
sizeof (SQLWCHAR);
12161 len *=
sizeof (SQLWCHAR);
12168 if (bufmax >=
sizeof (SQLWCHAR)) {
12169 *((SQLWCHAR *)val) = 0;
12173 len *=
sizeof (SQLWCHAR);
12201 if (
dbc == SQL_NULL_HDBC) {
12202 return SQL_INVALID_HANDLE;
12206 case SQL_AUTOCOMMIT:
12207 d->
autocommit = val == (SQLPOINTER) SQL_AUTOCOMMIT_ON;
12209 return endtran(d, SQL_COMMIT, 1);
12214 return SQL_SUCCESS;
12215 #ifdef SQL_ATTR_METADATA_ID 12216 case SQL_ATTR_METADATA_ID:
12217 if (val == (SQLPOINTER) SQL_FALSE) {
12223 setstatd(d, -1,
"option value changed",
"01S02");
12224 return SQL_SUCCESS_WITH_INFO;
12226 return SQL_SUCCESS;
12240 SQLSetConnectAttr(SQLHDBC
dbc, SQLINTEGER attr, SQLPOINTER val,
12289 if (
dbc == SQL_NULL_HDBC) {
12290 return SQL_INVALID_HANDLE;
12294 param = (SQLPOINTER) &dummy;
12297 case SQL_ACCESS_MODE:
12298 *((SQLINTEGER *) param) = SQL_MODE_READ_WRITE;
12300 case SQL_AUTOCOMMIT:
12301 *((SQLINTEGER *) param) =
12302 d->
autocommit ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF;
12304 case SQL_LOGIN_TIMEOUT:
12305 *((SQLINTEGER *) param) = 100;
12307 case SQL_ODBC_CURSORS:
12308 *((SQLINTEGER *) param) = SQL_CUR_USE_DRIVER;
12310 case SQL_PACKET_SIZE:
12311 *((SQLINTEGER *) param) = 16384;
12313 case SQL_TXN_ISOLATION:
12314 *((SQLINTEGER *) param) = SQL_TXN_SERIALIZABLE;
12316 case SQL_OPT_TRACE:
12317 case SQL_OPT_TRACEFILE:
12318 case SQL_QUIET_MODE:
12319 case SQL_TRANSLATE_DLL:
12320 case SQL_TRANSLATE_OPTION:
12321 case SQL_KEYSET_SIZE:
12322 case SQL_QUERY_TIMEOUT:
12323 case SQL_BIND_TYPE:
12324 case SQL_CURRENT_QUALIFIER:
12325 *((SQLINTEGER *) param) = 0;
12327 case SQL_USE_BOOKMARKS:
12328 *((SQLINTEGER *) param) = SQL_UB_OFF;
12330 case SQL_ASYNC_ENABLE:
12331 *((SQLINTEGER *) param) = SQL_ASYNC_ENABLE_OFF;
12334 *((SQLINTEGER *) param) = SQL_NOSCAN_ON;
12336 case SQL_CONCURRENCY:
12337 *((SQLINTEGER *) param) = SQL_CONCUR_LOCK;
12339 case SQL_SIMULATE_CURSOR:
12340 *((SQLINTEGER *) param) = SQL_SC_NON_UNIQUE;
12343 *((SQLINTEGER *) param) = 0;
12345 case SQL_ROWSET_SIZE:
12346 case SQL_MAX_LENGTH:
12347 *((SQLINTEGER *) param) = 1000000000;
12349 case SQL_CURSOR_TYPE:
12350 *((SQLINTEGER *) param) = d->
curtype;
12352 case SQL_RETRIEVE_DATA:
12353 *((SQLINTEGER *) param) = SQL_RD_ON;
12356 *((SQLINTEGER *) param) = 0;
12357 setstatd(d, -1,
"unsupported connect option %d",
12358 (*d->
ov3) ?
"HYC00" :
"S1C00", opt);
12361 return SQL_SUCCESS;
12374 SQLGetConnectOption(SQLHDBC
dbc, SQLUSMALLINT opt, SQLPOINTER param)
12401 if (SQL_SUCCEEDED(ret)) {
12403 case SQL_OPT_TRACEFILE:
12404 case SQL_CURRENT_QUALIFIER:
12405 case SQL_TRANSLATE_DLL:
12407 *(SQLWCHAR *) param = 0;
12430 if (
dbc == SQL_NULL_HDBC) {
12431 return SQL_INVALID_HANDLE;
12435 case SQL_AUTOCOMMIT:
12438 return endtran(d, SQL_COMMIT, 1);
12444 setstatd(d, -1,
"option value changed",
"01S02");
12445 return SQL_SUCCESS_WITH_INFO;
12447 return SQL_SUCCESS;
12460 SQLSetConnectOption(SQLHDBC
dbc, SQLUSMALLINT opt,
SQLULEN param)
12492 #if defined(WITHOUT_DRIVERMGR) || (!defined(_WIN32) && !defined(_WIN64)) 12507 char *str = dsn, *start;
12508 int len = strlen(attr);
12511 while (*str && *str ==
';') {
12515 if ((str = strchr(str,
'=')) == NULL) {
12518 if (str - start == len && strncasecmp(start, attr, len) == 0) {
12520 while (*str && *str !=
';') {
12523 len =
min(outLen - 1, str - start);
12524 strncpy(out, start, len);
12528 while (*str && *str !=
';') {
12549 int pwdLen,
int isu)
12554 char buf[SQL_MAX_MESSAGE_LENGTH * 6], dbname[SQL_MAX_MESSAGE_LENGTH];
12555 char busy[SQL_MAX_MESSAGE_LENGTH / 4], tracef[SQL_MAX_MESSAGE_LENGTH];
12556 char loadext[SQL_MAX_MESSAGE_LENGTH];
12557 char sflag[32], spflag[32], ntflag[32], nwflag[32], biflag[32];
12558 char snflag[32], lnflag[32], ncflag[32], fkflag[32], jmode[32];
12560 #if defined(_WIN32) || defined(_WIN64) 12564 if (
dbc == SQL_NULL_HDBC) {
12565 return SQL_INVALID_HANDLE;
12569 return SQL_INVALID_HANDLE;
12571 if (d->
sqlite != NULL) {
12572 setstatd(d, -1,
"connection already established",
"08002");
12576 if (dsnLen == SQL_NTS) {
12577 len =
sizeof (buf) - 1;
12579 len =
min(
sizeof (buf) - 1, dsnLen);
12582 strncpy(buf, (
char *) dsn, len);
12585 if (buf[0] ==
'\0') {
12586 setstatd(d, -1,
"invalid DSN", (*d->
ov3) ?
"HY090" :
"S1090");
12589 #if defined(_WIN32) || defined(_WIN64) 12595 char *cdsn = utf_to_wmb(buf, len);
12598 setstatd(d, -1,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
12607 #ifdef WITHOUT_DRIVERMGR 12608 getdsnattr(buf,
"database", dbname,
sizeof (dbname));
12609 if (dbname[0] ==
'\0') {
12610 strncpy(dbname, buf,
sizeof (dbname));
12611 dbname[
sizeof (dbname) - 1] =
'\0';
12613 getdsnattr(buf,
"timeout", busy,
sizeof (busy));
12615 getdsnattr(buf,
"stepapi", sflag,
sizeof (sflag));
12617 getdsnattr(buf,
"syncpragma", spflag,
sizeof (spflag));
12619 getdsnattr(buf,
"notxn", ntflag,
sizeof (ntflag));
12621 getdsnattr(buf,
"nowchar", nwflag,
sizeof (nwflag));
12623 getdsnattr(buf,
"shortnames", snflag,
sizeof (snflag));
12625 getdsnattr(buf,
"longnames", lnflag,
sizeof (lnflag));
12627 getdsnattr(buf,
"nocreat", ncflag,
sizeof (ncflag));
12629 getdsnattr(buf,
"fksupport", fkflag,
sizeof (fkflag));
12631 getdsnattr(buf,
"loadext", loadext,
sizeof (loadext));
12633 getdsnattr(buf,
"journalmode", jmode,
sizeof (jmode));
12635 getdsnattr(buf,
"jdconv", jdflag,
sizeof (jdflag));
12636 #if defined(_WIN32) || defined(_WIN64) 12638 getdsnattr(buf,
"oemcp", oemcp,
sizeof (oemcp));
12641 getdsnattr(buf,
"bigint", biflag,
sizeof (biflag));
12643 SQLGetPrivateProfileString(buf,
"timeout",
"100000",
12645 SQLGetPrivateProfileString(buf,
"database",
"",
12646 dbname,
sizeof (dbname),
ODBC_INI);
12647 #if defined(_WIN32) || defined(_WIN64) 12651 SQLGetPrivateProfileString(buf,
"stepapi",
"",
12653 SQLGetPrivateProfileString(buf,
"syncpragma",
"NORMAL",
12654 spflag,
sizeof (spflag),
ODBC_INI);
12655 SQLGetPrivateProfileString(buf,
"notxn",
"",
12656 ntflag,
sizeof (ntflag),
ODBC_INI);
12657 SQLGetPrivateProfileString(buf,
"nowchar",
"",
12658 nwflag,
sizeof (nwflag),
ODBC_INI);
12659 SQLGetPrivateProfileString(buf,
"shortnames",
"",
12660 snflag,
sizeof (snflag),
ODBC_INI);
12661 SQLGetPrivateProfileString(buf,
"longnames",
"",
12662 lnflag,
sizeof (lnflag),
ODBC_INI);
12663 SQLGetPrivateProfileString(buf,
"nocreat",
"",
12664 ncflag,
sizeof (ncflag),
ODBC_INI);
12665 SQLGetPrivateProfileString(buf,
"fksupport",
"",
12666 fkflag,
sizeof (fkflag),
ODBC_INI);
12667 SQLGetPrivateProfileString(buf,
"loadext",
"",
12668 loadext,
sizeof (loadext),
ODBC_INI);
12669 SQLGetPrivateProfileString(buf,
"journalmode",
"",
12671 SQLGetPrivateProfileString(buf,
"jdconv",
"",
12672 jdflag,
sizeof (jdflag),
ODBC_INI);
12673 #if defined(_WIN32) || defined(_WIN64) 12674 SQLGetPrivateProfileString(buf,
"oemcp",
"1",
12677 SQLGetPrivateProfileString(buf,
"bigint",
"",
12678 biflag,
sizeof (biflag),
ODBC_INI);
12681 #ifdef WITHOUT_DRIVERMGR 12682 getdsnattr(buf,
"tracefile", tracef,
sizeof (tracef));
12684 SQLGetPrivateProfileString(buf,
"tracefile",
"",
12685 tracef,
sizeof (tracef),
ODBC_INI);
12687 if (tracef[0] !=
'\0') {
12688 d->
trace = fopen(tracef,
"a");
12696 #if defined(_WIN32) || defined(_WIN64) 12705 d->
pwdLen = (pwdLen == SQL_NTS) ? strlen(d->
pwd) : pwdLen;
12707 ret =
dbopen(d, dbname, isu, (
char *) dsn, sflag, spflag, ntflag,
12709 if (ret == SQL_SUCCESS) {
12729 SQLConnect(SQLHDBC
dbc, SQLCHAR *dsn, SQLSMALLINT dsnLen,
12730 SQLCHAR *uid, SQLSMALLINT uidLen,
12731 SQLCHAR *pwd, SQLSMALLINT pwdLen)
12736 ret =
drvconnect(
dbc, dsn, dsnLen, (
char *) pwd, pwdLen, 0);
12757 SQLWCHAR *uid, SQLSMALLINT uidLen,
12758 SQLWCHAR *pwd, SQLSMALLINT pwdLen)
12770 setstatd(d, -1,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
12780 setstatd(d, -1,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
12785 ret =
drvconnect(
dbc, (SQLCHAR *) dsna, SQL_NTS, pwda, SQL_NTS, 1);
12806 if (
dbc == SQL_NULL_HDBC) {
12807 return SQL_INVALID_HANDLE;
12811 return SQL_INVALID_HANDLE;
12814 setstatd(d, -1,
"incomplete transaction",
"25000");
12822 fprintf(d->
trace,
"-- sqlite3_close: '%s'\n",
12826 rc = sqlite3_close(d->
sqlite);
12827 if (rc == SQLITE_BUSY) {
12828 setstatd(d, -1,
"unfinished statements",
"25000");
12835 return SQL_SUCCESS;
12855 #if defined(WITHOUT_DRIVERMGR) || (!defined(_WIN32) && !defined(_WIN64)) 12872 SQLCHAR *connIn, SQLSMALLINT connInLen,
12873 SQLCHAR *connOut, SQLSMALLINT connOutMax,
12874 SQLSMALLINT *connOutLen, SQLUSMALLINT drvcompl)
12879 char buf[SQL_MAX_MESSAGE_LENGTH * 8], dbname[SQL_MAX_MESSAGE_LENGTH];
12880 char dsn[SQL_MAX_MESSAGE_LENGTH], busy[SQL_MAX_MESSAGE_LENGTH / 4];
12881 char tracef[SQL_MAX_MESSAGE_LENGTH], loadext[SQL_MAX_MESSAGE_LENGTH];
12882 char pwd[SQL_MAX_MESSAGE_LENGTH];
12883 char sflag[32], spflag[32], ntflag[32], snflag[32], lnflag[32];
12884 char ncflag[32], nwflag[32], fkflag[32], jmode[32], biflag[32];
12887 if (
dbc == SQL_NULL_HDBC) {
12888 return SQL_INVALID_HANDLE;
12890 if (drvcompl != SQL_DRIVER_COMPLETE &&
12891 drvcompl != SQL_DRIVER_COMPLETE_REQUIRED &&
12892 drvcompl != SQL_DRIVER_PROMPT &&
12893 drvcompl != SQL_DRIVER_NOPROMPT) {
12894 return SQL_NO_DATA;
12898 setstatd(d, -1,
"connection already established",
"08002");
12902 if (connInLen == SQL_NTS) {
12903 len =
sizeof (buf) - 1;
12905 len =
min(connInLen,
sizeof (buf) - 1);
12907 if (connIn != NULL) {
12908 strncpy(buf, (
char *) connIn, len);
12912 setstatd(d, -1,
"invalid connect attributes",
12913 (*d->
ov3) ?
"HY090" :
"S1090");
12920 if (!dsn[0] && !strchr(buf,
';') && !strchr(buf,
'=')) {
12921 strncpy(dsn, buf,
sizeof (dsn) - 1);
12922 dsn[
sizeof (dsn) - 1] =
'\0';
12926 getdsnattr(buf,
"timeout", busy,
sizeof (busy));
12927 #ifndef WITHOUT_DRIVERMGR 12928 if (dsn[0] && !busy[0]) {
12929 SQLGetPrivateProfileString(dsn,
"timeout",
"100000",
12934 getdsnattr(buf,
"database", dbname,
sizeof (dbname));
12935 #ifndef WITHOUT_DRIVERMGR 12936 if (dsn[0] && !dbname[0]) {
12937 SQLGetPrivateProfileString(dsn,
"database",
"",
12938 dbname,
sizeof (dbname),
ODBC_INI);
12942 getdsnattr(buf,
"stepapi", sflag,
sizeof (sflag));
12943 #ifndef WITHOUT_DRIVERMGR 12944 if (dsn[0] && !sflag[0]) {
12945 SQLGetPrivateProfileString(dsn,
"stepapi",
"",
12950 getdsnattr(buf,
"syncpragma", spflag,
sizeof (spflag));
12951 #ifndef WITHOUT_DRIVERMGR 12952 if (dsn[0] && !spflag[0]) {
12953 SQLGetPrivateProfileString(dsn,
"syncpragma",
"NORMAL",
12954 spflag,
sizeof (spflag),
ODBC_INI);
12958 getdsnattr(buf,
"notxn", ntflag,
sizeof (ntflag));
12959 #ifndef WITHOUT_DRIVERMGR 12960 if (dsn[0] && !ntflag[0]) {
12961 SQLGetPrivateProfileString(dsn,
"notxn",
"",
12962 ntflag,
sizeof (ntflag),
ODBC_INI);
12966 getdsnattr(buf,
"shortnames", snflag,
sizeof (snflag));
12967 #ifndef WITHOUT_DRIVERMGR 12968 if (dsn[0] && !snflag[0]) {
12969 SQLGetPrivateProfileString(dsn,
"shortnames",
"",
12970 snflag,
sizeof (snflag),
ODBC_INI);
12974 getdsnattr(buf,
"longnames", lnflag,
sizeof (lnflag));
12975 #ifndef WITHOUT_DRIVERMGR 12976 if (dsn[0] && !lnflag[0]) {
12977 SQLGetPrivateProfileString(dsn,
"longnames",
"",
12978 lnflag,
sizeof (lnflag),
ODBC_INI);
12982 getdsnattr(buf,
"nocreat", ncflag,
sizeof (ncflag));
12983 #ifndef WITHOUT_DRIVERMGR 12984 if (dsn[0] && !ncflag[0]) {
12985 SQLGetPrivateProfileString(dsn,
"nocreat",
"",
12986 ncflag,
sizeof (ncflag),
ODBC_INI);
12990 getdsnattr(buf,
"nowchar", nwflag,
sizeof (nwflag));
12991 #ifndef WITHOUT_DRIVERMGR 12992 if (dsn[0] && !nwflag[0]) {
12993 SQLGetPrivateProfileString(dsn,
"nowchar",
"",
12994 nwflag,
sizeof (nwflag),
ODBC_INI);
12998 getdsnattr(buf,
"fksupport", fkflag,
sizeof (fkflag));
12999 #ifndef WITHOUT_DRIVERMGR 13000 if (dsn[0] && !fkflag[0]) {
13001 SQLGetPrivateProfileString(dsn,
"fksupport",
"",
13002 fkflag,
sizeof (fkflag),
ODBC_INI);
13006 getdsnattr(buf,
"loadext", loadext,
sizeof (loadext));
13007 #ifndef WITHOUT_DRIVERMGR 13008 if (dsn[0] && !loadext[0]) {
13009 SQLGetPrivateProfileString(dsn,
"loadext",
"",
13010 loadext,
sizeof (loadext),
ODBC_INI);
13014 getdsnattr(buf,
"journalmode", jmode,
sizeof (jmode));
13015 #ifndef WITHOUT_DRIVERMGR 13016 if (dsn[0] && !jmode[0]) {
13017 SQLGetPrivateProfileString(dsn,
"journalmode",
"",
13022 getdsnattr(buf,
"bigint", biflag,
sizeof (biflag));
13023 #ifndef WITHOUT_DRIVERMGR 13024 if (dsn[0] && !biflag[0]) {
13025 SQLGetPrivateProfileString(dsn,
"bigint",
"",
13026 biflag,
sizeof (biflag),
ODBC_INI);
13030 getdsnattr(buf,
"jdconv", jdflag,
sizeof (jdflag));
13031 #ifndef WITHOUT_DRIVERMGR 13032 if (dsn[0] && !jdflag[0]) {
13033 SQLGetPrivateProfileString(dsn,
"jdconv",
"",
13034 jdflag,
sizeof (jdflag),
ODBC_INI);
13039 #ifndef WITHOUT_DRIVERMGR 13040 if (dsn[0] && !pwd[0]) {
13041 SQLGetPrivateProfileString(dsn,
"pwd",
"",
13046 if (!dbname[0] && !dsn[0]) {
13047 strcpy(dsn,
"SQLite");
13048 strncpy(dbname, buf,
sizeof (dbname));
13049 dbname[
sizeof (dbname) - 1] =
'\0';
13052 getdsnattr(buf,
"tracefile", tracef,
sizeof (tracef));
13053 #ifndef WITHOUT_DRIVERMGR 13054 if (dsn[0] && !tracef[0]) {
13055 SQLGetPrivateProfileString(dsn,
"tracefile",
"",
13056 tracef,
sizeof (tracef),
ODBC_INI);
13059 if (connOut || connOutLen) {
13063 count = snprintf(buf,
sizeof (buf),
13064 "DSN=%s;Database=%s;StepAPI=%s;Timeout=%s;" 13065 "SyncPragma=%s;NoTXN=%s;ShortNames=%s;LongNames=%s;" 13066 "NoCreat=%s;NoWCHAR=%s;FKSupport=%s;Tracefile=%s;" 13067 "JournalMode=%s;LoadExt=%s;BigInt=%s;JDConv=%s;" 13069 dsn, dbname, sflag, busy, spflag, ntflag,
13070 snflag, lnflag, ncflag, nwflag, fkflag, tracef,
13071 jmode, loadext, biflag, jdflag, pwd);
13073 buf[
sizeof (buf) - 1] =
'\0';
13075 len =
min(connOutMax - 1, strlen(buf));
13077 strncpy((
char *) connOut, buf, len);
13078 connOut[len] =
'\0';
13084 if (tracef[0] !=
'\0') {
13085 d->
trace = fopen(tracef,
"a");
13095 d->
pwdLen = strlen(pwd);
13097 ret =
dbopen(d, dbname, 0, dsn, sflag, spflag, ntflag, jmode, busy);
13098 memset(pwd, 0,
sizeof (pwd));
13099 if (ret == SQL_SUCCESS) {
13118 if (
stmt == SQL_NULL_HSTMT) {
13119 return SQL_INVALID_HANDLE;
13154 return SQL_SUCCESS;
13170 if (
dbc == SQL_NULL_HDBC) {
13171 return SQL_INVALID_HANDLE;
13175 return SQL_INVALID_HANDLE;
13179 *
stmt = SQL_NULL_HSTMT;
13182 *
stmt = (SQLHSTMT) s;
13183 memset(s, 0,
sizeof (
STMT));
13186 s->
bkmrk = SQL_UB_OFF;
13207 sprintf((
char *) s->
cursorname,
"CUR_%I64X", (SQLUBIGINT) *
stmt);
13222 return SQL_SUCCESS;
13254 SQLRETURN ret = SQL_SUCCESS;
13257 if (
stmt == SQL_NULL_HSTMT) {
13258 return SQL_INVALID_HANDLE;
13264 case SQL_RESET_PARAMS:
13279 setstat(s, -1,
"unsupported option", (*s->
ov3) ?
"HYC00" :
"S1C00");
13309 if (
stmt != SQL_NULL_HSTMT) {
13311 #if defined(_WIN32) || defined(_WIN64) 13313 if (d->
magic ==
DBC_MAGIC && d->owner != GetCurrentThreadId() &&
13316 sqlite3_interrupt(d->
sqlite);
13317 return SQL_SUCCESS;
13322 sqlite3_interrupt(d->
sqlite);
13344 if (
stmt == SQL_NULL_HSTMT) {
13345 return SQL_INVALID_HANDLE;
13348 if (lenp && !cursor) {
13350 return SQL_SUCCESS;
13354 strncpy((
char *) cursor, (
char *) s->
cursorname, buflen - 1);
13355 cursor[buflen - 1] =
'\0';
13361 return SQL_SUCCESS;
13375 SQLGetCursorName(SQLHSTMT
stmt, SQLCHAR *cursor, SQLSMALLINT buflen,
13379 #if defined(_WIN32) || defined(_WIN64) 13380 SQLSMALLINT len = 0;
13384 #if defined(_WIN32) || defined(_WIN64) 13390 if (ret == SQL_SUCCESS) {
13394 c = utf_to_wmb((
char *) cursor, len);
13402 strncpy((
char *) cursor, c, buflen - 1);
13403 cursor[buflen - 1] = 0;
13408 *lenp =
min(len, buflen - 1);
13436 SQLSMALLINT len = 0;
13440 if (ret == SQL_SUCCESS) {
13441 SQLWCHAR *c = NULL;
13453 cursor[buflen - 1] = 0;
13458 *lenp =
min(len, buflen - 1);
13480 if (
stmt == SQL_NULL_HSTMT) {
13481 return SQL_INVALID_HANDLE;
13485 !((cursor[0] >=
'A' && cursor[0] <=
'Z') ||
13486 (cursor[0] >=
'a' && cursor[0] <=
'z'))) {
13487 setstat(s, -1,
"invalid cursor name", (*s->
ov3) ?
"HYC00" :
"S1C00");
13490 if (len == SQL_NTS) {
13495 strncpy((
char *) s->
cursorname, (
char *) cursor, len);
13497 return SQL_SUCCESS;
13510 SQLSetCursorName(SQLHSTMT
stmt, SQLCHAR *cursor, SQLSMALLINT len)
13512 #if defined(_WIN32) || defined(_WIN64) 13518 #if defined(_WIN32) || defined(_WIN64) 13524 c = wmb_to_utf_c((
char *) cursor, len);
13534 #if defined(_WIN32) || defined(_WIN64) 13602 case SQL_HANDLE_ENV:
13604 if (ret == SQL_SUCCESS) {
13605 ENV *e = (
ENV *) *output;
13612 case SQL_HANDLE_DBC:
13614 case SQL_HANDLE_STMT:
13616 ret =
drvallocstmt((SQLHDBC) input, (SQLHSTMT *) output);
13634 case SQL_HANDLE_ENV:
13636 case SQL_HANDLE_DBC:
13638 case SQL_HANDLE_STMT:
13655 for (i = 0; i < s->
dcols; i++) {
13746 for (i = s->
nbindcols; i < ncols; i++) {
13747 bindcols[i].
type = SQL_UNKNOWN_TYPE;
13748 bindcols[i].
max = 0;
13749 bindcols[i].
lenp = NULL;
13750 bindcols[i].
valp = NULL;
13751 bindcols[i].
index = i;
13752 bindcols[i].
offs = 0;
13757 }
else if (ncols > 0) {
13765 return SQL_SUCCESS;
13783 SQLPOINTER val, SQLINTEGER len,
SQLLEN *lenp,
int partial)
13785 char **data, valdummy[16];
13787 SQLINTEGER *ilenp = NULL;
13790 SQLRETURN sret = SQL_NO_DATA;
13796 if (((SQLINTEGER *) lenp) + 1 == (SQLINTEGER *) val) {
13797 ilenp = (SQLINTEGER *) lenp;
13800 if (col >= s->
ncols) {
13801 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009" :
"S1002");
13805 return SQL_SUCCESS;
13808 *lenp = SQL_NULL_DATA;
13812 *lenp = SQL_NULL_DATA;
13817 #if (defined(_WIN32) || defined(_WIN64)) && defined(WINTERFACE) 13819 if (type == SQL_C_WCHAR && otype == SQL_C_DEFAULT) {
13826 val = (SQLPOINTER) valdummy;
13828 if (*data == NULL) {
13829 *lenp = SQL_NULL_DATA;
13831 case SQL_C_UTINYINT:
13832 case SQL_C_TINYINT:
13833 case SQL_C_STINYINT:
13837 *((SQLCHAR *) val) = 0;
13842 *((SQLSMALLINT *) val) = 0;
13847 *((SQLINTEGER *) val) = 0;
13850 case SQL_C_SBIGINT:
13851 case SQL_C_UBIGINT:
13852 *((SQLBIGINT *) val) = 0;
13856 *((
float *) val) = 0;
13859 *((
double *) val) = 0;
13864 *((SQLCHAR *) val) =
'\0';
13867 #ifdef WCHARSUPPORT 13870 *((SQLWCHAR *) val) =
'\0';
13874 #ifdef SQL_C_TYPE_DATE 13875 case SQL_C_TYPE_DATE:
13878 memset((DATE_STRUCT *) val, 0,
sizeof (DATE_STRUCT));
13880 #ifdef SQL_C_TYPE_TIME 13881 case SQL_C_TYPE_TIME:
13884 memset((TIME_STRUCT *) val, 0,
sizeof (TIME_STRUCT));
13886 #ifdef SQL_C_TYPE_TIMESTAMP 13887 case SQL_C_TYPE_TIMESTAMP:
13889 case SQL_C_TIMESTAMP:
13890 memset((TIMESTAMP_STRUCT *) val, 0,
sizeof (TIMESTAMP_STRUCT));
13897 #if defined(_WIN32) || defined(_WIN64) 13904 case SQL_C_UTINYINT:
13905 case SQL_C_TINYINT:
13906 case SQL_C_STINYINT:
13907 *((SQLCHAR *) val) = strtol(*data, &endp, 0);
13908 if (endp && endp == *data) {
13909 *lenp = SQL_NULL_DATA;
13911 *lenp =
sizeof (SQLCHAR);
13916 *((SQLCHAR *) val) =
getbool(*data);
13917 *lenp =
sizeof (SQLCHAR);
13923 *((SQLSMALLINT *) val) = strtol(*data, &endp, 0);
13924 if (endp && endp == *data) {
13925 *lenp = SQL_NULL_DATA;
13927 *lenp =
sizeof (SQLSMALLINT);
13933 *((SQLINTEGER *) val) = strtol(*data, &endp, 0);
13934 if (endp && endp == *data) {
13935 *lenp = SQL_NULL_DATA;
13937 *lenp =
sizeof (SQLINTEGER);
13941 case SQL_C_UBIGINT:
13942 #if defined(_WIN32) || defined(_WIN64) 13943 if (sscanf(*data,
"%I64u%c", (SQLUBIGINT *) val, &endc) != 1) {
13944 *lenp = SQL_NULL_DATA;
13946 *lenp =
sizeof (SQLUBIGINT);
13950 *((SQLUBIGINT *) val) = strtoul(*data, &endp, 0);
13952 *((SQLUBIGINT *) val) = strtoull(*data, &endp, 0);
13954 if (endp && endp == *data) {
13955 *lenp = SQL_NULL_DATA;
13957 *lenp =
sizeof (SQLUBIGINT);
13961 case SQL_C_SBIGINT:
13962 #if defined(_WIN32) || defined(_WIN64) 13963 if (sscanf(*data,
"%I64d%c", (SQLBIGINT *) val, &endc) != 1) {
13964 *lenp = SQL_NULL_DATA;
13966 *lenp =
sizeof (SQLBIGINT);
13970 *((SQLBIGINT *) val) = strtol(*data, &endp, 0);
13972 *((SQLBIGINT *) val) = strtoll(*data, &endp, 0);
13974 if (endp && endp == *data) {
13975 *lenp = SQL_NULL_DATA;
13977 *lenp =
sizeof (SQLBIGINT);
13983 *((
float *) val) =
ln_strtod(*data, &endp);
13984 if (endp && endp == *data) {
13985 *lenp = SQL_NULL_DATA;
13987 *lenp =
sizeof (float);
13991 *((
double *) val) =
ln_strtod(*data, &endp);
13992 if (endp && endp == *data) {
13993 *lenp = SQL_NULL_DATA;
13995 *lenp =
sizeof (double);
13998 case SQL_C_BINARY: {
13999 int dlen, offs = 0;
14023 if (!(dp[0] ==
'x' || dp[0] ==
'X') || dp[1] !=
'\'' ||
14024 dp[dlen - 1] !=
'\'') {
14035 memset(bin, 0, dlen);
14037 for (i = 0; i < dlen; i++) {
14041 if (!*dp || !(x = strchr(
xdigits, *dp))) {
14045 bin[i] = (v >= 16) ? ((v - 6) << 4) : (v << 4);
14047 if (!*dp || !(x = strchr(
xdigits, *dp))) {
14051 setstat(s, -1,
"conversion error",
14052 (*s->
ov3) ?
"HY000" :
"S1000");
14056 bin[i] |= (v >= 16) ? (v - 6) : v;
14061 if (partial && len && s->
bindcols) {
14066 sret = SQL_SUCCESS;
14070 sret = SQL_NO_DATA;
14077 memcpy(val, bin + offs,
min(len, dlen));
14082 *lenp =
min(len, dlen);
14083 if (*lenp == len && *lenp != dlen) {
14084 *lenp = SQL_NO_TOTAL;
14087 if (partial && len && s->
bindcols) {
14088 if (*lenp == SQL_NO_TOTAL) {
14091 setstat(s, -1,
"data right truncated",
"01004");
14095 sret = SQL_SUCCESS_WITH_INFO;
14100 if (*lenp == SQL_NO_TOTAL) {
14102 setstat(s, -1,
"data right truncated",
"01004");
14103 sret = SQL_SUCCESS_WITH_INFO;
14109 #ifdef WCHARSUPPORT 14113 int doz, zlen = len - 1;
14114 int dlen = strlen(*data);
14116 #ifdef WCHARSUPPORT 14117 SQLWCHAR *ucdata = NULL;
14118 SQLCHAR *cdata = (SQLCHAR *) *data;
14121 #if (defined(_WIN32) || defined(_WIN64)) && defined(WINTERFACE) 14124 (s->
cols == statSpec2P || s->
cols == statSpec3P) &&
14125 type == SQL_C_WCHAR) {
14126 if (len > 0 && len <=
sizeof (SQLWCHAR)) {
14127 ((
char *) val)[0] = data[0][0];
14128 memset((
char *) val + 1, 0, len - 1);
14130 sret = SQL_SUCCESS;
14136 #ifdef WCHARSUPPORT 14142 doz =
sizeof (SQLWCHAR);
14148 if (type == SQL_C_WCHAR) {
14153 dlen =
uc_strlen(ucdata) *
sizeof (SQLWCHAR);
14155 #if defined(_WIN32) || defined(_WIN64) 14156 else if (*s->
oemcp && type == SQL_C_CHAR) {
14157 ucdata = (SQLWCHAR *) utf_to_wmb((
char *) cdata, dlen);
14161 cdata = (SQLCHAR *) ucdata;
14162 dlen = strlen((
char *) cdata);
14166 doz = (type == SQL_C_CHAR) ? 1 : 0;
14168 if (partial && len && s->
bindcols) {
14170 #ifdef WCHARSUPPORT 14175 #ifdef WCHARSUPPORT 14176 if (type == SQL_C_WCHAR) {
14177 ((SQLWCHAR *) val)[0] = 0;
14179 ((
char *) val)[0] =
'\0';
14182 ((
char *) val)[0] =
'\0';
14187 sret = SQL_SUCCESS;
14191 sret = SQL_NO_DATA;
14197 if (val && !valnull && len) {
14198 #ifdef WCHARSUPPORT 14199 if (type == SQL_C_WCHAR) {
14200 uc_strncpy(val, ucdata + offs /
sizeof (SQLWCHAR),
14201 (len - doz) /
sizeof (SQLWCHAR));
14203 strncpy(val, (
char *) cdata + offs, len - doz);
14206 strncpy(val, *data + offs, len - doz);
14209 if (valnull || len < 1) {
14212 *lenp =
min(len - doz, dlen);
14213 if (*lenp == len - doz && *lenp != dlen) {
14214 *lenp = SQL_NO_TOTAL;
14215 }
else if (*lenp < zlen) {
14219 if (len && !valnull && doz) {
14220 #ifdef WCHARSUPPORT 14221 if (type == SQL_C_WCHAR) {
14222 ((SQLWCHAR *) val)[zlen /
sizeof (SQLWCHAR)] = 0;
14224 ((
char *) val)[zlen] =
'\0';
14227 ((
char *) val)[zlen] =
'\0';
14230 #ifdef WCHARSUPPORT 14233 if (partial && len && s->
bindcols) {
14234 if (*lenp == SQL_NO_TOTAL) {
14237 setstat(s, -1,
"data right truncated",
"01004");
14241 sret = SQL_SUCCESS_WITH_INFO;
14246 if (*lenp == SQL_NO_TOTAL) {
14248 setstat(s, -1,
"data right truncated",
"01004");
14249 sret = SQL_SUCCESS_WITH_INFO;
14254 #ifdef SQL_C_TYPE_DATE 14255 case SQL_C_TYPE_DATE:
14259 *lenp = SQL_NULL_DATA;
14261 *lenp =
sizeof (DATE_STRUCT);
14264 #ifdef SQL_C_TYPE_TIME 14265 case SQL_C_TYPE_TIME:
14269 *lenp = SQL_NULL_DATA;
14271 *lenp =
sizeof (TIME_STRUCT);
14274 #ifdef SQL_C_TYPE_TIMESTAMP 14275 case SQL_C_TYPE_TIMESTAMP:
14277 case SQL_C_TIMESTAMP:
14279 (TIMESTAMP_STRUCT *) val) < 0) {
14280 *lenp = SQL_NULL_DATA;
14282 *lenp =
sizeof (TIMESTAMP_STRUCT);
14286 ((TIMESTAMP_STRUCT *) val)->fraction = 0;
14289 ((TIMESTAMP_STRUCT *) val)->fraction /= 100000000;
14290 ((TIMESTAMP_STRUCT *) val)->fraction *= 100000000;
14293 ((TIMESTAMP_STRUCT *) val)->fraction /= 10000000;
14294 ((TIMESTAMP_STRUCT *) val)->fraction *= 10000000;
14302 sret = SQL_SUCCESS;
14328 if (
stmt == SQL_NULL_HSTMT) {
14329 return SQL_INVALID_HANDLE;
14333 if (col == 0 && s->
bkmrk == SQL_UB_ON &&
14334 type == SQL_C_BOOKMARK) {
14343 return SQL_SUCCESS;
14344 }
else if (col == 0 && s->
bkmrk == SQL_UB_VARIABLE &&
14345 type == SQL_C_VARBOOKMARK &&
14346 max >= sizeof (sqlite_int64)) {
14355 return SQL_SUCCESS;
14357 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009" :
"S1002");
14364 if (type == SQL_C_DEFAULT) {
14372 sz =
sizeof (SQLINTEGER);
14374 case SQL_C_TINYINT:
14375 case SQL_C_UTINYINT:
14376 case SQL_C_STINYINT:
14377 sz =
sizeof (SQLCHAR);
14382 sz =
sizeof (SQLSMALLINT);
14385 sz =
sizeof (SQLFLOAT);
14388 sz =
sizeof (SQLDOUBLE);
14390 case SQL_C_TIMESTAMP:
14391 sz =
sizeof (SQL_TIMESTAMP_STRUCT);
14394 sz =
sizeof (SQL_TIME_STRUCT);
14397 sz =
sizeof (SQL_DATE_STRUCT);
14401 #ifdef WCHARSUPPORT 14405 #ifdef SQL_C_TYPE_DATE 14406 case SQL_C_TYPE_DATE:
14407 sz =
sizeof (SQL_DATE_STRUCT);
14410 #ifdef SQL_C_TYPE_TIME 14411 case SQL_C_TYPE_TIME:
14412 sz =
sizeof (SQL_TIME_STRUCT);
14415 #ifdef SQL_C_TYPE_TIMESTAMP 14416 case SQL_C_TYPE_TIMESTAMP:
14417 sz =
sizeof (SQL_TIMESTAMP_STRUCT);
14422 sz =
sizeof (SQLCHAR);
14428 case SQL_C_SBIGINT:
14429 case SQL_C_UBIGINT:
14430 sz =
sizeof (SQLBIGINT);
14438 setstat(s, -1,
"invalid type %d",
"HY003", type);
14449 if (sz == 0 &&
max < 0) {
14450 setstat(s, -1,
"invalid length",
"HY090");
14462 return SQL_SUCCESS;
14493 {
"SYSTEM",
"COLUMN",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
14494 {
"SYSTEM",
"COLUMN",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
14495 {
"SYSTEM",
"COLUMN",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
14496 {
"SYSTEM",
"COLUMN",
"TABLE_TYPE",
SCOL_VARCHAR, 50 },
14501 {
"SYSTEM",
"COLUMN",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
14502 {
"SYSTEM",
"COLUMN",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
14503 {
"SYSTEM",
"COLUMN",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
14504 {
"SYSTEM",
"COLUMN",
"TABLE_TYPE",
SCOL_VARCHAR, 50 },
14524 SQLCHAR *cat, SQLSMALLINT catLen,
14525 SQLCHAR *schema, SQLSMALLINT schemaLen,
14526 SQLCHAR *table, SQLSMALLINT tableLen,
14527 SQLCHAR *type, SQLSMALLINT typeLen)
14532 int ncols, asize, rc, size, npatt;
14533 char *errp = NULL, *sql, tname[512];
14534 char *where =
"(type = 'table' or type = 'view')";
14538 if (ret != SQL_SUCCESS) {
14543 if (type && (typeLen > 0 || typeLen == SQL_NTS) && type[0] ==
'%') {
14544 int size = 3 * asize;
14551 memset(s->
rows, 0, sizeof (
char *) * size);
14561 #ifdef MEMORY_DEBUG 14568 return SQL_SUCCESS;
14570 if (cat && (catLen > 0 || catLen == SQL_NTS) && cat[0] ==
'%') {
14574 if (schema && (schemaLen > 0 || schemaLen == SQL_NTS) &&
14575 schema[0] ==
'%') {
14576 if ((!cat || catLen == 0 || !cat[0]) &&
14577 (!table || tableLen == 0 || !table[0])) {
14582 if (type && (typeLen > 0 || typeLen == SQL_NTS) && type[0] !=
'\0') {
14584 int with_view = 0, with_table = 0;
14586 if (typeLen == SQL_NTS) {
14587 strncpy(tmp, (
char *) type,
sizeof (tmp));
14588 tmp[
sizeof (tmp) - 1] =
'\0';
14590 int len =
min(
sizeof (tmp) - 1, typeLen);
14592 strncpy(tmp, (
char *) type, len);
14603 if (t[0] ==
'\'') {
14606 if (strncmp(t,
"table", 5) == 0) {
14608 }
else if (strncmp(t,
"view", 4) == 0) {
14611 t = strchr(t,
',');
14616 if (with_view && with_table) {
14618 }
else if (with_view && !with_table) {
14619 where =
"type = 'view'";
14620 }
else if (!with_view && with_table) {
14621 where =
"type = 'table'";
14623 return SQL_SUCCESS;
14631 if (tableLen == SQL_NTS) {
14632 size =
sizeof (tname) - 1;
14634 size =
min(
sizeof (tname) - 1, tableLen);
14636 strncpy(tname, (
char *) table, size);
14638 tname[size] =
'\0';
14640 #if defined(_WIN32) || defined(_WIN64) 14641 sql = sqlite3_mprintf(
"select %s as 'TABLE_CAT', " 14642 "%s as 'TABLE_SCHEM', " 14643 "tbl_name as 'TABLE_NAME', " 14644 "upper(type) as 'TABLE_TYPE', " 14645 "NULL as 'REMARKS' " 14646 "from sqlite_master where %s " 14647 "and tbl_name %s %Q",
14648 d->xcelqrx ?
"'main'" :
"NULL",
14649 d->xcelqrx ?
"''" :
"NULL",
14651 npatt ?
"like" :
"=", tname);
14653 sql = sqlite3_mprintf(
"select NULL as 'TABLE_QUALIFIER', " 14654 "NULL as 'TABLE_OWNER', " 14655 "tbl_name as 'TABLE_NAME', " 14656 "upper(type) as 'TABLE_TYPE', " 14657 "NULL as 'REMARKS' " 14658 "from sqlite_master where %s " 14659 "and tbl_name %s %Q", where,
14660 npatt ?
"like" :
"=", tname);
14666 if (ret != SQL_SUCCESS) {
14671 rc = sqlite3_get_table(d->
sqlite, sql, &s->
rows, &s->
nrows, &ncols, &errp);
14673 if (rc == SQLITE_OK) {
14674 if (ncols != s->
ncols) {
14678 s->
rowfree = sqlite3_free_table;
14686 sqlite3_free(errp);
14690 return SQL_SUCCESS;
14709 SQLTables(SQLHSTMT
stmt,
14710 SQLCHAR *cat, SQLSMALLINT catLen,
14711 SQLCHAR *schema, SQLSMALLINT schemaLen,
14712 SQLCHAR *table, SQLSMALLINT tableLen,
14713 SQLCHAR *type, SQLSMALLINT typeLen)
14715 #if defined(_WIN32) || defined(_WIN64) 14716 char *c = NULL, *s = NULL, *t = NULL, *y = NULL;
14721 #if defined(_WIN32) || defined(_WIN64) 14724 table, tableLen, type, typeLen);
14728 c = wmb_to_utf_c((
char *) cat, catLen);
14735 s = wmb_to_utf_c((
char *) schema, schemaLen);
14742 t = wmb_to_utf_c((
char *) table, tableLen);
14749 y = wmb_to_utf_c((
char *) type, typeLen);
14755 ret =
drvtables(
stmt, (SQLCHAR *) c, SQL_NTS, (SQLCHAR *) s, SQL_NTS,
14756 (SQLCHAR *) t, SQL_NTS, (SQLCHAR *) y, SQL_NTS);
14759 table, tableLen, type, typeLen);
14761 #if defined(_WIN32) || defined(_WIN64) 14792 SQLWCHAR *cat, SQLSMALLINT catLen,
14793 SQLWCHAR *schema, SQLSMALLINT schemaLen,
14794 SQLWCHAR *table, SQLSMALLINT tableLen,
14795 SQLWCHAR *type, SQLSMALLINT typeLen)
14797 char *c = NULL, *s = NULL, *t = NULL, *y = NULL;
14829 ret =
drvtables(
stmt, (SQLCHAR *) c, SQL_NTS, (SQLCHAR *) s, SQL_NTS,
14830 (SQLCHAR *) t, SQL_NTS, (SQLCHAR *) y, SQL_NTS);
14846 {
"SYSTEM",
"COLUMN",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
14847 {
"SYSTEM",
"COLUMN",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
14848 {
"SYSTEM",
"COLUMN",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
14849 {
"SYSTEM",
"COLUMN",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
14850 {
"SYSTEM",
"COLUMN",
"DATA_TYPE", SQL_SMALLINT, 50 },
14851 {
"SYSTEM",
"COLUMN",
"TYPE_NAME",
SCOL_VARCHAR, 50 },
14852 {
"SYSTEM",
"COLUMN",
"PRECISION", SQL_INTEGER, 50 },
14853 {
"SYSTEM",
"COLUMN",
"LENGTH", SQL_INTEGER, 50 },
14854 {
"SYSTEM",
"COLUMN",
"SCALE", SQL_SMALLINT, 50 },
14855 {
"SYSTEM",
"COLUMN",
"RADIX", SQL_SMALLINT, 50 },
14856 {
"SYSTEM",
"COLUMN",
"NULLABLE", SQL_SMALLINT, 50 },
14858 {
"SYSTEM",
"COLUMN",
"COLUMN_DEF",
SCOL_VARCHAR, 50 },
14859 {
"SYSTEM",
"COLUMN",
"SQL_DATA_TYPE", SQL_SMALLINT, 50 },
14860 {
"SYSTEM",
"COLUMN",
"SQL_DATETIME_SUB", SQL_SMALLINT, 50 },
14861 {
"SYSTEM",
"COLUMN",
"CHAR_OCTET_LENGTH", SQL_SMALLINT, 50 },
14862 {
"SYSTEM",
"COLUMN",
"ORDINAL_POSITION", SQL_SMALLINT, 50 },
14863 {
"SYSTEM",
"COLUMN",
"IS_NULLABLE",
SCOL_VARCHAR, 50 }
14867 {
"SYSTEM",
"COLUMN",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
14868 {
"SYSTEM",
"COLUMN",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
14869 {
"SYSTEM",
"COLUMN",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
14870 {
"SYSTEM",
"COLUMN",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
14871 {
"SYSTEM",
"COLUMN",
"DATA_TYPE", SQL_SMALLINT, 50 },
14872 {
"SYSTEM",
"COLUMN",
"TYPE_NAME",
SCOL_VARCHAR, 50 },
14873 {
"SYSTEM",
"COLUMN",
"COLUMN_SIZE", SQL_INTEGER, 50 },
14874 {
"SYSTEM",
"COLUMN",
"BUFFER_LENGTH", SQL_INTEGER, 50 },
14875 {
"SYSTEM",
"COLUMN",
"DECIMAL_DIGITS", SQL_SMALLINT, 50 },
14876 {
"SYSTEM",
"COLUMN",
"NUM_PREC_RADIX", SQL_SMALLINT, 50 },
14877 {
"SYSTEM",
"COLUMN",
"NULLABLE", SQL_SMALLINT, 50 },
14879 {
"SYSTEM",
"COLUMN",
"COLUMN_DEF",
SCOL_VARCHAR, 50 },
14880 {
"SYSTEM",
"COLUMN",
"SQL_DATA_TYPE", SQL_SMALLINT, 50 },
14881 {
"SYSTEM",
"COLUMN",
"SQL_DATETIME_SUB", SQL_SMALLINT, 50 },
14882 {
"SYSTEM",
"COLUMN",
"CHAR_OCTET_LENGTH", SQL_SMALLINT, 50 },
14883 {
"SYSTEM",
"COLUMN",
"ORDINAL_POSITION", SQL_SMALLINT, 50 },
14884 {
"SYSTEM",
"COLUMN",
"IS_NULLABLE",
SCOL_VARCHAR, 50 }
14903 SQLCHAR *cat, SQLSMALLINT catLen,
14904 SQLCHAR *schema, SQLSMALLINT schemaLen,
14905 SQLCHAR *table, SQLSMALLINT tableLen,
14906 SQLCHAR *col, SQLSMALLINT colLen)
14911 int ret, nrows, ncols, asize, i, k, roffs, namec;
14912 int tnrows, tncols, npatt;
14914 char *errp = NULL, *sql, tname[512], cname[512], **rowp, **trows;
14918 if (sret != SQL_SUCCESS) {
14927 if (tableLen == SQL_NTS) {
14928 size =
sizeof (tname) - 1;
14930 size =
min(
sizeof (tname) - 1, tableLen);
14932 strncpy(tname, (
char *) table, size);
14934 tname[size] =
'\0';
14938 if (colLen == SQL_NTS) {
14939 size =
sizeof (cname) - 1;
14941 size =
min(
sizeof (cname) - 1, colLen);
14943 strncpy(cname, (
char *) col, size);
14945 cname[size] =
'\0';
14946 if (!strcmp(cname,
"%")) {
14949 sql = sqlite3_mprintf(
"select tbl_name from sqlite_master where " 14950 "(type = 'table' or type = 'view') " 14951 "and tbl_name %s %Q", npatt ?
"like" :
"=", tname);
14956 if (sret != SQL_SUCCESS) {
14961 ret = sqlite3_get_table(d->
sqlite, sql, &trows, &tnrows, &tncols, &errp);
14963 if (ret != SQLITE_OK) {
14964 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
14965 errp ? errp :
"unknown error", ret);
14967 sqlite3_free(errp);
14973 sqlite3_free(errp);
14977 if (tncols * tnrows <= 0) {
14978 sqlite3_free_table(trows);
14979 return SQL_SUCCESS;
14982 for (i = 1; i <= tnrows; i++) {
14983 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", trows[i]);
14985 sqlite3_free_table(trows);
14989 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
14991 if (ret != SQLITE_OK) {
14992 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
14993 errp ? errp :
"unknown error", ret);
14995 sqlite3_free(errp);
14998 sqlite3_free_table(trows);
15002 sqlite3_free(errp);
15005 if (ncols * nrows > 0) {
15007 for (k = 0; k < ncols; k++) {
15008 if (strcmp(rowp[k],
"name") == 0) {
15015 for (k = 1; k <= nrows; k++) {
15016 if (
namematch(rowp[k * ncols + namec], cname, 1)) {
15025 sqlite3_free_table(rowp);
15029 sqlite3_free_table(trows);
15030 return SQL_SUCCESS;
15033 size = (size + 1) * asize;
15037 sqlite3_free_table(trows);
15040 s->
rows[0] = (
char *) size;
15042 memset(s->
rows, 0, sizeof (
char *) * size);
15045 for (i = 1; i <= tnrows; i++) {
15046 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", trows[i]);
15048 sqlite3_free_table(trows);
15052 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
15054 if (ret != SQLITE_OK) {
15055 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
15056 errp ? errp :
"unknown error", ret);
15058 sqlite3_free(errp);
15061 sqlite3_free_table(trows);
15065 sqlite3_free(errp);
15068 if (ncols * nrows > 0) {
15069 int m, mr, nr = nrows;
15072 for (k = 0; k < ncols; k++) {
15073 if (strcmp(rowp[k],
"name") == 0) {
15081 for (k = 1; k <= nrows; k++) {
15082 if (
namematch(rowp[k * ncols + namec], cname, 1)) {
15088 for (k = 0; k < nr; k++) {
15089 m = asize * (roffs + k);
15090 #if defined(_WIN32) || defined(_WIN64) 15091 s->
rows[m + 0] =
xstrdup(d->xcelqrx ?
"main" :
"");
15102 for (k = 0; nr && k < ncols; k++) {
15103 if (strcmp(rowp[k],
"cid") == 0) {
15104 for (mr = 0, m = 1; m <= nrows; m++) {
15109 !
namematch(rowp[m * ncols + namec], cname, 1)) {
15112 ir = asize * (roffs + mr);
15113 sscanf(rowp[m * ncols + k],
"%d", &coln);
15114 sprintf(buf,
"%d", coln + 1);
15118 }
else if (k == namec) {
15119 for (mr = 0, m = 1; m <= nrows; m++) {
15123 !
namematch(rowp[m * ncols + namec], cname, 1)) {
15126 ir = asize * (roffs + mr);
15130 }
else if (strcmp(rowp[k],
"notnull") == 0) {
15131 for (mr = 0, m = 1; m <= nrows; m++) {
15135 !
namematch(rowp[m * ncols + namec], cname, 1)) {
15138 ir = asize * (roffs + mr);
15139 if (*rowp[m * ncols + k] !=
'0') {
15145 xstrdup((*rowp[m * ncols + k] !=
'0') ?
15149 }
else if (strcmp(rowp[k],
"dflt_value") == 0) {
15150 for (mr = 0, m = 1; m <= nrows; m++) {
15151 char *dflt =
unquote(rowp[m * ncols + k]);
15155 !
namematch(rowp[m * ncols + namec], cname, 1)) {
15158 ir = asize * (roffs + mr);
15159 s->
rows[ir + 12] =
xstrdup(dflt ? dflt :
"NULL");
15162 }
else if (strcmp(rowp[k],
"type") == 0) {
15163 for (mr = 0, m = 1; m <= nrows; m++) {
15164 char *
typename = rowp[m * ncols + k];
15165 int sqltype, mm, dd, ir;
15169 !
namematch(rowp[m * ncols + namec], cname, 1)) {
15172 ir = asize * (roffs + mr);
15176 getmd(
typename, sqltype, &mm, &dd);
15177 #ifdef SQL_LONGVARCHAR 15178 if (sqltype == SQL_VARCHAR && mm > 255) {
15179 sqltype = SQL_LONGVARCHAR;
15183 #ifdef SQL_WLONGVARCHAR 15184 if (sqltype == SQL_WVARCHAR && mm > 255) {
15185 sqltype = SQL_WLONGVARCHAR;
15189 if (sqltype == SQL_VARBINARY && mm > 255) {
15190 sqltype = SQL_LONGVARBINARY;
15192 sprintf(buf,
"%d", sqltype);
15195 sprintf(buf,
"%d", mm);
15197 sprintf(buf,
"%d", dd);
15205 sqlite3_free_table(rowp);
15207 sqlite3_free_table(trows);
15208 return SQL_SUCCESS;
15227 SQLColumns(SQLHSTMT
stmt,
15228 SQLCHAR *cat, SQLSMALLINT catLen,
15229 SQLCHAR *schema, SQLSMALLINT schemaLen,
15230 SQLCHAR *table, SQLSMALLINT tableLen,
15231 SQLCHAR *col, SQLSMALLINT colLen)
15233 #if defined(_WIN32) || defined(_WIN64) 15234 char *c = NULL, *s = NULL, *t = NULL, *k = NULL;
15239 #if defined(_WIN32) || defined(_WIN64) 15242 table, tableLen, col, colLen);
15246 c = wmb_to_utf_c((
char *) cat, catLen);
15253 s = wmb_to_utf_c((
char *) schema, schemaLen);
15260 t = wmb_to_utf_c((
char *) table, tableLen);
15267 k = wmb_to_utf_c((
char *) col, colLen);
15273 ret =
drvcolumns(
stmt, (SQLCHAR *) c, SQL_NTS, (SQLCHAR *) s, SQL_NTS,
15274 (SQLCHAR *) t, SQL_NTS, (SQLCHAR *) k, SQL_NTS);
15277 table, tableLen, col, colLen);
15279 #if defined(_WIN32) || defined(_WIN64) 15310 SQLWCHAR *cat, SQLSMALLINT catLen,
15311 SQLWCHAR *schema, SQLSMALLINT schemaLen,
15312 SQLWCHAR *table, SQLSMALLINT tableLen,
15313 SQLWCHAR *col, SQLSMALLINT colLen)
15315 char *c = NULL, *s = NULL, *t = NULL, *k = NULL;
15347 ret =
drvcolumns(
stmt, (SQLCHAR *) c, SQL_NTS, (SQLCHAR *) s, SQL_NTS,
15348 (SQLCHAR *) t, SQL_NTS, (SQLCHAR *) k, SQL_NTS);
15366 {
"SYSTEM",
"TYPE",
"DATA_TYPE", SQL_SMALLINT, 2 },
15367 {
"SYSTEM",
"TYPE",
"PRECISION", SQL_INTEGER, 9 },
15368 {
"SYSTEM",
"TYPE",
"LITERAL_PREFIX",
SCOL_VARCHAR, 50 },
15369 {
"SYSTEM",
"TYPE",
"LITERAL_SUFFIX",
SCOL_VARCHAR, 50 },
15370 {
"SYSTEM",
"TYPE",
"CREATE_PARAMS",
SCOL_VARCHAR, 50 },
15371 {
"SYSTEM",
"TYPE",
"NULLABLE", SQL_SMALLINT, 2 },
15372 {
"SYSTEM",
"TYPE",
"CASE_SENSITIVE", SQL_SMALLINT, 2 },
15373 {
"SYSTEM",
"TYPE",
"SEARCHABLE", SQL_SMALLINT, 2 },
15374 {
"SYSTEM",
"TYPE",
"UNSIGNED_ATTRIBUTE", SQL_SMALLINT, 2 },
15375 {
"SYSTEM",
"TYPE",
"MONEY", SQL_SMALLINT, 2 },
15376 {
"SYSTEM",
"TYPE",
"AUTO_INCREMENT", SQL_SMALLINT, 2 },
15377 {
"SYSTEM",
"TYPE",
"LOCAL_TYPE_NAME",
SCOL_VARCHAR, 50 },
15378 {
"SYSTEM",
"TYPE",
"MINIMUM_SCALE", SQL_SMALLINT, 2 },
15379 {
"SYSTEM",
"TYPE",
"MAXIMUM_SCALE", SQL_SMALLINT, 2 }
15384 {
"SYSTEM",
"TYPE",
"DATA_TYPE", SQL_SMALLINT, 2 },
15385 {
"SYSTEM",
"TYPE",
"COLUMN_SIZE", SQL_INTEGER, 9 },
15386 {
"SYSTEM",
"TYPE",
"LITERAL_PREFIX",
SCOL_VARCHAR, 50 },
15387 {
"SYSTEM",
"TYPE",
"LITERAL_SUFFIX",
SCOL_VARCHAR, 50 },
15388 {
"SYSTEM",
"TYPE",
"CREATE_PARAMS",
SCOL_VARCHAR, 50 },
15389 {
"SYSTEM",
"TYPE",
"NULLABLE", SQL_SMALLINT, 2 },
15390 {
"SYSTEM",
"TYPE",
"CASE_SENSITIVE", SQL_SMALLINT, 2 },
15391 {
"SYSTEM",
"TYPE",
"SEARCHABLE", SQL_SMALLINT, 2 },
15392 {
"SYSTEM",
"TYPE",
"UNSIGNED_ATTRIBUTE", SQL_SMALLINT, 2 },
15393 {
"SYSTEM",
"TYPE",
"FIXED_PREC_SCALE", SQL_SMALLINT, 2 },
15394 {
"SYSTEM",
"TYPE",
"AUTO_UNIQUE_VALUE", SQL_SMALLINT, 2 },
15395 {
"SYSTEM",
"TYPE",
"LOCAL_TYPE_NAME",
SCOL_VARCHAR, 50 },
15396 {
"SYSTEM",
"TYPE",
"MINIMUM_SCALE", SQL_SMALLINT, 2 },
15397 {
"SYSTEM",
"TYPE",
"MAXIMUM_SCALE", SQL_SMALLINT, 2 },
15398 {
"SYSTEM",
"TYPE",
"SQL_DATA_TYPE", SQL_SMALLINT, 2 },
15399 {
"SYSTEM",
"TYPE",
"SQL_DATETIME_SUB", SQL_SMALLINT, 2 },
15400 {
"SYSTEM",
"TYPE",
"NUM_PREC_RADIX", SQL_INTEGER, 4 },
15401 {
"SYSTEM",
"TYPE",
"INTERVAL_PRECISION", SQL_SMALLINT, 2 }
15417 int offs = row * asize;
15418 char *tcode, *crpar = NULL, *quote = NULL, *sign =
stringify(SQL_FALSE);
15419 static char tcodes[32 * 32];
15424 tcode = tcodes + tind * 32;
15425 sprintf(tcode,
"%d", type);
15426 s->
rows[offs + 0] =
typename;
15427 s->
rows[offs + 1] = tcode;
15429 s->
rows[offs + 15] = tcode;
15430 s->
rows[offs + 16] =
"0";
15434 #ifdef SQL_LONGVARCHAR 15435 case SQL_LONGVARCHAR:
15437 case SQL_WLONGVARCHAR:
15442 s->
rows[offs + 2] =
"65536";
15448 s->
rows[offs + 2] =
"1";
15457 s->
rows[offs + 2] =
"255";
15463 s->
rows[offs + 2] =
"3";
15466 s->
rows[offs + 2] =
"5";
15469 s->
rows[offs + 2] =
"9";
15473 s->
rows[offs + 2] =
"19";
15477 s->
rows[offs + 2] =
"7";
15480 s->
rows[offs + 2] =
"15";
15482 #ifdef SQL_TYPE_DATE 15483 case SQL_TYPE_DATE:
15486 s->
rows[offs + 2] =
"10";
15490 #ifdef SQL_TYPE_TIME 15491 case SQL_TYPE_TIME:
15494 s->
rows[offs + 2] =
"8";
15498 #ifdef SQL_TYPE_TIMESTAMP 15499 case SQL_TYPE_TIMESTAMP:
15501 case SQL_TIMESTAMP:
15502 s->
rows[offs + 2] =
"32";
15506 case SQL_VARBINARY:
15508 s->
rows[offs + 2] =
"255";
15510 case SQL_LONGVARBINARY:
15512 s->
rows[offs + 2] =
"65536";
15515 s->
rows[offs + 3] = s->
rows[offs + 4] = quote;
15516 s->
rows[offs + 5] = crpar;
15520 s->
rows[offs + 9] = sign;
15523 s->
rows[offs + 12] =
typename;
15527 s->
rows[offs + 13] =
"0";
15528 s->
rows[offs + 14] =
"0";
15530 #ifdef SQL_TYPE_TIMESTAMP 15531 case SQL_TYPE_TIMESTAMP:
15533 case SQL_TIMESTAMP:
15534 s->
rows[offs + 13] =
"0";
15535 s->
rows[offs + 14] =
"3";
15538 s->
rows[offs + 13] = NULL;
15539 s->
rows[offs + 14] = NULL;
15555 char **pa = (
char **) a;
15556 char **pb = (
char **) b;
15559 na = strtol(pa[1], NULL, 0);
15560 nb = strtol(pb[1], NULL, 0);
15580 if (ret != SQL_SUCCESS) {
15584 #ifdef SQL_LONGVARCHAR 15585 s->
nrows = (sqltype == SQL_ALL_TYPES) ? 13 : 1;
15587 s->
nrows = (sqltype == SQL_ALL_TYPES) ? 12 : 1;
15589 if (sqltype == SQL_ALL_TYPES) {
15592 #ifdef SQL_WLONGVARCHAR 15597 if (sqltype == SQL_ALL_TYPES) {
15611 #ifdef MEMORY_DEBUG 15616 memset(s->
rows, 0, sizeof (
char *) * (s->
nrows + 1) * asize);
15617 if (sqltype == SQL_ALL_TYPES) {
15620 mktypeinfo(s, cc++, asize,
"varchar", SQL_VARCHAR, 0);
15621 mktypeinfo(s, cc++, asize,
"tinyint", SQL_TINYINT, 0);
15622 mktypeinfo(s, cc++, asize,
"smallint", SQL_SMALLINT, 0);
15623 mktypeinfo(s, cc++, asize,
"integer", SQL_INTEGER, 0);
15624 mktypeinfo(s, cc++, asize,
"float", SQL_FLOAT, 0);
15625 mktypeinfo(s, cc++, asize,
"double", SQL_DOUBLE, 0);
15626 #ifdef SQL_TYPE_DATE 15628 (*s->
ov3) ? SQL_TYPE_DATE : SQL_DATE, 0);
15630 mktypeinfo(s, cc++, asize,
"date", SQL_DATE, 0);
15632 #ifdef SQL_TYPE_TIME 15634 (*s->
ov3) ? SQL_TYPE_TIME : SQL_TIME, 0);
15636 mktypeinfo(s, cc++, asize,
"time", SQL_TIME, 0);
15638 #ifdef SQL_TYPE_TIMESTAMP 15640 (*s->
ov3) ? SQL_TYPE_TIMESTAMP : SQL_TIMESTAMP, 0);
15642 mktypeinfo(s, cc++, asize,
"timestamp", SQL_TIMESTAMP, 0);
15644 mktypeinfo(s, cc++, asize,
"char", SQL_CHAR, 0);
15645 mktypeinfo(s, cc++, asize,
"numeric", SQL_DOUBLE, 0);
15646 #ifdef SQL_LONGVARCHAR 15647 mktypeinfo(s, cc++, asize,
"text", SQL_LONGVARCHAR, 0);
15648 mktypeinfo(s, cc++, asize,
"longvarchar", SQL_LONGVARCHAR, 0);
15650 mktypeinfo(s, cc++, asize,
"text", SQL_VARCHAR, 0);
15652 mktypeinfo(s, cc++, asize,
"varbinary", SQL_VARBINARY, 0);
15653 mktypeinfo(s, cc++, asize,
"longvarbinary", SQL_LONGVARBINARY, 0);
15655 mktypeinfo(s, cc++, asize,
"bit", SQL_BIT, 0);
15658 mktypeinfo(s, cc++, asize,
"bigint", SQL_BIGINT, 0);
15661 mktypeinfo(s, cc++, asize,
"wvarchar", SQL_WVARCHAR, 0);
15662 mktypeinfo(s, cc++, asize,
"wchar", SQL_WCHAR, 0);
15663 #ifdef SQL_WLONGVARCHAR 15664 mktypeinfo(s, cc++, asize,
"wtext", SQL_WLONGVARCHAR, 0);
15665 mktypeinfo(s, cc++, asize,
"longwvarchar", SQL_WLONGVARCHAR, 0);
15668 qsort(s->
rows + asize, s->
nrows, sizeof (
char *) * asize,
15673 mktypeinfo(s, 1, asize,
"char", SQL_CHAR, 10);
15676 mktypeinfo(s, 1, asize,
"varchar", SQL_VARCHAR, 1);
15679 mktypeinfo(s, 1, asize,
"tinyint", SQL_TINYINT, 2);
15682 mktypeinfo(s, 1, asize,
"smallint", SQL_SMALLINT, 3);
15685 mktypeinfo(s, 1, asize,
"integer", SQL_INTEGER, 4);
15688 mktypeinfo(s, 1, asize,
"float", SQL_FLOAT, 5);
15691 mktypeinfo(s, 1, asize,
"double", SQL_DOUBLE, 6);
15693 #ifdef SQL_TYPE_DATE 15694 case SQL_TYPE_DATE:
15695 mktypeinfo(s, 1, asize,
"date", SQL_TYPE_DATE, 25);
15699 mktypeinfo(s, 1, asize,
"date", SQL_DATE, 7);
15701 #ifdef SQL_TYPE_TIME 15702 case SQL_TYPE_TIME:
15703 mktypeinfo(s, 1, asize,
"time", SQL_TYPE_TIME, 26);
15707 mktypeinfo(s, 1, asize,
"time", SQL_TIME, 8);
15709 #ifdef SQL_TYPE_TIMESTAMP 15710 case SQL_TYPE_TIMESTAMP:
15711 mktypeinfo(s, 1, asize,
"timestamp", SQL_TYPE_TIMESTAMP, 27);
15714 case SQL_TIMESTAMP:
15715 mktypeinfo(s, 1, asize,
"timestamp", SQL_TIMESTAMP, 9);
15717 #ifdef SQL_LONGVARCHAR 15718 case SQL_LONGVARCHAR:
15719 mktypeinfo(s, 1, asize,
"longvarchar", SQL_LONGVARCHAR, 12);
15722 case SQL_VARBINARY:
15723 mktypeinfo(s, 1, asize,
"varbinary", SQL_VARBINARY, 30);
15725 case SQL_LONGVARBINARY:
15726 mktypeinfo(s, 1, asize,
"longvarbinary", SQL_LONGVARBINARY, 31);
15730 mktypeinfo(s, 1, asize,
"bit", SQL_BIT, 29);
15735 mktypeinfo(s, 1, asize,
"bigint", SQL_BIGINT, 28);
15741 mktypeinfo(s, 1, asize,
"wchar", SQL_WCHAR, 18);
15744 #ifdef SQL_WVARCHAR 15746 mktypeinfo(s, 1, asize,
"wvarchar", SQL_WVARCHAR, 19);
15749 #ifdef SQL_WLONGVARCHAR 15750 case SQL_WLONGVARCHAR:
15751 mktypeinfo(s, 1, asize,
"longwvarchar", SQL_WLONGVARCHAR, 20);
15759 return SQL_SUCCESS;
15771 SQLGetTypeInfo(SQLHSTMT
stmt, SQLSMALLINT sqltype)
15807 {
"SYSTEM",
"STATISTICS",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
15808 {
"SYSTEM",
"STATISTICS",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
15809 {
"SYSTEM",
"STATISTICS",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
15810 {
"SYSTEM",
"STATISTICS",
"NON_UNIQUE", SQL_SMALLINT, 50 },
15811 {
"SYSTEM",
"STATISTICS",
"INDEX_QUALIFIER",
SCOL_VARCHAR, 255 },
15812 {
"SYSTEM",
"STATISTICS",
"INDEX_NAME",
SCOL_VARCHAR, 255 },
15813 {
"SYSTEM",
"STATISTICS",
"TYPE", SQL_SMALLINT, 50 },
15814 {
"SYSTEM",
"STATISTICS",
"SEQ_IN_INDEX", SQL_SMALLINT, 50 },
15815 {
"SYSTEM",
"STATISTICS",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
15816 {
"SYSTEM",
"STATISTICS",
"COLLATION",
SCOL_CHAR, 1 },
15817 {
"SYSTEM",
"STATISTICS",
"CARDINALITY", SQL_INTEGER, 50 },
15818 {
"SYSTEM",
"STATISTICS",
"PAGES", SQL_INTEGER, 50 },
15819 {
"SYSTEM",
"STATISTICS",
"FILTER_CONDITION",
SCOL_VARCHAR, 255 }
15823 {
"SYSTEM",
"STATISTICS",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
15824 {
"SYSTEM",
"STATISTICS",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
15825 {
"SYSTEM",
"STATISTICS",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
15826 {
"SYSTEM",
"STATISTICS",
"NON_UNIQUE", SQL_SMALLINT, 50 },
15827 {
"SYSTEM",
"STATISTICS",
"INDEX_QUALIFIER",
SCOL_VARCHAR, 255 },
15828 {
"SYSTEM",
"STATISTICS",
"INDEX_NAME",
SCOL_VARCHAR, 255 },
15829 {
"SYSTEM",
"STATISTICS",
"TYPE", SQL_SMALLINT, 50 },
15830 {
"SYSTEM",
"STATISTICS",
"ORDINAL_POSITION", SQL_SMALLINT, 50 },
15831 {
"SYSTEM",
"STATISTICS",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
15832 {
"SYSTEM",
"STATISTICS",
"ASC_OR_DESC",
SCOL_CHAR, 1 },
15833 {
"SYSTEM",
"STATISTICS",
"CARDINALITY", SQL_INTEGER, 50 },
15834 {
"SYSTEM",
"STATISTICS",
"PAGES", SQL_INTEGER, 50 },
15835 {
"SYSTEM",
"STATISTICS",
"FILTER_CONDITION",
SCOL_VARCHAR, 255 }
15854 SQLCHAR *schema, SQLSMALLINT schemaLen,
15855 SQLCHAR *table, SQLSMALLINT tableLen,
15856 SQLUSMALLINT itype, SQLUSMALLINT resv)
15861 int i, asize, ret, nrows, ncols, offs, namec, uniquec, addipk = 0;
15863 char **rowp, *errp = NULL, *sql, tname[512];
15867 if (sret != SQL_SUCCESS) {
15872 if (!table || table[0] ==
'\0' || table[0] ==
'%') {
15873 setstat(s, -1,
"need table name", (*s->
ov3) ?
"HY000" :
"S1000");
15876 if (tableLen == SQL_NTS) {
15877 size =
sizeof (tname) - 1;
15879 size =
min(
sizeof (tname) - 1, tableLen);
15881 strncpy(tname, (
char *) table, size);
15882 tname[size] =
'\0';
15885 if (sret != SQL_SUCCESS) {
15891 if (itype == SQL_INDEX_UNIQUE || itype == SQL_INDEX_ALL) {
15893 ret = SQLITE_ERROR;
15894 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", tname);
15897 ret = sqlite3_get_table(d->
sqlite, sql, &rowp,
15898 &nrows, &ncols, NULL);
15901 if (ret == SQLITE_OK) {
15902 int colid, typec, npk = 0, npkint = 0;
15904 namec =
findcol(rowp, ncols,
"name");
15905 uniquec =
findcol(rowp, ncols,
"pk");
15906 typec =
findcol(rowp, ncols,
"type");
15907 colid =
findcol(rowp, ncols,
"cid");
15908 if (namec < 0 || uniquec < 0 || typec < 0 || colid < 0) {
15911 for (i = 1; i <= nrows; i++) {
15912 if (*rowp[i * ncols + uniquec] !=
'0') {
15914 if (strlen(rowp[i * ncols + typec]) == 7 &&
15915 strncasecmp(rowp[i * ncols + typec],
"integer", 7)
15921 if (npkint == 1 && npk == npkint) {
15926 sqlite3_free_table(rowp);
15928 sql = sqlite3_mprintf(
"PRAGMA index_list(%Q)", tname);
15933 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
15935 if (ret != SQLITE_OK) {
15936 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
15937 errp ? errp :
"unknown error", ret);
15939 sqlite3_free(errp);
15945 sqlite3_free(errp);
15949 namec =
findcol(rowp, ncols,
"name");
15950 uniquec =
findcol(rowp, ncols,
"unique");
15951 if (namec < 0 || uniquec < 0) {
15954 for (i = 1; i <= nrows; i++) {
15955 int nnrows, nncols;
15959 isuniq = *rowp[i * ncols + uniquec] !=
'0';
15960 if (isuniq || itype == SQL_INDEX_ALL) {
15961 ret = SQLITE_ERROR;
15962 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
15963 rowp[i * ncols + namec]);
15966 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
15967 &nnrows, &nncols, NULL);
15970 if (ret == SQLITE_OK) {
15972 sqlite3_free_table(rowpp);
15981 sqlite3_free_table(rowp);
15982 return SQL_SUCCESS;
15985 size = (size + 1) * asize;
15991 s->
rows[0] = (
char *) size;
15993 memset(s->
rows, 0, sizeof (
char *) * size);
15998 int nrows2, ncols2;
16000 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", tname);
16003 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
16004 &nrows2, &ncols2, NULL);
16007 if (ret == SQLITE_OK) {
16008 int colid, typec, roffs, namecc, uniquecc;
16010 namecc =
findcol(rowpp, ncols2,
"name");
16011 uniquecc =
findcol(rowpp, ncols2,
"pk");
16012 typec =
findcol(rowpp, ncols2,
"type");
16013 colid =
findcol(rowpp, ncols2,
"cid");
16014 if (namecc < 0 || uniquecc < 0 || typec < 0 || colid < 0) {
16019 for (i = 1; i <= nrows2; i++) {
16020 if (*rowpp[i * ncols2 + uniquecc] !=
'0' &&
16021 strlen(rowpp[i * ncols2 + typec]) == 7 &&
16022 strncasecmp(rowpp[i * ncols2 + typec],
"integer", 7)
16033 #if defined(_WIN32) || defined(_WIN64) 16034 s->
rows[roffs + 0] =
xstrdup(d->xcelqrx ?
"main" :
"");
16042 s->
rows[roffs + 5] =
xstrdup(
"sqlite_autoindex_0");
16045 s->
rows[roffs + 8] =
xstrdup(rowpp[i * ncols2 + namecc]);
16049 sqlite3_free_table(rowpp);
16051 for (i = 1; i <= nrows; i++) {
16052 int nnrows, nncols;
16055 if (*rowp[i * ncols + uniquec] !=
'0' || itype == SQL_INDEX_ALL) {
16058 ret = SQLITE_ERROR;
16059 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
16060 rowp[i * ncols + namec]);
16063 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
16064 &nnrows, &nncols, NULL);
16067 if (ret != SQLITE_OK) {
16070 for (k = 0; nnrows && k < nncols; k++) {
16071 if (strcmp(rowpp[k],
"name") == 0) {
16074 for (m = 1; m <= nnrows; m++) {
16075 int roffs = (offs + addipk + m) * s->
ncols;
16078 isuniq = *rowp[i * ncols + uniquec] !=
'0';
16087 s->
rows[roffs + 5] =
xstrdup(rowp[i * ncols + namec]);
16088 s->
rows[roffs + 6] =
16090 s->
rows[roffs + 8] =
xstrdup(rowpp[m * nncols + k]);
16093 }
else if (strcmp(rowpp[k],
"seqno") == 0) {
16096 for (m = 1; m <= nnrows; m++) {
16097 int roffs = (offs + addipk + m) * s->
ncols;
16101 sscanf(rowpp[m * nncols + k],
"%d", &pos);
16102 sprintf(buf,
"%d", pos + 1);
16108 sqlite3_free_table(rowpp);
16111 sqlite3_free_table(rowp);
16112 return SQL_SUCCESS;
16131 SQLStatistics(SQLHSTMT
stmt, SQLCHAR *cat, SQLSMALLINT catLen,
16132 SQLCHAR *schema, SQLSMALLINT schemaLen,
16133 SQLCHAR *table, SQLSMALLINT tableLen,
16134 SQLUSMALLINT itype, SQLUSMALLINT resv)
16136 #if defined(_WIN32) || defined(_WIN64) 16137 char *c = NULL, *s = NULL, *t = NULL;
16142 #if defined(_WIN32) || defined(_WIN64) 16145 table, tableLen, itype, resv);
16149 c = wmb_to_utf_c((
char *) cat, catLen);
16156 s = wmb_to_utf_c((
char *) schema, schemaLen);
16163 t = wmb_to_utf_c((
char *) table, tableLen);
16170 (SQLCHAR *) t, SQL_NTS, itype, resv);
16173 table, tableLen, itype, resv);
16175 #if defined(_WIN32) || defined(_WIN64) 16205 SQLWCHAR *schema, SQLSMALLINT schemaLen,
16206 SQLWCHAR *table, SQLSMALLINT tableLen,
16207 SQLUSMALLINT itype, SQLUSMALLINT resv)
16209 char *c = NULL, *s = NULL, *t = NULL;
16235 (SQLCHAR *) t, SQL_NTS, itype, resv);
16261 SQLRETURN ret = SQL_ERROR;
16264 if (
stmt == SQL_NULL_HSTMT) {
16265 return SQL_INVALID_HANDLE;
16268 if (col == 0 && s->
bkmrk != SQL_UB_OFF) {
16269 if (s->
bkmrk == SQL_UB_ON && type == SQL_C_BOOKMARK) {
16270 *((SQLINTEGER *) val) = s->
rowp;
16272 *lenp =
sizeof (SQLINTEGER);
16276 }
else if (s->
bkmrk == SQL_UB_VARIABLE && type == SQL_C_VARBOOKMARK) {
16278 char **data, *endp = 0;
16283 *((sqlite_int64 *) val) = strtol(*data, &endp, 0);
16285 *((sqlite_int64 *) val) = strtoll(*data, &endp, 0);
16288 *((sqlite_int64 *) val) = s->
rowp;
16291 *lenp =
sizeof (sqlite_int64);
16297 if (col < 1 || col > s->
ncols) {
16298 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009" :
"S1002");
16302 ret =
getrowdata(s, col, type, val, len, lenp, 1);
16318 int ret, i, withinfo = 0;
16322 int bsize =
sizeof (SQLINTEGER);
16327 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
16335 val = (SQLPOINTER) ((
char *) val + *s->
bind_offs);
16338 char **data, *endp = 0;
16343 *(sqlite_int64 *) val = strtol(*data, &endp, 0);
16345 *(sqlite_int64 *) val = strtoll(*data, &endp, 0);
16348 *(sqlite_int64 *) val = s->
rowp;
16350 bsize =
sizeof (sqlite_int64);
16354 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
16355 val = (SQLINTEGER *)
16361 val = (SQLINTEGER *) ((
char *) val + *s->
bind_offs);
16368 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
16388 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
16391 dp = (SQLPOINTER) ((
char *) b->
valp + b->
max * rsi);
16394 dp = (SQLPOINTER) ((
char *) dp + *s->
bind_offs);
16398 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
16401 lp = b->
lenp + rsi;
16409 if (!SQL_SUCCEEDED(ret)) {
16413 if (ret != SQL_SUCCESS) {
16415 #ifdef SQL_ROW_SUCCESS_WITH_INFO 16421 if (SQL_SUCCEEDED(ret)) {
16422 ret = withinfo ? SQL_SUCCESS_WITH_INFO : SQL_SUCCESS;
16439 int i, withinfo = 0;
16442 if (
stmt == SQL_NULL_HSTMT) {
16443 return SQL_INVALID_HANDLE;
16466 setstat(s, -1,
"no result set available",
"24000");
16471 if (s->
curtype == SQL_CURSOR_FORWARD_ONLY && orient != SQL_FETCH_NEXT) {
16472 setstat(s, -1,
"wrong fetch direction",
"01000");
16479 if (((
DBC *) (s->
dbc))->cur_s3stmt == s && s->
s3stmt) {
16483 ret = (i == 0) ? SQL_NO_DATA : SQL_SUCCESS;
16487 if (ret != SQL_SUCCESS) {
16491 if (s->
nrows < 1) {
16495 if (!SQL_SUCCEEDED(ret)) {
16497 }
else if (ret == SQL_SUCCESS_WITH_INFO) {
16501 }
else if (s->
rows) {
16503 case SQL_FETCH_NEXT:
16504 if (s->
nrows < 1) {
16505 return SQL_NO_DATA;
16512 return SQL_NO_DATA;
16515 case SQL_FETCH_PRIOR:
16518 return SQL_NO_DATA;
16521 if (s->
rowp < -1) {
16523 return SQL_NO_DATA;
16526 case SQL_FETCH_FIRST:
16527 if (s->
nrows < 1) {
16528 return SQL_NO_DATA;
16532 case SQL_FETCH_LAST:
16533 if (s->
nrows < 1) {
16534 return SQL_NO_DATA;
16537 if (--s->
rowp < -1) {
16541 case SQL_FETCH_ABSOLUTE:
16544 return SQL_NO_DATA;
16545 }
else if (offset < 0) {
16546 if (0 - offset <= s->nrows) {
16551 return SQL_NO_DATA;
16552 }
else if (offset > s->
nrows) {
16554 return SQL_NO_DATA;
16556 s->
rowp = offset - 1 - 1;
16558 case SQL_FETCH_RELATIVE:
16563 return SQL_NO_DATA;
16567 if (s->
rowp < -1) {
16569 return SQL_NO_DATA;
16573 case SQL_FETCH_BOOKMARK:
16575 if (offset < 0 || offset >= s->
nrows) {
16576 return SQL_NO_DATA;
16578 s->
rowp = offset - 1;
16584 if (s->
bkmrk == SQL_UB_VARIABLE) {
16586 sqlite_int64 bkmrk, rowid;
16588 bkmrk = *(sqlite_int64 *) s->
bkmrkptr;
16589 for (rowp = 0; rowp < s->
nrows; rowp++) {
16590 char **data, *endp = 0;
16595 rowid = strtol(*data, &endp, 0);
16597 rowid = strtoll(*data, &endp, 0);
16599 if (rowid == bkmrk) {
16604 rowp = *(sqlite_int64 *) s->
bkmrkptr;
16609 if (rowp + offset < 0 || rowp + offset >= s->
nrows) {
16610 return SQL_NO_DATA;
16612 s->
rowp = rowp + offset - 1;
16628 if (!SQL_SUCCEEDED(ret)) {
16630 }
else if (ret == SQL_SUCCESS_WITH_INFO) {
16637 if (SQL_SUCCEEDED(ret)) {
16638 return SQL_NO_DATA;
16642 if (SQL_SUCCEEDED(ret)) {
16643 ret = withinfo ? SQL_SUCCESS_WITH_INFO : SQL_SUCCESS;
16710 SQLINTEGER *bkmrkptr;
16713 if (
stmt == SQL_NULL_HSTMT) {
16714 return SQL_INVALID_HANDLE;
16749 if (
stmt == SQL_NULL_HSTMT) {
16750 return SQL_INVALID_HANDLE;
16757 return SQL_SUCCESS;
16773 if (
stmt == SQL_NULL_HSTMT) {
16774 return SQL_INVALID_HANDLE;
16781 return SQL_SUCCESS;
16800 SQLSMALLINT nameMax, SQLSMALLINT *nameLen,
16801 SQLSMALLINT *type,
SQLULEN *size,
16802 SQLSMALLINT *digits, SQLSMALLINT *nullable)
16808 if (
stmt == SQL_NULL_HSTMT) {
16809 return SQL_INVALID_HANDLE;
16813 setstat(s, -1,
"no columns", (*s->
ov3) ?
"07009" :
"S1002");
16816 if (col < 1 || col > s->
ncols) {
16817 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009" :
"S1002");
16820 c = s->
cols + col - 1;
16821 if (name && nameMax > 0) {
16822 strncpy((
char *) name, c->
column, nameMax);
16823 name[nameMax - 1] =
'\0';
16828 *nameLen = strlen((
char *) name);
16830 *nameLen = strlen(c->
column);
16842 *type = SQL_VARCHAR;
16844 #ifdef SQL_LONGVARCHAR 16845 case SQL_WLONGVARCHAR:
16846 *type = SQL_LONGVARCHAR;
16862 return SQL_SUCCESS;
16881 SQLDescribeCol(SQLHSTMT
stmt, SQLUSMALLINT col, SQLCHAR *name,
16882 SQLSMALLINT nameMax, SQLSMALLINT *nameLen,
16883 SQLSMALLINT *type,
SQLULEN *size,
16884 SQLSMALLINT *digits, SQLSMALLINT *nullable)
16886 #if defined(_WIN32) || defined(_WIN64) 16887 SQLSMALLINT len = 0;
16892 #if defined(_WIN32) || defined(_WIN64) 16895 type, size, digits, nullable);
16899 &len, type, size, digits, nullable);
16900 if (ret == SQL_SUCCESS) {
16905 n = (SQLCHAR *) utf_to_wmb((
char *) name, len);
16907 strncpy((
char *) name, (
char *) n, nameMax);
16909 len =
min(nameMax, strlen((
char *) n));
16927 len = strlen(c->
column);
16938 type, size, digits, nullable);
16962 SQLSMALLINT nameMax, SQLSMALLINT *nameLen,
16963 SQLSMALLINT *type,
SQLULEN *size,
16964 SQLSMALLINT *digits, SQLSMALLINT *nullable)
16967 SQLSMALLINT len = 0;
16971 (SQLSMALLINT) (nameMax *
sizeof (SQLWCHAR)),
16972 &len, type, size, digits, nullable);
16973 if (ret == SQL_SUCCESS) {
16976 SQLWCHAR *n = NULL;
17000 len = strlen(c->
column);
17026 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17032 char *valc = (
char *) val;
17034 if (
stmt == SQL_NULL_HSTMT) {
17035 return SQL_INVALID_HANDLE;
17044 if (
id == SQL_COLUMN_COUNT) {
17048 *valLen =
sizeof (int);
17049 return SQL_SUCCESS;
17051 if (
id == SQL_COLUMN_TYPE && col == 0) {
17053 *val2 = SQL_INTEGER;
17055 *valLen =
sizeof (int);
17056 return SQL_SUCCESS;
17058 #ifdef SQL_DESC_OCTET_LENGTH 17059 if (
id == SQL_DESC_OCTET_LENGTH && col == 0) {
17063 *valLen =
sizeof (int);
17064 return SQL_SUCCESS;
17067 if (col < 1 || col > s->
ncols) {
17068 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009":
"S1002");
17071 c = s->
cols + col - 1;
17074 case SQL_COLUMN_LABEL:
17076 if (valc && valMax > 0) {
17077 strncpy(valc, c->
label, valMax);
17078 valc[valMax - 1] =
'\0';
17080 *valLen = strlen(c->
label);
17084 case SQL_COLUMN_NAME:
17085 case SQL_DESC_NAME:
17086 if (valc && valMax > 0) {
17087 strncpy(valc, c->
column, valMax);
17088 valc[valMax - 1] =
'\0';
17090 *valLen = strlen(c->
column);
17092 if (*valLen >= valMax) {
17093 setstat(s, -1,
"data right truncated",
"01004");
17094 return SQL_SUCCESS_WITH_INFO;
17096 return SQL_SUCCESS;
17097 #ifdef SQL_DESC_BASE_COLUMN_NAME 17098 case SQL_DESC_BASE_COLUMN_NAME:
17099 if (strchr(c->
column,
'(') || strchr(c->
column,
')')) {
17100 if (valc && valMax > 0) {
17104 }
else if (valc && valMax > 0) {
17105 strncpy(valc, c->
column, valMax);
17106 valc[valMax - 1] =
'\0';
17107 *valLen = strlen(c->
column);
17111 case SQL_COLUMN_TYPE:
17112 case SQL_DESC_TYPE:
17115 int type = c->
type;
17123 type = SQL_VARCHAR;
17125 #ifdef SQL_LONGVARCHAR 17126 case SQL_WLONGVARCHAR:
17127 type = SQL_LONGVARCHAR;
17141 *valLen =
sizeof (int);
17142 return SQL_SUCCESS;
17143 case SQL_COLUMN_DISPLAY_SIZE:
17147 *valLen =
sizeof (int);
17148 return SQL_SUCCESS;
17149 case SQL_COLUMN_UNSIGNED:
17151 *val2 = c->
nosign ? SQL_TRUE : SQL_FALSE;
17153 *valLen =
sizeof (int);
17154 return SQL_SUCCESS;
17155 case SQL_COLUMN_SCALE:
17156 case SQL_DESC_SCALE:
17160 *valLen =
sizeof (int);
17161 return SQL_SUCCESS;
17162 case SQL_COLUMN_PRECISION:
17163 case SQL_DESC_PRECISION:
17183 #ifdef SQL_TYPE_TIMESTAMP 17184 case SQL_TYPE_TIMESTAMP:
17186 case SQL_TIMESTAMP:
17194 *valLen =
sizeof (int);
17195 return SQL_SUCCESS;
17196 case SQL_COLUMN_MONEY:
17200 *valLen =
sizeof (int);
17201 return SQL_SUCCESS;
17202 case SQL_COLUMN_AUTO_INCREMENT:
17206 *valLen =
sizeof (int);
17207 return SQL_SUCCESS;
17208 case SQL_COLUMN_LENGTH:
17209 case SQL_DESC_LENGTH:
17213 *valLen =
sizeof (int);
17214 return SQL_SUCCESS;
17215 case SQL_COLUMN_NULLABLE:
17216 case SQL_DESC_NULLABLE:
17220 *valLen =
sizeof (int);
17221 return SQL_SUCCESS;
17222 case SQL_COLUMN_SEARCHABLE:
17224 *val2 = SQL_SEARCHABLE;
17226 *valLen =
sizeof (int);
17227 return SQL_SUCCESS;
17228 case SQL_COLUMN_CASE_SENSITIVE:
17232 *valLen =
sizeof (int);
17233 return SQL_SUCCESS;
17234 case SQL_COLUMN_UPDATABLE:
17238 *valLen =
sizeof (int);
17239 return SQL_SUCCESS;
17240 case SQL_DESC_COUNT:
17244 *valLen =
sizeof (int);
17245 return SQL_SUCCESS;
17246 case SQL_COLUMN_TYPE_NAME: {
17250 if (c->
type == SQL_WCHAR ||
17251 c->
type == SQL_WVARCHAR ||
17252 c->
type == SQL_WLONGVARCHAR) {
17254 if (strcasecmp(tn,
"varchar") == 0) {
17260 if (valc && valMax > 0) {
17261 strncpy(valc, tn, valMax);
17262 valc[valMax - 1] =
'\0';
17263 p = strchr(valc,
'(');
17266 while (p > valc &&
ISSPACE(p[-1])) {
17271 *valLen = strlen(valc);
17273 *valLen = strlen(tn);
17274 p = strchr(tn,
'(');
17277 while (p > tn &&
ISSPACE(p[-1])) {
17285 case SQL_COLUMN_OWNER_NAME:
17286 case SQL_COLUMN_QUALIFIER_NAME: {
17289 if (valc && valMax > 0) {
17290 strncpy(valc, z, valMax);
17291 valc[valMax - 1] =
'\0';
17293 *valLen = strlen(z);
17296 case SQL_COLUMN_TABLE_NAME:
17297 #if (SQL_COLUMN_TABLE_NAME != SQL_DESC_TABLE_NAME) 17298 case SQL_DESC_TABLE_NAME:
17300 #ifdef SQL_DESC_BASE_TABLE_NAME 17301 case SQL_DESC_BASE_TABLE_NAME:
17303 if (valc && valMax > 0) {
17304 strncpy(valc, c->
table, valMax);
17305 valc[valMax - 1] =
'\0';
17307 *valLen = strlen(c->
table);
17309 #ifdef SQL_DESC_NUM_PREC_RADIX 17310 case SQL_DESC_NUM_PREC_RADIX:
17316 #ifdef SQL_LONGVARCHAR 17317 case SQL_WLONGVARCHAR:
17322 #ifdef SQL_LONGVARCHAR 17323 case SQL_LONGVARCHAR:
17326 case SQL_VARBINARY:
17327 case SQL_LONGVARBINARY:
17334 *valLen =
sizeof (int);
17335 return SQL_SUCCESS;
17338 setstat(s, -1,
"unsupported column attributes %d",
"HY091",
id);
17356 SQLColAttributes(SQLHSTMT
stmt, SQLUSMALLINT col, SQLUSMALLINT
id,
17357 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17360 #if defined(_WIN32) || defined(_WIN64) 17361 SQLSMALLINT len = 0;
17366 #if defined(_WIN32) || defined(_WIN64) 17372 if (SQL_SUCCEEDED(ret)) {
17376 case SQL_COLUMN_LABEL:
17377 case SQL_COLUMN_NAME:
17378 case SQL_DESC_NAME:
17379 case SQL_COLUMN_TYPE_NAME:
17380 case SQL_COLUMN_OWNER_NAME:
17381 case SQL_COLUMN_QUALIFIER_NAME:
17382 case SQL_COLUMN_TABLE_NAME:
17383 #if (SQL_COLUMN_TABLE_NAME != SQL_DESC_TABLE_NAME) 17384 case SQL_DESC_TABLE_NAME:
17386 #ifdef SQL_DESC_BASE_COLUMN_NAME 17387 case SQL_DESC_BASE_COLUMN_NAME:
17389 #ifdef SQL_DESC_BASE_TABLE_NAME 17390 case SQL_DESC_BASE_TABLE_NAME:
17392 if (val && valMax > 0) {
17395 v = utf_to_wmb((
char *) val, SQL_NTS);
17397 strncpy(val, v, vmax);
17398 len =
min(vmax, strlen(v));
17403 v[vmax - 1] =
'\0';
17439 SQLColAttributesW(SQLHSTMT
stmt, SQLUSMALLINT col, SQLUSMALLINT
id,
17440 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17444 SQLSMALLINT len = 0;
17448 if (SQL_SUCCEEDED(ret)) {
17449 SQLWCHAR *v = NULL;
17452 case SQL_COLUMN_LABEL:
17453 case SQL_COLUMN_NAME:
17454 case SQL_DESC_NAME:
17455 case SQL_COLUMN_TYPE_NAME:
17456 case SQL_COLUMN_OWNER_NAME:
17457 case SQL_COLUMN_QUALIFIER_NAME:
17458 case SQL_COLUMN_TABLE_NAME:
17459 #if (SQL_COLUMN_TABLE_NAME != SQL_DESC_TABLE_NAME) 17460 case SQL_DESC_TABLE_NAME:
17462 #ifdef SQL_DESC_BASE_COLUMN_NAME 17463 case SQL_DESC_BASE_COLUMN_NAME:
17465 #ifdef SQL_DESC_BASE_TABLE_NAME 17466 case SQL_DESC_BASE_TABLE_NAME:
17468 if (val && valMax > 0) {
17469 int vmax = valMax /
sizeof (SQLWCHAR);
17476 len *=
sizeof (SQLWCHAR);
17479 v = (SQLWCHAR *) val;
17480 v[vmax - 1] =
'\0';
17510 drvcolattribute(SQLHSTMT
stmt, SQLUSMALLINT col, SQLUSMALLINT
id,
17511 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17517 char *valc = (
char *) val;
17520 if (
stmt == SQL_NULL_HSTMT) {
17521 return SQL_INVALID_HANDLE;
17527 if (col < 1 || col > s->
ncols) {
17528 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009" :
"S1002");
17534 c = s->
cols + col - 1;
17536 case SQL_DESC_COUNT:
17539 case SQL_DESC_CATALOG_NAME:
17540 if (valc && valMax > 0) {
17541 strncpy(valc, c->
db, valMax);
17542 valc[valMax - 1] =
'\0';
17544 *valLen = strlen(c->
db);
17546 if (*valLen >= valMax) {
17547 setstat(s, -1,
"data right truncated",
"01004");
17548 return SQL_SUCCESS_WITH_INFO;
17551 case SQL_COLUMN_LENGTH:
17552 case SQL_DESC_LENGTH:
17555 case SQL_COLUMN_LABEL:
17557 if (valc && valMax > 0) {
17558 strncpy(valc, c->
label, valMax);
17559 valc[valMax - 1] =
'\0';
17561 *valLen = strlen(c->
label);
17565 case SQL_COLUMN_NAME:
17566 case SQL_DESC_NAME:
17567 if (valc && valMax > 0) {
17568 strncpy(valc, c->
column, valMax);
17569 valc[valMax - 1] =
'\0';
17571 *valLen = strlen(c->
column);
17573 case SQL_DESC_SCHEMA_NAME: {
17576 if (valc && valMax > 0) {
17577 strncpy(valc, z, valMax);
17578 valc[valMax - 1] =
'\0';
17580 *valLen = strlen(z);
17583 #ifdef SQL_DESC_BASE_COLUMN_NAME 17584 case SQL_DESC_BASE_COLUMN_NAME:
17585 if (strchr(c->
column,
'(') || strchr(c->
column,
')')) {
17588 }
else if (valc && valMax > 0) {
17589 strncpy(valc, c->
column, valMax);
17590 valc[valMax - 1] =
'\0';
17591 *valLen = strlen(c->
column);
17595 case SQL_DESC_TYPE_NAME: {
17599 if (c->
type == SQL_WCHAR ||
17600 c->
type == SQL_WVARCHAR ||
17601 c->
type == SQL_WLONGVARCHAR) {
17603 if (strcasecmp(tn,
"varchar") == 0) {
17609 if (valc && valMax > 0) {
17610 strncpy(valc, tn, valMax);
17611 valc[valMax - 1] =
'\0';
17612 p = strchr(valc,
'(');
17615 while (p > valc &&
ISSPACE(p[-1])) {
17620 *valLen = strlen(valc);
17622 *valLen = strlen(tn);
17623 p = strchr(tn,
'(');
17626 while (p > tn &&
ISSPACE(p[-1])) {
17634 case SQL_DESC_OCTET_LENGTH:
17637 if (c->
type == SQL_WCHAR ||
17638 c->
type == SQL_WVARCHAR ||
17639 c->
type == SQL_WLONGVARCHAR) {
17641 v *=
sizeof (SQLWCHAR);
17646 #if (SQL_COLUMN_TABLE_NAME != SQL_DESC_TABLE_NAME) 17647 case SQL_COLUMN_TABLE_NAME:
17649 #ifdef SQL_DESC_BASE_TABLE_NAME 17650 case SQL_DESC_BASE_TABLE_NAME:
17652 case SQL_DESC_TABLE_NAME:
17653 if (valc && valMax > 0) {
17654 strncpy(valc, c->
table, valMax);
17655 valc[valMax - 1] =
'\0';
17657 *valLen = strlen(c->
table);
17659 case SQL_DESC_TYPE:
17670 #ifdef SQL_LONGVARCHAR 17671 case SQL_WLONGVARCHAR:
17672 v = SQL_LONGVARCHAR;
17679 case SQL_DESC_CONCISE_TYPE:
17696 case SQL_TIMESTAMP:
17697 v = SQL_C_TIMESTAMP;
17705 #ifdef SQL_C_TYPE_TIMESTAMP 17706 case SQL_TYPE_TIMESTAMP:
17707 v = SQL_C_TYPE_TIMESTAMP;
17710 #ifdef SQL_C_TYPE_TIME 17711 case SQL_TYPE_TIME:
17712 v = SQL_C_TYPE_TIME;
17715 #ifdef SQL_C_TYPE_DATE 17716 case SQL_TYPE_DATE:
17717 v = SQL_C_TYPE_DATE;
17732 v = (s->
nowchar[0] || s->
nowchar[1]) ? SQL_C_CHAR : SQL_C_WCHAR;
17739 case SQL_DESC_UPDATABLE:
17742 case SQL_COLUMN_DISPLAY_SIZE:
17745 case SQL_COLUMN_UNSIGNED:
17746 v = c->
nosign ? SQL_TRUE : SQL_FALSE;
17748 case SQL_COLUMN_SEARCHABLE:
17749 v = SQL_SEARCHABLE;
17751 case SQL_COLUMN_SCALE:
17752 case SQL_DESC_SCALE:
17755 case SQL_COLUMN_PRECISION:
17756 case SQL_DESC_PRECISION:
17775 #ifdef SQL_TYPE_TIMESTAMP 17776 case SQL_TYPE_TIMESTAMP:
17778 case SQL_TIMESTAMP:
17786 case SQL_COLUMN_MONEY:
17789 case SQL_COLUMN_AUTO_INCREMENT:
17792 case SQL_DESC_NULLABLE:
17795 #ifdef SQL_DESC_NUM_PREC_RADIX 17796 case SQL_DESC_NUM_PREC_RADIX:
17801 #ifdef SQL_LONGVARCHAR 17802 case SQL_WLONGVARCHAR:
17807 #ifdef SQL_LONGVARCHAR 17808 case SQL_LONGVARCHAR:
17811 case SQL_VARBINARY:
17812 case SQL_LONGVARBINARY:
17821 setstat(s, -1,
"unsupported column attribute %d",
"HY091",
id);
17827 return SQL_SUCCESS;
17844 SQLColAttribute(SQLHSTMT
stmt, SQLUSMALLINT col, SQLUSMALLINT
id,
17845 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17848 #if defined(_WIN32) || defined(_WIN64) 17849 SQLSMALLINT len = 0;
17854 #if defined(_WIN32) || defined(_WIN64) 17856 ret = drvcolattribute(
stmt, col,
id, val, valMax, valLen,
17857 (SQLPOINTER) val2);
17860 ret = drvcolattribute(
stmt, col,
id, val, valMax, &len,
17861 (SQLPOINTER) val2);
17862 if (SQL_SUCCEEDED(ret)) {
17866 case SQL_DESC_SCHEMA_NAME:
17867 case SQL_DESC_CATALOG_NAME:
17868 case SQL_COLUMN_LABEL:
17869 case SQL_DESC_NAME:
17870 case SQL_DESC_TABLE_NAME:
17871 #ifdef SQL_DESC_BASE_TABLE_NAME 17872 case SQL_DESC_BASE_TABLE_NAME:
17874 #ifdef SQL_DESC_BASE_COLUMN_NAME 17875 case SQL_DESC_BASE_COLUMN_NAME:
17877 case SQL_DESC_TYPE_NAME:
17878 if (val && valMax > 0) {
17881 v = utf_to_wmb((
char *) val, SQL_NTS);
17883 strncpy(val, v, vmax);
17884 len =
min(vmax, strlen(v));
17889 v[vmax - 1] =
'\0';
17904 ret = drvcolattribute(
stmt, col,
id, val, valMax, valLen,
17905 (SQLPOINTER) val2);
17926 SQLColAttributeW(SQLHSTMT
stmt, SQLUSMALLINT col, SQLUSMALLINT
id,
17927 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17931 SQLSMALLINT len = 0;
17934 ret = drvcolattribute(
stmt, col,
id, val, valMax, &len,
17935 (SQLPOINTER) val2);
17936 if (SQL_SUCCEEDED(ret)) {
17937 SQLWCHAR *v = NULL;
17940 case SQL_DESC_SCHEMA_NAME:
17941 case SQL_DESC_CATALOG_NAME:
17942 case SQL_COLUMN_LABEL:
17943 case SQL_DESC_NAME:
17944 case SQL_DESC_TABLE_NAME:
17945 #ifdef SQL_DESC_BASE_TABLE_NAME 17946 case SQL_DESC_BASE_TABLE_NAME:
17948 #ifdef SQL_DESC_BASE_COLUMN_NAME 17949 case SQL_DESC_BASE_COLUMN_NAME:
17951 case SQL_DESC_TYPE_NAME:
17952 if (val && valMax > 0) {
17953 int vmax = valMax /
sizeof (SQLWCHAR);
17960 len *=
sizeof (SQLWCHAR);
17963 v = (SQLWCHAR *) val;
17964 v[vmax - 1] =
'\0';
17995 drverror(SQLHENV env, SQLHDBC
dbc, SQLHSTMT
stmt,
17996 SQLCHAR *sqlState, SQLINTEGER *nativeErr,
17997 SQLCHAR *errmsg, SQLSMALLINT errmax, SQLSMALLINT *errlen)
18001 SQLSMALLINT dummy2;
18003 if (env == SQL_NULL_HENV &&
18004 dbc == SQL_NULL_HDBC &&
18005 stmt == SQL_NULL_HSTMT) {
18006 return SQL_INVALID_HANDLE;
18009 sqlState[0] =
'\0';
18014 nativeErr = &dummy1;
18033 if (s->
logmsg[0] ==
'\0') {
18038 strcpy((
char *) sqlState, s->
sqlstate);
18039 if (errmax == SQL_NTS) {
18040 strcpy((
char *) errmsg,
"[SQLite]");
18041 strcat((
char *) errmsg, (
char *) s->
logmsg);
18042 *errlen = strlen((
char *) errmsg);
18044 strncpy((
char *) errmsg,
"[SQLite]", errmax);
18045 if (errmax - 8 > 0) {
18046 strncpy((
char *) errmsg + 8, (
char *) s->
logmsg, errmax - 8);
18048 *errlen =
min(strlen((
char *) s->
logmsg) + 8, errmax);
18052 return SQL_SUCCESS;
18063 strcpy((
char *) sqlState, d->
sqlstate);
18064 if (errmax == SQL_NTS) {
18065 strcpy((
char *) errmsg,
"[SQLite]");
18066 strcat((
char *) errmsg, (
char *) d->
logmsg);
18067 *errlen = strlen((
char *) errmsg);
18069 strncpy((
char *) errmsg,
"[SQLite]", errmax);
18070 if (errmax - 8 > 0) {
18071 strncpy((
char *) errmsg + 8, (
char *) d->
logmsg, errmax - 8);
18073 *errlen =
min(strlen((
char *) d->
logmsg) + 8, errmax);
18077 return SQL_SUCCESS;
18080 sqlState[0] =
'\0';
18084 return SQL_NO_DATA;
18102 SQLError(SQLHENV env, SQLHDBC
dbc, SQLHSTMT
stmt,
18103 SQLCHAR *sqlState, SQLINTEGER *nativeErr,
18104 SQLCHAR *errmsg, SQLSMALLINT errmax, SQLSMALLINT *errlen)
18106 return drverror(env,
dbc,
stmt, sqlState, nativeErr,
18107 errmsg, errmax, errlen);
18126 SQLErrorW(SQLHENV env, SQLHDBC
dbc, SQLHSTMT
stmt,
18127 SQLWCHAR *sqlState, SQLINTEGER *nativeErr,
18128 SQLWCHAR *errmsg, SQLSMALLINT errmax, SQLSMALLINT *errlen)
18131 SQLSMALLINT len = 0;
18134 ret = drverror(env,
dbc,
stmt, (SQLCHAR *) state, nativeErr,
18135 (SQLCHAR *) errmsg, errmax, &len);
18136 if (ret == SQL_SUCCESS) {
18139 6 *
sizeof (SQLWCHAR));
18143 SQLWCHAR *e = NULL;
18171 }
else if (ret == SQL_NO_DATA) {
18195 SQLMoreResults(SQLHSTMT
stmt)
18198 if (
stmt == SQL_NULL_HSTMT) {
18199 return SQL_INVALID_HANDLE;
18202 return SQL_NO_DATA;
18216 int ncols = *ncolsp, guessed_types = 0;
18217 SQLRETURN ret = SQL_SUCCESS;
18225 const char *colname, *
typename;
18226 #
if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME)
18230 for (i = size = 0; i < ncols; i++) {
18231 colname = sqlite3_column_name(s3stmt, i);
18232 size += 3 + 3 * strlen(colname);
18234 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME) 18235 tblname = (
char *) size;
18236 for (i = 0; i < ncols; i++) {
18237 p = (
char *) sqlite3_column_table_name(s3stmt, i);
18238 size += 2 + (p ? strlen(p) : 0);
18241 dyncols =
xmalloc(ncols *
sizeof (
COL) + size);
18247 p = (
char *) (dyncols + ncols);
18248 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME) 18251 for (i = 0; i < ncols; i++) {
18254 colname = sqlite3_column_name(s3stmt, i);
18256 fprintf(d->
trace,
"-- column %d name: '%s'\n",
18260 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME) 18261 q = (
char *) sqlite3_column_table_name(s3stmt, i);
18262 strcpy(tblname, q ? q :
"");
18264 fprintf(d->
trace,
"-- table %d name: '%s'\n",
18268 dyncols[i].
table = tblname;
18269 tblname += strlen(tblname) + 1;
18272 dyncols[i].
db = ((
DBC *) (s->
dbc))->dbname;
18273 strcpy(p, colname);
18274 dyncols[i].
label = p;
18275 p += strlen(p) + 1;
18276 q = strchr(colname,
'.');
18278 char *q2 = strchr(q + 1,
'.');
18286 #if !defined(HAVE_SQLITE3COLUMNTABLENAME) || !(HAVE_SQLITE3COLUMNTABLENAME) 18287 dyncols[i].
table = p;
18289 strncpy(p, colname, q - colname);
18290 p[q - colname] =
'\0';
18291 p += strlen(p) + 1;
18294 p += strlen(p) + 1;
18296 #if !defined(HAVE_SQLITE3COLUMNTABLENAME) || !(HAVE_SQLITE3COLUMNTABLENAME) 18297 dyncols[i].
table =
"";
18299 strcpy(p, colname);
18301 p += strlen(p) + 1;
18306 #ifdef SQL_LONGVARCHAR 18307 dyncols[i].
type = SQL_LONGVARCHAR;
18308 dyncols[i].
size = 65535;
18310 dyncols[i].
type = SQL_VARCHAR;
18311 dyncols[i].
size = 255;
18313 dyncols[i].
index = i;
18314 dyncols[i].
scale = 0;
18315 dyncols[i].
prec = 0;
18317 dyncols[i].
autoinc = SQL_FALSE;
18318 dyncols[i].
notnull = SQL_NULLABLE;
18319 dyncols[i].
ispk = -1;
18321 #ifdef FULL_METADATA 18322 s3stmt_addmeta(s3stmt, i, d, &dyncols[i]);
18345 drvprepare(SQLHSTMT
stmt, SQLCHAR *query, SQLINTEGER queryLen)
18352 if (
stmt == SQL_NULL_HSTMT) {
18353 return SQL_INVALID_HANDLE;
18356 if (s->
dbc == SQL_NULL_HDBC) {
18367 if (sret != SQL_SUCCESS) {
18376 setstat(s, -1,
"%s", (*s->
ov3) ?
"HY000" :
"S1000", errp);
18384 int ret, ncols, nretry = 0;
18386 sqlite3_stmt *s3stmt = NULL;
18388 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 18395 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 18396 ret = sqlite3_prepare_v2(d->
sqlite, (
char *) s->
query, -1,
18399 ret = sqlite3_prepare(d->
sqlite, (
char *) s->
query, -1,
18402 if (ret != SQLITE_OK) {
18404 sqlite3_finalize(s3stmt);
18408 }
while (ret == SQLITE_SCHEMA && (++nretry) < 2);
18410 if (ret != SQLITE_OK) {
18413 sqlite3_finalize(s3stmt);
18415 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
18416 sqlite3_errmsg(d->
sqlite), ret);
18419 if (sqlite3_bind_parameter_count(s3stmt) != s->
nparams) {
18421 sqlite3_finalize(s3stmt);
18422 setstat(s, SQLITE_ERROR,
"parameter marker count incorrect",
18423 (*s->
ov3) ?
"HY000" :
"S1000");
18426 ncols = sqlite3_column_count(s3stmt);
18434 return SQL_SUCCESS;
18450 int rc, i, ncols = 0, nrows = 0, busy_count;
18453 if (
stmt == SQL_NULL_HSTMT) {
18454 return SQL_INVALID_HANDLE;
18457 if (s->
dbc == SQL_NULL_HDBC) {
18466 setstat(s, -1,
"no query prepared", (*s->
ov3) ?
"HY000" :
"S1000");
18471 setstat(s, -1,
"unbound parameters in query",
18472 (*s->
ov3) ?
"HY000" :
"S1000");
18475 for (i = 0; i < s->
nparams; i++) {
18484 if (lenp && *lenp < 0 && *lenp > SQL_LEN_DATA_AT_EXEC_OFFSET &&
18485 *lenp != SQL_NTS && *lenp != SQL_NULL_DATA &&
18486 *lenp != SQL_DATA_AT_EXEC) {
18487 setstat(s, -1,
"invalid length reference",
"HY009");
18490 if (lenp && (*lenp <= SQL_LEN_DATA_AT_EXEC_OFFSET ||
18491 *lenp == SQL_DATA_AT_EXEC)) {
18499 if (ret != SQL_SUCCESS) {
18508 for (i = 0; i < s->
nparams; i++) {
18515 if (p->
need <= 0 &&
18516 p->
lenp && (*p->
lenp <= SQL_LEN_DATA_AT_EXEC_OFFSET ||
18517 *p->
lenp == SQL_DATA_AT_EXEC)) {
18525 for (i = 0; i < s->
nparams; i++) {
18527 if (ret != SQL_SUCCESS) {
18534 s->
curtype == SQL_CURSOR_FORWARD_ONLY &&
18538 if (ret == SQL_SUCCESS) {
18545 if (rc == SQLITE_BUSY) {
18548 sqlite3_free(errp);
18551 for (i = 0; i < s->
nparams; i++) {
18558 if (!p->
lenp || (*p->
lenp > SQL_LEN_DATA_AT_EXEC_OFFSET &&
18559 *p->
lenp != SQL_DATA_AT_EXEC)) {
18568 if (rc != SQLITE_OK) {
18569 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
18570 errp ? errp :
"unknown error", rc);
18572 sqlite3_free(errp);
18579 sqlite3_free(errp);
18588 nrows += sqlite3_changes(d->sqlite);
18592 if (s->
ncols != ncols) {
18596 setstat(s, -1,
"broken result set %d/%d",
18597 (*s->
ov3) ?
"HY000" :
"S1000", s->
ncols, ncols);
18609 for (i = 0; i < s->
nparams; i++) {
18620 }
else if (p->
lenp0 && p->
inc > 0) {
18623 if (!p->
lenp || (*p->
lenp > SQL_LEN_DATA_AT_EXEC_OFFSET &&
18624 *p->
lenp != SQL_DATA_AT_EXEC)) {
18633 }
else if (p->
lenp && (*p->
lenp <= SQL_LEN_DATA_AT_EXEC_OFFSET ||
18634 *p->
lenp == SQL_DATA_AT_EXEC)) {
18643 if (ret != SQL_NEED_DATA) {
18644 for (i = 0; i < s->
nparams; i++) {
18651 if (!p->
lenp || (*p->
lenp > SQL_LEN_DATA_AT_EXEC_OFFSET &&
18652 *p->
lenp != SQL_DATA_AT_EXEC)) {
18669 ret == SQL_SUCCESS && nrows == 0) {
18685 SQLPrepare(SQLHSTMT
stmt, SQLCHAR *query, SQLINTEGER queryLen)
18688 #if defined(_WIN32) || defined(_WIN64) 18693 #if defined(_WIN32) || defined(_WIN64) 18695 ret = drvprepare(
stmt, query, queryLen);
18698 q = wmb_to_utf_c((
char *) query, queryLen);
18703 query = (SQLCHAR *) q;
18704 queryLen = SQL_NTS;
18706 ret = drvprepare(
stmt, query, queryLen);
18707 #if defined(_WIN32) || defined(_WIN64) 18727 SQLPrepareW(SQLHSTMT
stmt, SQLWCHAR *query, SQLINTEGER queryLen)
18737 ret = drvprepare(
stmt, (SQLCHAR *) q, SQL_NTS);
18752 SQLExecute(SQLHSTMT
stmt)
18772 SQLExecDirect(SQLHSTMT
stmt, SQLCHAR *query, SQLINTEGER queryLen)
18775 #if defined(_WIN32) || defined(_WIN64) 18780 #if defined(_WIN32) || defined(_WIN64) 18782 ret = drvprepare(
stmt, query, queryLen);
18783 if (ret == SQL_SUCCESS) {
18788 q = wmb_to_utf_c((
char *) query, queryLen);
18793 query = (SQLCHAR *) q;
18794 queryLen = SQL_NTS;
18796 ret = drvprepare(
stmt, query, queryLen);
18797 if (ret == SQL_SUCCESS) {
18800 #if defined(_WIN32) || defined(_WIN64) 18820 SQLExecDirectW(SQLHSTMT
stmt, SQLWCHAR *query, SQLINTEGER queryLen)
18830 ret = drvprepare(
stmt, (SQLCHAR *) q, SQL_NTS);
18832 if (ret == SQL_SUCCESS) {
18842 #if defined(_WIN32) || defined(_WIN64) 18843 #ifndef WITHOUT_DRIVERMGR 18849 #include <windowsx.h> 18850 #include <winuser.h> 18852 #define MAXPATHLEN (259+1) 18853 #define MAXKEYLEN (15+1) 18854 #define MAXDESC (255+1) 18855 #define MAXDSNAME (255+1) 18856 #define MAXTONAME (32+1) 18857 #define MAXDBNAME MAXPATHLEN 18863 #define KEY_DBNAME 2 18865 #define KEY_DRIVER 4 18866 #define KEY_STEPAPI 5 18867 #define KEY_SYNCP 6 18868 #define KEY_NOTXN 7 18869 #define KEY_SHORTNAM 8 18870 #define KEY_LONGNAM 9 18871 #define KEY_NOCREAT 10 18872 #define KEY_NOWCHAR 11 18873 #define KEY_LOADEXT 12 18874 #define KEY_JMODE 13 18875 #define KEY_FKSUPPORT 14 18876 #define KEY_OEMCP 15 18877 #define KEY_BIGINT 16 18878 #define KEY_PASSWD 17 18879 #define KEY_JDCONV 18 18880 #define NUMOFKEYS 19 18884 char attr[MAXPATHLEN*4];
18890 ATTR attr[NUMOFKEYS];
18891 char DSN[MAXDSNAME];
18900 {
"DSN", KEY_DSN },
18901 {
"DESC", KEY_DESC },
18902 {
"Description", KEY_DESC},
18903 {
"Database", KEY_DBNAME },
18904 {
"Timeout", KEY_BUSY },
18905 {
"Driver", KEY_DRIVER },
18906 {
"StepAPI", KEY_STEPAPI },
18907 {
"SyncPragma", KEY_SYNCP },
18908 {
"NoTXN", KEY_NOTXN },
18909 {
"ShortNames", KEY_SHORTNAM },
18910 {
"LongNames", KEY_LONGNAM },
18911 {
"NoCreat", KEY_NOCREAT },
18912 {
"NoWCHAR", KEY_NOWCHAR },
18913 {
"LoadExt", KEY_LOADEXT },
18914 {
"JournalMode", KEY_JMODE },
18915 {
"FKSupport", KEY_FKSUPPORT },
18916 {
"OEMCP", KEY_OEMCP },
18917 {
"BigInt", KEY_BIGINT },
18918 {
"PWD", KEY_PASSWD },
18919 {
"JDConv", KEY_JDCONV },
18930 ParseAttributes(LPCSTR attribs, SETUPDLG *setupdlg)
18932 char *str = (
char *) attribs, *start, key[MAXKEYLEN];
18937 if ((str = strchr(str,
'=')) == NULL) {
18941 nkey = str - start;
18942 if (nkey <
sizeof (key)) {
18945 memcpy(key, start, nkey);
18947 for (i = 0; attrLookup[i].key; i++) {
18948 if (strcasecmp(attrLookup[i].key, key) == 0) {
18949 elem = attrLookup[i].ikey;
18955 while (*str && *str !=
';') {
18959 int end =
min(str - start,
sizeof (setupdlg->attr[elem].attr) - 1);
18961 setupdlg->attr[elem].supplied = TRUE;
18962 memcpy(setupdlg->attr[elem].attr, start, end);
18963 setupdlg->attr[elem].attr[end] =
'\0';
18977 SetDSNAttributes(HWND parent, SETUPDLG *setupdlg)
18979 char *dsn = setupdlg->attr[KEY_DSN].attr;
18981 if (setupdlg->newDSN && strlen(dsn) == 0) {
18984 if (!SQLWriteDSNToIni(dsn, setupdlg->driver)) {
18986 char buf[MAXPATHLEN], msg[MAXPATHLEN];
18988 LoadString(hModule, IDS_BADDSN, buf,
sizeof (buf));
18989 wsprintf(msg, buf, dsn);
18990 LoadString(hModule, IDS_MSGTITLE, buf,
sizeof (buf));
18991 MessageBox(parent, msg, buf,
18992 MB_ICONEXCLAMATION | MB_OK | MB_TASKMODAL |
18997 if (parent || setupdlg->attr[KEY_DESC].supplied) {
18998 SQLWritePrivateProfileString(dsn,
"Description",
18999 setupdlg->attr[KEY_DESC].attr,
19002 if (parent || setupdlg->attr[KEY_DBNAME].supplied) {
19003 SQLWritePrivateProfileString(dsn,
"Database",
19004 setupdlg->attr[KEY_DBNAME].attr,
19007 if (parent || setupdlg->attr[KEY_BUSY].supplied) {
19008 SQLWritePrivateProfileString(dsn,
"Timeout",
19009 setupdlg->attr[KEY_BUSY].attr,
19012 if (parent || setupdlg->attr[KEY_STEPAPI].supplied) {
19013 SQLWritePrivateProfileString(dsn,
"StepAPI",
19014 setupdlg->attr[KEY_STEPAPI].attr,
19017 if (parent || setupdlg->attr[KEY_SYNCP].supplied) {
19018 SQLWritePrivateProfileString(dsn,
"SyncPragma",
19019 setupdlg->attr[KEY_SYNCP].attr,
19022 if (parent || setupdlg->attr[KEY_NOTXN].supplied) {
19023 SQLWritePrivateProfileString(dsn,
"NoTXN",
19024 setupdlg->attr[KEY_NOTXN].attr,
19027 if (parent || setupdlg->attr[KEY_SHORTNAM].supplied) {
19028 SQLWritePrivateProfileString(dsn,
"ShortNames",
19029 setupdlg->attr[KEY_SHORTNAM].attr,
19032 if (parent || setupdlg->attr[KEY_LONGNAM].supplied) {
19033 SQLWritePrivateProfileString(dsn,
"LongNames",
19034 setupdlg->attr[KEY_LONGNAM].attr,
19037 if (parent || setupdlg->attr[KEY_NOCREAT].supplied) {
19038 SQLWritePrivateProfileString(dsn,
"NoCreat",
19039 setupdlg->attr[KEY_NOCREAT].attr,
19042 if (parent || setupdlg->attr[KEY_NOWCHAR].supplied) {
19043 SQLWritePrivateProfileString(dsn,
"NoWCHAR",
19044 setupdlg->attr[KEY_NOWCHAR].attr,
19047 if (parent || setupdlg->attr[KEY_FKSUPPORT].supplied) {
19048 SQLWritePrivateProfileString(dsn,
"FKSupport",
19049 setupdlg->attr[KEY_FKSUPPORT].attr,
19052 if (parent || setupdlg->attr[KEY_OEMCP].supplied) {
19053 SQLWritePrivateProfileString(dsn,
"OEMCP",
19054 setupdlg->attr[KEY_OEMCP].attr,
19057 if (parent || setupdlg->attr[KEY_LOADEXT].supplied) {
19058 SQLWritePrivateProfileString(dsn,
"LoadExt",
19059 setupdlg->attr[KEY_LOADEXT].attr,
19062 if (parent || setupdlg->attr[KEY_BIGINT].supplied) {
19063 SQLWritePrivateProfileString(dsn,
"BigInt",
19064 setupdlg->attr[KEY_BIGINT].attr,
19067 if (parent || setupdlg->attr[KEY_JDCONV].supplied) {
19068 SQLWritePrivateProfileString(dsn,
"JDConv",
19069 setupdlg->attr[KEY_JDCONV].attr,
19072 if (parent || setupdlg->attr[KEY_PASSWD].supplied) {
19073 SQLWritePrivateProfileString(dsn,
"PWD",
19074 setupdlg->attr[KEY_PASSWD].attr,
19077 if (setupdlg->attr[KEY_DSN].supplied &&
19078 strcasecmp(setupdlg->DSN, setupdlg->attr[KEY_DSN].attr)) {
19079 SQLRemoveDSNFromIni(setupdlg->DSN);
19090 GetAttributes(SETUPDLG *setupdlg)
19092 char *dsn = setupdlg->attr[KEY_DSN].attr;
19094 if (!setupdlg->attr[KEY_DESC].supplied) {
19095 SQLGetPrivateProfileString(dsn,
"Description",
"",
19096 setupdlg->attr[KEY_DESC].attr,
19097 sizeof (setupdlg->attr[KEY_DESC].attr),
19100 if (!setupdlg->attr[KEY_DBNAME].supplied) {
19101 SQLGetPrivateProfileString(dsn,
"Database",
"",
19102 setupdlg->attr[KEY_DBNAME].attr,
19103 sizeof (setupdlg->attr[KEY_DBNAME].attr),
19106 if (!setupdlg->attr[KEY_BUSY].supplied) {
19107 SQLGetPrivateProfileString(dsn,
"Timeout",
"100000",
19108 setupdlg->attr[KEY_BUSY].attr,
19109 sizeof (setupdlg->attr[KEY_BUSY].attr),
19112 if (!setupdlg->attr[KEY_STEPAPI].supplied) {
19113 SQLGetPrivateProfileString(dsn,
"StepAPI",
"0",
19114 setupdlg->attr[KEY_STEPAPI].attr,
19115 sizeof (setupdlg->attr[KEY_STEPAPI].attr),
19118 if (!setupdlg->attr[KEY_SYNCP].supplied) {
19119 SQLGetPrivateProfileString(dsn,
"SyncPragma",
"NORMAL",
19120 setupdlg->attr[KEY_SYNCP].attr,
19121 sizeof (setupdlg->attr[KEY_SYNCP].attr),
19124 if (!setupdlg->attr[KEY_NOTXN].supplied) {
19125 SQLGetPrivateProfileString(dsn,
"NoTXN",
"",
19126 setupdlg->attr[KEY_NOTXN].attr,
19127 sizeof (setupdlg->attr[KEY_NOTXN].attr),
19130 if (!setupdlg->attr[KEY_SHORTNAM].supplied) {
19131 SQLGetPrivateProfileString(dsn,
"ShortNames",
"",
19132 setupdlg->attr[KEY_SHORTNAM].attr,
19133 sizeof (setupdlg->attr[KEY_SHORTNAM].attr),
19136 if (!setupdlg->attr[KEY_LONGNAM].supplied) {
19137 SQLGetPrivateProfileString(dsn,
"LongNames",
"",
19138 setupdlg->attr[KEY_LONGNAM].attr,
19139 sizeof (setupdlg->attr[KEY_LONGNAM].attr),
19142 if (!setupdlg->attr[KEY_NOCREAT].supplied) {
19143 SQLGetPrivateProfileString(dsn,
"NoCreat",
"",
19144 setupdlg->attr[KEY_NOCREAT].attr,
19145 sizeof (setupdlg->attr[KEY_NOCREAT].attr),
19148 if (!setupdlg->attr[KEY_NOWCHAR].supplied) {
19149 SQLGetPrivateProfileString(dsn,
"NoWCHAR",
"",
19150 setupdlg->attr[KEY_NOWCHAR].attr,
19151 sizeof (setupdlg->attr[KEY_NOWCHAR].attr),
19154 if (!setupdlg->attr[KEY_FKSUPPORT].supplied) {
19155 SQLGetPrivateProfileString(dsn,
"FKSupport",
"",
19156 setupdlg->attr[KEY_FKSUPPORT].attr,
19157 sizeof (setupdlg->attr[KEY_FKSUPPORT].attr),
19160 if (!setupdlg->attr[KEY_OEMCP].supplied) {
19161 SQLGetPrivateProfileString(dsn,
"OEMCP",
"",
19162 setupdlg->attr[KEY_OEMCP].attr,
19163 sizeof (setupdlg->attr[KEY_OEMCP].attr),
19166 if (!setupdlg->attr[KEY_LOADEXT].supplied) {
19167 SQLGetPrivateProfileString(dsn,
"LoadExt",
"",
19168 setupdlg->attr[KEY_LOADEXT].attr,
19169 sizeof (setupdlg->attr[KEY_LOADEXT].attr),
19172 if (!setupdlg->attr[KEY_JMODE].supplied) {
19173 SQLGetPrivateProfileString(dsn,
"JournalMode",
"",
19174 setupdlg->attr[KEY_JMODE].attr,
19175 sizeof (setupdlg->attr[KEY_JMODE].attr),
19178 if (!setupdlg->attr[KEY_BIGINT].supplied) {
19179 SQLGetPrivateProfileString(dsn,
"BigInt",
"",
19180 setupdlg->attr[KEY_BIGINT].attr,
19181 sizeof (setupdlg->attr[KEY_BIGINT].attr),
19184 if (!setupdlg->attr[KEY_PASSWD].supplied) {
19185 SQLGetPrivateProfileString(dsn,
"PWD",
"",
19186 setupdlg->attr[KEY_PASSWD].attr,
19187 sizeof (setupdlg->attr[KEY_PASSWD].attr),
19190 if (!setupdlg->attr[KEY_JDCONV].supplied) {
19191 SQLGetPrivateProfileString(dsn,
"JDConv",
"",
19192 setupdlg->attr[KEY_JDCONV].attr,
19193 sizeof (setupdlg->attr[KEY_JDCONV].attr),
19204 GetDBFile(HWND hdlg)
19207 SETUPDLG *setupdlg = (SETUPDLG *) GetWindowLongPtr(hdlg, DWLP_USER);
19209 SETUPDLG *setupdlg = (SETUPDLG *) GetWindowLong(hdlg, DWL_USER);
19213 memset(&ofn, 0,
sizeof (ofn));
19214 ofn.lStructSize =
sizeof (ofn);
19215 ofn.hwndOwner = hdlg;
19217 ofn.hInstance = (HINSTANCE) GetWindowLongPtr(hdlg, GWLP_HINSTANCE);
19219 ofn.hInstance = (HINSTANCE) GetWindowLong(hdlg, GWL_HINSTANCE);
19221 ofn.lpstrFile = (LPTSTR) setupdlg->attr[KEY_DBNAME].attr;
19222 ofn.nMaxFile = MAXPATHLEN;
19223 ofn.Flags = OFN_HIDEREADONLY | OFN_PATHMUSTEXIST |
19224 OFN_NOCHANGEDIR | OFN_EXPLORER | OFN_FILEMUSTEXIST;
19225 if (GetOpenFileName(&ofn)) {
19226 SetDlgItemText(hdlg, IDC_DBNAME, setupdlg->attr[KEY_DBNAME].attr);
19227 setupdlg->attr[KEY_DBNAME].supplied = TRUE;
19240 static BOOL CALLBACK
19241 ConfigDlgProc(HWND hdlg, WORD wmsg, WPARAM wparam, LPARAM lparam)
19243 SETUPDLG *setupdlg = NULL;
19247 case WM_INITDIALOG:
19249 SetWindowLongPtr(hdlg, DWLP_USER, lparam);
19251 SetWindowLong(hdlg, DWL_USER, lparam);
19253 setupdlg = (SETUPDLG *) lparam;
19254 GetAttributes(setupdlg);
19255 SetDlgItemText(hdlg, IDC_DSNAME, setupdlg->attr[KEY_DSN].attr);
19256 SetDlgItemText(hdlg, IDC_DESC, setupdlg->attr[KEY_DESC].attr);
19257 SetDlgItemText(hdlg, IDC_DBNAME, setupdlg->attr[KEY_DBNAME].attr);
19258 SetDlgItemText(hdlg, IDC_TONAME, setupdlg->attr[KEY_BUSY].attr);
19259 SetDlgItemText(hdlg, IDC_LOADEXT, setupdlg->attr[KEY_LOADEXT].attr);
19260 SendDlgItemMessage(hdlg, IDC_DSNAME, EM_LIMITTEXT,
19261 (WPARAM) (MAXDSNAME - 1), (LPARAM) 0);
19262 SendDlgItemMessage(hdlg, IDC_DESC, EM_LIMITTEXT,
19263 (WPARAM) (MAXDESC - 1), (LPARAM) 0);
19264 SendDlgItemMessage(hdlg, IDC_DBNAME, EM_LIMITTEXT,
19265 (WPARAM) (MAXDBNAME - 1), (LPARAM) 0);
19266 SendDlgItemMessage(hdlg, IDC_TONAME, EM_LIMITTEXT,
19267 (WPARAM) (MAXTONAME - 1), (LPARAM) 0);
19268 SendDlgItemMessage(hdlg, IDC_LOADEXT, EM_LIMITTEXT,
19269 (WPARAM) (MAXPATHLEN*4 - 1), (LPARAM) 0);
19270 CheckDlgButton(hdlg, IDC_STEPAPI,
19271 getbool(setupdlg->attr[KEY_STEPAPI].attr) ?
19272 BST_CHECKED : BST_UNCHECKED);
19273 CheckDlgButton(hdlg, IDC_NOTXN,
19274 getbool(setupdlg->attr[KEY_NOTXN].attr) ?
19275 BST_CHECKED : BST_UNCHECKED);
19276 CheckDlgButton(hdlg, IDC_SHORTNAM,
19277 getbool(setupdlg->attr[KEY_SHORTNAM].attr) ?
19278 BST_CHECKED : BST_UNCHECKED);
19279 CheckDlgButton(hdlg, IDC_LONGNAM,
19280 getbool(setupdlg->attr[KEY_LONGNAM].attr) ?
19281 BST_CHECKED : BST_UNCHECKED);
19282 CheckDlgButton(hdlg, IDC_NOCREAT,
19283 getbool(setupdlg->attr[KEY_NOCREAT].attr) ?
19284 BST_CHECKED : BST_UNCHECKED);
19285 CheckDlgButton(hdlg, IDC_NOWCHAR,
19286 getbool(setupdlg->attr[KEY_NOWCHAR].attr) ?
19287 BST_CHECKED : BST_UNCHECKED);
19288 CheckDlgButton(hdlg, IDC_FKSUPPORT,
19289 getbool(setupdlg->attr[KEY_FKSUPPORT].attr) ?
19290 BST_CHECKED : BST_UNCHECKED);
19291 CheckDlgButton(hdlg, IDC_OEMCP,
19292 getbool(setupdlg->attr[KEY_OEMCP].attr) ?
19293 BST_CHECKED : BST_UNCHECKED);
19294 CheckDlgButton(hdlg, IDC_BIGINT,
19295 getbool(setupdlg->attr[KEY_BIGINT].attr) ?
19296 BST_CHECKED : BST_UNCHECKED);
19297 CheckDlgButton(hdlg, IDC_JDCONV,
19298 getbool(setupdlg->attr[KEY_JDCONV].attr) ?
19299 BST_CHECKED : BST_UNCHECKED);
19300 SendDlgItemMessage(hdlg, IDC_SYNCP,
19301 CB_LIMITTEXT, (WPARAM) 10, (LPARAM) 0);
19302 SendDlgItemMessage(hdlg, IDC_SYNCP,
19303 CB_ADDSTRING, 0, (LPARAM)
"NORMAL");
19304 SendDlgItemMessage(hdlg, IDC_SYNCP,
19305 CB_ADDSTRING, 0, (LPARAM)
"OFF");
19306 SendDlgItemMessage(hdlg, IDC_SYNCP,
19307 CB_ADDSTRING, 0, (LPARAM)
"FULL");
19308 SendDlgItemMessage(hdlg, IDC_SYNCP,
19309 CB_SELECTSTRING, (WPARAM) -1,
19310 (LPARAM) setupdlg->attr[KEY_SYNCP].attr);
19311 if (setupdlg->defDSN) {
19312 EnableWindow(GetDlgItem(hdlg, IDC_DSNAME), FALSE);
19313 EnableWindow(GetDlgItem(hdlg, IDC_DSNAMETEXT), FALSE);
19317 switch (GET_WM_COMMAND_ID(wparam, lparam)) {
19319 if (GET_WM_COMMAND_CMD(wparam, lparam) == EN_CHANGE) {
19320 char item[MAXDSNAME];
19322 EnableWindow(GetDlgItem(hdlg, IDOK),
19323 GetDlgItemText(hdlg, IDC_DSNAME,
19324 item,
sizeof (item)));
19333 setupdlg = (SETUPDLG *) GetWindowLongPtr(hdlg, DWLP_USER);
19335 setupdlg = (SETUPDLG *) GetWindowLong(hdlg, DWL_USER);
19337 if (!setupdlg->defDSN) {
19338 GetDlgItemText(hdlg, IDC_DSNAME,
19339 setupdlg->attr[KEY_DSN].attr,
19340 sizeof (setupdlg->attr[KEY_DSN].attr));
19342 GetDlgItemText(hdlg, IDC_DESC,
19343 setupdlg->attr[KEY_DESC].attr,
19344 sizeof (setupdlg->attr[KEY_DESC].attr));
19345 GetDlgItemText(hdlg, IDC_DBNAME,
19346 setupdlg->attr[KEY_DBNAME].attr,
19347 sizeof (setupdlg->attr[KEY_DBNAME].attr));
19348 GetDlgItemText(hdlg, IDC_TONAME,
19349 setupdlg->attr[KEY_BUSY].attr,
19350 sizeof (setupdlg->attr[KEY_BUSY].attr));
19351 GetDlgItemText(hdlg, IDC_LOADEXT,
19352 setupdlg->attr[KEY_LOADEXT].attr,
19353 sizeof (setupdlg->attr[KEY_LOADEXT].attr));
19354 index = SendDlgItemMessage(hdlg, IDC_SYNCP,
19355 CB_GETCURSEL, (WPARAM) 0, (LPARAM) 0);
19356 if (index != (WORD) CB_ERR) {
19357 SendDlgItemMessage(hdlg, IDC_SYNCP,
19358 CB_GETLBTEXT, index,
19359 (LPARAM) setupdlg->attr[KEY_SYNCP].attr);
19361 strcpy(setupdlg->attr[KEY_STEPAPI].attr,
19362 (IsDlgButtonChecked(hdlg, IDC_STEPAPI) == BST_CHECKED) ?
19364 strcpy(setupdlg->attr[KEY_NOTXN].attr,
19365 (IsDlgButtonChecked(hdlg, IDC_NOTXN) == BST_CHECKED) ?
19367 strcpy(setupdlg->attr[KEY_SHORTNAM].attr,
19368 (IsDlgButtonChecked(hdlg, IDC_SHORTNAM) == BST_CHECKED) ?
19370 strcpy(setupdlg->attr[KEY_LONGNAM].attr,
19371 (IsDlgButtonChecked(hdlg, IDC_LONGNAM) == BST_CHECKED) ?
19373 strcpy(setupdlg->attr[KEY_NOCREAT].attr,
19374 (IsDlgButtonChecked(hdlg, IDC_NOCREAT) == BST_CHECKED) ?
19376 strcpy(setupdlg->attr[KEY_NOWCHAR].attr,
19377 (IsDlgButtonChecked(hdlg, IDC_NOWCHAR) == BST_CHECKED) ?
19379 strcpy(setupdlg->attr[KEY_FKSUPPORT].attr,
19380 (IsDlgButtonChecked(hdlg, IDC_FKSUPPORT) == BST_CHECKED) ?
19382 strcpy(setupdlg->attr[KEY_OEMCP].attr,
19383 (IsDlgButtonChecked(hdlg, IDC_OEMCP) == BST_CHECKED) ?
19385 strcpy(setupdlg->attr[KEY_BIGINT].attr,
19386 (IsDlgButtonChecked(hdlg, IDC_BIGINT) == BST_CHECKED) ?
19388 strcpy(setupdlg->attr[KEY_JDCONV].attr,
19389 (IsDlgButtonChecked(hdlg, IDC_JDCONV) == BST_CHECKED) ?
19391 SetDSNAttributes(hdlg, setupdlg);
19394 EndDialog(hdlg, wparam);
19412 ConfigDSN(HWND hwnd, WORD request, LPCSTR driver, LPCSTR attribs)
19415 SETUPDLG *setupdlg;
19417 setupdlg = (SETUPDLG *)
xmalloc(
sizeof (SETUPDLG));
19418 if (setupdlg == NULL) {
19421 memset(setupdlg, 0,
sizeof (SETUPDLG));
19423 ParseAttributes(attribs, setupdlg);
19425 if (setupdlg->attr[KEY_DSN].supplied) {
19426 strcpy(setupdlg->DSN, setupdlg->attr[KEY_DSN].attr);
19428 setupdlg->DSN[0] =
'\0';
19430 if (request == ODBC_REMOVE_DSN) {
19431 if (!setupdlg->attr[KEY_DSN].supplied) {
19434 success = SQLRemoveDSNFromIni(setupdlg->attr[KEY_DSN].attr);
19437 setupdlg->parent = hwnd;
19438 setupdlg->driver = driver;
19439 setupdlg->newDSN = request == ODBC_ADD_DSN;
19440 setupdlg->defDSN = strcasecmp(setupdlg->attr[KEY_DSN].attr,
19443 success = DialogBoxParam(hModule, MAKEINTRESOURCE(CONFIGDSN),
19444 hwnd, (DLGPROC) ConfigDlgProc,
19445 (LPARAM) setupdlg) == IDOK;
19446 }
else if (setupdlg->attr[KEY_DSN].supplied) {
19447 success = SetDSNAttributes(hwnd, setupdlg);
19465 static BOOL CALLBACK
19466 DriverConnectProc(HWND hdlg, WORD wmsg, WPARAM wparam, LPARAM lparam)
19468 SETUPDLG *setupdlg;
19472 case WM_INITDIALOG:
19474 SetWindowLongPtr(hdlg, DWLP_USER, lparam);
19476 SetWindowLong(hdlg, DWL_USER, lparam);
19478 setupdlg = (SETUPDLG *) lparam;
19479 SetDlgItemText(hdlg, IDC_DSNAME, setupdlg->attr[KEY_DSN].attr);
19480 SetDlgItemText(hdlg, IDC_DESC, setupdlg->attr[KEY_DESC].attr);
19481 SetDlgItemText(hdlg, IDC_DBNAME, setupdlg->attr[KEY_DBNAME].attr);
19482 SetDlgItemText(hdlg, IDC_TONAME, setupdlg->attr[KEY_BUSY].attr);
19483 SetDlgItemText(hdlg, IDC_LOADEXT, setupdlg->attr[KEY_LOADEXT].attr);
19484 SendDlgItemMessage(hdlg, IDC_DSNAME, EM_LIMITTEXT,
19485 (WPARAM) (MAXDSNAME - 1), (LPARAM) 0);
19486 SendDlgItemMessage(hdlg, IDC_DESC, EM_LIMITTEXT,
19487 (WPARAM) (MAXDESC - 1), (LPARAM) 0);
19488 SendDlgItemMessage(hdlg, IDC_DBNAME, EM_LIMITTEXT,
19489 (WPARAM) (MAXDBNAME - 1), (LPARAM) 0);
19490 SendDlgItemMessage(hdlg, IDC_TONAME, EM_LIMITTEXT,
19491 (WPARAM) (MAXTONAME - 1), (LPARAM) 0);
19492 SendDlgItemMessage(hdlg, IDC_LOADEXT, EM_LIMITTEXT,
19493 (WPARAM) (MAXPATHLEN*4 - 1), (LPARAM) 0);
19494 CheckDlgButton(hdlg, IDC_STEPAPI,
19495 getbool(setupdlg->attr[KEY_STEPAPI].attr) ?
19496 BST_CHECKED : BST_UNCHECKED);
19497 CheckDlgButton(hdlg, IDC_NOTXN,
19498 getbool(setupdlg->attr[KEY_NOTXN].attr) ?
19499 BST_CHECKED : BST_UNCHECKED);
19500 CheckDlgButton(hdlg, IDC_SHORTNAM,
19501 getbool(setupdlg->attr[KEY_SHORTNAM].attr) ?
19502 BST_CHECKED : BST_UNCHECKED);
19503 CheckDlgButton(hdlg, IDC_LONGNAM,
19504 getbool(setupdlg->attr[KEY_LONGNAM].attr) ?
19505 BST_CHECKED : BST_UNCHECKED);
19506 CheckDlgButton(hdlg, IDC_NOCREAT,
19507 getbool(setupdlg->attr[KEY_NOCREAT].attr) ?
19508 BST_CHECKED : BST_UNCHECKED);
19509 CheckDlgButton(hdlg, IDC_NOWCHAR,
19510 getbool(setupdlg->attr[KEY_NOWCHAR].attr) ?
19511 BST_CHECKED : BST_UNCHECKED);
19512 CheckDlgButton(hdlg, IDC_FKSUPPORT,
19513 getbool(setupdlg->attr[KEY_FKSUPPORT].attr) ?
19514 BST_CHECKED : BST_UNCHECKED);
19515 CheckDlgButton(hdlg, IDC_OEMCP,
19516 getbool(setupdlg->attr[KEY_OEMCP].attr) ?
19517 BST_CHECKED : BST_UNCHECKED);
19518 CheckDlgButton(hdlg, IDC_BIGINT,
19519 getbool(setupdlg->attr[KEY_BIGINT].attr) ?
19520 BST_CHECKED : BST_UNCHECKED);
19521 CheckDlgButton(hdlg, IDC_JDCONV,
19522 getbool(setupdlg->attr[KEY_JDCONV].attr) ?
19523 BST_CHECKED : BST_UNCHECKED);
19524 SendDlgItemMessage(hdlg, IDC_SYNCP,
19525 CB_LIMITTEXT, (WPARAM) 10, (LPARAM) 0);
19526 SendDlgItemMessage(hdlg, IDC_SYNCP,
19527 CB_ADDSTRING, 0, (LPARAM)
"NORMAL");
19528 SendDlgItemMessage(hdlg, IDC_SYNCP,
19529 CB_ADDSTRING, 0, (LPARAM)
"OFF");
19530 SendDlgItemMessage(hdlg, IDC_SYNCP,
19531 CB_ADDSTRING, 0, (LPARAM)
"FULL");
19532 SendDlgItemMessage(hdlg, IDC_SYNCP,
19533 CB_SELECTSTRING, (WORD) -1,
19534 (LPARAM) setupdlg->attr[KEY_SYNCP].attr);
19535 if (setupdlg->defDSN) {
19536 EnableWindow(GetDlgItem(hdlg, IDC_DSNAME), FALSE);
19537 EnableWindow(GetDlgItem(hdlg, IDC_DSNAMETEXT), FALSE);
19541 switch (GET_WM_COMMAND_ID(wparam, lparam)) {
19547 setupdlg = (SETUPDLG *) GetWindowLongPtr(hdlg, DWLP_USER);
19549 setupdlg = (SETUPDLG *) GetWindowLong(hdlg, DWL_USER);
19551 GetDlgItemText(hdlg, IDC_DSNAME,
19552 setupdlg->attr[KEY_DSN].attr,
19553 sizeof (setupdlg->attr[KEY_DSN].attr));
19554 GetDlgItemText(hdlg, IDC_DBNAME,
19555 setupdlg->attr[KEY_DBNAME].attr,
19556 sizeof (setupdlg->attr[KEY_DBNAME].attr));
19557 GetDlgItemText(hdlg, IDC_TONAME,
19558 setupdlg->attr[KEY_BUSY].attr,
19559 sizeof (setupdlg->attr[KEY_BUSY].attr));
19560 GetDlgItemText(hdlg, IDC_LOADEXT,
19561 setupdlg->attr[KEY_LOADEXT].attr,
19562 sizeof (setupdlg->attr[KEY_LOADEXT].attr));
19563 index = SendDlgItemMessage(hdlg, IDC_SYNCP,
19564 CB_GETCURSEL, (WPARAM) 0, (LPARAM) 0);
19565 if (index != (WORD) CB_ERR) {
19566 SendDlgItemMessage(hdlg, IDC_SYNCP,
19567 CB_GETLBTEXT, index,
19568 (LPARAM) setupdlg->attr[KEY_SYNCP].attr);
19570 strcpy(setupdlg->attr[KEY_STEPAPI].attr,
19571 (IsDlgButtonChecked(hdlg, IDC_STEPAPI) == BST_CHECKED) ?
19573 strcpy(setupdlg->attr[KEY_NOTXN].attr,
19574 (IsDlgButtonChecked(hdlg, IDC_NOTXN) == BST_CHECKED) ?
19576 strcpy(setupdlg->attr[KEY_SHORTNAM].attr,
19577 (IsDlgButtonChecked(hdlg, IDC_SHORTNAM) == BST_CHECKED) ?
19579 strcpy(setupdlg->attr[KEY_LONGNAM].attr,
19580 (IsDlgButtonChecked(hdlg, IDC_LONGNAM) == BST_CHECKED) ?
19582 strcpy(setupdlg->attr[KEY_NOCREAT].attr,
19583 (IsDlgButtonChecked(hdlg, IDC_NOCREAT) == BST_CHECKED) ?
19585 strcpy(setupdlg->attr[KEY_NOWCHAR].attr,
19586 (IsDlgButtonChecked(hdlg, IDC_NOWCHAR) == BST_CHECKED) ?
19588 strcpy(setupdlg->attr[KEY_FKSUPPORT].attr,
19589 (IsDlgButtonChecked(hdlg, IDC_FKSUPPORT) == BST_CHECKED) ?
19591 strcpy(setupdlg->attr[KEY_OEMCP].attr,
19592 (IsDlgButtonChecked(hdlg, IDC_OEMCP) == BST_CHECKED) ?
19594 strcpy(setupdlg->attr[KEY_BIGINT].attr,
19595 (IsDlgButtonChecked(hdlg, IDC_BIGINT) == BST_CHECKED) ?
19597 strcpy(setupdlg->attr[KEY_JDCONV].attr,
19598 (IsDlgButtonChecked(hdlg, IDC_JDCONV) == BST_CHECKED) ?
19602 EndDialog(hdlg, GET_WM_COMMAND_ID(wparam, lparam) == IDOK);
19624 SQLCHAR *connIn, SQLSMALLINT connInLen,
19625 SQLCHAR *connOut, SQLSMALLINT connOutMax,
19626 SQLSMALLINT *connOutLen, SQLUSMALLINT drvcompl)
19628 BOOL maybeprompt, prompt = FALSE, defaultdsn = FALSE;
19630 SETUPDLG *setupdlg;
19632 char *dsn = NULL, *driver = NULL, *dbname = NULL;
19634 if (
dbc == SQL_NULL_HDBC) {
19635 return SQL_INVALID_HANDLE;
19639 setstatd(d, -1,
"connection already established",
"08002");
19642 setupdlg = (SETUPDLG *)
xmalloc(
sizeof (SETUPDLG));
19643 if (setupdlg == NULL) {
19646 memset(setupdlg, 0,
sizeof (SETUPDLG));
19647 maybeprompt = drvcompl == SQL_DRIVER_COMPLETE ||
19648 drvcompl == SQL_DRIVER_COMPLETE_REQUIRED;
19649 if (connIn == NULL || !connInLen ||
19650 (connInLen == SQL_NTS && !connIn[0])) {
19653 ParseAttributes((LPCSTR) connIn, setupdlg);
19654 if (!setupdlg->attr[KEY_DSN].attr[0] &&
19655 drvcompl == SQL_DRIVER_COMPLETE_REQUIRED) {
19656 strcpy(setupdlg->attr[KEY_DSN].attr,
"DEFAULT");
19659 GetAttributes(setupdlg);
19660 if (drvcompl == SQL_DRIVER_PROMPT ||
19662 !setupdlg->attr[KEY_DBNAME].attr[0])) {
19670 setupdlg->defDSN = setupdlg->attr[KEY_DRIVER].attr[0] !=
'\0';
19671 dlgret = DialogBoxParam(hModule, MAKEINTRESOURCE(DRIVERCONNECT),
19672 hwnd, (DLGPROC) DriverConnectProc,
19673 (LPARAM) setupdlg);
19675 if (!dlgret || dlgret == -1) {
19677 return SQL_NO_DATA;
19680 dsn = setupdlg->attr[KEY_DSN].attr;
19681 driver = setupdlg->attr[KEY_DRIVER].attr;
19682 dbname = setupdlg->attr[KEY_DBNAME].attr;
19683 if (connOut || connOutLen) {
19684 char buf[SQL_MAX_MESSAGE_LENGTH * 8];
19686 char dsn_0 = (dsn && !defaultdsn) ? dsn[0] :
'\0';
19687 char drv_0 = driver ? driver[0] :
'\0';
19690 count = snprintf(buf,
sizeof (buf),
19691 "%s%s%s%s%s%sDatabase=%s;StepAPI=%s;" 19692 "SyncPragma=%s;NoTXN=%s;Timeout=%s;" 19693 "ShortNames=%s;LongNames=%s;" 19694 "NoCreat=%s;NoWCHAR=%s;" 19695 "FKSupport=%s;JournalMode=%s;OEMCP=%s;LoadExt=%s;" 19696 "BigInt=%s;JDConv=%s;PWD=%s",
19697 dsn_0 ?
"DSN=" :
"",
19700 drv_0 ?
"Driver=" :
"",
19701 drv_0 ? driver :
"",
19703 dbname ? dbname :
"",
19704 setupdlg->attr[KEY_STEPAPI].attr,
19705 setupdlg->attr[KEY_SYNCP].attr,
19706 setupdlg->attr[KEY_NOTXN].attr,
19707 setupdlg->attr[KEY_BUSY].attr,
19708 setupdlg->attr[KEY_SHORTNAM].attr,
19709 setupdlg->attr[KEY_LONGNAM].attr,
19710 setupdlg->attr[KEY_NOCREAT].attr,
19711 setupdlg->attr[KEY_NOWCHAR].attr,
19712 setupdlg->attr[KEY_FKSUPPORT].attr,
19713 setupdlg->attr[KEY_JMODE].attr,
19714 setupdlg->attr[KEY_OEMCP].attr,
19715 setupdlg->attr[KEY_LOADEXT].attr,
19716 setupdlg->attr[KEY_BIGINT].attr,
19717 setupdlg->attr[KEY_JDCONV].attr,
19718 setupdlg->attr[KEY_PASSWD].attr);
19720 buf[
sizeof (buf) - 1] =
'\0';
19722 len =
min(connOutMax - 1, strlen(buf));
19724 strncpy((
char *) connOut, buf, len);
19725 connOut[len] =
'\0';
19732 char tracef[SQL_MAX_MESSAGE_LENGTH];
19735 SQLGetPrivateProfileString(setupdlg->attr[KEY_DSN].attr,
19736 "tracefile",
"", tracef,
19738 if (tracef[0] !=
'\0') {
19739 d->
trace = fopen(tracef,
"a");
19750 d->
pwdLen = strlen(setupdlg->attr[KEY_PASSWD].attr);
19751 d->
pwd = (d->
pwdLen > 0) ? setupdlg->attr[KEY_PASSWD].attr : NULL;
19752 ret =
dbopen(d, dbname ? dbname :
"", 0,
19754 setupdlg->attr[KEY_STEPAPI].attr,
19755 setupdlg->attr[KEY_SYNCP].attr,
19756 setupdlg->attr[KEY_NOTXN].attr,
19757 setupdlg->attr[KEY_JMODE].attr,
19758 setupdlg->attr[KEY_BUSY].attr);
19759 if (ret != SQL_SUCCESS) {
19760 if (maybeprompt && !prompt) {
19765 memset(setupdlg->attr[KEY_PASSWD].attr, 0,
19766 sizeof (setupdlg->attr[KEY_PASSWD].attr));
19767 if (ret == SQL_SUCCESS) {
19768 dbloadext(d, setupdlg->attr[KEY_LOADEXT].attr);
19792 SQLDriverConnect(SQLHDBC
dbc, SQLHWND hwnd,
19793 SQLCHAR *connIn, SQLSMALLINT connInLen,
19794 SQLCHAR *connOut, SQLSMALLINT connOutMax,
19795 SQLSMALLINT *connOutLen, SQLUSMALLINT drvcompl)
19801 connOut, connOutMax, connOutLen, drvcompl);
19822 SQLDriverConnectW(SQLHDBC
dbc, SQLHWND hwnd,
19823 SQLWCHAR *connIn, SQLSMALLINT connInLen,
19824 SQLWCHAR *connOut, SQLSMALLINT connOutMax,
19825 SQLSMALLINT *connOutLen, SQLUSMALLINT drvcompl)
19829 SQLSMALLINT len = 0;
19833 #if defined(_WIN32) || defined(_WIN64) 19834 if (connInLen == SQL_NTS) {
19837 ci = uc_to_wmb(connIn, connInLen);
19844 setstatd(d, -1,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
19850 (SQLCHAR *) connOut, connOutMax, &len, drvcompl);
19853 if (ret == SQL_SUCCESS) {
19854 SQLWCHAR *co = NULL;
19858 #if defined(_WIN32) || defined(_WIN64) 19859 co = wmb_to_uc((
char *) connOut, len);
19864 uc_strncpy(connOut, co, connOutMax /
sizeof (SQLWCHAR));
19865 len =
min(connOutMax /
sizeof (SQLWCHAR),
uc_strlen(co));
19886 #if defined(_WIN32) || defined(_WIN64) 19897 LibMain(HANDLE hinst, DWORD reason, LPVOID reserved)
19902 case DLL_PROCESS_ATTACH:
19910 #ifdef SQLITE_DYNLOAD 19913 #ifdef SQLITE_HAS_CODEC 19914 sqlite3_activate_see(SQLITE_ACTIVATION_KEY);
19917 #if defined(ENABLE_NVFS) && (ENABLE_NVFS) 19921 case DLL_THREAD_ATTACH:
19923 case DLL_PROCESS_DETACH:
19925 #ifdef SQLITE_DYNLOAD 19930 case DLL_THREAD_DETACH:
19947 DllMain(HANDLE hinst, DWORD reason, LPVOID reserved)
19949 return LibMain(hinst, reason, reserved);
19952 #ifndef WITHOUT_INSTALLER 19961 InUnError(
char *name)
19966 WORD errlen, errmax =
sizeof (errmsg) - 1;
19972 sqlret = SQLInstallerError(err, &code, errmsg, errmax, &errlen);
19973 if (SQL_SUCCEEDED(sqlret)) {
19974 MessageBox(NULL, errmsg, name,
19975 MB_ICONSTOP | MB_OK | MB_TASKMODAL | MB_SETFOREGROUND);
19979 }
while (sqlret != SQL_NO_DATA);
19990 InUn(
int remove,
char *cmdline)
19992 #ifdef SQLITE_HAS_CODEC 19993 static char *drivername =
"SQLite3 ODBC Driver (SEE)";
19994 static char *dsname =
"SQLite3 SEE Datasource";
19996 static char *drivername =
"SQLite3 ODBC Driver";
19997 static char *dsname =
"SQLite3 Datasource";
20000 char dllbuf[301], path[301], driver[300], attr[300], inst[400];
20001 WORD pathmax =
sizeof (path) - 1, pathlen;
20002 DWORD usecnt, mincnt;
20006 GetModuleFileName(hModule, dllbuf,
sizeof (dllbuf));
20007 p = strrchr(dllbuf,
'\\');
20008 dllname = p ? (p + 1) : dllbuf;
20009 quiet = cmdline && strstr(cmdline,
"quiet");
20010 if (SQLInstallDriverManager(path, pathmax, &pathlen)) {
20011 sprintf(driver,
"%s;Driver=%s;Setup=%s;",
20012 drivername, dllname, dllname);
20022 SQLInstallDriverEx(driver, NULL, path, pathmax, NULL,
20023 ODBC_INSTALL_INQUIRY, &usecnt);
20024 pathlen = strlen(path);
20025 while (pathlen > 0 && path[pathlen - 1] ==
'\\') {
20027 path[pathlen] =
'\0';
20029 sprintf(driver,
"%s;Driver=%s\\%s;Setup=%s\\%s;",
20030 drivername, path, dllname, path, dllname);
20038 sprintf(inst,
"%s\\%s", path, dllname);
20039 if (!
remove && usecnt > 0) {
20041 if (GetFileAttributesA(dllbuf) != INVALID_FILE_ATTRIBUTES &&
20042 CopyFile(dllbuf, inst, 0)) {
20046 sprintf(buf,
"%s replaced.", drivername);
20047 MessageBox(NULL, buf,
"Info",
20048 MB_ICONINFORMATION | MB_OK | MB_TASKMODAL |
20054 mincnt =
remove ? 1 : 0;
20055 while (usecnt != mincnt) {
20056 if (!SQLRemoveDriver(driver, TRUE, &usecnt)) {
20061 if (usecnt && !SQLRemoveDriver(driver, TRUE, &usecnt)) {
20062 InUnError(
"SQLRemoveDriver");
20070 sprintf(buf,
"%s uninstalled.", drivername);
20071 MessageBox(NULL, buf,
"Info",
20072 MB_ICONINFORMATION |MB_OK | MB_TASKMODAL |
20076 sprintf(attr,
"DSN=%s;Database=;", dsname);
20084 SQLConfigDataSource(NULL, ODBC_REMOVE_SYS_DSN, drivername, attr);
20087 if (GetFileAttributesA(dllbuf) == INVALID_FILE_ATTRIBUTES) {
20090 if (strcasecmp(dllbuf, inst) != 0 && !CopyFile(dllbuf, inst, 0)) {
20093 sprintf(buf,
"Copy %s to %s failed.", dllbuf, inst);
20094 MessageBox(NULL, buf,
"CopyFile",
20095 MB_ICONSTOP |MB_OK | MB_TASKMODAL | MB_SETFOREGROUND);
20098 if (!SQLInstallDriverEx(driver, path, path, pathmax, &pathlen,
20099 ODBC_INSTALL_COMPLETE, &usecnt)) {
20100 InUnError(
"SQLInstallDriverEx");
20103 sprintf(attr,
"DSN=%s;Database=;", dsname);
20111 SQLConfigDataSource(NULL, ODBC_REMOVE_SYS_DSN, drivername, attr);
20112 if (!SQLConfigDataSource(NULL, ODBC_ADD_SYS_DSN, drivername, attr)) {
20113 InUnError(
"SQLConfigDataSource");
20119 sprintf(buf,
"%s installed.", drivername);
20120 MessageBox(NULL, buf,
"Info",
20121 MB_ICONINFORMATION | MB_OK | MB_TASKMODAL |
20125 InUnError(
"SQLInstallDriverManager");
20140 install(HWND hwnd, HINSTANCE hinst, LPSTR lpszCmdLine,
int nCmdShow)
20142 InUn(0, lpszCmdLine);
20154 uninstall(HWND hwnd, HINSTANCE hinst, LPSTR lpszCmdLine,
int nCmdShow)
20156 InUn(1, lpszCmdLine);
20161 #ifndef WITHOUT_SHELL 20172 setargv(
int *argcp,
char ***argvp,
char *cmdline,
char *argv0)
20174 char *p, *arg, *argspace, **argv;
20175 int argc, size, inquote, copy, slashes;
20177 size = 2 + (argv0 ? 1 : 0);
20178 for (p = cmdline; *p !=
'\0'; p++) {
20189 argspace = malloc(size *
sizeof (
char *) + strlen(cmdline) + 1);
20190 argv = (
char **) argspace;
20191 argspace += size *
sizeof (
char *);
20195 argv[argc++] = argv0;
20198 for (; argc < size; argc++) {
20199 argv[argc] = arg = argspace;
20210 while (*p ==
'\\') {
20215 if ((slashes & 1) == 0) {
20217 if (inquote && p[1] ==
'"') {
20221 inquote = !inquote;
20231 if (*p ==
'\0' || (!inquote &&
ISSPACE(*p))) {
20241 argspace = arg + 1;
20257 shell(HWND hwnd, HINSTANCE hinst, LPSTR lpszCmdLine,
int nCmdShow)
20259 int argc, needcon = 0;
20261 extern int sqlite3_main(
int,
char **);
20262 static const char *name =
"SQLite3 Shell";
20263 DWORD ftype0, ftype1, ftype2;
20265 ftype0 = GetFileType(GetStdHandle(STD_INPUT_HANDLE));
20266 ftype1 = GetFileType(GetStdHandle(STD_OUTPUT_HANDLE));
20267 ftype2 = GetFileType(GetStdHandle(STD_ERROR_HANDLE));
20268 if (ftype0 != FILE_TYPE_DISK && ftype0 != FILE_TYPE_CHAR &&
20269 ftype0 != FILE_TYPE_PIPE) {
20272 ftype0 = FILE_TYPE_UNKNOWN;
20274 if (ftype1 != FILE_TYPE_DISK && ftype1 != FILE_TYPE_CHAR &&
20275 ftype1 != FILE_TYPE_PIPE) {
20278 ftype1 = FILE_TYPE_UNKNOWN;
20280 if (ftype2 != FILE_TYPE_DISK && ftype2 != FILE_TYPE_CHAR &&
20281 ftype2 != FILE_TYPE_PIPE) {
20284 ftype2 = FILE_TYPE_UNKNOWN;
20288 SetConsoleTitle(name);
20290 if (ftype0 == FILE_TYPE_UNKNOWN) {
20291 freopen(
"CONIN$",
"r", stdin);
20293 if (ftype1 == FILE_TYPE_UNKNOWN) {
20294 freopen(
"CONOUT$",
"w", stdout);
20296 if (ftype2 == FILE_TYPE_UNKNOWN) {
20297 freopen(
"CONOUT$",
"w", stderr);
20299 setargv(&argc, &argv, lpszCmdLine, (
char *) name);
20300 #if defined(ENABLE_NVFS) && (ENABLE_NVFS) 20303 sqlite3_main(argc, argv);
20310 #if defined(HAVE_ODBCINSTEXT_H) && (HAVE_ODBCINSTEXT_H) 20317 #include <odbcinstext.h> 20320 ODBCINSTGetProperties(HODBCINSTPROPERTY prop)
20322 static const char *instYN[] = {
"No",
"Yes", NULL };
20323 static const char *syncPragma[] = {
"NORMAL",
"OFF",
"FULL", NULL };
20324 static const char *jmPragma[] = {
20325 "DELETE",
"PERSIST",
"OFF",
"TRUNCATE",
"MEMORY",
"WAL", NULL
20328 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20329 prop = prop->pNext;
20330 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20331 prop->nPromptType = ODBCINST_PROMPTTYPE_FILENAME;
20332 strncpy(prop->szName,
"Database", INI_MAX_PROPERTY_NAME);
20333 strncpy(prop->szValue,
"", INI_MAX_PROPERTY_VALUE);
20334 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20335 prop = prop->pNext;
20336 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20337 prop->nPromptType = ODBCINST_PROMPTTYPE_TEXTEDIT;
20338 strncpy(prop->szName,
"Timeout", INI_MAX_PROPERTY_NAME);
20339 strncpy(prop->szValue,
"100000", INI_MAX_PROPERTY_VALUE);
20340 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20341 prop = prop->pNext;
20342 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20343 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20344 prop->aPromptData = malloc(
sizeof (instYN));
20345 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20346 strncpy(prop->szName,
"StepAPI", INI_MAX_PROPERTY_NAME);
20347 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20348 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20349 prop = prop->pNext;
20350 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20351 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20352 prop->aPromptData = malloc(
sizeof (instYN));
20353 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20354 strncpy(prop->szName,
"ShortNames", INI_MAX_PROPERTY_NAME);
20355 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20356 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20357 prop = prop->pNext;
20358 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20359 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20360 prop->aPromptData = malloc(
sizeof (instYN));
20361 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20362 strncpy(prop->szName,
"LongNames", INI_MAX_PROPERTY_NAME);
20363 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20364 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20365 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20366 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20367 prop->aPromptData = malloc(
sizeof (instYN));
20368 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20369 strncpy(prop->szName,
"NoCreat", INI_MAX_PROPERTY_NAME);
20370 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20372 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20373 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20374 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20375 prop->aPromptData = malloc(
sizeof (instYN));
20376 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20377 strncpy(prop->szName,
"NoWCHAR", INI_MAX_PROPERTY_NAME);
20378 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20380 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20381 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20382 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20383 prop->aPromptData = malloc(
sizeof (instYN));
20384 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20385 strncpy(prop->szName,
"FKSupport", INI_MAX_PROPERTY_NAME);
20386 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20387 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20388 prop = prop->pNext;
20389 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20390 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20391 prop->aPromptData = malloc(
sizeof (syncPragma));
20392 memcpy(prop->aPromptData, syncPragma, sizeof (syncPragma));
20393 strncpy(prop->szName,
"SyncPragma", INI_MAX_PROPERTY_NAME);
20394 strncpy(prop->szValue,
"NORMAL", INI_MAX_PROPERTY_VALUE);
20395 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20396 prop = prop->pNext;
20397 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20398 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20399 prop->aPromptData = malloc(
sizeof (jmPragma));
20400 memcpy(prop->aPromptData, jmPragma, sizeof (jmPragma));
20401 strncpy(prop->szName,
"JournalMode", INI_MAX_PROPERTY_NAME);
20402 strncpy(prop->szValue,
"DELETE", INI_MAX_PROPERTY_VALUE);
20403 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20404 prop = prop->pNext;
20405 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20406 prop->nPromptType = ODBCINST_PROMPTTYPE_TEXTEDIT;
20407 strncpy(prop->szName,
"LoadExt", INI_MAX_PROPERTY_NAME);
20408 strncpy(prop->szValue,
"", INI_MAX_PROPERTY_VALUE);
20409 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20410 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20411 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20412 prop->aPromptData = malloc(
sizeof (instYN));
20413 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20414 strncpy(prop->szName,
"BigInt", INI_MAX_PROPERTY_NAME);
20415 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20421 #ifdef SQLITE_DYNLOAD 20435 return SQLITE_ERROR;
20444 static sqlite_int64
20462 static const char *
20471 return SQLITE_NULL;
20474 #define DLS_ENT(name, func) \ 20475 { "sqlite3_" #name, offsetof(struct dl_sqlite3_funcs, name), \ 20478 #define DLS_ENT3(name, off, func) \ 20479 { "sqlite3_" #name, offsetof(struct dl_sqlite3_funcs, off), \ 20482 #define DLS_END { NULL, 0, NULL } 20488 } dls_nametab[] = {
20489 DLS_ENT(activate_see, dls_void),
20490 DLS_ENT(bind_blob, dls_error),
20491 DLS_ENT(bind_double, dls_error),
20492 DLS_ENT(bind_int, dls_error),
20493 DLS_ENT(bind_int64, dls_error),
20494 DLS_ENT(bind_null, dls_error),
20495 DLS_ENT(bind_parameter_count, dls_0),
20496 DLS_ENT(bind_text, dls_error),
20498 DLS_ENT(changes, dls_0),
20499 DLS_ENT(close, dls_error),
20500 DLS_ENT(column_blob, dls_null),
20501 DLS_ENT(column_bytes, dls_0),
20502 DLS_ENT(column_count, dls_0),
20503 DLS_ENT(column_database_name, dls_empty),
20504 DLS_ENT(column_decltype, dls_empty),
20505 DLS_ENT(column_double, dls_00),
20506 DLS_ENT(column_name, dls_empty),
20507 DLS_ENT(column_origin_name, dls_null),
20508 DLS_ENT(column_table_name, dls_null),
20509 DLS_ENT(column_text, dls_null),
20510 DLS_ENT(column_type, dls_snull),
20511 DLS_ENT(create_function, dls_error),
20512 DLS_ENT(enable_load_extension, dls_error),
20513 DLS_ENT(errcode, dls_error),
20514 DLS_ENT(errmsg, dls_empty),
20515 DLS_ENT(exec, dls_error),
20516 DLS_ENT(finalize, dls_error),
20517 DLS_ENT(free, free),
20518 DLS_ENT(free_table, dls_void),
20519 DLS_ENT(get_table, dls_error),
20520 DLS_ENT(interrupt, dls_void),
20521 DLS_ENT(key, dls_error),
20522 DLS_ENT(last_insert_rowid, dls_0LL),
20523 DLS_ENT(libversion, dls_empty),
20524 DLS_ENT(load_extension, dls_error),
20525 DLS_ENT(malloc, malloc),
20526 DLS_ENT(mprintf, dls_null),
20527 DLS_ENT(open, dls_error),
20528 DLS_ENT(open16, dls_error),
20529 DLS_ENT(open_v2, dls_error),
20530 DLS_ENT(prepare, dls_error),
20531 DLS_ENT(prepare_v2, dls_error),
20532 DLS_ENT(profile, dls_null),
20533 DLS_ENT(realloc, realloc),
20534 DLS_ENT(rekey, dls_error),
20535 DLS_ENT(reset, dls_error),
20536 DLS_ENT(result_blob, dls_void),
20537 DLS_ENT(result_error, dls_void),
20538 DLS_ENT(result_int, dls_void),
20539 DLS_ENT(result_null, dls_void),
20540 DLS_ENT(step, dls_error),
20541 #if defined(_WIN32) || defined(_WIN64) 20542 DLS_ENT3(strnicmp, xstrnicmp, _strnicmp),
20544 DLS_ENT3(strnicmp, xstrnicmp, strncasecmp),
20546 DLS_ENT(table_column_metadata, dls_error),
20547 DLS_ENT(trace, dls_null),
20548 DLS_ENT(user_data, dls_null),
20549 DLS_ENT(value_blob, dls_null),
20550 DLS_ENT(value_bytes, dls_0),
20551 DLS_ENT(value_text, dls_empty),
20552 DLS_ENT(value_type, dls_snull),
20556 #if defined(_WIN32) || defined(_WIN64) 20558 static HMODULE sqlite3_dll = 0;
20564 static const char *dll_names[] = {
20565 "System.Data.SQLite.dll",
20571 while (dll_names[i]) {
20572 sqlite3_dll = LoadLibrary(dll_names[i]);
20579 while (dls_nametab[i].name) {
20580 void *func = 0, **loc;
20583 func = (
void *) GetProcAddress(sqlite3_dll, dls_nametab[i].name);
20586 func = dls_nametab[i].func;
20588 loc = (
void **) ((
char *) &dls_funcs + dls_nametab[i].offset);
20592 if (!sqlite3_dll) {
20593 char buf[MAXPATHLEN], msg[MAXPATHLEN];
20595 LoadString(hModule, IDS_DRVTITLE, buf,
sizeof (buf));
20596 LoadString(hModule, IDS_DLLERR, msg,
sizeof (msg));
20597 MessageBox(NULL, msg, buf,
20598 MB_ICONEXCLAMATION | MB_OK | MB_TASKMODAL |
20607 FreeLibrary(sqlite3_dll);
20616 static void *libsqlite3_so = 0;
20623 libsqlite3_so = dlopen(
"libsqlite3.so.0", RTLD_NOW | RTLD_GLOBAL);
20625 while (dls_nametab[i].name) {
20626 void *func = 0, **loc;
20628 if (libsqlite3_so) {
20629 func = dlsym(libsqlite3_so, dls_nametab[i].name);
20632 func = dls_nametab[i].func;
20634 loc = (
void **) ((
char *) &dls_funcs + dls_nametab[i].offset);
20638 if (!libsqlite3_so) {
20639 const char errmsg[] =
"SQLite3 shared library not found.\n";
20641 write(2, errmsg,
sizeof (errmsg) - 1);
20648 if (libsqlite3_so) {
20649 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 a string double 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.