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(WINTERFACE) && !defined(_WIN32) && !defined(_WIN64)
243 #define SCOL_VARCHAR SQL_WVARCHAR
244 #define SCOL_CHAR SQL_WCHAR
246 #define SCOL_VARCHAR SQL_VARCHAR
247 #define SCOL_CHAR SQL_CHAR
250 #define ENV_MAGIC 0x53544145
251 #define DBC_MAGIC 0x53544144
252 #define DEAD_MAGIC 0xdeadbeef
267 static const char *
xdigits =
"0123456789ABCDEFabcdef";
272 xmalloc_(
int n,
char *file,
int line)
274 int nn = n + 4 *
sizeof (long);
279 #if (MEMORY_DEBUG > 1)
280 fprintf(stderr,
"malloc\t%d\tNULL\t%s:%d\n", n, file, line);
285 nn = nn /
sizeof (long) - 1;
288 #if (MEMORY_DEBUG > 1)
289 fprintf(stderr,
"malloc\t%d\t%p\t%s:%d\n", n, &p[2], file, line);
291 return (
void *) &p[2];
295 xrealloc_(
void *old,
int n,
char *file,
int line)
297 int nn = n + 4 *
sizeof (long), nnn;
300 if (n == 0 || !old) {
301 return xmalloc_(n, file, line);
303 p = &((
long *) old)[-2];
304 if (p[0] != 0xdead1234) {
305 fprintf(stderr,
"*** low end corruption @ %p\n", old);
308 nnn = p[1] + 4 *
sizeof (long);
309 nnn = nnn /
sizeof (long) - 1;
310 if (p[nnn] != 0xdead5678) {
311 fprintf(stderr,
"*** high end corruption @ %p\n", old);
316 #if (MEMORY_DEBUG > 1)
317 fprintf(stderr,
"realloc\t%p,%d\tNULL\t%s:%d\n", old, n, file, line);
321 #if (MEMORY_DEBUG > 1)
322 fprintf(stderr,
"realloc\t%p,%d\t%p\t%s:%d\n", old, n, &pp[2], file, line);
326 nn = nn /
sizeof (long) - 1;
328 return (
void *) &p[2];
332 xfree_(
void *x,
char *file,
int line)
340 p = &((
long *) x)[-2];
341 if (p[0] != 0xdead1234) {
342 fprintf(stderr,
"*** low end corruption @ %p\n", x);
345 n = p[1] + 4 *
sizeof (long);
346 n = n /
sizeof (long) - 1;
347 if (p[n] != 0xdead5678) {
348 fprintf(stderr,
"*** high end corruption @ %p\n", x);
351 #if (MEMORY_DEBUG > 1)
352 fprintf(stderr,
"free\t%p\t\t%s:%d\n", x, file, line);
360 xfree_(x,
"unknown location", 0);
364 xstrdup_(
const char *str,
char *file,
int line)
369 #if (MEMORY_DEBUG > 1)
370 fprintf(stderr,
"strdup\tNULL\tNULL\t%s:%d\n", file, line);
374 p = xmalloc_(strlen(str) + 1, file, line);
378 #if (MEMORY_DEBUG > 1)
379 fprintf(stderr,
"strdup\t%p\t%p\t%s:%d\n", str, p, file, line);
384 #define xmalloc(x) xmalloc_(x, __FILE__, __LINE__)
385 #define xrealloc(x,y) xrealloc_(x, y, __FILE__, __LINE__)
386 #define xfree(x) xfree_(x, __FILE__, __LINE__)
387 #define xstrdup(x) xstrdup_(x, __FILE__, __LINE__)
391 #define xmalloc(x) sqlite3_malloc(x)
392 #define xrealloc(x,y) sqlite3_realloc(x, y)
393 #define xfree(x) sqlite3_free(x)
394 #define xstrdup(x) strdup_(x)
398 #if defined(_WIN32) || defined(_WIN64)
400 #define vsnprintf _vsnprintf
401 #define snprintf _snprintf
402 #define strcasecmp _stricmp
403 #define strncasecmp _strnicmp
406 #define strtoll _strtoi64
407 #define strtoull _strtoui64
410 static HINSTANCE NEAR hModule;
414 #ifdef HAVE_SQLITE3STRNICMP
416 #define strncasecmp(A,B,C) sqlite3_strnicmp(A,B,C)
418 #define strcasecmp(A,B) strcasecmp_(A,B)
420 #if defined(__GNUC__) && (__GNUC__ >= 2)
421 static int strcasecmp_(
const char *a,
const char *b)
422 __attribute__((__unused__));
425 static int strcasecmp_(
const char *a,
const char *b)
427 int c = strlen(a), d = strlen(b);
430 return strncasecmp(a, b, c);
432 return strncasecmp(a, b, d);
436 #if defined(_WIN32) || defined(_WIN64)
444 #define HDBC_LOCK(hdbc) \
448 if ((hdbc) == SQL_NULL_HDBC) { \
449 return SQL_INVALID_HANDLE; \
451 d = (DBC *) (hdbc); \
452 if (d->magic != DBC_MAGIC) { \
453 return SQL_INVALID_HANDLE; \
455 EnterCriticalSection(&d->cs); \
456 d->owner = GetCurrentThreadId(); \
459 #define HDBC_UNLOCK(hdbc) \
460 if ((hdbc) != SQL_NULL_HDBC) { \
463 d = (DBC *) (hdbc); \
464 if (d->magic == DBC_MAGIC) { \
466 LeaveCriticalSection(&d->cs); \
470 #define HSTMT_LOCK(hstmt) \
474 if ((hstmt) == SQL_NULL_HSTMT) { \
475 return SQL_INVALID_HANDLE; \
477 d = (DBC *) ((STMT *) (hstmt))->dbc; \
478 if (d->magic != DBC_MAGIC) { \
479 return SQL_INVALID_HANDLE; \
481 EnterCriticalSection(&d->cs); \
482 d->owner = GetCurrentThreadId(); \
485 #define HSTMT_UNLOCK(hstmt) \
486 if ((hstmt) != SQL_NULL_HSTMT) { \
489 d = (DBC *) ((STMT *) (hstmt))->dbc; \
490 if (d->magic == DBC_MAGIC) { \
492 LeaveCriticalSection(&d->cs); \
518 #define HDBC_LOCK(hdbc)
519 #define HDBC_UNLOCK(hdbc)
520 #define HSTMT_LOCK(hdbc)
521 #define HSTMT_UNLOCK(hdbc)
525 #if defined(ENABLE_NVFS) && (ENABLE_NVFS)
526 extern void nvfs_init(
void);
527 extern const char *nvfs_makevfs(
const char *);
541 char *p = strchr(upper_chars, c);
557 ((c) && strchr(digit_chars, (c)) != NULL)
566 ((c) && strchr(space_chars, (c)) != NULL)
587 static SQLRETURN
getrowdata(
STMT *s, SQLUSMALLINT col, SQLSMALLINT otype,
588 SQLPOINTER val, SQLINTEGER len,
SQLLEN *lenp,
591 #if (defined(_WIN32) || defined(_WIN64)) && defined(WINTERFACE)
593 static COL *statSpec2P, *statSpec3P;
596 #if (MEMORY_DEBUG < 1)
651 if (dsp->
len + len > dsp->
max) {
652 int max = dsp->
max + len + 256;
656 strcpy(dsp->
buffer,
"OUT OF MEMORY");
688 for (p = str; *p; ++p) {
710 if (dsp->
len + len > dsp->
max) {
711 int max = dsp->
max + len + 256;
715 strcpy(dsp->
buffer,
"OUT OF MEMORY");
724 for (p = str, q = dsp->
buffer + dsp->
len; *p; ++p) {
745 return (
const char *) dsp->
buffer;
759 return !dsp || dsp->
oom;
834 ucLen = ucLen /
sizeof (SQLWCHAR);
835 if (!uc || ucLen < 0) {
845 while (i < len && *str && i < ucLen) {
846 unsigned char c = str[0];
851 }
else if (c <= 0xc1 || c >= 0xf5) {
854 }
else if (c < 0xe0) {
855 if ((str[1] & 0xc0) == 0x80) {
856 unsigned long t = ((c & 0x1f) << 6) | (str[1] & 0x3f);
864 }
else if (c < 0xf0) {
865 if ((str[1] & 0xc0) == 0x80 && (str[2] & 0xc0) == 0x80) {
866 unsigned long t = ((c & 0x0f) << 12) |
867 ((str[1] & 0x3f) << 6) | (str[2] & 0x3f);
875 }
else if (c < 0xf8) {
876 if ((str[1] & 0xc0) == 0x80 && (str[2] & 0xc0) == 0x80 &&
877 (str[3] & 0xc0) == 0x80) {
878 unsigned long t = ((c & 0x03) << 18) |
879 ((str[1] & 0x3f) << 12) | ((str[2] & 0x3f) << 6) |
882 if (
sizeof (SQLWCHAR) == 2 *
sizeof (char) &&
885 uc[i++] = 0xd800 | ((t >> 10) & 0x3ff);
889 t = 0xdc00 | (t & 0x3ff);
897 }
else if (c < 0xfc) {
898 if ((str[1] & 0xc0) == 0x80 && (str[2] & 0xc0) == 0x80 &&
899 (str[3] & 0xc0) == 0x80 && (str[4] & 0xc0) == 0x80) {
900 unsigned long t = ((c & 0x01) << 24) |
901 ((str[1] & 0x3f) << 18) | ((str[2] & 0x3f) << 12) |
902 ((str[3] & 0x3f) << 6) | (str[4] & 0x3f);
904 if (
sizeof (SQLWCHAR) == 2 *
sizeof (char) &&
907 uc[i++] = 0xd800 | ((t >> 10) & 0x3ff);
911 t = 0xdc00 | (t & 0x3ff);
944 if (len == SQL_NTS) {
945 len = strlen((
char *) str);
947 ucLen =
sizeof (SQLWCHAR) * (len + 1);
967 char *cp, *ret = NULL;
972 if (len == SQL_NTS) {
975 len = len /
sizeof (SQLWCHAR);
982 for (i = 0; i < len; i++) {
983 unsigned long c = str[i];
985 if (
sizeof (SQLWCHAR) == 2 *
sizeof (
char)) {
990 }
else if (c < 0x800) {
991 *cp++ = 0xc0 | ((c >> 6) & 0x1f);
992 *cp++ = 0x80 | (c & 0x3f);
993 }
else if (c < 0x10000) {
994 if (
sizeof (SQLWCHAR) == 2 *
sizeof (char) &&
995 c >= 0xd800 && c <= 0xdbff && i + 1 < len) {
996 unsigned long c2 = str[i + 1] & 0xffff;
998 if (c2 >= 0xdc00 && c2 <= 0xdfff) {
999 c = (((c & 0x3ff) << 10) | (c2 & 0x3ff)) + 0x10000;
1000 *cp++ = 0xf0 | ((c >> 18) & 0x07);
1001 *cp++ = 0x80 | ((c >> 12) & 0x3f);
1002 *cp++ = 0x80 | ((c >> 6) & 0x3f);
1003 *cp++ = 0x80 | (c & 0x3f);
1008 *cp++ = 0xe0 | ((c >> 12) & 0x0f);
1009 *cp++ = 0x80 | ((c >> 6) & 0x3f);
1010 *cp++ = 0x80 | (c & 0x3f);
1011 }
else if (c < 0x200000) {
1012 *cp++ = 0xf0 | ((c >> 18) & 0x07);
1013 *cp++ = 0x80 | ((c >> 12) & 0x3f);
1014 *cp++ = 0x80 | ((c >> 6) & 0x3f);
1015 *cp++ = 0x80 | (c & 0x3f);
1016 }
else if (c < 0x4000000) {
1017 *cp++ = 0xf8 | ((c >> 24) & 0x03);
1018 *cp++ = 0x80 | ((c >> 18) & 0x3f);
1019 *cp++ = 0x80 | ((c >> 12) & 0x3f);
1020 *cp++ = 0x80 | ((c >> 6) & 0x3f);
1021 *cp++ = 0x80 | (c & 0x3f);
1022 }
else if (c < 0x80000000) {
1023 *cp++ = 0xfc | ((c >> 31) & 0x01);
1024 *cp++ = 0x80 | ((c >> 24) & 0x3f);
1025 *cp++ = 0x80 | ((c >> 18) & 0x3f);
1026 *cp++ = 0x80 | ((c >> 12) & 0x3f);
1027 *cp++ = 0x80 | ((c >> 6) & 0x3f);
1028 *cp++ = 0x80 | (c & 0x3f);
1049 if (len != SQL_NTS) {
1050 len = len *
sizeof (SQLWCHAR);
1057 #if defined(WCHARSUPPORT) || defined(_WIN32) || defined(_WIN64)
1074 #if defined(_WIN32) || defined(_WIN64)
1084 wmb_to_utf(
char *str,
int len)
1088 int nchar, is2k, cp = CP_OEMCP;
1090 ovi.dwOSVersionInfoSize =
sizeof (ovi);
1092 is2k = ovi.dwPlatformId == VER_PLATFORM_WIN32_NT && ovi.dwMajorVersion > 4;
1093 if (AreFileApisANSI()) {
1094 cp = is2k ? CP_THREAD_ACP : CP_ACP;
1096 nchar = MultiByteToWideChar(cp, 0, str, len, NULL, 0);
1097 wstr =
xmalloc((nchar + 1) *
sizeof (WCHAR));
1102 nchar = MultiByteToWideChar(cp, 0, str, len, wstr, nchar);
1104 str =
xmalloc((nchar + 1) * 7);
1110 nchar = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, str, nchar * 7, 0, 0);
1126 wmb_to_utf_c(
char *str,
int len)
1128 if (len == SQL_NTS) {
1131 return wmb_to_utf(str, len);
1144 utf_to_wmb(
char *str,
int len)
1148 int nchar, is2k, cp = CP_OEMCP;
1150 ovi.dwOSVersionInfoSize =
sizeof (ovi);
1152 is2k = ovi.dwPlatformId == VER_PLATFORM_WIN32_NT && ovi.dwMajorVersion > 4;
1153 if (AreFileApisANSI()) {
1154 cp = is2k ? CP_THREAD_ACP : CP_ACP;
1156 nchar = MultiByteToWideChar(CP_UTF8, 0, str, len, NULL, 0);
1157 wstr =
xmalloc((nchar + 1) *
sizeof (WCHAR));
1162 nchar = MultiByteToWideChar(CP_UTF8, 0, str, len, wstr, nchar);
1164 str =
xmalloc((nchar + 1) * 7);
1170 nchar = WideCharToMultiByte(cp, 0, wstr, -1, str, nchar * 7, 0, 0);
1186 wmb_to_uc(
char *str,
int len)
1190 int nchar, is2k, cp = CP_OEMCP;
1192 ovi.dwOSVersionInfoSize =
sizeof (ovi);
1194 is2k = ovi.dwPlatformId == VER_PLATFORM_WIN32_NT && ovi.dwMajorVersion > 4;
1195 if (AreFileApisANSI()) {
1196 cp = is2k ? CP_THREAD_ACP : CP_ACP;
1198 nchar = MultiByteToWideChar(cp, 0, str, len, NULL, 0);
1199 wstr =
xmalloc((nchar + 1) *
sizeof (WCHAR));
1204 nchar = MultiByteToWideChar(cp, 0, str, len, wstr, nchar);
1217 uc_to_wmb(WCHAR *wstr,
int len)
1221 int nchar, is2k, cp = CP_OEMCP;
1223 ovi.dwOSVersionInfoSize =
sizeof (ovi);
1225 is2k = ovi.dwPlatformId == VER_PLATFORM_WIN32_NT && ovi.dwMajorVersion > 4;
1226 if (AreFileApisANSI()) {
1227 cp = is2k ? CP_THREAD_ACP : CP_ACP;
1229 nchar = WideCharToMultiByte(cp, 0, wstr, len, NULL, 0, 0, 0);
1230 str =
xmalloc((nchar + 1) * 2);
1235 nchar = WideCharToMultiByte(cp, 0, wstr, len, str, nchar * 2, 0, 0);
1245 #ifdef USE_DLOPEN_FOR_GPPS
1249 #define SQLGetPrivateProfileString(A,B,C,D,E,F) drvgpps(d,A,B,C,D,E,F)
1264 lib = dlopen(
"libodbcinst.so.1", RTLD_LAZY);
1266 lib = dlopen(
"libodbcinst.so", RTLD_LAZY);
1269 lib = dlopen(
"libiodbcinst.so.2", RTLD_LAZY);
1272 lib = dlopen(
"libiodbcinst.so", RTLD_LAZY);
1275 gpps = (int (*)()) dlsym(lib,
"SQLGetPrivateProfileString");
1289 dlclose(d->instlib);
1295 drvgpps(
DBC *d,
char *sect,
char *ent,
char *def,
char *buf,
1296 int bufsiz,
char *fname)
1299 return d->gpps(sect, ent, def, buf, bufsiz, fname);
1301 strncpy(buf, def, bufsiz);
1302 buf[bufsiz - 1] =
'\0';
1306 #include <odbcinst.h>
1307 #define drvgetgpps(d)
1308 #define drvrelgpps(d)
1320 if (stmt && p && nparams > 0) {
1321 for (i = 0; i < nparams; i++, p++) {
1325 sqlite3_bind_null(stmt, i + 1);
1327 fprintf(d->
trace,
"-- parameter %d: NULL\n", i + 1);
1332 sqlite3_bind_text(stmt, i + 1, p->
s3val, p->
s3size,
1335 fprintf(d->
trace,
"-- parameter %d: '%*s'\n", i + 1,
1341 sqlite3_bind_blob(stmt, i + 1, p->
s3val, p->
s3size,
1344 fprintf(d->
trace,
"-- parameter %d: [BLOB]'\n", i + 1);
1349 sqlite3_bind_double(stmt, i + 1, p->
s3dval);
1351 fprintf(d->
trace,
"-- parameter %d: %g\n",
1356 case SQLITE_INTEGER:
1357 if (p->
s3size > sizeof (
int)) {
1358 sqlite3_bind_int64(stmt, i + 1, p->
s3lival);
1362 "-- parameter %d: %I64d\n",
1364 "-- parameter %d: %lld\n",
1370 sqlite3_bind_int(stmt, i + 1, p->
s3ival);
1372 fprintf(d->
trace,
"-- parameter %d: %d\n",
1414 if (t->
nrow == 0 && rc == SQLITE_ROW) {
1421 int nalloc = t->
nalloc * 2 + need + 1;
1426 t->
rc = SQLITE_NOMEM;
1435 for (i = 0; i < ncol; i++) {
1436 p = (
char *) sqlite3_column_name(t->
stmt, i);
1438 char *q =
xmalloc(strlen(p) + 1);
1455 }
else if (t->
ncol != ncol) {
1456 t->
errmsg = sqlite3_mprintf(
"drvgettable() called with two or"
1457 " more incompatible queries");
1458 t->
rc = SQLITE_ERROR;
1462 if (rc == SQLITE_ROW) {
1463 for (i = 0; i < ncol; i++) {
1464 int coltype = sqlite3_column_type(t->
stmt, i);
1467 if (coltype == SQLITE_BLOB) {
1468 int k, nbytes = sqlite3_column_bytes(t->
stmt, i);
1470 unsigned const char *bp;
1472 bp = sqlite3_column_blob(t->
stmt, i);
1480 for (k = 0; k < nbytes; k++) {
1481 *qp++ =
xdigits[(bp[k] >> 4)];
1482 *qp++ =
xdigits[(bp[k] & 0xF)];
1487 }
else if (coltype == SQLITE_FLOAT) {
1488 static struct lconv *lc = 0;
1489 double val = sqlite3_column_double(t->
stmt, i);
1497 snprintf(buffer,
sizeof (buffer),
"%.15g", val);
1501 if (lc && lc->decimal_point && lc->decimal_point[0] &&
1502 lc->decimal_point[0] !=
'.') {
1503 p = strchr(buffer, lc->decimal_point[0]);
1513 }
else if (coltype != SQLITE_NULL) {
1514 p =
xstrdup((
char *) sqlite3_column_text(t->
stmt, i));
1528 int *ncolp,
char **errp,
int nparam,
BINDPARM *p)
1531 int rc = SQLITE_OK, keep = sql == NULL;
1533 const char *sqlleft = 0;
1534 int nretry = 0, haveerr = 0;
1537 return SQLITE_ERROR;
1551 tres.rc = SQLITE_OK;
1552 tres.resarr =
xmalloc(
sizeof (
char *) * tres.nalloc);
1556 return SQLITE_NOMEM;
1561 if (tres.stmt == NULL) {
1562 return SQLITE_NOMEM;
1566 while (sql && *sql && (rc == SQLITE_OK ||
1567 (rc == SQLITE_SCHEMA && (++nretry) < 2))) {
1571 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
1573 rc = sqlite3_prepare_v2(d->
sqlite, sql, -1, &tres.stmt, &sqlleft);
1576 rc = sqlite3_prepare(d->
sqlite, sql, -1, &tres.stmt, &sqlleft);
1578 if (rc != SQLITE_OK) {
1581 sqlite3_finalize(tres.stmt);
1592 if (sqlite3_bind_parameter_count(tres.stmt) != nparam) {
1595 sqlite3_mprintf(
"%s",
"parameter marker count incorrect");
1602 ncol = sqlite3_column_count(tres.stmt);
1608 rc = sqlite3_step(tres.stmt);
1609 if (rc == SQLITE_ROW || rc == SQLITE_DONE) {
1615 if (rc != SQLITE_ROW) {
1618 rc = sqlite3_reset(tres.stmt);
1622 rc = sqlite3_finalize(tres.stmt);
1625 if (rc != SQLITE_SCHEMA) {
1628 while (sql &&
ISSPACE(*sql)) {
1632 if (rc == SQLITE_DONE) {
1644 sqlite3_reset(tres.stmt);
1649 sqlite3_finalize(tres.stmt);
1654 }
else if (rc != SQLITE_OK && rc == sqlite3_errcode(d->
sqlite) && errp) {
1655 *errp = sqlite3_mprintf(
"%s", sqlite3_errmsg(d->
sqlite));
1660 tres.resarr[0] = (
char *) (tres.ndata - 1);
1662 if (rc == SQLITE_ABORT) {
1667 sqlite3_free(*errp);
1669 *errp = tres.errmsg;
1671 sqlite3_free(tres.errmsg);
1676 sqlite3_free(tres.errmsg);
1677 if (rc != SQLITE_OK) {
1681 *resp = &tres.resarr[1];
1699 #if defined(__GNUC__) && (__GNUC__ >= 2)
1700 static void setstatd(
DBC *,
int,
char *,
char *, ...)
1701 __attribute__((format (printf, 3, 5)));
1718 count = vsnprintf((
char *) d->
logmsg, sizeof (d->
logmsg), msg, ap);
1739 #if defined(__GNUC__) && (__GNUC__ >= 2)
1740 static void setstat(
STMT *,
int,
char *,
char *, ...)
1741 __attribute__((format (printf, 3, 5)));
1758 count = vsnprintf((
char *) s->
logmsg, sizeof (s->
logmsg), msg, ap);
1782 if (dbc == SQL_NULL_HDBC) {
1783 return SQL_INVALID_HANDLE;
1786 setstatd(d, -1,
"not supported",
"IM001");
1801 if (stmt == SQL_NULL_HSTMT) {
1802 return SQL_INVALID_HANDLE;
1805 setstat(s, -1,
"not supported",
"IM001");
1817 if (x && ((
char **) x)[0]) {
1818 xfree(((
char **) x)[0]);
1819 ((
char **) x)[0] = NULL;
1832 setstat(s, -1,
"out of memory", (*s->
ov3) ?
"HY000" :
"S1000");
1845 setstat(s, -1,
"not connected", (*s->
ov3) ?
"HY000" :
"S1000");
1856 #if defined(HAVE_LOCALECONV) || defined(_WIN32) || defined(_WIN64)
1861 static struct lconv *lc = 0;
1862 char buf[128], *p, *end;
1868 if (lc && lc->decimal_point && lc->decimal_point[0] &&
1869 lc->decimal_point[0] !=
'.') {
1870 strncpy(buf, data,
sizeof (buf) - 1);
1871 buf[
sizeof (buf) - 1] =
'\0';
1872 p = strchr(buf,
'.');
1874 *p = lc->decimal_point[0];
1880 value = strtod(p, &end);
1881 end = (
char *) data + (end - p);
1890 #define ln_strtod(A,B) strtod(A,B)
1903 int len = strlen(str);
1906 if ((str[0] ==
'\'' && str[len - 1] ==
'\'') ||
1907 (str[0] ==
'"' && str[len - 1] ==
'"') ||
1908 (str[0] ==
'[' && str[len - 1] ==
']')) {
1909 str[len - 1] =
'\0';
1910 strcpy(str, str + 1);
1931 while ((q = strchr(p,
'_')) != NULL) {
1932 if (q == str || q[-1] !=
'\\') {
1938 while ((q = strchr(p,
'%')) != NULL) {
1939 if (q == str || q[-1] !=
'\\') {
1945 while ((q = strchr(p,
'\\')) != NULL) {
1946 if (q[1] ==
'\\' || q[1] ==
'_' || q[1] ==
'%') {
1975 if (*str ==
'\0' && cp !=
'%') {
1979 while (*pat ==
'%') {
1987 if (cp !=
'_' && cp !=
'\\') {
2011 if (esc && cp ==
'\\' &&
2012 (pat[1] ==
'\\' || pat[1] ==
'%' || pat[1] ==
'_')) {
2041 #if !defined(_WIN32) && !defined(_WIN64)
2043 #ifdef HAVE_NANOSLEEP
2056 #if defined(_WIN32) || defined(_WIN64)
2057 d->
t0 = GetTickCount();
2059 gettimeofday(&tv, NULL);
2060 d->
t0 = tv.tv_sec * 1000 + tv.tv_usec / 1000;
2063 #if defined(_WIN32) || defined(_WIN64)
2064 t1 = GetTickCount();
2066 gettimeofday(&tv, NULL);
2067 t1 = tv.tv_sec * 1000 + tv.tv_usec / 1000;
2072 #if defined(_WIN32) || defined(_WIN64)
2075 #ifdef HAVE_NANOSLEEP
2077 ts.tv_nsec = 10000000;
2079 ret = nanosleep(&ts, &ts);
2080 if (ret < 0 && errno != EINTR) {
2090 select(0, NULL, NULL, NULL, &tv);
2113 int count = 0, step = 0,
max, rc = SQLITE_ERROR;
2115 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME)
2123 while (step <
max) {
2125 rc = sqlite3_exec(x,
"PRAGMA empty_result_callbacks = on;",
2127 if (rc == SQLITE_OK) {
2129 "PRAGMA foreign_keys = on;" :
2130 "PRAGMA foreign_keys = off;",
2133 }
else if (step < 2) {
2135 "PRAGMA full_column_names = off;" :
2136 "PRAGMA full_column_names = on;",
2138 }
else if (step < 3) {
2140 "PRAGMA short_column_names = on;" :
2141 "PRAGMA short_column_names = off;",
2144 if (rc != SQLITE_OK) {
2145 if (rc != SQLITE_BUSY ||
2177 for (i = 1; i <= size; i++) {
2194 mapsqltype(
const char *
typename,
int *nosign,
int ov3,
int nowchar,
2198 int testsign = 0, result;
2201 result = nowchar ? SQL_VARCHAR : SQL_WVARCHAR;
2203 result = SQL_VARCHAR;
2208 q = p =
xmalloc(strlen(
typename) + 1);
2212 strcpy(p,
typename);
2217 if (strncmp(p,
"inter", 5) == 0) {
2218 }
else if (strncmp(p,
"int", 3) == 0 ||
2219 strncmp(p,
"mediumint", 9) == 0) {
2221 result = SQL_INTEGER;
2222 }
else if (strncmp(p,
"numeric", 7) == 0) {
2223 result = SQL_DOUBLE;
2224 }
else if (strncmp(p,
"tinyint", 7) == 0) {
2226 result = SQL_TINYINT;
2227 }
else if (strncmp(p,
"smallint", 8) == 0) {
2229 result = SQL_SMALLINT;
2230 }
else if (strncmp(p,
"float", 5) == 0) {
2231 result = SQL_DOUBLE;
2232 }
else if (strncmp(p,
"double", 6) == 0 ||
2233 strncmp(p,
"real", 4) == 0) {
2234 result = SQL_DOUBLE;
2235 }
else if (strncmp(p,
"timestamp", 9) == 0) {
2236 #ifdef SQL_TYPE_TIMESTAMP
2237 result = ov3 ? SQL_TYPE_TIMESTAMP : SQL_TIMESTAMP;
2239 result = SQL_TIMESTAMP;
2241 }
else if (strncmp(p,
"datetime", 8) == 0) {
2242 #ifdef SQL_TYPE_TIMESTAMP
2243 result = ov3 ? SQL_TYPE_TIMESTAMP : SQL_TIMESTAMP;
2245 result = SQL_TIMESTAMP;
2247 }
else if (strncmp(p,
"time", 4) == 0) {
2248 #ifdef SQL_TYPE_TIME
2249 result = ov3 ? SQL_TYPE_TIME : SQL_TIME;
2253 }
else if (strncmp(p,
"date", 4) == 0) {
2254 #ifdef SQL_TYPE_DATE
2255 result = ov3 ? SQL_TYPE_DATE : SQL_DATE;
2259 #ifdef SQL_LONGVARCHAR
2260 }
else if (strncmp(p,
"text", 4) == 0 ||
2261 strncmp(p,
"memo", 4) == 0 ||
2262 strncmp(p,
"longvarchar", 11) == 0) {
2264 result = nowchar ? SQL_LONGVARCHAR : SQL_WLONGVARCHAR;
2266 result = SQL_LONGVARCHAR;
2269 }
else if (strncmp(p,
"wtext", 5) == 0 ||
2270 strncmp(p,
"wvarchar", 8) == 0 ||
2271 strncmp(p,
"longwvarchar", 12) == 0) {
2272 result = SQL_WLONGVARCHAR;
2276 }
else if (strncmp(p,
"bool", 4) == 0 ||
2277 strncmp(p,
"bit", 3) == 0) {
2281 }
else if (strncmp(p,
"bigint", 6) == 0) {
2283 result = SQL_BIGINT;
2285 }
else if (strncmp(p,
"blob", 4) == 0) {
2286 result = SQL_BINARY;
2287 }
else if (strncmp(p,
"varbinary", 9) == 0) {
2288 result = SQL_VARBINARY;
2289 }
else if (strncmp(p,
"longvarbinary", 13) == 0) {
2290 result = SQL_LONGVARBINARY;
2294 *nosign = strstr(p,
"unsigned") != NULL;
2300 if (dobigint && result == SQL_INTEGER) {
2301 result = SQL_BIGINT;
2318 getmd(
const char *
typename,
int sqltype,
int *mp,
int *dp)
2323 case SQL_INTEGER: m = 10; d = 9;
break;
2324 case SQL_TINYINT: m = 4; d = 3;
break;
2325 case SQL_SMALLINT: m = 6; d = 5;
break;
2326 case SQL_FLOAT: m = 25; d = 24;
break;
2327 case SQL_DOUBLE: m = 54; d = 53;
break;
2328 case SQL_VARCHAR: m = 255; d = 0;
break;
2331 case SQL_WVARCHAR: m = 255; d = 0;
break;
2334 #ifdef SQL_TYPE_DATE
2337 case SQL_DATE: m = 10; d = 0;
break;
2338 #ifdef SQL_TYPE_TIME
2341 case SQL_TIME: m = 8; d = 0;
break;
2342 #ifdef SQL_TYPE_TIMESTAMP
2343 case SQL_TYPE_TIMESTAMP:
2345 case SQL_TIMESTAMP: m = 32; d = 3;
break;
2346 #ifdef SQL_LONGVARCHAR
2347 case SQL_LONGVARCHAR : m = 65536; d = 0;
break;
2350 #ifdef SQL_WLONGVARCHAR
2351 case SQL_WLONGVARCHAR: m = 65536; d = 0;
break;
2355 case SQL_VARBINARY: m = 255; d = 0;
break;
2356 case SQL_LONGVARBINARY: m = 65536; d = 0;
break;
2358 case SQL_BIGINT: m = 20; d = 19;
break;
2361 case SQL_BIT: m = 1; d = 1;
break;
2364 if (m &&
typename) {
2368 if (sscanf(
typename,
"%*[^(](%d,%d %1[)]", &mm, &dd, clbr) == 3) {
2371 }
else if (sscanf(
typename,
"%*[^(](%d %1[)]", &mm, clbr) == 2) {
2372 if (sqltype == SQL_TIMESTAMP) {
2375 #ifdef SQL_TYPE_TIMESTAMP
2376 else if (sqltype == SQL_TYPE_TIMESTAMP) {
2405 if (type == SQL_C_DEFAULT) {
2408 type = (nosign > 0) ? SQL_C_ULONG : SQL_C_LONG;
2411 type = (nosign > 0) ? SQL_C_UTINYINT : SQL_C_TINYINT;
2414 type = (nosign > 0) ? SQL_C_USHORT : SQL_C_SHORT;
2420 type = SQL_C_DOUBLE;
2423 type = SQL_C_TIMESTAMP;
2431 #ifdef SQL_C_TYPE_TIMESTAMP
2432 case SQL_TYPE_TIMESTAMP:
2433 type = SQL_C_TYPE_TIMESTAMP;
2436 #ifdef SQL_C_TYPE_TIME
2438 type = SQL_C_TYPE_TIME;
2441 #ifdef SQL_C_TYPE_DATE
2443 type = SQL_C_TYPE_DATE;
2449 #ifdef SQL_WLONGVARCHAR
2450 case SQL_WLONGVARCHAR:
2452 type = nowchar ? SQL_C_CHAR : SQL_C_WCHAR;
2457 case SQL_LONGVARBINARY:
2458 type = SQL_C_BINARY;
2472 type = nowchar ? SQL_C_CHAR : SQL_C_WCHAR;
2494 fixupsql(
char *sql,
int sqlLen,
int cte,
int *nparam,
int *isselect,
2497 char *q = sql, *qz = NULL, *p, *inq = NULL, *out;
2498 int np = 0, isddl = -1, size;
2503 if (sqlLen != SQL_NTS) {
2508 memcpy(q, sql, sqlLen);
2512 size = strlen(sql) * 4;
2514 size +=
sizeof (
char *) - 1;
2515 size &= ~(
sizeof (
char *) - 1);
2560 if (*qq && *qq !=
';') {
2562 static const struct {
2584 if (size >= ddlstr[i].len &&
2585 strncasecmp(qq, ddlstr[i].str, ddlstr[i].len)
2601 }
while (*qq &&
ISSPACE(*qq));
2602 if (*qq && *qq !=
';') {
2605 *errmsg =
"only one SQL statement allowed";
2620 int ojfn = 0, brc = 0;
2621 char *inq2 = NULL, *end = q + 1, *start;
2623 while (*end &&
ISSPACE(*end)) {
2626 if (*end !=
'd' && *end !=
'D' &&
2627 *end !=
't' && *end !=
'T') {
2632 if (inq2 && *end == *inq2) {
2634 }
else if (inq2 == NULL && *end ==
'{') {
2635 char *nerr = 0, *nsql;
2637 nsql =
fixupsql(end, SQL_NTS, cte, 0, 0, &nerr);
2638 if (nsql && !nerr) {
2644 }
else if (inq2 == NULL && *end ==
'}') {
2648 }
else if (inq2 == NULL && (*end ==
'\'' || *end ==
'"')) {
2650 }
else if (inq2 == NULL && *end ==
'?') {
2656 char *end2 = end - 1;
2659 while (start < end) {
2665 while (start < end) {
2672 while (start < end2 && *start !=
'\'') {
2675 while (end2 > start && *end2 !=
'\'') {
2678 if (*start ==
'\'' && *end2 ==
'\'') {
2679 while (start <= end2) {
2710 if (!incom && p[1] ==
'-') {
2720 if (incom > 0 && p[-1] ==
'*') {
2724 }
else if (!incom && p[1] ==
'*') {
2736 (strncasecmp(p,
"select", 6) == 0 ||
2737 strncasecmp(p,
"pragma", 6) == 0)) {
2739 }
else if (cte && size >= 4 && strncasecmp(p,
"with", 4) == 0) {
2741 }
else if (size >= 7 && strncasecmp(p,
"explain", 7) == 0) {
2765 for (i = 0; i < ncols; i++) {
2766 if (strcmp(cols[i], name) == 0) {
2794 #if !defined(HAVE_SQLITE3TABLECOLUMNMETADATA) || !(HAVE_SQLITE3TABLECOLUMNMETADATA)
2795 int pk, nn, t, r, nrows, ncols;
2796 char **rowp, *flagp, flags[128];
2807 for (i = 1; table[0] && i < s->
dcols; i++) {
2812 if (i >= s->
dcols) {
2813 for (i = 0; i < s->
dcols; i++) {
2817 }
else if (s->
dcols == 1) {
2821 for (i = 0; i < s->
dcols; i++) {
2827 #ifdef SQL_LONGVARCHAR
2834 #ifdef SQL_WLONGVARCHAR
2846 #if !defined(HAVE_SQLITE3TABLECOLUMNMETADATA) || !(HAVE_SQLITE3TABLECOLUMNMETADATA)
2849 if (flagp == NULL) {
2855 memset(flagp, 0,
sizeof (flags[0]) * s->
dcols);
2856 for (i = 0; i < s->
dcols; i++) {
2860 for (i = 0; i < s->
dcols; i++) {
2861 int ret, lastpk = -1, autoinccount = 0;
2870 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", s->
dyncols[i].
table);
2875 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, NULL);
2877 if (ret != SQLITE_OK) {
2880 k =
findcol(rowp, ncols,
"name");
2881 t =
findcol(rowp, ncols,
"type");
2882 pk =
findcol(rowp, ncols,
"pk");
2883 nn =
findcol(rowp, ncols,
"notnull");
2884 if (k < 0 || t < 0) {
2887 for (r = 1; r <= nrows; r++) {
2890 for (m = i; m < s->
dcols; m++) {
2894 char *dotp = strchr(colname,
'.');
2901 strcmp(colname, rowp[r * ncols + k]) == 0 &&
2903 char *
typename = rowp[r * ncols + t];
2914 #ifdef SQL_LONGVARCHAR
2921 #ifdef SQL_WLONGVARCHAR
2932 if (pk >= 0 && strcmp(rowp[r * ncols + pk],
"1") == 0) {
2934 if (++autoinccount > 1) {
2941 if (strlen(
typename) == 7 &&
2942 strncasecmp(
typename,
"integer", 7) == 0) {
2949 if (nn >= 0 && rowp[r * ncols + nn][0] !=
'0') {
2956 sqlite3_free_table(rowp);
2958 for (i = k = 0; i < s->
dcols; i++) {
2959 if (flagp[i] == 0) {
2964 }
else if (flagp[i] != k) {
2972 for (i = 0; i < s->
dcols; i++) {
2979 if (flagp != flags) {
2983 for (i = 1, k = 0; i < s->
dcols; i++) {
2991 for (i = 0; i < s->
dcols; i++) {
3013 int z, a, b, c, d, e, x1;
3016 ijd = jd * 86400000.0 + 0.5;
3017 z = (int) ((ijd + 43200000) / 86400000);
3018 a = (int) ((z - 1867216.25) / 36524.25);
3019 a = z + 1 + a - (a / 4);
3021 c = (int) ((b - 122.1) / 365.25);
3022 d = (36525 * c) / 100;
3023 e = (int) ((b - d) / 30.6001);
3024 x1 = (int) (30.6001 * e);
3025 ds->day = b - d - x1;
3026 ds->month = (e < 14) ? (e - 1) : (e - 13);
3027 ds->year = (ds->month > 2) ? (c - 4716) : (c - 4715);
3045 ijd = jd * 86400000.0 + 0.5;
3046 s = (int)((ijd + 43200000) % 86400000);
3049 *fp = (s % 1000) * 1000000;
3053 ts->hour = s / 3600;
3054 s -= ts->hour * 3600;
3055 ts->minute = s / 60;
3056 ds += s - ts->minute *60;
3057 ts->second = (int) ds;
3070 static const int mdays[] = {
3071 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
3078 mday = mdays[(month - 1) % 12];
3079 if (mday == 28 && year % 4 == 0 &&
3080 (!(year % 100 == 0) || year % 400 == 0)) {
3106 char *p, *q, sepc =
'\0';
3108 ds->year = ds->month = ds->day = 0;
3110 p = strchr(str,
'.');
3134 strncpy(buf, p + 0, 4); buf[4] =
'\0';
3135 ds->year = strtol(buf, NULL, 10);
3136 strncpy(buf, p + 4, 2); buf[2] =
'\0';
3137 ds->month = strtol(buf, NULL, 10);
3138 strncpy(buf, p + 6, 2); buf[2] =
'\0';
3139 ds->day = strtol(buf, NULL, 10);
3147 n = strtol(p, &q, 10);
3159 if (*q ==
'-' || *q ==
'/' || *q ==
'\0' || i == 2) {
3161 case 0: ds->year = n;
break;
3162 case 1: ds->month = n;
break;
3163 case 2: ds->day = n;
break;
3180 ds->month < 1 || ds->month > 12 ||
3181 ds->day < 1 || ds->day >
getmdays(ds->year, ds->month)) {
3192 if (ds->month >= 1 && ds->month <= 12 &&
3193 (ds->day >= 1 || ds->day <=
getmdays(ds->year, ds->month))) {
3219 int i, err = 0, ampm = -1;
3223 ts->hour = ts->minute = ts->second = 0;
3225 p = strchr(str,
'.');
3249 strncpy(buf, p + 0, 2); buf[2] =
'\0';
3250 ts->hour = strtol(buf, NULL, 10);
3251 strncpy(buf, p + 2, 2); buf[2] =
'\0';
3252 ts->minute = strtol(buf, NULL, 10);
3253 strncpy(buf, p + 4, 2); buf[2] =
'\0';
3254 ts->second = strtol(buf, NULL, 10);
3262 n = strtol(p, &q, 10);
3271 if (*q ==
':' || *q ==
'\0' || i == 2) {
3273 case 0: ts->hour = n;
break;
3274 case 1: ts->minute = n;
break;
3275 case 2: ts->second = n;
break;
3291 if ((p[0] ==
'p' || p[0] ==
'P') &&
3292 (p[1] ==
'm' || p[1] ==
'M')) {
3294 }
else if ((p[0] ==
'a' || p[0] ==
'A') &&
3295 (p[1] ==
'm' || p[1] ==
'M')) {
3301 if (ts->hour < 12) {
3304 }
else if (ampm == 0) {
3305 if (ts->hour == 12) {
3312 if (err || ts->hour > 23 || ts->minute > 59 || ts->second > 59) {
3340 int i, m, n, err = 0, ampm = -1;
3342 char *p, *q, in =
'\0', sepc =
'\0';
3344 tss->year = tss->month = tss->day = 0;
3345 tss->hour = tss->minute = tss->second = 0;
3348 p = strchr(str,
'.');
3350 q = strchr(str,
'-');
3355 q = strchr(str,
'/');
3357 q = strchr(str,
':');
3370 tss->year = ds.year;
3371 tss->month = ds.month;
3373 tss->hour = ts.hour;
3374 tss->minute = ts.minute;
3375 tss->second = ts.second;
3395 strncpy(buf, p + 0, 4); buf[4] =
'\0';
3396 tss->year = strtol(buf, NULL, 10);
3397 strncpy(buf, p + 4, 2); buf[2] =
'\0';
3398 tss->month = strtol(buf, NULL, 10);
3399 strncpy(buf, p + 6, 2); buf[2] =
'\0';
3400 tss->day = strtol(buf, NULL, 10);
3401 strncpy(buf, p + 8, 2); buf[2] =
'\0';
3402 tss->hour = strtol(buf, NULL, 10);
3403 strncpy(buf, p + 10, 2); buf[2] =
'\0';
3404 tss->minute = strtol(buf, NULL, 10);
3405 strncpy(buf, p + 12, 2); buf[2] =
'\0';
3406 tss->second = strtol(buf, NULL, 10);
3409 strncpy(buf, p + 14, m);
3415 tss->fraction = strtol(buf, NULL, 10);
3421 while ((m & 7) != 7) {
3423 n = strtol(p, &q, 10);
3463 case 0: tss->year = n;
break;
3464 case 1: tss->month = n;
break;
3465 case 2: tss->day = n;
break;
3480 case 0: tss->hour = n;
break;
3481 case 1: tss->minute = n;
break;
3482 case 2: tss->second = n;
break;
3495 (void) strtol(q + 1, &e, 10);
3496 if (e && *e ==
'-') {
3512 if (p[0] ==
'+' || p[0] ==
'-') {
3528 if ((q[0] ==
'a' || q[0] ==
'A') &&
3529 (q[1] ==
'm' || q[1] ==
'M')) {
3532 }
else if ((q[0] ==
'p' || q[0] ==
'P') &&
3533 (q[1] ==
'm' || q[1] ==
'M')) {
3542 if ((m & 7) > 1 && (m & 8)) {
3548 if (*q !=
'+' && *q !=
'-') {
3551 sign = (*q ==
'+') ? -1 : 1;
3553 n = strtol(p, &q, 10);
3554 if (!q || *q++ !=
':' || !
ISDIGIT(*q)) {
3559 nn = strtol(p, &q, 10);
3560 tss->minute += nn * sign;
3561 if ((SQLSMALLINT) tss->minute < 0) {
3564 }
else if (tss->minute >= 60) {
3568 tss->hour += n * sign;
3569 if ((SQLSMALLINT) tss->hour < 0) {
3572 }
else if (tss->hour >= 24) {
3576 if ((
short) tss->day < 1 || tss->day >= 28) {
3577 int mday, pday, pmon;
3579 mday =
getmdays(tss->year, tss->month);
3580 pmon = tss->month - 1;
3585 if ((SQLSMALLINT) tss->day < 1) {
3588 }
else if (tss->day > mday) {
3592 if ((SQLSMALLINT) tss->month < 1) {
3595 }
else if (tss->month > 12) {
3604 (tss->month < 1 || tss->month > 12 ||
3605 tss->day < 1 || tss->day >
getmdays(tss->year, tss->month))) {
3619 if (!err && (m & 1) == 0) {
3624 tss->year = t.wYear;
3625 tss->month = t.wMonth;
3631 gettimeofday(&tv, NULL);
3632 tm = *localtime(&tv.tv_sec);
3633 tss->year = tm.tm_year + 1900;
3634 tss->month = tm.tm_mon + 1;
3635 tss->day = tm.tm_mday;
3639 if (tss->fraction < 0) {
3644 tss->month < 1 || tss->month > 12 ||
3645 tss->day < 1 || tss->day >
getmdays(tss->year, tss->month) ||
3646 tss->hour > 23 || tss->minute > 59 || tss->second > 59) {
3651 if (tss->hour < 12) {
3654 }
else if (ampm == 0) {
3655 if (tss->hour == 12) {
3660 return ((m & 7) < 1) ? -1 : 0;
3673 return string[0] && strchr(
"Yy123456789Tt",
string[0]) != NULL;
3689 DBC *d = (
DBC *) sqlite3_user_data(ctx);
3694 if (sqlite3_value_type(args[0]) != SQLITE_NULL) {
3695 filename = (
char *) sqlite3_value_text(args[0]);
3700 char *wname = utf_to_wmb(filename, -1);
3703 FILE *f = fopen(filename,
"r");
3710 f = fopen(wname,
"rb");
3712 sqlite3_result_error(ctx,
"out of memory", -1);
3718 if (fseek(f, 0, SEEK_END) == 0) {
3720 if (fseek(f, 0, SEEK_SET) == 0) {
3721 p = sqlite3_malloc(n);
3723 nn = fread(p, 1, n, f);
3725 sqlite3_result_error(ctx,
"read error", -1);
3728 sqlite3_result_blob(ctx, p, n, sqlite3_free);
3731 sqlite3_result_error(ctx,
"out of memory", -1);
3734 sqlite3_result_error(ctx,
"seek error", -1);
3737 sqlite3_result_error(ctx,
"seek error", -1);
3741 sqlite3_result_error(ctx,
"cannot open file", -1);
3744 sqlite3_result_error(ctx,
"no filename given", -1);
3759 DBC *d = (
DBC *) sqlite3_user_data(ctx);
3766 p = (
char *) sqlite3_value_blob(args[0]);
3767 n = sqlite3_value_bytes(args[0]);
3770 if (sqlite3_value_type(args[1]) != SQLITE_NULL) {
3771 filename = (
char *) sqlite3_value_text(args[1]);
3777 char *wname = utf_to_wmb(filename, -1);
3780 FILE *f = fopen(filename,
"w");
3786 f = fopen(wname,
"wb");
3788 sqlite3_result_error(ctx,
"out of memory", -1);
3794 nn = fwrite(p, 1, n, f);
3797 sqlite3_result_error(ctx,
"write error", -1);
3799 sqlite3_result_int(ctx, nn);
3802 sqlite3_result_error(ctx,
"cannot open file", -1);
3805 sqlite3_result_error(ctx,
"no filename given", -1);
3808 sqlite3_result_null(ctx);
3820 #if defined(HAVE_SQLITE3PROFILE) && (HAVE_SQLITE3PROFILE)
3821 dbtrace(
void *arg,
const char *msg, sqlite_uint64 et)
3823 dbtrace(
void *arg,
const char *msg)
3828 if (msg && d->
trace) {
3829 int len = strlen(msg);
3830 #if defined(HAVE_SQLITE3PROFILE) && (HAVE_SQLITE3PROFILE)
3837 if (msg[len - 1] !=
';') {
3840 fprintf(d->
trace,
"%s%s", msg, end);
3841 #if defined(HAVE_SQLITE3PROFILE) && (HAVE_SQLITE3PROFILE)
3842 s = et / 1000000000LL;
3843 f = et % 1000000000LL;
3844 fprintf(d->
trace,
"-- took %lu.%09lu seconds\n", s, f);
3861 if (fn && d->
trace) {
3863 fprintf(d->
trace,
"-- %s: %s\n", fn, sql);
3865 fprintf(d->
trace,
"-- %s\n", fn);
3881 if (rc != SQLITE_OK && d->
trace) {
3882 fprintf(d->
trace,
"-- SQLITE ERROR CODE %d", rc);
3883 fprintf(d->
trace, err ?
": %s\n" :
"\n", err);
3904 char *spflag,
char *ntflag,
char *jmode,
char *busy)
3907 int rc, tmp, busyto = 100000;
3908 #if defined(HAVE_SQLITE3VFS) && (HAVE_SQLITE3VFS)
3909 int flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
3911 const char *vfs_name = NULL;
3916 fprintf(d->
trace,
"-- sqlite3_close (deferred): '%s'\n",
3920 #if defined(HAVE_SQLITE3CLOSEV2) && (HAVE_SQLITE3CLOSEV2)
3921 sqlite3_close_v2(d->
sqlite);
3923 sqlite3_close(d->
sqlite);
3927 #if defined(HAVE_SQLITE3VFS) && (HAVE_SQLITE3VFS)
3929 flags &= ~ SQLITE_OPEN_CREATE;
3931 #if defined(_WIN32) || defined(_WIN64)
3933 char expname[MAX_PATH];
3936 rc = ExpandEnvironmentStrings(name, expname,
sizeof (expname));
3937 if (rc <=
sizeof (expname)) {
3938 uname = wmb_to_utf(expname, rc - 1);
3940 uname = wmb_to_utf(name, -1);
3944 setstatd(d, rc,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
3949 #if defined(ENABLE_NVFS) && (ENABLE_NVFS)
3950 vfs_name = nvfs_makevfs(uname);
3952 #ifdef SQLITE_OPEN_URI
3953 flags |= SQLITE_OPEN_URI;
3955 rc = sqlite3_open_v2(uname, &d->
sqlite, flags, vfs_name);
3956 #if defined(WINTERFACE) || defined(_WIN32) || defined(_WIN64)
3957 if (uname != name) {
3962 #if defined(_WIN32) || defined(_WIN64)
3967 cname = utf_to_wmb(name, -1);
3969 if (GetFileAttributesA(cname ? cname : name) ==
3970 INVALID_FILE_ATTRIBUTES) {
3972 rc = SQLITE_CANTOPEN;
3973 setstatd(d, rc,
"cannot open database",
3974 (*d->
ov3) ?
"HY000" :
"S1000");
3980 if (d->
nocreat && access(name, 004) < 0) {
3981 rc = SQLITE_CANTOPEN;
3982 setstatd(d, rc,
"cannot open database", (*d->
ov3) ?
"HY000" :
"S1000");
3986 #if defined(_WIN32) || defined(_WIN64)
3988 WCHAR *wname = wmb_to_uc(name, -1);
3992 setstatd(d, rc,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
3995 rc = sqlite3_open16(wname, &d->
sqlite);
3999 rc = sqlite3_open(name, &d->
sqlite);
4001 if (rc != SQLITE_OK) {
4003 setstatd(d, rc,
"connect failed", (*d->
ov3) ?
"HY000" :
"S1000");
4005 sqlite3_close(d->
sqlite);
4010 #if defined(SQLITE_DYNLOAD) || defined(SQLITE_HAS_CODEC)
4018 #if defined(HAVE_SQLITE3PROFILE) && (HAVE_SQLITE3PROFILE)
4027 SQL_CURSOR_FORWARD_ONLY : SQL_CURSOR_STATIC;
4028 tmp = strtol(busy, &endp, 0);
4029 if (endp && *endp ==
'\0' && endp != busy) {
4032 if (busyto < 1 || busyto > 1000000) {
4042 fprintf(d->
trace,
"-- sqlite3_close: '%s'\n",
4046 sqlite3_close(d->
sqlite);
4050 if (!spflag || spflag[0] ==
'\0') {
4053 if (spflag[0] !=
'\0') {
4056 sprintf(syncp,
"PRAGMA synchronous = %8.8s;", spflag);
4057 sqlite3_exec(d->
sqlite, syncp, NULL, NULL, NULL);
4059 if (jmode[0] !=
'\0') {
4062 sprintf(jourp,
"PRAGMA journal_mode = %16.16s;", jmode);
4063 sqlite3_exec(d->
sqlite, jourp, NULL, NULL, NULL);
4066 fprintf(d->
trace,
"-- sqlite3_open: '%s'\n", d->
dbname);
4069 #if defined(_WIN32) || defined(_WIN64)
4071 char pname[MAX_PATH];
4072 HANDLE h = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
4073 FALSE, GetCurrentProcessId());
4077 HMODULE m = NULL, l = LoadLibrary(
"psapi.dll");
4079 typedef BOOL (WINAPI *epmfunc)(HANDLE, HMODULE *, DWORD, LPDWORD);
4080 typedef BOOL (WINAPI *gmbfunc)(HANDLE, HMODULE, LPSTR, DWORD);
4085 epm = (epmfunc) GetProcAddress(l,
"EnumProcessModules");
4086 gmb = (gmbfunc) GetProcAddress(l,
"GetModuleBaseNameA");
4087 if (epm && gmb && epm(h, &m,
sizeof (m), &need)) {
4088 gmb(h, m, pname,
sizeof (pname));
4094 d->xcelqrx = strncasecmp(pname,
"EXCEL", 5) == 0 ||
4095 strncasecmp(pname,
"MSQRY", 5) == 0;
4096 if (d->
trace && d->xcelqrx) {
4098 fprintf(d->
trace,
"-- enabled EXCEL quirks\n");
4103 sqlite3_create_function(d->
sqlite,
"blob_import", 1, SQLITE_UTF8,
4105 sqlite3_create_function(d->
sqlite,
"blob_export", 2, SQLITE_UTF8,
4119 #if defined(HAVE_SQLITE3LOADEXTENSION) && (HAVE_SQLITE3LOADEXTENSION)
4121 char path[SQL_MAX_MESSAGE_LENGTH];
4127 sqlite3_enable_load_extension(d->
sqlite, 1);
4128 #if defined(_WIN32) || defined(_WIN64)
4129 GetModuleFileName(hModule, path,
sizeof (path));
4130 p = strrchr(path,
'\\');
4131 plen = p ? ((p + 1) - path) : 0;
4134 p = strchr(exts,
',');
4136 strncpy(path + plen, exts, p - exts);
4137 path[plen + (p - exts)] =
'\0';
4139 strcpy(path + plen, exts);
4142 char *errmsg = NULL;
4144 #if defined(_WIN32) || defined(_WIN64)
4149 ((q[1] ==
':' && (q[2] ==
'\\' || q[2] ==
'/')) ||
4150 q[0] ==
'\\' || q[0] ==
'/' || q[0] ==
'.'))) {
4153 rc = sqlite3_load_extension(d->
sqlite, q, 0, &errmsg);
4155 rc = sqlite3_load_extension(d->
sqlite, path, 0, &errmsg);
4157 if (rc != SQLITE_OK) {
4158 #if defined(_WIN32) || defined(_WIN64)
4159 char buf[512], msg[512];
4161 LoadString(hModule, IDS_EXTERR, buf,
sizeof (buf));
4162 wsprintf(msg, buf, q, errmsg ?
4163 errmsg :
"no error info available");
4164 LoadString(hModule, IDS_EXTTITLE, buf,
sizeof (buf));
4165 MessageBox(NULL, msg, buf,
4166 MB_ICONEXCLAMATION | MB_OK | MB_TASKMODAL |
4169 fprintf(stderr,
"extension '%s' did not load%s%s\n",
4170 path, errmsg ?
": " :
"", errmsg ? errmsg :
"");
4193 char *
typename = (
char *) sqlite3_column_decltype(s3stmt, col);
4198 int coltype = sqlite3_column_type(s3stmt, col);
4200 if (guessed_types) {
4204 sprintf(guess,
" (guessed from %d)", coltype);
4207 case SQLITE_INTEGER:
typename =
"integer";
break;
4208 case SQLITE_FLOAT:
typename =
"double";
break;
4210 case SQLITE_TEXT:
typename =
"varchar";
break;
4211 case SQLITE_BLOB:
typename =
"blob";
break;
4213 case SQLITE_NULL:
typename =
"null";
break;
4218 fprintf(d->
trace,
"-- column %d type%s: '%s'\n", col + 1,
4225 #if defined(HAVE_SQLITE3TABLECOLUMNMETADATA) && (HAVE_SQLITE3TABLECOLUMNMETADATA)
4236 s3stmt_addmeta(sqlite3_stmt *s3stmt,
int col,
DBC *d,
COL *ci)
4238 int nn = 0, pk = 0, ai = 0;
4239 const char *dn, *tn, *cn, *dummy[4];
4241 dn = sqlite3_column_database_name(s3stmt, col);
4242 tn = sqlite3_column_table_name(s3stmt, col);
4243 cn = sqlite3_column_origin_name(s3stmt, col);
4244 dummy[0] = dummy[1] = 0;
4246 sqlite3_table_column_metadata(d->
sqlite, dn, tn, cn,
4250 ci->
autoinc = ai ? SQL_TRUE: SQL_FALSE;
4251 ci->
notnull = nn ? SQL_NO_NULLS : SQL_NULLABLE;
4252 ci->
ispk = pk ? 1 : 0;
4254 fprintf(d->
trace,
"-- column %d %s\n",
4255 col + 1, nn ?
"notnull" :
"nullable");
4257 fprintf(d->
trace,
"-- column %d autoincrement\n", col + 1);
4262 if (ci->
ispk && tn) {
4264 dummy[2] = dummy[3] = 0;
4266 sqlite3_table_column_metadata(d->
sqlite, dn, tn,
"rowid",
4267 dummy + 2, dummy + 3,
4269 if (pk && dummy[0] && dummy[0] == dummy[2]) {
4288 const char *errp = NULL;
4292 setstat(s, -1,
"stale statement", (*s->
ov3) ?
"HY000" :
"S1000");
4295 rc = sqlite3_step(s->
s3stmt);
4296 if (rc == SQLITE_ROW || rc == SQLITE_DONE) {
4298 ncols = sqlite3_column_count(s->
s3stmt);
4303 const char *colname, *
typename;
4304 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME)
4308 for (i = size = 0; i < ncols; i++) {
4309 colname = sqlite3_column_name(s->
s3stmt, i);
4310 size += 3 + 3 * strlen(colname);
4312 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME)
4313 tblname = (
char *) size;
4314 for (i = 0; i < ncols; i++) {
4315 p = (
char *) sqlite3_column_table_name(s->
s3stmt, i);
4316 size += 2 + (p ? strlen(p) : 0);
4319 dyncols =
xmalloc(ncols *
sizeof (
COL) + size);
4324 sqlite3_finalize(s->
s3stmt);
4329 p = (
char *) (dyncols + ncols);
4330 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME)
4333 for (i = 0; i < ncols; i++) {
4336 colname = sqlite3_column_name(s->
s3stmt, i);
4338 fprintf(d->
trace,
"-- column %d name: '%s'\n",
4342 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME)
4343 q = (
char *) sqlite3_column_table_name(s->
s3stmt, i);
4344 strcpy(tblname, q ? q :
"");
4346 fprintf(d->
trace,
"-- table %d name: '%s'\n",
4350 dyncols[i].
table = tblname;
4351 tblname += strlen(tblname) + 1;
4354 dyncols[i].
db = ((
DBC *) (s->
dbc))->dbname;
4356 dyncols[i].
label = p;
4358 q = strchr(colname,
'.');
4360 char *q2 = strchr(q + 1,
'.');
4368 #if !defined(HAVE_SQLITE3COLUMNTABLENAME) || !(HAVE_SQLITE3COLUMNTABLENAME)
4369 dyncols[i].
table = p;
4371 strncpy(p, colname, q - colname);
4372 p[q - colname] =
'\0';
4378 #if !defined(HAVE_SQLITE3COLUMNTABLENAME) || !(HAVE_SQLITE3COLUMNTABLENAME)
4379 dyncols[i].
table =
"";
4388 #ifdef SQL_LONGVARCHAR
4389 dyncols[i].
type = SQL_LONGVARCHAR;
4390 dyncols[i].
size = 65535;
4392 dyncols[i].
type = SQL_VARCHAR;
4393 dyncols[i].
size = 255;
4395 dyncols[i].
index = i;
4396 dyncols[i].
scale = 0;
4397 dyncols[i].
prec = 0;
4399 #if defined(HAVE_SQLITE3TABLECOLUMNMETADATA) && (HAVE_SQLITE3TABLECOLUMNMETADATA)
4400 s3stmt_addmeta(s->
s3stmt, i, d, &dyncols[i]);
4402 dyncols[i].
autoinc = SQL_FALSE;
4403 dyncols[i].
notnull = SQL_NULLABLE;
4404 dyncols[i].
ispk = -1;
4419 if (rc == SQLITE_DONE) {
4423 sqlite3_finalize(s->
s3stmt);
4428 rowd =
xmalloc((1 + 2 * ncols) *
sizeof (
char *));
4430 const unsigned char *value;
4432 rowd[0] = (
char *) ((
PTRDIFF_T) (ncols * 2));
4434 for (i = 0; i < ncols; i++) {
4435 int coltype = sqlite3_column_type(s->
s3stmt, i);
4437 rowd[i] = rowd[i + ncols] = NULL;
4438 if (coltype == SQLITE_BLOB) {
4439 int k, nbytes = sqlite3_column_bytes(s->
s3stmt, i);
4441 unsigned const char *bp;
4443 bp = sqlite3_column_blob(s->
s3stmt, i);
4446 rowd[i + ncols] = qp;
4449 for (k = 0; k < nbytes; k++) {
4450 *qp++ =
xdigits[(bp[k] >> 4)];
4451 *qp++ =
xdigits[(bp[k] & 0xF)];
4457 }
else if (coltype == SQLITE_FLOAT) {
4458 static struct lconv *lc = 0;
4459 double d = sqlite3_column_double(s->
s3stmt, i);
4460 char *p, buffer[128];
4467 snprintf(buffer,
sizeof (buffer),
"%.15g", d);
4471 if (lc && lc->decimal_point && lc->decimal_point[0] &&
4472 lc->decimal_point[0] !=
'.') {
4473 p = strchr(buffer, lc->decimal_point[0]);
4478 rowd[i + ncols] =
xstrdup(buffer);
4480 }
else if (coltype != SQLITE_NULL) {
4481 value = sqlite3_column_text(s->
s3stmt, i);
4482 rowd[i + ncols] =
xstrdup((
char *) value);
4485 for (i = 0; i < ncols; i++) {
4486 int coltype = sqlite3_column_type(s->
s3stmt, i);
4489 if (coltype == SQLITE_BLOB) {
4490 value = sqlite3_column_blob(s->
s3stmt, i);
4491 }
else if (coltype != SQLITE_NULL) {
4492 value = sqlite3_column_text(s->
s3stmt, i);
4494 if (value && !rowd[i + ncols]) {
4506 if (rc == SQLITE_DONE) {
4508 sqlite3_finalize(s->
s3stmt);
4517 rc = sqlite3_reset(s->
s3stmt);
4519 errp = sqlite3_errmsg(d->
sqlite);
4523 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
4524 errp ? errp :
"unknown error", rc);
4547 sqlite3_reset(s->
s3stmt);
4588 sqlite3_finalize(s->
s3stmt);
4605 sqlite3_stmt *s3stmt = NULL;
4610 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
4617 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
4618 rc = sqlite3_prepare_v2(d->
sqlite, (
char *) s->
query, -1,
4621 rc = sqlite3_prepare(d->
sqlite, (
char *) s->
query, -1,
4624 if (rc != SQLITE_OK) {
4626 sqlite3_finalize(s3stmt);
4630 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
4632 if (rc != SQLITE_OK) {
4635 sqlite3_finalize(s3stmt);
4637 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
4638 sqlite3_errmsg(d->
sqlite), rc);
4641 if (sqlite3_bind_parameter_count(s3stmt) != s->
nparams) {
4643 sqlite3_finalize(s3stmt);
4644 setstat(s, SQLITE_ERROR,
"parameter marker count incorrect",
4645 (*s->
ov3) ?
"HY000" :
"S1000");
4664 SQLDataSources(SQLHENV env, SQLUSMALLINT dir, SQLCHAR *srvname,
4665 SQLSMALLINT buflen1, SQLSMALLINT *lenp1,
4666 SQLCHAR *desc, SQLSMALLINT buflen2, SQLSMALLINT *lenp2)
4668 if (env == SQL_NULL_HENV) {
4669 return SQL_INVALID_HANDLE;
4682 SQLSMALLINT buflen1, SQLSMALLINT *lenp1,
4683 SQLWCHAR *desc, SQLSMALLINT buflen2, SQLSMALLINT *lenp2)
4685 if (env == SQL_NULL_HENV) {
4686 return SQL_INVALID_HANDLE;
4698 SQLDrivers(SQLHENV env, SQLUSMALLINT dir, SQLCHAR *drvdesc,
4699 SQLSMALLINT descmax, SQLSMALLINT *desclenp,
4700 SQLCHAR *drvattr, SQLSMALLINT attrmax, SQLSMALLINT *attrlenp)
4702 if (env == SQL_NULL_HENV) {
4703 return SQL_INVALID_HANDLE;
4716 SQLSMALLINT descmax, SQLSMALLINT *desclenp,
4717 SQLWCHAR *drvattr, SQLSMALLINT attrmax, SQLSMALLINT *attrlenp)
4719 if (env == SQL_NULL_HENV) {
4720 return SQL_INVALID_HANDLE;
4732 SQLBrowseConnect(SQLHDBC
dbc, SQLCHAR *connin, SQLSMALLINT conninLen,
4733 SQLCHAR *connout, SQLSMALLINT connoutMax,
4734 SQLSMALLINT *connoutLen)
4752 SQLWCHAR *connout, SQLSMALLINT connoutMax,
4753 SQLSMALLINT *connoutLen)
4776 int i, dlen, done = 0;
4779 if (stmt == SQL_NULL_HSTMT) {
4780 return SQL_INVALID_HANDLE;
4785 setstat(s, -1,
"sequence error",
"HY010");
4788 for (i = (s->
pdcount < 0) ? 0 : s->
pdcount; i < s->nparams; i++) {
4793 if (len == SQL_NULL_DATA) {
4796 p->
len = SQL_NULL_DATA;
4798 }
else if (type != SQL_C_CHAR
4800 && type != SQL_C_WCHAR
4802 && type != SQL_C_BINARY) {
4807 case SQL_C_UTINYINT:
4808 case SQL_C_STINYINT:
4812 size =
sizeof (SQLCHAR);
4817 size =
sizeof (SQLSMALLINT);
4822 size =
sizeof (SQLINTEGER);
4827 size =
sizeof (SQLBIGINT);
4831 size =
sizeof (float);
4834 size =
sizeof (double);
4836 #ifdef SQL_C_TYPE_DATE
4837 case SQL_C_TYPE_DATE:
4840 size =
sizeof (DATE_STRUCT);
4842 #ifdef SQL_C_TYPE_DATE
4843 case SQL_C_TYPE_TIME:
4846 size =
sizeof (TIME_STRUCT);
4848 #ifdef SQL_C_TYPE_DATE
4849 case SQL_C_TYPE_TIMESTAMP:
4851 case SQL_C_TIMESTAMP:
4852 size =
sizeof (TIMESTAMP_STRUCT);
4861 memcpy(p->
param, data, size);
4864 }
else if (len == SQL_NTS && (
4867 || type == SQL_C_WCHAR
4873 if (type == SQL_C_WCHAR) {
4880 #if defined(_WIN32) || defined(_WIN64)
4882 dp = wmb_to_utf(data, strlen (data));
4898 strcpy(p->
param, dp);
4904 }
else if (len < 0) {
4905 setstat(s, -1,
"invalid length",
"HY090");
4910 setstat(s, -1,
"no memory for parameter",
"HY013");
4913 memcpy((
char *) p->
param + p->
offs, data, dlen);
4917 if (type == SQL_C_WCHAR) {
4939 *((
char *) p->
param + p->
len) =
'\0';
4941 p->
need = (type == SQL_C_CHAR || type == SQL_C_WCHAR)
4944 *((
char *) p->
param + p->
len) =
'\0';
4945 p->
need = (type == SQL_C_CHAR) ? -1 : 0;
4947 #if defined(_WIN32) || defined(_WIN64)
4948 if (type == SQL_C_CHAR && *s->
oemcp &&
4949 !(p->
stype == SQL_BINARY ||
4950 p->
stype == SQL_VARBINARY ||
4951 p->
stype == SQL_LONGVARBINARY)) {
4952 char *dp = wmb_to_utf(p->
param, p->
len);
4961 p->
len = strlen(dp);
4963 if (p->
type == SQL_C_WCHAR &&
4964 (p->
stype == SQL_VARCHAR ||
4965 p->
stype == SQL_LONGVARCHAR) &&
4966 p->
len == p->
coldef * sizeof (SQLWCHAR)) {
5035 int type, len = 0, needalloc = 0;
5043 #if (defined(_WIN32) || defined(_WIN64)) && defined(WINTERFACE)
5045 if (type == SQL_C_WCHAR && p->
type == SQL_C_DEFAULT) {
5058 if (type == SQL_C_CHAR &&
5059 (p->
stype == SQL_BINARY ||
5060 p->
stype == SQL_VARBINARY ||
5061 p->
stype == SQL_LONGVARBINARY)) {
5062 type = SQL_C_BINARY;
5074 }
else if (*p->
lenp == SQL_DATA_AT_EXEC) {
5078 if (len <= SQL_LEN_DATA_AT_EXEC_OFFSET) {
5079 len = SQL_LEN_DATA_AT_EXEC(len);
5083 setstat(s, -1,
"invalid length",
"HY009");
5100 if (type == SQL_C_WCHAR) {
5101 if (!p->
lenp || *p->
lenp == SQL_NTS) {
5103 }
else if (*p->
lenp >= 0) {
5108 if (type == SQL_C_CHAR) {
5109 if (!p->
lenp || *p->
lenp == SQL_NTS) {
5111 #if defined(_WIN32) || defined(_WIN64)
5114 }
else if (*p->
lenp >= 0) {
5124 if (type == SQL_C_WCHAR) {
5140 if (type == SQL_C_CHAR) {
5145 #if defined(_WIN32) || defined(_WIN64)
5157 #if defined(_WIN32) || defined(_WIN64)
5159 p->
len = strlen(dp);
5178 case SQL_C_UTINYINT:
5180 case SQL_C_STINYINT:
5181 p->
s3type = SQLITE_INTEGER;
5182 p->
s3size =
sizeof (int);
5186 p->
s3type = SQLITE_INTEGER;
5187 p->
s3size =
sizeof (int);
5192 p->
s3type = SQLITE_INTEGER;
5193 p->
s3size =
sizeof (int);
5197 p->
s3type = SQLITE_INTEGER;
5198 p->
s3size =
sizeof (int);
5203 p->
s3type = SQLITE_INTEGER;
5204 p->
s3size =
sizeof (int);
5209 p->
s3type = SQLITE_INTEGER;
5210 p->
s3size =
sizeof (int);
5216 p->
s3type = SQLITE_INTEGER;
5217 p->
s3size =
sizeof (sqlite_int64);
5221 p->
s3type = SQLITE_INTEGER;
5222 p->
s3size =
sizeof (sqlite_int64);
5227 p->
s3type = SQLITE_FLOAT;
5228 p->
s3size =
sizeof (double);
5232 p->
s3type = SQLITE_FLOAT;
5233 p->
s3size =
sizeof (double);
5236 #ifdef SQL_C_TYPE_DATE
5237 case SQL_C_TYPE_DATE:
5241 int a, b, x1, x2, y, m, d;
5243 p->
s3type = SQLITE_FLOAT;
5244 p->
s3size =
sizeof (double);
5245 y = ((DATE_STRUCT *) p->
param)->year;
5246 m = ((DATE_STRUCT *) p->
param)->month;
5247 d = ((DATE_STRUCT *) p->
param)->day;
5253 b = 2 - a + (a / 4);
5254 x1 = 36525 * (y + 4716) / 100;
5255 x2 = 306001 * (m + 1) / 10000;
5256 p->
s3dval = x1 + x2 + d + b - 1524.5;
5259 sprintf(p->
strbuf,
"%04d-%02d-%02d",
5260 ((DATE_STRUCT *) p->
param)->year,
5261 ((DATE_STRUCT *) p->
param)->month,
5262 ((DATE_STRUCT *) p->
param)->day);
5267 #ifdef SQL_C_TYPE_TIME
5268 case SQL_C_TYPE_TIME:
5272 p->
s3type = SQLITE_FLOAT;
5273 p->
s3size =
sizeof (double);
5275 (((TIME_STRUCT *) p->
param)->hour * 3600000.0 +
5276 ((TIME_STRUCT *) p->
param)->minute * 60000.0 +
5277 ((TIME_STRUCT *) p->
param)->second * 1000.0) / 86400000.0;
5280 sprintf(p->
strbuf,
"%02d:%02d:%02d",
5281 ((TIME_STRUCT *) p->
param)->hour,
5282 ((TIME_STRUCT *) p->
param)->minute,
5283 ((TIME_STRUCT *) p->
param)->second);
5288 #ifdef SQL_C_TYPE_TIMESTAMP
5289 case SQL_C_TYPE_TIMESTAMP:
5291 case SQL_C_TIMESTAMP:
5293 int a, b, x1, x2, y, m, d;
5295 p->
s3type = SQLITE_FLOAT;
5296 p->
s3size =
sizeof (double);
5297 y = ((TIMESTAMP_STRUCT *) p->
param)->year;
5298 m = ((TIMESTAMP_STRUCT *) p->
param)->month;
5299 d = ((TIMESTAMP_STRUCT *) p->
param)->day;
5305 b = 2 - a + (a / 4);
5306 x1 = 36525 * (y + 4716) / 100;
5307 x2 = 306001 * (m + 1) / 10000;
5308 p->
s3dval = x1 + x2 + d + b - 1524.5 +
5309 (((TIMESTAMP_STRUCT *) p->
param)->hour * 3600000.0 +
5310 ((TIMESTAMP_STRUCT *) p->
param)->minute * 60000.0 +
5311 ((TIMESTAMP_STRUCT *) p->
param)->second * 1000.0 +
5312 ((TIMESTAMP_STRUCT *) p->
param)->fraction / 1.0E6)
5316 len = (int) ((TIMESTAMP_STRUCT *) p->
param)->fraction;
5323 sprintf(p->
strbuf,
"%04d-%02d-%02d %02d:%02d:00.000",
5324 ((TIMESTAMP_STRUCT *) p->
param)->year,
5325 ((TIMESTAMP_STRUCT *) p->
param)->month,
5326 ((TIMESTAMP_STRUCT *) p->
param)->day,
5327 ((TIMESTAMP_STRUCT *) p->
param)->hour,
5328 ((TIMESTAMP_STRUCT *) p->
param)->minute);
5330 sprintf(p->
strbuf,
"%04d-%02d-%02d %02d:%02d:%02d.000",
5331 ((TIMESTAMP_STRUCT *) p->
param)->year,
5332 ((TIMESTAMP_STRUCT *) p->
param)->month,
5333 ((TIMESTAMP_STRUCT *) p->
param)->day,
5334 ((TIMESTAMP_STRUCT *) p->
param)->hour,
5335 ((TIMESTAMP_STRUCT *) p->
param)->minute,
5336 ((TIMESTAMP_STRUCT *) p->
param)->second);
5338 sprintf(p->
strbuf,
"%04d-%02d-%02d %02d:%02d:%02d.%03d",
5339 ((TIMESTAMP_STRUCT *) p->
param)->year,
5340 ((TIMESTAMP_STRUCT *) p->
param)->month,
5341 ((TIMESTAMP_STRUCT *) p->
param)->day,
5342 ((TIMESTAMP_STRUCT *) p->
param)->hour,
5343 ((TIMESTAMP_STRUCT *) p->
param)->minute,
5344 ((TIMESTAMP_STRUCT *) p->
param)->second,
5353 setstat(s, -1,
"unsupported parameter type",
5354 (*s->
ov3) ?
"07009" :
"S1093");
5377 SQLSMALLINT buftype, SQLSMALLINT ptype, SQLUINTEGER coldef,
5379 SQLPOINTER data, SQLINTEGER buflen,
SQLLEN *len)
5384 if (stmt == SQL_NULL_HSTMT) {
5385 return SQL_INVALID_HANDLE;
5389 setstat(s, -1,
"invalid parameter", (*s->
ov3) ?
"07009" :
"S1093");
5392 if (!data && !len) {
5393 setstat(s, -1,
"invalid buffer",
"HY003");
5413 int npar =
max(10, pnum + 1);
5423 case SQL_C_STINYINT:
5424 case SQL_C_UTINYINT:
5429 buflen =
sizeof (SQLCHAR);
5434 buflen =
sizeof (SQLSMALLINT);
5439 buflen =
sizeof (SQLINTEGER);
5442 buflen =
sizeof (float);
5445 buflen =
sizeof (double);
5447 case SQL_C_TIMESTAMP:
5448 #ifdef SQL_C_TYPE_TIMESTAMP
5449 case SQL_C_TYPE_TIMESTAMP:
5451 buflen =
sizeof (TIMESTAMP_STRUCT);
5454 #ifdef SQL_C_TYPE_TIME
5455 case SQL_C_TYPE_TIME:
5457 buflen =
sizeof (TIME_STRUCT);
5460 #ifdef SQL_C_TYPE_DATE
5461 case SQL_C_TYPE_DATE:
5463 buflen =
sizeof (DATE_STRUCT);
5465 #ifdef SQL_C_UBIGINT
5467 buflen =
sizeof (SQLBIGINT);
5470 #ifdef SQL_C_SBIGINT
5472 buflen =
sizeof (SQLBIGINT);
5477 buflen =
sizeof (SQLBIGINT);
5516 SQLSMALLINT buftype, SQLSMALLINT ptype,
SQLULEN coldef,
5523 ret =
drvbindparam(stmt, pnum, iotype, buftype, ptype, coldef,
5524 scale, data, buflen, len);
5545 SQLSMALLINT ptype,
SQLULEN lenprec,
5546 SQLSMALLINT scale, SQLPOINTER val,
5552 ret =
drvbindparam(stmt, pnum, SQL_PARAM_INPUT, vtype, ptype,
5553 lenprec, scale, val, 0, lenp);
5573 if (stmt == SQL_NULL_HSTMT) {
5574 return SQL_INVALID_HANDLE;
5596 if (*p->
lenp == SQL_DATA_AT_EXEC) {
5599 p->
len = SQL_LEN_DATA_AT_EXEC(*p->
lenp);
5601 if (p->
len < 0 && p->
len != SQL_NTS &&
5602 p->
len != SQL_NULL_DATA) {
5603 setstat(s, -1,
"invalid length",
"HY009");
5616 return SQL_NEED_DATA;
5636 if (stmt == SQL_NULL_HSTMT) {
5637 return SQL_INVALID_HANDLE;
5646 for (i = 0; i < s->
pdcount; i++) {
5651 p->
need = (type == SQL_C_CHAR || type == SQL_C_WCHAR) ? -1 : 0;
5657 *pind = (SQLPOINTER) p->
param0;
5682 SQLULEN *size, SQLSMALLINT *decdigits, SQLSMALLINT *nullable)
5685 SQLRETURN ret = SQL_ERROR;
5688 if (stmt == SQL_NULL_HSTMT) {
5689 return SQL_INVALID_HANDLE;
5694 setstat(s, -1,
"invalid parameter index",
5695 (*s->
ov3) ?
"HY000" :
"S1000");
5699 #ifdef SQL_LONGVARCHAR
5701 *dtype = s->
nowchar[0] ? SQL_LONGVARCHAR : SQL_WLONGVARCHAR;
5703 *dtype = SQL_LONGVARCHAR;
5707 *dtype = s->
nowchar[0] ? SQL_VARCHAR : SQL_WVARCHAR;
5709 *dtype = SQL_VARCHAR;
5714 #ifdef SQL_LONGVARCHAR
5724 *nullable = SQL_NULLABLE;
5747 SQLSMALLINT sqltype,
SQLULEN coldef,
5748 SQLSMALLINT scale, SQLPOINTER val,
SQLLEN *nval)
5754 type, sqltype, coldef, scale, val,
5755 SQL_SETPARAM_VALUE_MAX, nval);
5781 SQLGetDescField(SQLHDESC handle, SQLSMALLINT recno,
5782 SQLSMALLINT fieldid, SQLPOINTER value,
5783 SQLINTEGER buflen, SQLINTEGER *strlen)
5796 SQLSMALLINT fieldid, SQLPOINTER value,
5797 SQLINTEGER buflen, SQLINTEGER *strlen)
5809 SQLSetDescField(SQLHDESC handle, SQLSMALLINT recno,
5810 SQLSMALLINT fieldid, SQLPOINTER value,
5824 SQLSMALLINT fieldid, SQLPOINTER value,
5837 SQLGetDescRec(SQLHDESC handle, SQLSMALLINT recno,
5838 SQLCHAR *name, SQLSMALLINT buflen,
5839 SQLSMALLINT *strlen, SQLSMALLINT *type,
5840 SQLSMALLINT *subtype,
SQLLEN *len,
5841 SQLSMALLINT *prec, SQLSMALLINT *scale,
5842 SQLSMALLINT *nullable)
5855 SQLWCHAR *name, SQLSMALLINT buflen,
5856 SQLSMALLINT *strlen, SQLSMALLINT *type,
5857 SQLSMALLINT *subtype,
SQLLEN *len,
5858 SQLSMALLINT *prec, SQLSMALLINT *scale,
5859 SQLSMALLINT *nullable)
5871 SQLSMALLINT type, SQLSMALLINT subtype,
5872 SQLLEN len, SQLSMALLINT prec,
5873 SQLSMALLINT scale, SQLPOINTER data,
5892 int ncols3,
int *nret)
5897 if (stmt == SQL_NULL_HSTMT) {
5898 return SQL_INVALID_HANDLE;
5901 if (s->
dbc == SQL_NULL_HDBC) {
5911 if (colspec3 && *s->
ov3) {
5934 {
"SYSTEM",
"TABLEPRIV",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
5935 {
"SYSTEM",
"TABLEPRIV",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
5936 {
"SYSTEM",
"TABLEPRIV",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
5937 {
"SYSTEM",
"TABLEPRIV",
"GRANTOR",
SCOL_VARCHAR, 50 },
5938 {
"SYSTEM",
"TABLEPRIV",
"GRANTEE",
SCOL_VARCHAR, 50 },
5939 {
"SYSTEM",
"TABLEPRIV",
"PRIVILEGE",
SCOL_VARCHAR, 50 },
5940 {
"SYSTEM",
"TABLEPRIV",
"IS_GRANTABLE",
SCOL_VARCHAR, 50 }
5944 {
"SYSTEM",
"TABLEPRIV",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
5945 {
"SYSTEM",
"TABLEPRIV",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
5946 {
"SYSTEM",
"TABLEPRIV",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
5947 {
"SYSTEM",
"TABLEPRIV",
"GRANTOR",
SCOL_VARCHAR, 50 },
5948 {
"SYSTEM",
"TABLEPRIV",
"GRANTEE",
SCOL_VARCHAR, 50 },
5949 {
"SYSTEM",
"TABLEPRIV",
"PRIVILEGE",
SCOL_VARCHAR, 50 },
5950 {
"SYSTEM",
"TABLEPRIV",
"IS_GRANTABLE",
SCOL_VARCHAR, 50 }
5967 SQLCHAR *cat, SQLSMALLINT catLen,
5968 SQLCHAR *schema, SQLSMALLINT schemaLen,
5969 SQLCHAR *table, SQLSMALLINT tableLen)
5974 int ncols, rc, size, npatt;
5975 char *errp = NULL, *sql, tname[512];
5978 tablePrivSpec3,
array_size(tablePrivSpec3), NULL);
5979 if (ret != SQL_SUCCESS) {
5984 if (cat && (catLen > 0 || catLen == SQL_NTS) && cat[0] ==
'%') {
5988 if (schema && (schemaLen > 0 || schemaLen == SQL_NTS) &&
5990 if ((!cat || catLen == 0 || !cat[0]) &&
5991 (!table || tableLen == 0 || !table[0])) {
6001 if (tableLen == SQL_NTS) {
6002 size =
sizeof (tname) - 1;
6004 size =
min(
sizeof (tname) - 1, tableLen);
6006 strncpy(tname, (
char *) table, size);
6010 #if defined(_WIN32) || defined(_WIN64)
6011 sql = sqlite3_mprintf(
"select %s as 'TABLE_QUALIFIER', "
6012 "%s as 'TABLE_OWNER', "
6013 "tbl_name as 'TABLE_NAME', "
6016 "'SELECT' AS 'PRIVILEGE', "
6017 "NULL as 'IS_GRANTABLE' "
6018 "from sqlite_master where "
6019 "(type = 'table' or type = 'view') "
6020 "and tbl_name %s %Q "
6022 "select %s as 'TABLE_QUALIFIER', "
6023 "%s as 'TABLE_OWNER', "
6024 "tbl_name as 'TABLE_NAME', "
6027 "'UPDATE' AS 'PRIVILEGE', "
6028 "NULL as 'IS_GRANTABLE' "
6029 "from sqlite_master where "
6030 "(type = 'table' or type = 'view') "
6031 "and tbl_name %s %Q "
6033 "select %s as 'TABLE_QUALIFIER', "
6034 "%s as 'TABLE_OWNER', "
6035 "tbl_name as 'TABLE_NAME', "
6038 "'DELETE' AS 'PRIVILEGE', "
6039 "NULL as 'IS_GRANTABLE' "
6040 "from sqlite_master where "
6041 "(type = 'table' or type = 'view') "
6042 "and tbl_name %s %Q "
6044 "select %s as 'TABLE_QUALIFIER', "
6045 "%s as 'TABLE_OWNER', "
6046 "tbl_name as 'TABLE_NAME', "
6049 "'INSERT' AS 'PRIVILEGE', "
6050 "NULL as 'IS_GRANTABLE' "
6051 "from sqlite_master where "
6052 "(type = 'table' or type = 'view') "
6053 "and tbl_name %s %Q "
6055 "select %s as 'TABLE_QUALIFIER', "
6056 "%s as 'TABLE_OWNER', "
6057 "tbl_name as 'TABLE_NAME', "
6060 "'REFERENCES' AS 'PRIVILEGE', "
6061 "NULL as 'IS_GRANTABLE' "
6062 "from sqlite_master where "
6063 "(type = 'table' or type = 'view') "
6064 "and tbl_name %s %Q",
6065 d->xcelqrx ?
"'main'" :
"NULL",
6066 d->xcelqrx ?
"''" :
"NULL",
6067 npatt ?
"like" :
"=", tname,
6068 d->xcelqrx ?
"'main'" :
"NULL",
6069 d->xcelqrx ?
"''" :
"NULL",
6070 npatt ?
"like" :
"=", tname,
6071 d->xcelqrx ?
"'main'" :
"NULL",
6072 d->xcelqrx ?
"''" :
"NULL",
6073 npatt ?
"like" :
"=", tname,
6074 d->xcelqrx ?
"'main'" :
"NULL",
6075 d->xcelqrx ?
"''" :
"NULL",
6076 npatt ?
"like" :
"=", tname,
6077 d->xcelqrx ?
"'main'" :
"NULL",
6078 d->xcelqrx ?
"''" :
"NULL",
6079 npatt ?
"like" :
"=", tname);
6081 sql = sqlite3_mprintf(
"select NULL as 'TABLE_QUALIFIER', "
6082 "NULL as 'TABLE_OWNER', "
6083 "tbl_name as 'TABLE_NAME', "
6086 "'SELECT' AS 'PRIVILEGE', "
6087 "NULL as 'IS_GRANTABLE' "
6088 "from sqlite_master where "
6089 "(type = 'table' or type = 'view') "
6090 "and tbl_name %s %Q "
6092 "select NULL as 'TABLE_QUALIFIER', "
6093 "NULL as 'TABLE_OWNER', "
6094 "tbl_name as 'TABLE_NAME', "
6097 "'UPDATE' AS 'PRIVILEGE', "
6098 "NULL as 'IS_GRANTABLE' "
6099 "from sqlite_master where "
6100 "(type = 'table' or type = 'view') "
6101 "and tbl_name %s %Q "
6103 "select NULL as 'TABLE_QUALIFIER', "
6104 "NULL as 'TABLE_OWNER', "
6105 "tbl_name as 'TABLE_NAME', "
6108 "'DELETE' AS 'PRIVILEGE', "
6109 "NULL as 'IS_GRANTABLE' "
6110 "from sqlite_master where "
6111 "(type = 'table' or type = 'view') "
6112 "and tbl_name %s %Q "
6114 "select NULL as 'TABLE_QUALIFIER', "
6115 "NULL as 'TABLE_OWNER', "
6116 "tbl_name as 'TABLE_NAME', "
6119 "'INSERT' AS 'PRIVILEGE', "
6120 "NULL as 'IS_GRANTABLE' "
6121 "from sqlite_master where "
6122 "(type = 'table' or type = 'view') "
6123 "and tbl_name %s %Q "
6125 "select NULL as 'TABLE_QUALIFIER', "
6126 "NULL as 'TABLE_OWNER', "
6127 "tbl_name as 'TABLE_NAME', "
6130 "'REFERENCES' AS 'PRIVILEGE', "
6131 "NULL as 'IS_GRANTABLE' "
6132 "from sqlite_master where "
6133 "(type = 'table' or type = 'view') "
6134 "and tbl_name %s %Q",
6135 npatt ?
"like" :
"=", tname,
6136 npatt ?
"like" :
"=", tname,
6137 npatt ?
"like" :
"=", tname,
6138 npatt ?
"like" :
"=", tname,
6139 npatt ?
"like" :
"=", tname);
6145 if (ret != SQL_SUCCESS) {
6150 rc = sqlite3_get_table(d->
sqlite, sql, &s->
rows, &s->
nrows, &ncols, &errp);
6152 if (rc == SQLITE_OK) {
6153 if (ncols != s->
ncols) {
6157 s->
rowfree = sqlite3_free_table;
6173 #if !defined(WINTERFACE) || (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC))
6187 SQLTablePrivileges(SQLHSTMT
stmt,
6188 SQLCHAR *catalog, SQLSMALLINT catalogLen,
6189 SQLCHAR *schema, SQLSMALLINT schemaLen,
6190 SQLCHAR *table, SQLSMALLINT tableLen)
6192 #if defined(_WIN32) || defined(_WIN64)
6193 char *c = NULL, *s = NULL, *t = NULL;
6198 #if defined(_WIN32) || defined(_WIN64)
6199 if (!((
STMT *) stmt)->oemcp[0]) {
6205 c = wmb_to_utf_c((
char *) catalog, catalogLen);
6212 s = wmb_to_utf_c((
char *) schema, schemaLen);
6219 t = wmb_to_utf_c((
char *) table, tableLen);
6226 (SQLCHAR *) s, SQL_NTS,
6227 (SQLCHAR *) t, SQL_NTS);
6232 #if defined(_WIN32) || defined(_WIN64)
6245 #if !defined(HAVE_UNIXODBC) || !(HAVE_UNIXODBC)
6261 SQLWCHAR *catalog, SQLSMALLINT catalogLen,
6262 SQLWCHAR *schema, SQLSMALLINT schemaLen,
6263 SQLWCHAR *table, SQLSMALLINT tableLen)
6265 char *c = NULL, *s = NULL, *t = NULL;
6291 (SQLCHAR *) s, SQL_NTS,
6292 (SQLCHAR *) t, SQL_NTS);
6308 {
"SYSTEM",
"COLPRIV",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
6309 {
"SYSTEM",
"COLPRIV",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
6310 {
"SYSTEM",
"COLPRIV",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
6311 {
"SYSTEM",
"COLPRIV",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6318 {
"SYSTEM",
"COLPRIV",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
6319 {
"SYSTEM",
"COLPRIV",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
6320 {
"SYSTEM",
"COLPRIV",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
6321 {
"SYSTEM",
"COLPRIV",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6327 #if !defined(WINTERFACE) || (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC))
6343 SQLColumnPrivileges(SQLHSTMT stmt,
6344 SQLCHAR *catalog, SQLSMALLINT catalogLen,
6345 SQLCHAR *schema, SQLSMALLINT schemaLen,
6346 SQLCHAR *table, SQLSMALLINT tableLen,
6347 SQLCHAR *column, SQLSMALLINT columnLen)
6353 colPrivSpec3,
array_size(colPrivSpec3), NULL);
6359 #if !defined(HAVE_UNIXODBC) || !(HAVE_UNIXODBC)
6377 SQLWCHAR *catalog, SQLSMALLINT catalogLen,
6378 SQLWCHAR *schema, SQLSMALLINT schemaLen,
6379 SQLWCHAR *table, SQLSMALLINT tableLen,
6380 SQLWCHAR *column, SQLSMALLINT columnLen)
6386 colPrivSpec3,
array_size(colPrivSpec3), NULL);
6398 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
6399 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
6400 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
6401 {
"SYSTEM",
"PRIMARYKEY",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6402 {
"SYSTEM",
"PRIMARYKEY",
"KEY_SEQ", SQL_SMALLINT, 50 },
6403 {
"SYSTEM",
"PRIMARYKEY",
"PK_NAME",
SCOL_VARCHAR, 50 }
6407 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
6408 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
6409 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
6410 {
"SYSTEM",
"PRIMARYKEY",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6411 {
"SYSTEM",
"PRIMARYKEY",
"KEY_SEQ", SQL_SMALLINT, 50 },
6412 {
"SYSTEM",
"PRIMARYKEY",
"PK_NAME",
SCOL_VARCHAR, 50 }
6429 SQLCHAR *cat, SQLSMALLINT catLen,
6430 SQLCHAR *schema, SQLSMALLINT schemaLen,
6431 SQLCHAR *table, SQLSMALLINT tableLen)
6436 int i, asize, ret, nrows, ncols, nrows2 = 0, ncols2 = 0;
6437 int namec = -1, uniquec = -1, namec2 = -1, uniquec2 = -1, offs, seq = 1;
6439 char **rowp = NULL, **rowp2 = NULL, *errp = NULL, *sql, tname[512];
6443 if (sret != SQL_SUCCESS) {
6448 if (!table || table[0] ==
'\0' || table[0] ==
'%') {
6449 setstat(s, -1,
"need table name", (*s->
ov3) ?
"HY000" :
"S1000");
6452 if (tableLen == SQL_NTS) {
6453 size =
sizeof (tname) - 1;
6455 size =
min(
sizeof (tname) - 1, tableLen);
6457 strncpy(tname, (
char *) table, size);
6460 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", tname);
6465 if (sret != SQL_SUCCESS) {
6470 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
6472 if (ret != SQLITE_OK) {
6473 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
6474 errp ? errp :
"unknown error", ret);
6486 if (ncols * nrows > 0) {
6489 namec =
findcol(rowp, ncols,
"name");
6490 uniquec =
findcol(rowp, ncols,
"pk");
6491 typec =
findcol(rowp, ncols,
"type");
6492 if (namec >= 0 && uniquec >= 0 && typec >= 0) {
6493 for (i = 1; i <= nrows; i++) {
6494 if (*rowp[i * ncols + uniquec] !=
'0') {
6501 sql = sqlite3_mprintf(
"PRAGMA index_list(%Q)", tname);
6503 sqlite3_free_table(rowp);
6507 ret = sqlite3_get_table(d->
sqlite, sql, &rowp2, &nrows2, &ncols2,
6510 if (ret != SQLITE_OK) {
6511 sqlite3_free_table(rowp);
6512 sqlite3_free_table(rowp2);
6513 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
6514 errp ? errp :
"unknown error", ret);
6526 if (ncols2 * nrows2 > 0) {
6527 namec2 =
findcol(rowp2, ncols2,
"name");
6528 uniquec2 =
findcol(rowp2, ncols2,
"unique");
6529 if (namec2 >= 0 && uniquec2 >= 0) {
6530 for (i = 1; i <= nrows2; i++) {
6531 int nnrows, nncols, nlen = 0;
6534 if (rowp2[i * ncols2 + namec2]) {
6535 nlen = strlen(rowp2[i * ncols2 + namec2]);
6538 strncmp(rowp2[i * ncols2 + namec2],
6539 "sqlite_autoindex_", 17)) {
6542 if (*rowp2[i * ncols2 + uniquec2] !=
'0') {
6544 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
6545 rowp2[i * ncols2 + namec2]);
6548 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
6549 &nnrows, &nncols, NULL);
6552 if (ret == SQLITE_OK) {
6554 sqlite3_free_table(rowpp);
6561 sqlite3_free_table(rowp);
6562 sqlite3_free_table(rowp2);
6566 size = (size + 1) * asize;
6570 sqlite3_free_table(rowp);
6571 sqlite3_free_table(rowp2);
6574 s->
rows[0] = (
char *) size;
6576 memset(s->
rows, 0, sizeof (
char *) * size);
6580 for (i = 1; i <= nrows; i++) {
6581 if (*rowp[i * ncols + uniquec] !=
'0') {
6584 #if defined(_WIN32) || defined(_WIN64)
6585 s->
rows[offs + 0] =
xstrdup(d->xcelqrx ?
"main" :
"");
6592 s->
rows[offs + 3] =
xstrdup(rowp[i * ncols + namec]);
6593 sprintf(buf,
"%d", seq++);
6600 for (i = 1; i <= nrows2; i++) {
6601 int nnrows, nncols, nlen = 0;
6604 if (rowp2[i * ncols2 + namec2]) {
6605 nlen = strlen(rowp2[i * ncols2 + namec2]);
6608 strncmp(rowp2[i * ncols2 + namec2],
"sqlite_autoindex_", 17)) {
6611 if (*rowp2[i * ncols2 + uniquec2] !=
'0') {
6615 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
6616 rowp2[i * ncols2 + namec2]);
6619 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
6620 &nnrows, &nncols, NULL);
6623 if (ret != SQLITE_OK) {
6626 for (k = 0; nnrows && k < nncols; k++) {
6627 if (strcmp(rowpp[k],
"name") == 0) {
6630 for (m = 1; m <= nnrows; m++) {
6631 int roffs = offs + (m - 1) * s->
ncols;
6633 #
if defined(_WIN32) || defined(_WIN64)
6634 s->
rows[roffs + 0] =
6635 xstrdup(d->xcelqrx ?
"main" :
"");
6642 s->
rows[roffs + 3] =
6643 xstrdup(rowpp[m * nncols + k]);
6644 s->
rows[roffs + 5] =
6645 xstrdup(rowp2[i * ncols2 + namec2]);
6647 }
else if (strcmp(rowpp[k],
"seqno") == 0) {
6650 for (m = 1; m <= nnrows; m++) {
6651 int roffs = offs + (m - 1) * s->
ncols;
6655 sscanf(rowpp[m * nncols + k],
"%d", &pos);
6656 sprintf(buf,
"%d", pos + 1);
6661 offs += nnrows * s->
ncols;
6662 sqlite3_free_table(rowpp);
6666 sqlite3_free_table(rowp);
6667 sqlite3_free_table(rowp2);
6685 SQLPrimaryKeys(SQLHSTMT stmt,
6686 SQLCHAR *cat, SQLSMALLINT catLen,
6687 SQLCHAR *schema, SQLSMALLINT schemaLen,
6688 SQLCHAR *table, SQLSMALLINT tableLen)
6690 #if defined(_WIN32) || defined(_WIN64)
6691 char *c = NULL, *s = NULL, *t = NULL;
6696 #if defined(_WIN32) || defined(_WIN64)
6697 if (!((
STMT *) stmt)->oemcp[0]) {
6703 c = wmb_to_utf_c((
char *) cat, catLen);
6710 s = wmb_to_utf_c((
char *) schema, schemaLen);
6717 t = wmb_to_utf_c((
char *) table, tableLen);
6724 (SQLCHAR *) s, SQL_NTS, (SQLCHAR *) t, SQL_NTS);
6729 #if defined(_WIN32) || defined(_WIN64)
6757 SQLWCHAR *cat, SQLSMALLINT catLen,
6758 SQLWCHAR *schema, SQLSMALLINT schemaLen,
6759 SQLWCHAR *table, SQLSMALLINT tableLen)
6761 char *c = NULL, *s = NULL, *t = NULL;
6787 (SQLCHAR *) s, SQL_NTS, (SQLCHAR *) t, SQL_NTS);
6802 {
"SYSTEM",
"COLUMN",
"SCOPE", SQL_SMALLINT, 1 },
6803 {
"SYSTEM",
"COLUMN",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6804 {
"SYSTEM",
"COLUMN",
"DATA_TYPE", SQL_SMALLINT, 50 },
6806 {
"SYSTEM",
"COLUMN",
"PRECISION", SQL_INTEGER, 50 },
6807 {
"SYSTEM",
"COLUMN",
"LENGTH", SQL_INTEGER, 50 },
6808 {
"SYSTEM",
"COLUMN",
"DECIMAL_DIGITS", SQL_INTEGER, 50 },
6809 {
"SYSTEM",
"COLUMN",
"PSEUDO_COLUMN", SQL_SMALLINT, 1 },
6810 {
"SYSTEM",
"COLUMN",
"NULLABLE", SQL_SMALLINT, 1 }
6814 {
"SYSTEM",
"COLUMN",
"SCOPE", SQL_SMALLINT, 1 },
6815 {
"SYSTEM",
"COLUMN",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6816 {
"SYSTEM",
"COLUMN",
"DATA_TYPE", SQL_SMALLINT, 50 },
6818 {
"SYSTEM",
"COLUMN",
"COLUMN_SIZE", SQL_INTEGER, 50 },
6819 {
"SYSTEM",
"COLUMN",
"BUFFER_LENGTH", SQL_INTEGER, 50 },
6820 {
"SYSTEM",
"COLUMN",
"DECIMAL_DIGITS", SQL_INTEGER, 50 },
6821 {
"SYSTEM",
"COLUMN",
"PSEUDO_COLUMN", SQL_SMALLINT, 1 },
6822 {
"SYSTEM",
"COLUMN",
"NULLABLE", SQL_SMALLINT, 1 }
6842 SQLCHAR *cat, SQLSMALLINT catLen,
6843 SQLCHAR *schema, SQLSMALLINT schemaLen,
6844 SQLCHAR *table, SQLSMALLINT tableLen,
6845 SQLUSMALLINT scope, SQLUSMALLINT nullable)
6850 int i, asize, ret, nrows, ncols, nnnrows, nnncols, offs;
6852 int namec = -1, uniquec = -1, namecc = -1, typecc = -1;
6853 int notnullcc = -1, mkrowid = 0;
6854 char *errp = NULL, *sql, tname[512];
6855 char **rowp = NULL, **rowppp = NULL;
6859 if (sret != SQL_SUCCESS) {
6864 if (!table || table[0] ==
'\0' || table[0] ==
'%') {
6865 setstat(s, -1,
"need table name", (*s->
ov3) ?
"HY000" :
"S1000");
6868 if (tableLen == SQL_NTS) {
6869 size =
sizeof (tname) - 1;
6871 size =
min(
sizeof (tname) - 1, tableLen);
6873 strncpy(tname, (
char *) table, size);
6876 if (
id != SQL_BEST_ROWID) {
6879 sql = sqlite3_mprintf(
"PRAGMA index_list(%Q)", tname);
6884 if (sret != SQL_SUCCESS) {
6889 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
6891 if (ret != SQLITE_OK) {
6893 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
6894 errp ? errp :
"unknown error", ret);
6906 if (ncols * nrows <= 0) {
6907 goto nodata_but_rowid;
6909 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", tname);
6914 ret = sqlite3_get_table(d->
sqlite, sql, &rowppp, &nnnrows, &nnncols,
6917 if (ret != SQLITE_OK) {
6918 sqlite3_free_table(rowp);
6925 namec =
findcol(rowp, ncols,
"name");
6926 uniquec =
findcol(rowp, ncols,
"unique");
6927 if (namec < 0 || uniquec < 0) {
6928 goto nodata_but_rowid;
6930 namecc =
findcol(rowppp, nnncols,
"name");
6931 typecc =
findcol(rowppp, nnncols,
"type");
6932 notnullcc =
findcol(rowppp, nnncols,
"notnull");
6933 for (i = 1; i <= nrows; i++) {
6935 char **rowpp = NULL;
6937 if (*rowp[i * ncols + uniquec] !=
'0') {
6939 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
6940 rowp[i * ncols + namec]);
6943 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
6944 &nnrows, &nncols, NULL);
6947 if (ret == SQLITE_OK) {
6949 sqlite3_free_table(rowpp);
6959 size = (size + 1) * asize;
6963 sqlite3_free_table(rowp);
6964 sqlite3_free_table(rowppp);
6967 s->
rows[0] = (
char *) size;
6969 memset(s->
rows, 0, sizeof (
char *) * size);
6976 for (i = 1; i <= nrows; i++) {
6978 char **rowpp = NULL;
6980 if (*rowp[i * ncols + uniquec] !=
'0') {
6984 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
6985 rowp[i * ncols + namec]);
6988 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
6989 &nnrows, &nncols, NULL);
6992 if (ret != SQLITE_OK) {
6995 for (k = 0; nnrows && k < nncols; k++) {
6996 if (strcmp(rowpp[k],
"name") == 0) {
6999 for (m = 1; m <= nnrows; m++) {
7000 int roffs = (offs + m) * s->
ncols;
7002 s->
rows[roffs + 0] =
7004 s->
rows[roffs + 1] =
xstrdup(rowpp[m * nncols + k]);
7006 s->
rows[roffs + 7] =
7008 if (namecc >= 0 && typecc >= 0) {
7011 for (ii = 1; ii <= nnnrows; ii++) {
7012 if (strcmp(rowppp[ii * nnncols + namecc],
7013 rowpp[m * nncols + k]) == 0) {
7014 char *typen = rowppp[ii * nnncols + typecc];
7015 int sqltype, mm, dd, isnullable = 0;
7022 getmd(typen, sqltype, &mm, &dd);
7023 #ifdef SQL_LONGVARCHAR
7024 if (sqltype == SQL_VARCHAR && mm > 255) {
7025 sqltype = SQL_LONGVARCHAR;
7029 #ifdef SQL_WLONGVARCHAR
7030 if (sqltype == SQL_WVARCHAR && mm > 255) {
7031 sqltype = SQL_WLONGVARCHAR;
7035 if (sqltype == SQL_VARBINARY && mm > 255) {
7036 sqltype = SQL_LONGVARBINARY;
7038 sprintf(buf,
"%d", sqltype);
7040 sprintf(buf,
"%d", mm);
7042 sprintf(buf,
"%d", dd);
7044 if (notnullcc >= 0) {
7046 rowppp[ii * nnncols + notnullcc];
7048 isnullable = inp[0] !=
'0';
7050 sprintf(buf,
"%d", isnullable);
7059 sqlite3_free_table(rowpp);
7062 if (nullable == SQL_NO_NULLS) {
7063 for (i = 1; i < s->
nrows; i++) {
7064 if (s->
rows[i * s->
ncols + 8][0] ==
'0') {
7067 for (m = 0; m < s->
ncols; m++) {
7070 size = s->
ncols *
sizeof (
char *) * (s->
nrows - i1);
7076 s->
ncols * sizeof (
char *));
7084 sqlite3_free_table(rowp);
7085 sqlite3_free_table(rowppp);
7086 if (s->
nrows == 0) {
7118 SQLSpecialColumns(SQLHSTMT stmt, SQLUSMALLINT
id,
7119 SQLCHAR *cat, SQLSMALLINT catLen,
7120 SQLCHAR *schema, SQLSMALLINT schemaLen,
7121 SQLCHAR *table, SQLSMALLINT tableLen,
7122 SQLUSMALLINT scope, SQLUSMALLINT nullable)
7124 #if defined(_WIN32) || defined(_WIN64)
7125 char *c = NULL, *s = NULL, *t = NULL;
7130 #if defined(_WIN32) || defined(_WIN64)
7131 if (!((
STMT *) stmt)->oemcp[0]) {
7133 table, tableLen, scope, nullable);
7137 c = wmb_to_utf_c((
char *) cat, catLen);
7144 s = wmb_to_utf_c((
char *) schema, schemaLen);
7151 t = wmb_to_utf_c((
char *) table, tableLen);
7158 (SQLCHAR *) s, SQL_NTS, (SQLCHAR *) t, SQL_NTS,
7162 table, tableLen, scope, nullable);
7164 #if defined(_WIN32) || defined(_WIN64)
7195 SQLWCHAR *cat, SQLSMALLINT catLen,
7196 SQLWCHAR *schema, SQLSMALLINT schemaLen,
7197 SQLWCHAR *table, SQLSMALLINT tableLen,
7198 SQLUSMALLINT scope, SQLUSMALLINT nullable)
7200 char *c = NULL, *s = NULL, *t = NULL;
7226 (SQLCHAR *) s, SQL_NTS, (SQLCHAR *) t, SQL_NTS,
7242 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
7243 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_OWNER",
SCOL_VARCHAR, 50 },
7244 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_NAME",
SCOL_VARCHAR, 255 },
7245 {
"SYSTEM",
"FOREIGNKEY",
"PKCOLUMN_NAME",
SCOL_VARCHAR, 255 },
7246 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
7247 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_OWNER",
SCOL_VARCHAR, 50 },
7248 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_NAME",
SCOL_VARCHAR, 255 },
7249 {
"SYSTEM",
"FOREIGNKEY",
"FKCOLUMN_NAME",
SCOL_VARCHAR, 255 },
7250 {
"SYSTEM",
"FOREIGNKEY",
"KEY_SEQ", SQL_SMALLINT, 5 },
7251 {
"SYSTEM",
"FOREIGNKEY",
"UPDATE_RULE", SQL_SMALLINT, 5 },
7252 {
"SYSTEM",
"FOREIGNKEY",
"DELETE_RULE", SQL_SMALLINT, 5 },
7253 {
"SYSTEM",
"FOREIGNKEY",
"FK_NAME",
SCOL_VARCHAR, 255 },
7254 {
"SYSTEM",
"FOREIGNKEY",
"PK_NAME",
SCOL_VARCHAR, 255 },
7255 {
"SYSTEM",
"FOREIGNKEY",
"DEFERRABILITY", SQL_SMALLINT, 5 }
7259 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_CAT",
SCOL_VARCHAR, 50 },
7260 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_SCHEM",
SCOL_VARCHAR, 50 },
7261 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_NAME",
SCOL_VARCHAR, 255 },
7262 {
"SYSTEM",
"FOREIGNKEY",
"PKCOLUMN_NAME",
SCOL_VARCHAR, 255 },
7263 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_CAT",
SCOL_VARCHAR, 50 },
7264 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_SCHEM",
SCOL_VARCHAR, 50 },
7265 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_NAME",
SCOL_VARCHAR, 255 },
7266 {
"SYSTEM",
"FOREIGNKEY",
"FKCOLUMN_NAME",
SCOL_VARCHAR, 255 },
7267 {
"SYSTEM",
"FOREIGNKEY",
"KEY_SEQ", SQL_SMALLINT, 5 },
7268 {
"SYSTEM",
"FOREIGNKEY",
"UPDATE_RULE", SQL_SMALLINT, 5 },
7269 {
"SYSTEM",
"FOREIGNKEY",
"DELETE_RULE", SQL_SMALLINT, 5 },
7270 {
"SYSTEM",
"FOREIGNKEY",
"FK_NAME",
SCOL_VARCHAR, 255 },
7271 {
"SYSTEM",
"FOREIGNKEY",
"PK_NAME",
SCOL_VARCHAR, 255 },
7272 {
"SYSTEM",
"FOREIGNKEY",
"DEFERRABILITY", SQL_SMALLINT, 5 }
7295 SQLCHAR *PKcatalog, SQLSMALLINT PKcatalogLen,
7296 SQLCHAR *PKschema, SQLSMALLINT PKschemaLen,
7297 SQLCHAR *PKtable, SQLSMALLINT PKtableLen,
7298 SQLCHAR *FKcatalog, SQLSMALLINT FKcatalogLen,
7299 SQLCHAR *FKschema, SQLSMALLINT FKschemaLen,
7300 SQLCHAR *FKtable, SQLSMALLINT FKtableLen)
7305 int i, asize, ret, nrows, ncols, offs, namec, seqc, fromc, toc;
7308 char **rowp, *errp = NULL, *sql, pname[512], fname[512];
7312 if (sret != SQL_SUCCESS) {
7317 if (sret != SQL_SUCCESS) {
7321 if ((!PKtable || PKtable[0] ==
'\0' || PKtable[0] ==
'%') &&
7322 (!FKtable || FKtable[0] ==
'\0' || FKtable[0] ==
'%')) {
7323 setstat(s, -1,
"need table name", (*s->
ov3) ?
"HY000" :
"S1000");
7328 if (PKtableLen == SQL_NTS) {
7329 size =
sizeof (pname) - 1;
7331 size =
min(
sizeof (pname) - 1, PKtableLen);
7333 strncpy(pname, (
char *) PKtable, size);
7339 if (FKtableLen == SQL_NTS) {
7340 size =
sizeof (fname) - 1;
7342 size =
min(
sizeof (fname) - 1, FKtableLen);
7344 strncpy(fname, (
char *) FKtable, size);
7347 if (fname[0] !=
'\0') {
7351 sql = sqlite3_mprintf(
"PRAGMA foreign_key_list(%Q)", fname);
7354 ret = sqlite3_get_table(d->
sqlite, sql, &rowp,
7355 &nrows, &ncols, &errp);
7358 if (ret != SQLITE_OK) {
7359 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
7360 errp ? errp :
"unknown error", ret);
7371 if (ncols * nrows <= 0) {
7373 sqlite3_free_table(rowp);
7377 namec =
findcol(rowp, ncols,
"table");
7378 seqc =
findcol(rowp, ncols,
"seq");
7379 fromc =
findcol(rowp, ncols,
"from");
7380 toc =
findcol(rowp, ncols,
"to");
7381 onu =
findcol(rowp, ncols,
"on_update");
7382 ond =
findcol(rowp, ncols,
"on_delete");
7383 if (namec < 0 || seqc < 0 || fromc < 0 || toc < 0) {
7386 plen = strlen(pname);
7387 for (i = 1; i <= nrows; i++) {
7388 char *ptab =
unquote(rowp[i * ncols + namec]);
7391 int len = strlen(ptab);
7393 if (plen != len || strncasecmp(pname, ptab, plen) != 0) {
7403 size = (size + 1) * asize;
7409 s->
rows[0] = (
char *) size;
7411 memset(s->
rows, 0, sizeof (
char *) * size);
7414 for (i = 1; i <= nrows; i++) {
7415 int pos = 0, roffs = (offs + 1) * s->
ncols;
7416 char *ptab = rowp[i * ncols + namec];
7420 int len = strlen(ptab);
7422 if (plen != len || strncasecmp(pname, ptab, plen) != 0) {
7426 #if defined(_WIN32) || defined(_WIN64)
7427 s->
rows[roffs + 0] =
xstrdup(d->xcelqrx ?
"main" :
"");
7434 s->
rows[roffs + 3] =
xstrdup(rowp[i * ncols + toc]);
7438 s->
rows[roffs + 7] =
xstrdup(rowp[i * ncols + fromc]);
7439 sscanf(rowp[i * ncols + seqc],
"%d", &pos);
7440 sprintf(buf,
"%d", pos + 1);
7445 if (strcmp(rowp[i * ncols + onu],
"SET NULL") == 0) {
7447 }
else if (strcmp(rowp[i * ncols + onu],
"SET DEFAULT") == 0) {
7449 }
else if (strcmp(rowp[i * ncols + onu],
"CASCADE") == 0) {
7451 }
else if (strcmp(rowp[i * ncols + onu],
"RESTRICT") == 0) {
7460 if (strcmp(rowp[i * ncols + ond],
"SET NULL") == 0) {
7462 }
else if (strcmp(rowp[i * ncols + ond],
"SET DEFAULT") == 0) {
7464 }
else if (strcmp(rowp[i * ncols + ond],
"CASCADE") == 0) {
7466 }
else if (strcmp(rowp[i * ncols + ond],
"RESTRICT") == 0) {
7472 s->
rows[roffs + 11] = NULL;
7473 s->
rows[roffs + 12] = NULL;
7477 sqlite3_free_table(rowp);
7479 int nnrows, nncols, plen = strlen(pname);
7482 sql =
"select name from sqlite_master where type='table'";
7484 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
7485 if (ret != SQLITE_OK) {
7486 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
7487 errp ? errp :
"unknown error", ret);
7498 if (ncols * nrows <= 0) {
7502 for (i = 1; i <= nrows; i++) {
7510 sql = sqlite3_mprintf(
"PRAGMA foreign_key_list(%Q)", rowp[i]);
7513 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
7514 &nnrows, &nncols, NULL);
7517 if (ret != SQLITE_OK || nncols * nnrows <= 0) {
7518 sqlite3_free_table(rowpp);
7521 namec =
findcol(rowpp, nncols,
"table");
7522 seqc =
findcol(rowpp, nncols,
"seq");
7523 fromc =
findcol(rowpp, nncols,
"from");
7524 toc =
findcol(rowpp, nncols,
"to");
7525 if (namec < 0 || seqc < 0 || fromc < 0 || toc < 0) {
7526 sqlite3_free_table(rowpp);
7529 for (k = 1; k <= nnrows; k++) {
7530 char *ptab =
unquote(rowpp[k * nncols + namec]);
7533 int len = strlen(ptab);
7535 if (len != plen || strncasecmp(pname, ptab, plen) != 0) {
7541 sqlite3_free_table(rowpp);
7547 size = (size + 1) * asize;
7553 s->
rows[0] = (
char *) size;
7555 memset(s->
rows, 0, sizeof (
char *) * size);
7558 for (i = 1; i <= nrows; i++) {
7566 sql = sqlite3_mprintf(
"PRAGMA foreign_key_list(%Q)", rowp[i]);
7569 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
7570 &nnrows, &nncols, NULL);
7573 if (ret != SQLITE_OK || nncols * nnrows <= 0) {
7574 sqlite3_free_table(rowpp);
7577 namec =
findcol(rowpp, nncols,
"table");
7578 seqc =
findcol(rowpp, nncols,
"seq");
7579 fromc =
findcol(rowpp, nncols,
"from");
7580 toc =
findcol(rowpp, nncols,
"to");
7581 onu =
findcol(rowpp, nncols,
"on_update");
7582 ond =
findcol(rowpp, nncols,
"on_delete");
7583 if (namec < 0 || seqc < 0 || fromc < 0 || toc < 0) {
7584 sqlite3_free_table(rowpp);
7587 for (k = 1; k <= nnrows; k++) {
7588 int pos = 0, roffs = (offs + 1) * s->
ncols;
7589 char *ptab =
unquote(rowpp[k * nncols + namec]);
7593 int len = strlen(ptab);
7595 if (len != plen || strncasecmp(pname, ptab, plen) != 0) {
7599 #if defined(_WIN32) || defined(_WIN64)
7600 s->
rows[roffs + 0] =
xstrdup(d->xcelqrx ?
"main" :
"");
7607 s->
rows[roffs + 3] =
xstrdup(rowpp[k * nncols + toc]);
7611 s->
rows[roffs + 7] =
xstrdup(rowpp[k * nncols + fromc]);
7612 sscanf(rowpp[k * nncols + seqc],
"%d", &pos);
7613 sprintf(buf,
"%d", pos + 1);
7618 if (strcmp(rowpp[k * nncols + onu],
"SET NULL") == 0) {
7620 }
else if (strcmp(rowpp[k * nncols + onu],
"SET DEFAULT")
7622 s->
rows[roffs + 9] =
7624 }
else if (strcmp(rowpp[k * nncols + onu],
"CASCADE")
7627 }
else if (strcmp(rowpp[k * nncols + onu],
"RESTRICT")
7631 s->
rows[roffs + 9] =
7638 if (strcmp(rowpp[k * nncols + ond],
"SET NULL") == 0) {
7640 }
else if (strcmp(rowpp[k * nncols + ond],
"SET DEFAULT")
7642 s->
rows[roffs + 10] =
7644 }
else if (strcmp(rowpp[k * nncols + ond],
"CASCADE")
7647 }
else if (strcmp(rowpp[k * nncols + ond],
"RESTRICT")
7651 s->
rows[roffs + 10] =
7655 s->
rows[roffs + 11] = NULL;
7656 s->
rows[roffs + 12] = NULL;
7660 sqlite3_free_table(rowpp);
7662 sqlite3_free_table(rowp);
7687 SQLForeignKeys(SQLHSTMT stmt,
7688 SQLCHAR *PKcatalog, SQLSMALLINT PKcatalogLen,
7689 SQLCHAR *PKschema, SQLSMALLINT PKschemaLen,
7690 SQLCHAR *PKtable, SQLSMALLINT PKtableLen,
7691 SQLCHAR *FKcatalog, SQLSMALLINT FKcatalogLen,
7692 SQLCHAR *FKschema, SQLSMALLINT FKschemaLen,
7693 SQLCHAR *FKtable, SQLSMALLINT FKtableLen)
7695 #if defined(_WIN32) || defined(_WIN64)
7696 char *pc = NULL, *ps = NULL, *pt = NULL;
7697 char *fc = NULL, *fs = NULL, *ft = NULL;
7702 #if defined(_WIN32) || defined(_WIN64)
7703 if (!((
STMT *) stmt)->oemcp[0]) {
7705 PKcatalog, PKcatalogLen,
7706 PKschema, PKschemaLen, PKtable, PKtableLen,
7707 FKcatalog, FKcatalogLen,
7708 FKschema, FKschemaLen,
7709 FKtable, FKtableLen);
7713 pc = wmb_to_utf_c((
char *) PKcatalog, PKcatalogLen);
7720 ps = wmb_to_utf_c((
char *) PKschema, PKschemaLen);
7727 pt = wmb_to_utf_c((
char *) PKtable, PKtableLen);
7734 fc = wmb_to_utf_c((
char *) FKcatalog, FKcatalogLen);
7741 fs = wmb_to_utf_c((
char *) FKschema, FKschemaLen);
7748 ft = wmb_to_utf_c((
char *) FKtable, FKtableLen);
7755 (SQLCHAR *) ps, SQL_NTS, (SQLCHAR *) pt, SQL_NTS,
7756 (SQLCHAR *) fc, SQL_NTS, (SQLCHAR *) fs, SQL_NTS,
7757 (SQLCHAR *) ft, SQL_NTS);
7760 PKcatalog, PKcatalogLen,
7761 PKschema, PKschemaLen, PKtable, PKtableLen,
7762 FKcatalog, FKcatalogLen,
7763 FKschema, FKschemaLen,
7764 FKtable, FKtableLen);
7766 #if defined(_WIN32) || defined(_WIN64)
7803 SQLWCHAR *PKcatalog, SQLSMALLINT PKcatalogLen,
7804 SQLWCHAR *PKschema, SQLSMALLINT PKschemaLen,
7805 SQLWCHAR *PKtable, SQLSMALLINT PKtableLen,
7806 SQLWCHAR *FKcatalog, SQLSMALLINT FKcatalogLen,
7807 SQLWCHAR *FKschema, SQLSMALLINT FKschemaLen,
7808 SQLWCHAR *FKtable, SQLSMALLINT FKtableLen)
7810 char *pc = NULL, *ps = NULL, *pt = NULL;
7811 char *fc = NULL, *fs = NULL, *ft = NULL;
7858 (SQLCHAR *) ps, SQL_NTS, (SQLCHAR *) pt, SQL_NTS,
7859 (SQLCHAR *) fc, SQL_NTS, (SQLCHAR *) fs, SQL_NTS,
7860 (SQLCHAR *) ft, SQL_NTS);
7882 int ret = SQL_SUCCESS, rc, busy_count = 0;
7888 rc = sqlite3_exec(d->
sqlite,
"BEGIN TRANSACTION", NULL, NULL, &errp);
7889 if (rc == SQLITE_BUSY) {
7899 if (rc != SQLITE_OK) {
7900 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
7901 errp ? errp :
"unknown error", rc);
7925 int ret, busy_count = 0;
7926 char *sql, *errp = NULL;
7929 setstatd(d, -1,
"not connected", (*d->
ov3) ?
"HY000" :
"S1000");
7937 sql =
"COMMIT TRANSACTION";
7940 sql =
"ROLLBACK TRANSACTION";
7942 ret = sqlite3_exec(d->
sqlite, sql, NULL, NULL, &errp);
7944 if (ret == SQLITE_BUSY && busy_count < 10) {
7953 if (ret != SQLITE_OK) {
7954 setstatd(d, ret,
"%s", (*d->
ov3) ?
"HY000" :
"S1000",
7955 errp ? errp :
"transaction failed");
7969 setstatd(d, -1,
"invalid completion type", (*d->
ov3) ?
"HY000" :
"S1000");
7982 drvendtran(SQLSMALLINT type, SQLHANDLE handle, SQLSMALLINT comptype)
7987 #if defined(_WIN32) || defined(_WIN64)
7992 case SQL_HANDLE_DBC:
7994 if (handle == SQL_NULL_HDBC) {
7995 return SQL_INVALID_HANDLE;
7998 ret =
endtran(d, comptype, 0);
8001 case SQL_HANDLE_ENV:
8002 if (handle == SQL_NULL_HENV) {
8003 return SQL_INVALID_HANDLE;
8005 #if defined(_WIN32) || defined(_WIN64)
8008 return SQL_INVALID_HANDLE;
8010 EnterCriticalSection(&e->cs);
8012 d = ((
ENV *) handle)->dbcs;
8015 ret =
endtran(d, comptype, 0);
8017 if (ret != SQL_SUCCESS) {
8022 #if defined(_WIN32) || defined(_WIN64)
8023 LeaveCriticalSection(&e->cs);
8025 return fail ? SQL_ERROR : SQL_SUCCESS;
8027 return SQL_INVALID_HANDLE;
8039 SQLEndTran(SQLSMALLINT type, SQLHANDLE handle, SQLSMALLINT comptype)
8055 if (dbc != SQL_NULL_HDBC) {
8056 return drvendtran(SQL_HANDLE_DBC, (SQLHANDLE) dbc, type);
8058 return drvendtran(SQL_HANDLE_ENV, (SQLHANDLE) env, type);
8084 SQLNativeSql(SQLHSTMT stmt, SQLCHAR *sqlin, SQLINTEGER sqlinLen,
8085 SQLCHAR *sql, SQLINTEGER sqlMax, SQLINTEGER *sqlLen)
8088 SQLRETURN ret = SQL_SUCCESS;
8091 if (sqlinLen == SQL_NTS) {
8092 sqlinLen = strlen((
char *) sqlin);
8096 strncpy((
char *) sql, (
char *) sqlin, sqlMax - 1);
8097 sqlin[sqlMax - 1] =
'\0';
8098 outLen =
min(sqlMax - 1, sqlinLen);
8106 if (sql && outLen < sqlinLen) {
8107 setstat((
STMT *) stmt, -1,
"data right truncated",
"01004");
8108 ret = SQL_SUCCESS_WITH_INFO;
8129 SQLWCHAR *sql, SQLINTEGER sqlMax, SQLINTEGER *sqlLen)
8132 SQLRETURN ret = SQL_SUCCESS;
8135 if (sqlinLen == SQL_NTS) {
8141 sqlin[sqlMax - 1] = 0;
8142 outLen =
min(sqlMax - 1, sqlinLen);
8150 if (sql && outLen < sqlinLen) {
8151 setstat((
STMT *) stmt, -1,
"data right truncated",
"01004");
8152 ret = SQL_SUCCESS_WITH_INFO;
8164 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_QUALIFIER",
SCOL_VARCHAR, 50 },
8165 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_OWNER",
SCOL_VARCHAR, 50 },
8166 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_NAME",
SCOL_VARCHAR, 255 },
8167 {
"SYSTEM",
"PROCEDURE",
"NUM_INPUT_PARAMS", SQL_SMALLINT, 5 },
8168 {
"SYSTEM",
"PROCEDURE",
"NUM_OUTPUT_PARAMS", SQL_SMALLINT, 5 },
8169 {
"SYSTEM",
"PROCEDURE",
"NUM_RESULT_SETS", SQL_SMALLINT, 5 },
8170 {
"SYSTEM",
"PROCEDURE",
"REMARKS",
SCOL_VARCHAR, 255 },
8171 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_TYPE", SQL_SMALLINT, 5 }
8175 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_CAT",
SCOL_VARCHAR, 50 },
8176 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_SCHEM",
SCOL_VARCHAR, 50 },
8177 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_NAME",
SCOL_VARCHAR, 255 },
8178 {
"SYSTEM",
"PROCEDURE",
"NUM_INPUT_PARAMS", SQL_SMALLINT, 5 },
8179 {
"SYSTEM",
"PROCEDURE",
"NUM_OUTPUT_PARAMS", SQL_SMALLINT, 5 },
8180 {
"SYSTEM",
"PROCEDURE",
"NUM_RESULT_SETS", SQL_SMALLINT, 5 },
8181 {
"SYSTEM",
"PROCEDURE",
"REMARKS",
SCOL_VARCHAR, 255 },
8182 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_TYPE", SQL_SMALLINT, 5 }
8199 SQLProcedures(SQLHSTMT stmt,
8200 SQLCHAR *catalog, SQLSMALLINT catalogLen,
8201 SQLCHAR *schema, SQLSMALLINT schemaLen,
8202 SQLCHAR *proc, SQLSMALLINT procLen)
8229 SQLWCHAR *catalog, SQLSMALLINT catalogLen,
8230 SQLWCHAR *schema, SQLSMALLINT schemaLen,
8231 SQLWCHAR *proc, SQLSMALLINT procLen)
8248 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_QUALIFIER",
SCOL_VARCHAR, 50 },
8249 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_OWNER",
SCOL_VARCHAR, 50 },
8250 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_NAME",
SCOL_VARCHAR, 255 },
8251 {
"SYSTEM",
"PROCCOL",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
8252 {
"SYSTEM",
"PROCCOL",
"COLUMN_TYPE", SQL_SMALLINT, 5 },
8253 {
"SYSTEM",
"PROCCOL",
"DATA_TYPE", SQL_SMALLINT, 5 },
8254 {
"SYSTEM",
"PROCCOL",
"TYPE_NAME",
SCOL_VARCHAR, 50 },
8255 {
"SYSTEM",
"PROCCOL",
"PRECISION", SQL_INTEGER, 10 },
8256 {
"SYSTEM",
"PROCCOL",
"LENGTH", SQL_INTEGER, 10 },
8257 {
"SYSTEM",
"PROCCOL",
"SCALE", SQL_SMALLINT, 5 },
8258 {
"SYSTEM",
"PROCCOL",
"RADIX", SQL_SMALLINT, 5 },
8259 {
"SYSTEM",
"PROCCOL",
"NULLABLE", SQL_SMALLINT, 5 },
8261 {
"SYSTEM",
"PROCCOL",
"COLUMN_DEF",
SCOL_VARCHAR, 50 },
8262 {
"SYSTEM",
"PROCCOL",
"SQL_DATA_TYPE", SQL_SMALLINT, 5 },
8263 {
"SYSTEM",
"PROCCOL",
"SQL_DATETIME_SUB", SQL_SMALLINT, 5 },
8264 {
"SYSTEM",
"PROCCOL",
"CHAR_OCTET_LENGTH", SQL_SMALLINT, 5 },
8265 {
"SYSTEM",
"PROCCOL",
"ORDINAL_POSITION", SQL_SMALLINT, 5 },
8266 {
"SYSTEM",
"PROCCOL",
"IS_NULLABLE",
SCOL_VARCHAR, 50 }
8270 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_CAT",
SCOL_VARCHAR, 50 },
8271 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_SCHEM",
SCOL_VARCHAR, 50 },
8272 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_NAME",
SCOL_VARCHAR, 255 },
8273 {
"SYSTEM",
"PROCCOL",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
8274 {
"SYSTEM",
"PROCCOL",
"COLUMN_TYPE", SQL_SMALLINT, 5 },
8275 {
"SYSTEM",
"PROCCOL",
"DATA_TYPE", SQL_SMALLINT, 5 },
8276 {
"SYSTEM",
"PROCCOL",
"TYPE_NAME",
SCOL_VARCHAR, 50 },
8277 {
"SYSTEM",
"PROCCOL",
"COLUMN_SIZE", SQL_INTEGER, 10 },
8278 {
"SYSTEM",
"PROCCOL",
"BUFFER_LENGTH", SQL_INTEGER, 10 },
8279 {
"SYSTEM",
"PROCCOL",
"DECIMAL_DIGITS", SQL_SMALLINT, 5 },
8280 {
"SYSTEM",
"PROCCOL",
"NUM_PREC_RADIX", SQL_SMALLINT, 5 },
8281 {
"SYSTEM",
"PROCCOL",
"NULLABLE", SQL_SMALLINT, 5 },
8283 {
"SYSTEM",
"PROCCOL",
"COLUMN_DEF",
SCOL_VARCHAR, 50 },
8284 {
"SYSTEM",
"PROCCOL",
"SQL_DATA_TYPE", SQL_SMALLINT, 5 },
8285 {
"SYSTEM",
"PROCCOL",
"SQL_DATETIME_SUB", SQL_SMALLINT, 5 },
8286 {
"SYSTEM",
"PROCCOL",
"CHAR_OCTET_LENGTH", SQL_SMALLINT, 5 },
8287 {
"SYSTEM",
"PROCCOL",
"ORDINAL_POSITION", SQL_SMALLINT, 5 },
8288 {
"SYSTEM",
"PROCCOL",
"IS_NULLABLE",
SCOL_VARCHAR, 50 }
8307 SQLProcedureColumns(SQLHSTMT stmt,
8308 SQLCHAR *catalog, SQLSMALLINT catalogLen,
8309 SQLCHAR *schema, SQLSMALLINT schemaLen,
8310 SQLCHAR *proc, SQLSMALLINT procLen,
8311 SQLCHAR *column, SQLSMALLINT columnLen)
8317 procColSpec3,
array_size(procColSpec3), NULL);
8341 SQLWCHAR *catalog, SQLSMALLINT catalogLen,
8342 SQLWCHAR *schema, SQLSMALLINT schemaLen,
8343 SQLWCHAR *proc, SQLSMALLINT procLen,
8344 SQLWCHAR *column, SQLSMALLINT columnLen)
8350 procColSpec3,
array_size(procColSpec3), NULL);
8368 SQLINTEGER len, SQLINTEGER *lenp)
8371 SQLRETURN ret = SQL_ERROR;
8373 if (env == SQL_NULL_HENV) {
8374 return SQL_INVALID_HANDLE;
8378 return SQL_INVALID_HANDLE;
8380 #if defined(_WIN32) || defined(_WIN64)
8381 EnterCriticalSection(&e->cs);
8384 case SQL_ATTR_CONNECTION_POOLING:
8387 case SQL_ATTR_CP_MATCH:
8390 case SQL_ATTR_OUTPUT_NTS:
8392 *((SQLINTEGER *) val) = SQL_TRUE;
8395 *lenp =
sizeof (SQLINTEGER);
8399 case SQL_ATTR_ODBC_VERSION:
8401 *((SQLINTEGER *) val) = e->
ov3 ? SQL_OV_ODBC3 : SQL_OV_ODBC2;
8404 *lenp =
sizeof (SQLINTEGER);
8409 #if defined(_WIN32) || defined(_WIN64)
8410 LeaveCriticalSection(&e->cs);
8428 SQLRETURN ret = SQL_ERROR;
8430 if (env == SQL_NULL_HENV) {
8431 return SQL_INVALID_HANDLE;
8435 return SQL_INVALID_HANDLE;
8437 #if defined(_WIN32) || defined(_WIN64)
8438 EnterCriticalSection(&e->cs);
8441 case SQL_ATTR_CONNECTION_POOLING:
8444 case SQL_ATTR_CP_MATCH:
8447 case SQL_ATTR_OUTPUT_NTS:
8448 if (val == (SQLPOINTER) SQL_TRUE) {
8452 case SQL_ATTR_ODBC_VERSION:
8456 if (val == (SQLPOINTER) SQL_OV_ODBC2) {
8460 if (val == (SQLPOINTER) SQL_OV_ODBC3) {
8466 #if defined(_WIN32) || defined(_WIN64)
8467 LeaveCriticalSection(&e->cs);
8487 SQLCHAR *sqlstate, SQLINTEGER *nativeerr, SQLCHAR *msg,
8488 SQLSMALLINT buflen, SQLSMALLINT *msglen)
8493 char *logmsg, *sqlst;
8494 SQLRETURN ret = SQL_ERROR;
8496 if (handle == SQL_NULL_HANDLE) {
8497 return SQL_INVALID_HANDLE;
8502 if (msg && buflen > 0) {
8512 case SQL_HANDLE_ENV:
8513 case SQL_HANDLE_DESC:
8515 case SQL_HANDLE_DBC:
8518 logmsg = (
char *) d->
logmsg;
8522 case SQL_HANDLE_STMT:
8524 s = (
STMT *) handle;
8525 logmsg = (
char *) s->
logmsg;
8530 return SQL_INVALID_HANDLE;
8539 len = strlen(logmsg);
8545 *nativeerr = naterr;
8548 strcpy((
char *) sqlstate, sqlst);
8553 if (len >= buflen) {
8554 if (msg && buflen > 0) {
8555 strncpy((
char *) msg, logmsg, buflen);
8556 msg[buflen - 1] =
'\0';
8560 strcpy((
char *) msg, logmsg);
8566 case SQL_HANDLE_DBC:
8569 case SQL_HANDLE_STMT:
8576 #if !defined(WINTERFACE) || (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC))
8591 SQLGetDiagRec(SQLSMALLINT htype, SQLHANDLE handle, SQLSMALLINT recno,
8592 SQLCHAR *sqlstate, SQLINTEGER *nativeerr, SQLCHAR *msg,
8593 SQLSMALLINT buflen, SQLSMALLINT *msglen)
8596 nativeerr, msg, buflen, msglen);
8600 #if !defined(HAVE_UNIXODBC) || !(HAVE_UNIXODBC)
8618 SQLWCHAR *sqlstate, SQLINTEGER *nativeerr, SQLWCHAR *msg,
8619 SQLSMALLINT buflen, SQLSMALLINT *msglen)
8625 ret =
drvgetdiagrec(htype, handle, recno, (SQLCHAR *) state,
8626 nativeerr, (SQLCHAR *) msg, buflen, &len);
8627 if (ret == SQL_SUCCESS) {
8630 6 *
sizeof (SQLWCHAR));
8639 buflen /=
sizeof (SQLWCHAR);
8659 len *=
sizeof (SQLWCHAR);
8664 }
else if (ret == SQL_NO_DATA) {
8696 SQLSMALLINT
id, SQLPOINTER info,
8697 SQLSMALLINT buflen, SQLSMALLINT *stringlen)
8701 int len, naterr,
strbuf = 1;
8702 char *logmsg, *sqlst, *clrmsg = NULL;
8703 SQLRETURN ret = SQL_ERROR;
8705 if (handle == SQL_NULL_HANDLE) {
8706 return SQL_INVALID_HANDLE;
8712 case SQL_HANDLE_ENV:
8713 case SQL_HANDLE_DESC:
8715 case SQL_HANDLE_DBC:
8718 logmsg = (
char *) d->
logmsg;
8722 case SQL_HANDLE_STMT:
8724 s = (
STMT *) handle;
8726 logmsg = (
char *) s->
logmsg;
8731 return SQL_INVALID_HANDLE;
8735 case SQL_IS_POINTER:
8736 case SQL_IS_UINTEGER:
8737 case SQL_IS_INTEGER:
8738 case SQL_IS_USMALLINT:
8739 case SQL_IS_SMALLINT:
8752 case SQL_DIAG_CLASS_ORIGIN:
8753 logmsg =
"ISO 9075";
8754 if (sqlst[0] ==
'I' && sqlst[1] ==
'M') {
8755 logmsg =
"ODBC 3.0";
8758 case SQL_DIAG_SUBCLASS_ORIGIN:
8759 logmsg =
"ISO 9075";
8760 if (sqlst[0] ==
'I' && sqlst[1] ==
'M') {
8761 logmsg =
"ODBC 3.0";
8762 }
else if (sqlst[0] ==
'H' && sqlst[1] ==
'Y') {
8763 logmsg =
"ODBC 3.0";
8764 }
else if (sqlst[0] ==
'2' || sqlst[0] ==
'0' || sqlst[0] ==
'4') {
8765 logmsg =
"ODBC 3.0";
8768 case SQL_DIAG_CONNECTION_NAME:
8769 case SQL_DIAG_SERVER_NAME:
8770 logmsg = d->
dsn ? d->
dsn :
"No DSN";
8772 case SQL_DIAG_SQLSTATE:
8775 case SQL_DIAG_MESSAGE_TEXT:
8780 case SQL_DIAG_NUMBER:
8783 case SQL_DIAG_NATIVE:
8784 len = strlen(logmsg);
8790 *((SQLINTEGER *) info) = naterr;
8794 case SQL_DIAG_DYNAMIC_FUNCTION:
8797 case SQL_DIAG_CURSOR_ROW_COUNT:
8798 if (htype == SQL_HANDLE_STMT) {
8806 case SQL_DIAG_ROW_COUNT:
8807 if (htype == SQL_HANDLE_STMT) {
8818 if (info && buflen > 0) {
8819 ((
char *) info)[0] =
'\0';
8821 len = strlen(logmsg);
8830 if (len >= buflen) {
8831 if (info && buflen > 0) {
8833 *stringlen = buflen - 1;
8835 strncpy((
char *) info, logmsg, buflen);
8836 ((
char *) info)[buflen - 1] =
'\0';
8839 strcpy((
char *) info, logmsg);
8848 case SQL_HANDLE_DBC:
8851 case SQL_HANDLE_STMT:
8872 SQLGetDiagField(SQLSMALLINT htype, SQLHANDLE handle, SQLSMALLINT recno,
8873 SQLSMALLINT
id, SQLPOINTER info,
8874 SQLSMALLINT buflen, SQLSMALLINT *stringlen)
8876 return drvgetdiagfield(htype, handle, recno,
id, info, buflen, stringlen);
8895 SQLSMALLINT
id, SQLPOINTER info,
8896 SQLSMALLINT buflen, SQLSMALLINT *stringlen)
8902 if (ret == SQL_SUCCESS) {
8905 case SQL_DIAG_CLASS_ORIGIN:
8906 case SQL_DIAG_SUBCLASS_ORIGIN:
8907 case SQL_DIAG_CONNECTION_NAME:
8908 case SQL_DIAG_SERVER_NAME:
8909 case SQL_DIAG_SQLSTATE:
8910 case SQL_DIAG_MESSAGE_TEXT:
8911 case SQL_DIAG_DYNAMIC_FUNCTION:
8918 buflen /=
sizeof (SQLWCHAR);
8926 len *=
sizeof (SQLWCHAR);
8934 ((SQLWCHAR *) info)[0] = 0;
8940 case SQL_DIAG_CLASS_ORIGIN:
8941 case SQL_DIAG_SUBCLASS_ORIGIN:
8942 case SQL_DIAG_CONNECTION_NAME:
8943 case SQL_DIAG_SERVER_NAME:
8944 case SQL_DIAG_SQLSTATE:
8945 case SQL_DIAG_MESSAGE_TEXT:
8946 case SQL_DIAG_DYNAMIC_FUNCTION:
8947 len *=
sizeof (SQLWCHAR);
8971 SQLINTEGER bufmax, SQLINTEGER *buflen)
8982 uval = (SQLPOINTER) dummybuf;
8985 case SQL_QUERY_TIMEOUT:
8989 case SQL_ATTR_CURSOR_TYPE:
8993 case SQL_ATTR_CURSOR_SCROLLABLE:
8994 *uval = (s->
curtype != SQL_CURSOR_FORWARD_ONLY) ?
8995 SQL_SCROLLABLE : SQL_NONSCROLLABLE;
8998 #ifdef SQL_ATTR_CURSOR_SENSITIVITY
8999 case SQL_ATTR_CURSOR_SENSITIVITY:
9000 *uval = SQL_UNSPECIFIED;
9004 case SQL_ATTR_ROW_NUMBER:
9009 *uval = (s->
rowp < 0) ? SQL_ROW_NUMBER_UNKNOWN : (s->
rowp + 1);
9013 case SQL_ATTR_ASYNC_ENABLE:
9014 *uval = SQL_ASYNC_ENABLE_OFF;
9017 case SQL_CONCURRENCY:
9018 *uval = SQL_CONCUR_LOCK;
9021 case SQL_ATTR_RETRIEVE_DATA:
9025 case SQL_ROWSET_SIZE:
9026 case SQL_ATTR_ROW_ARRAY_SIZE:
9031 case SQL_ATTR_IMP_ROW_DESC:
9032 case SQL_ATTR_APP_ROW_DESC:
9033 case SQL_ATTR_IMP_PARAM_DESC:
9034 case SQL_ATTR_APP_PARAM_DESC:
9035 *((SQLHDESC *) uval) = (SQLHDESC)
DEAD_MAGIC;
9036 *buflen =
sizeof (SQLHDESC);
9038 case SQL_ATTR_ROW_STATUS_PTR:
9040 *buflen =
sizeof (SQLUSMALLINT *);
9042 case SQL_ATTR_ROWS_FETCHED_PTR:
9046 case SQL_ATTR_USE_BOOKMARKS: {
9049 *(SQLUINTEGER *) uval = s->
bkmrk;
9050 *buflen = sizeof (SQLUINTEGER);
9053 case SQL_ATTR_FETCH_BOOKMARK_PTR:
9054 *(SQLPOINTER *) uval = s->
bkmrkptr;
9055 *buflen = sizeof (SQLPOINTER);
9057 case SQL_ATTR_PARAM_BIND_OFFSET_PTR:
9061 case SQL_ATTR_PARAM_BIND_TYPE:
9065 case SQL_ATTR_PARAM_OPERATION_PTR:
9066 *((SQLUSMALLINT **) uval) = s->
parm_oper;
9067 *buflen =
sizeof (SQLUSMALLINT *);
9069 case SQL_ATTR_PARAM_STATUS_PTR:
9071 *buflen =
sizeof (SQLUSMALLINT *);
9073 case SQL_ATTR_PARAMS_PROCESSED_PTR:
9077 case SQL_ATTR_PARAMSET_SIZE:
9081 case SQL_ATTR_ROW_BIND_TYPE:
9085 case SQL_ATTR_ROW_BIND_OFFSET_PTR:
9089 case SQL_ATTR_MAX_ROWS:
9093 case SQL_ATTR_MAX_LENGTH:
9094 *((
SQLULEN *) uval) = 1000000000;
9097 #ifdef SQL_ATTR_METADATA_ID
9098 case SQL_ATTR_METADATA_ID:
9099 *((
SQLULEN *) uval) = SQL_FALSE;
9107 #if (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC)) || !defined(WINTERFACE)
9119 SQLGetStmtAttr(SQLHSTMT stmt, SQLINTEGER attr, SQLPOINTER val,
9120 SQLINTEGER bufmax, SQLINTEGER *buflen)
9144 SQLINTEGER bufmax, SQLINTEGER *buflen)
9169 #if defined(SQL_BIGINT) && defined(__WORDSIZE) && (__WORDSIZE == 64)
9172 uval = (SQLBIGINT) val;
9179 case SQL_ATTR_CURSOR_TYPE:
9180 if (val == (SQLPOINTER) SQL_CURSOR_FORWARD_ONLY) {
9181 s->
curtype = SQL_CURSOR_FORWARD_ONLY;
9183 s->
curtype = SQL_CURSOR_STATIC;
9185 if (val != (SQLPOINTER) SQL_CURSOR_FORWARD_ONLY &&
9186 val != (SQLPOINTER) SQL_CURSOR_STATIC) {
9190 case SQL_ATTR_CURSOR_SCROLLABLE:
9191 if (val == (SQLPOINTER) SQL_NONSCROLLABLE) {
9192 s->
curtype = SQL_CURSOR_FORWARD_ONLY;
9194 s->
curtype = SQL_CURSOR_STATIC;
9197 case SQL_ATTR_ASYNC_ENABLE:
9198 if (val != (SQLPOINTER) SQL_ASYNC_ENABLE_OFF) {
9200 setstat(s, -1,
"option value changed",
"01S02");
9201 return SQL_SUCCESS_WITH_INFO;
9204 case SQL_CONCURRENCY:
9205 if (val != (SQLPOINTER) SQL_CONCUR_LOCK) {
9209 #ifdef SQL_ATTR_CURSOR_SENSITIVITY
9210 case SQL_ATTR_CURSOR_SENSITIVITY:
9211 if (val != (SQLPOINTER) SQL_UNSPECIFIED) {
9216 case SQL_ATTR_QUERY_TIMEOUT:
9218 case SQL_ATTR_RETRIEVE_DATA:
9219 if (val != (SQLPOINTER) SQL_RD_ON &&
9220 val != (SQLPOINTER) SQL_RD_OFF) {
9225 case SQL_ROWSET_SIZE:
9226 case SQL_ATTR_ROW_ARRAY_SIZE:
9228 setstat(s, -1,
"invalid rowset size",
"HY000");
9234 rst =
xmalloc(
sizeof (SQLUSMALLINT) * uval);
9246 case SQL_ATTR_ROW_STATUS_PTR:
9249 case SQL_ATTR_ROWS_FETCHED_PTR:
9252 case SQL_ATTR_PARAM_BIND_OFFSET_PTR:
9255 case SQL_ATTR_PARAM_BIND_TYPE:
9258 case SQL_ATTR_PARAM_OPERATION_PTR:
9261 case SQL_ATTR_PARAM_STATUS_PTR:
9264 case SQL_ATTR_PARAMS_PROCESSED_PTR:
9267 case SQL_ATTR_PARAMSET_SIZE:
9274 case SQL_ATTR_ROW_BIND_TYPE:
9277 case SQL_ATTR_ROW_BIND_OFFSET_PTR:
9280 case SQL_ATTR_USE_BOOKMARKS:
9281 if (val != (SQLPOINTER) SQL_UB_OFF &&
9282 val != (SQLPOINTER) SQL_UB_ON &&
9283 val != (SQLPOINTER) SQL_UB_VARIABLE) {
9286 if (*s->
ov3 && val == (SQLPOINTER) SQL_UB_VARIABLE) {
9287 s->
bkmrk = SQL_UB_VARIABLE;
9290 if (val == (SQLPOINTER) SQL_UB_VARIABLE) {
9291 s->
bkmrk = SQL_UB_ON;
9294 s->
bkmrk = (val == (SQLPOINTER) SQL_UB_ON) ? SQL_UB_ON : SQL_UB_OFF;
9296 case SQL_ATTR_FETCH_BOOKMARK_PTR:
9299 case SQL_ATTR_MAX_ROWS:
9302 case SQL_ATTR_MAX_LENGTH:
9303 if (val != (SQLPOINTER) 1000000000) {
9307 #ifdef SQL_ATTR_METADATA_ID
9308 case SQL_ATTR_METADATA_ID:
9309 if (val != (SQLPOINTER) SQL_FALSE) {
9318 #if (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC)) || !defined(WINTERFACE)
9329 SQLSetStmtAttr(SQLHSTMT stmt, SQLINTEGER attr, SQLPOINTER val,
9376 SQLUINTEGER *ret = (SQLUINTEGER *) param;
9379 case SQL_QUERY_TIMEOUT:
9382 case SQL_CURSOR_TYPE:
9385 case SQL_ROW_NUMBER:
9390 *ret = (s->
rowp < 0) ? SQL_ROW_NUMBER_UNKNOWN : (s->
rowp + 1);
9393 case SQL_ASYNC_ENABLE:
9394 *ret = SQL_ASYNC_ENABLE_OFF;
9396 case SQL_CONCURRENCY:
9397 *ret = SQL_CONCUR_LOCK;
9399 case SQL_ATTR_RETRIEVE_DATA:
9402 case SQL_ROWSET_SIZE:
9403 case SQL_ATTR_ROW_ARRAY_SIZE:
9406 case SQL_ATTR_MAX_ROWS:
9409 case SQL_ATTR_MAX_LENGTH:
9470 case SQL_CURSOR_TYPE:
9471 if (param == SQL_CURSOR_FORWARD_ONLY) {
9474 s->
curtype = SQL_CURSOR_STATIC;
9476 if (param != SQL_CURSOR_FORWARD_ONLY &&
9477 param != SQL_CURSOR_STATIC) {
9481 case SQL_ASYNC_ENABLE:
9482 if (param != SQL_ASYNC_ENABLE_OFF) {
9486 case SQL_CONCURRENCY:
9487 if (param != SQL_CONCUR_LOCK) {
9491 case SQL_QUERY_TIMEOUT:
9493 case SQL_RETRIEVE_DATA:
9494 if (param != SQL_RD_ON && param != SQL_RD_OFF) {
9496 setstat(s, -1,
"option value changed",
"01S02");
9497 return SQL_SUCCESS_WITH_INFO;
9501 case SQL_ROWSET_SIZE:
9502 case SQL_ATTR_ROW_ARRAY_SIZE:
9504 setstat(s, -1,
"invalid rowset size",
"HY000");
9510 rst =
xmalloc(
sizeof (SQLUSMALLINT) * param);
9522 case SQL_ATTR_MAX_ROWS:
9525 case SQL_ATTR_MAX_LENGTH:
9526 if (param != 1000000000) {
9589 setstat(s, -1,
"unbound columns", (*s->
ov3) ?
"HY000" :
"S1000");
9592 for (i = 0; i < s->
ncols; i++) {
9595 if (b->
type == SQL_UNKNOWN_TYPE || !b->
valp) {
9624 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
9625 dp = (SQLPOINTER) ((
char *) b->valp + s->
bind_type * rsi);
9627 dp = (SQLPOINTER) ((
char *) b->valp + b->max * rsi);
9630 dp = (SQLPOINTER) ((
char *) dp + *s->
bind_offs);
9634 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
9644 setstat(s, -1,
"unbound column in positional update",
9645 (*s->
ov3) ?
"HY000" :
"S1000");
9648 if (*lp == SQL_NULL_DATA) {
9649 sqlite3_bind_null(stmt, si);
9651 fprintf(d->
trace,
"-- parameter %d: NULL\n", si);
9657 case SQL_C_UTINYINT:
9659 case SQL_C_STINYINT:
9660 sqlite3_bind_int(stmt, si, *(SQLCHAR *) dp);
9662 fprintf(d->
trace,
"-- parameter %d: %d\n", si, *(SQLCHAR *) dp);
9668 sqlite3_bind_int(stmt, si, (*(SQLCHAR *) dp) ? 1 : 0);
9670 fprintf(d->
trace,
"-- parameter %d: %d\n", si,
9671 (*(SQLCHAR *) dp) ? 1 : 0);
9677 sqlite3_bind_int(stmt, si, *(SQLUSMALLINT *) dp);
9679 fprintf(d->
trace,
"-- parameter %d: %d\n", si,
9680 *(SQLUSMALLINT *) dp);
9686 sqlite3_bind_int(stmt, si, *(SQLSMALLINT *) dp);
9688 fprintf(d->
trace,
"-- parameter %d: %d\n", si,
9689 *(SQLSMALLINT *) dp);
9694 sqlite3_bind_int(stmt, si, *(SQLUINTEGER *) dp);
9696 fprintf(d->
trace,
"-- parameter %d: %ld\n", si,
9697 (
long) *(SQLUINTEGER *) dp);
9703 sqlite3_bind_int(stmt, si, *(SQLINTEGER *) dp);
9705 fprintf(d->
trace,
"-- parameter %d: %ld\n", si,
9706 (
long) *(SQLINTEGER *) dp);
9713 sqlite3_bind_int64(stmt, si, *(SQLBIGINT *) dp);
9717 "-- parameter %d: %I64d\n",
9719 "-- parameter %d: %lld\n",
9721 si, (sqlite_int64) *(SQLBIGINT *) dp);
9727 sqlite3_bind_double(stmt, si, *(
float *) dp);
9729 fprintf(d->
trace,
"-- parameter %d: %g\n", si,
9735 sqlite3_bind_double(stmt, si, *(
double *) dp);
9737 fprintf(d->
trace,
"-- parameter %d: %g\n", si,
9743 sqlite3_bind_blob(stmt, si, (
char *) dp, *lp, SQLITE_STATIC);
9745 fprintf(d->
trace,
"-- parameter %d: [BLOB]\n", si);
9755 sqlite3_bind_text(stmt, si, cp, -1, SQLITE_TRANSIENT);
9757 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si, cp);
9764 #if defined(_WIN32) || defined(_WIN64)
9766 cp = wmb_to_utf((
char *) dp, *lp);
9770 sqlite3_bind_text(stmt, si, cp, -1, SQLITE_TRANSIENT);
9772 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si, cp);
9779 if (*lp == SQL_NTS) {
9780 sqlite3_bind_text(stmt, si, (
char *) dp, -1,
9783 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si,
9788 sqlite3_bind_text(stmt, si, (
char *) dp, *lp,
9791 fprintf(d->
trace,
"-- parameter %d: '%*s'\n", si,
9792 (
int) *lp, (
char *) dp);
9798 #ifdef SQL_C_TYPE_DATE
9799 case SQL_C_TYPE_DATE:
9803 int a, b, x1, x2, y, m, dd;
9806 y = ((DATE_STRUCT *) dp)->year;
9807 m = ((DATE_STRUCT *) dp)->month;
9808 dd = ((DATE_STRUCT *) dp)->day;
9814 b = 2 - a + (a / 4);
9815 x1 = 36525 * (y + 4716) / 100;
9816 x2 = 306001 * (m + 1) / 10000;
9817 v = x1 + x2 + dd + b - 1524.5;
9818 sqlite3_bind_double(stmt, si, v);
9820 fprintf(d->
trace,
"-- parameter %d: %g\n", si, v);
9824 sprintf(strbuf,
"%04d-%02d-%02d",
9825 ((DATE_STRUCT *) dp)->year,
9826 ((DATE_STRUCT *) dp)->month,
9827 ((DATE_STRUCT *) dp)->day);
9828 sqlite3_bind_text(stmt, si, strbuf, -1, SQLITE_TRANSIENT);
9830 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si, strbuf);
9835 #ifdef SQL_C_TYPE_TIME
9836 case SQL_C_TYPE_TIME:
9843 (((TIME_STRUCT *) dp)->hour * 3600000.0 +
9844 ((TIME_STRUCT *) dp)->minute * 60000.0 +
9845 ((TIME_STRUCT *) dp)->second * 1000.0) / 86400000.0;
9846 sqlite3_bind_double(stmt, si, v);
9848 fprintf(d->
trace,
"-- parameter %d: %g\n", si, v);
9852 sprintf(strbuf,
"%02d:%02d:%02d",
9853 ((TIME_STRUCT *) dp)->hour,
9854 ((TIME_STRUCT *) dp)->minute,
9855 ((TIME_STRUCT *) dp)->second);
9856 sqlite3_bind_text(stmt, si, strbuf, -1, SQLITE_TRANSIENT);
9858 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si, strbuf);
9863 #ifdef SQL_C_TYPE_TIMESTAMP
9864 case SQL_C_TYPE_TIMESTAMP:
9866 case SQL_C_TIMESTAMP:
9868 int a, b, x1, x2, y, m, dd;
9871 y = ((TIMESTAMP_STRUCT *) dp)->year;
9872 m = ((TIMESTAMP_STRUCT *) dp)->month;
9873 dd = ((TIMESTAMP_STRUCT *) dp)->day;
9879 b = 2 - a + (a / 4);
9880 x1 = 36525 * (y + 4716) / 100;
9881 x2 = 306001 * (m + 1) / 10000;
9882 v = x1 + x2 + dd + b - 1524.5 +
9883 (((TIMESTAMP_STRUCT *) dp)->hour * 3600000.0 +
9884 ((TIMESTAMP_STRUCT *) dp)->minute * 60000.0 +
9885 ((TIMESTAMP_STRUCT *) dp)->second * 1000.0 +
9886 ((TIMESTAMP_STRUCT *) dp)->fraction / 1.0E6)
9888 sqlite3_bind_double(stmt, si, v);
9890 fprintf(d->
trace,
"-- parameter %d: %g\n", si, v);
9896 frac = (int) ((TIMESTAMP_STRUCT *) dp)->fraction;
9902 if (c->prec && c->prec <= 16) {
9903 sprintf(strbuf,
"%04d-%02d-%02d %02d:%02d:00.000",
9904 ((TIMESTAMP_STRUCT *) dp)->year,
9905 ((TIMESTAMP_STRUCT *) dp)->month,
9906 ((TIMESTAMP_STRUCT *) dp)->day,
9907 ((TIMESTAMP_STRUCT *) dp)->hour,
9908 ((TIMESTAMP_STRUCT *) dp)->minute);
9909 }
else if (c->prec && c->prec <= 19) {
9910 sprintf(strbuf,
"%04d-%02d-%02d %02d:%02d:%02d.000",
9911 ((TIMESTAMP_STRUCT *) dp)->year,
9912 ((TIMESTAMP_STRUCT *) dp)->month,
9913 ((TIMESTAMP_STRUCT *) dp)->day,
9914 ((TIMESTAMP_STRUCT *) dp)->hour,
9915 ((TIMESTAMP_STRUCT *) dp)->minute,
9916 ((TIMESTAMP_STRUCT *) dp)->second);
9918 sprintf(strbuf,
"%04d-%02d-%02d %02d:%02d:%02d.%03d",
9919 ((TIMESTAMP_STRUCT *) dp)->year,
9920 ((TIMESTAMP_STRUCT *) dp)->month,
9921 ((TIMESTAMP_STRUCT *) dp)->day,
9922 ((TIMESTAMP_STRUCT *) dp)->hour,
9923 ((TIMESTAMP_STRUCT *) dp)->minute,
9924 ((TIMESTAMP_STRUCT *) dp)->second,
9927 sqlite3_bind_text(stmt, si, strbuf, -1, SQLITE_TRANSIENT);
9929 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si, strbuf);
9935 setstat(s, -1,
"unsupported column type in positional update",
9936 (*s->
ov3) ?
"HY000" :
"S1000");
9962 setstat(s, -1,
"row out of range", (*s->
ov3) ?
"HY107" :
"S1107");
9967 if (*data == NULL) {
9968 sqlite3_bind_null(stmt, si);
9970 fprintf(d->
trace,
"-- parameter %d: NULL\n", si);
9974 sqlite3_bind_text(stmt, si, *data, -1, SQLITE_STATIC);
9976 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si, *data);
9993 int i, withinfo = 0;
9994 SQLRETURN ret = SQL_SUCCESS;
10003 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10006 dp = (SQLPOINTER) ((
char *) b->
valp + b->
max * rsi);
10009 dp = (SQLPOINTER) ((
char *) dp + *s->
bind_offs);
10013 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10016 lp = b->
lenp + rsi;
10023 int rowp = s->
rowp;
10029 if (!SQL_SUCCEEDED(ret)) {
10033 if (ret != SQL_SUCCESS) {
10035 #ifdef SQL_ROW_SUCCESS_WITH_INFO
10041 if (SQL_SUCCEEDED(ret)) {
10042 ret = withinfo ? SQL_SUCCESS_WITH_INFO : SQL_SUCCESS;
10061 int rowp, i, k, rc, nretry = 0;
10064 sqlite3_stmt *s3stmt = NULL;
10067 if (lock != SQL_LOCK_NO_CHANGE) {
10068 setstat(s, -1,
"unsupported locking mode",
10069 (*s->
ov3) ?
"HY000" :
"S1000");
10073 setstat(s, -1,
"incompatible statement",
10074 (*s->
ov3) ?
"HY000" :
"S1000");
10077 if (op == SQL_ADD) {
10079 setstat(s, -1,
"incompatible rowset",
10080 (*s->
ov3) ?
"HY000" :
"S1000");
10087 if (ret != SQL_SUCCESS) {
10090 sql =
dsappend(sql,
"INSERT INTO ");
10096 for (i = 0; i < s->
ncols; i++) {
10097 sql =
dsappend(sql, (i > 0) ?
"," :
"(");
10101 for (i = 0; i < s->
ncols; i++) {
10102 sql =
dsappend(sql, (i > 0) ?
",?" :
"(?");
10109 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10116 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10117 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10123 if (rc != SQLITE_OK) {
10125 sqlite3_finalize(s3stmt);
10129 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10132 if (rc != SQLITE_OK) {
10134 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10135 sqlite3_errmsg(d->
sqlite), rc);
10138 sqlite3_finalize(s3stmt);
10144 if (ret != SQL_SUCCESS) {
10146 sqlite3_finalize(s3stmt);
10151 rc = sqlite3_step(s3stmt);
10152 if (rc != SQLITE_DONE) {
10155 sqlite3_finalize(s3stmt);
10156 if (sqlite3_changes(d->
sqlite) > 0 && row <= s->rowset_size) {
10164 return SQL_SUCCESS;
10165 }
else if (op == SQL_UPDATE || op == SQL_DELETE) {
10167 setstat(s, -1,
"incompatible rowset",
10168 (*s->
ov3) ?
"HY000" :
"S1000");
10175 if (!SQL_SUCCEEDED(ret)) {
10185 if (op != SQL_POSITION && op != SQL_REFRESH &&
10186 op != SQL_DELETE && op != SQL_UPDATE) {
10189 if (op == SQL_POSITION) {
10190 rowp = s->
rowp + row - 1;
10191 if (!s->
rows || row == 0 || rowp < -1 || rowp >= s->
nrows) {
10193 setstat(s, -1,
"row out of range", (*s->
ov3) ?
"HY107" :
"S1107");
10197 }
else if (op == SQL_REFRESH) {
10205 if (!SQL_SUCCEEDED(ret)) {
10212 }
else if (op == SQL_DELETE) {
10213 sql =
dsappend(sql,
"DELETE FROM ");
10219 for (i = k = 0; i < s->
ncols; i++) {
10223 sql =
dsappend(sql, (k > 0) ?
" AND " :
" WHERE ");
10232 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10239 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10240 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10246 if (rc != SQLITE_OK) {
10248 sqlite3_finalize(s3stmt);
10252 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10255 if (rc != SQLITE_OK) {
10257 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10258 sqlite3_errmsg(d->
sqlite), rc);
10261 sqlite3_finalize(s3stmt);
10270 if (ret != SQL_SUCCESS) {
10272 sqlite3_finalize(s3stmt);
10277 rc = sqlite3_step(s3stmt);
10278 if (rc != SQLITE_DONE) {
10281 sqlite3_finalize(s3stmt);
10282 if (sqlite3_changes(d->
sqlite) > 0) {
10290 return SQL_SUCCESS;
10291 }
else if (op == SQL_UPDATE) {
10293 if (ret != SQL_SUCCESS) {
10302 for (i = 0; i < s->
ncols; i++) {
10303 sql =
dsappend(sql, (i > 0) ?
", " :
" SET ");
10307 for (i = k = 0; i < s->
ncols; i++) {
10311 sql =
dsappend(sql, (k > 0) ?
" AND " :
" WHERE ");
10320 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10327 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10328 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10334 if (rc != SQLITE_OK) {
10336 sqlite3_finalize(s3stmt);
10340 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10343 if (rc != SQLITE_OK) {
10345 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10346 sqlite3_errmsg(d->
sqlite), rc);
10349 sqlite3_finalize(s3stmt);
10355 if (ret != SQL_SUCCESS) {
10357 sqlite3_finalize(s3stmt);
10367 if (ret != SQL_SUCCESS) {
10369 sqlite3_finalize(s3stmt);
10374 rc = sqlite3_step(s3stmt);
10375 if (rc != SQLITE_DONE) {
10378 sqlite3_finalize(s3stmt);
10379 if (sqlite3_changes(d->
sqlite) > 0) {
10387 return SQL_SUCCESS;
10389 return SQL_SUCCESS;
10424 int row, i, k, rc, nretry = 0;
10427 sqlite3_stmt *s3stmt = NULL;
10431 setstat(s, -1,
"incompatible statement",
10432 (*s->
ov3) ?
"HY000" :
"S1000");
10435 if (op == SQL_ADD) {
10437 setstat(s, -1,
"incompatible rowset",
10438 (*s->
ov3) ?
"HY000" :
"S1000");
10442 if (ret != SQL_SUCCESS) {
10445 sql =
dsappend(sql,
"INSERT INTO ");
10451 for (i = 0; i < s->
ncols; i++) {
10452 sql =
dsappend(sql, (i > 0) ?
"," :
"(");
10456 for (i = 0; i < s->
ncols; i++) {
10457 sql =
dsappend(sql, (i > 0) ?
",?" :
"(?");
10464 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10471 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10472 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10478 if (rc != SQLITE_OK) {
10480 sqlite3_finalize(s3stmt);
10484 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10487 if (rc != SQLITE_OK) {
10488 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10489 sqlite3_errmsg(d->
sqlite), rc);
10492 sqlite3_finalize(s3stmt);
10499 if (ret != SQL_SUCCESS) {
10508 sqlite3_finalize(s3stmt);
10513 rc = sqlite3_step(s3stmt);
10514 if (rc != SQLITE_DONE) {
10515 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10516 sqlite3_errmsg(d->
sqlite), rc);
10520 if (sqlite3_changes(d->
sqlite) > 0) {
10528 if (s->
bkmrk == SQL_UB_VARIABLE &&
10533 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10541 val = (SQLPOINTER) ((
char *) val + *s->
bind_offs);
10543 *(sqlite_int64 *) val = sqlite3_last_insert_rowid(d->
sqlite);
10547 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10556 *ival =
sizeof (sqlite_int64);
10560 sqlite3_reset(s3stmt);
10563 sqlite3_finalize(s3stmt);
10564 return SQL_SUCCESS;
10565 }
else if (op == SQL_DELETE_BY_BOOKMARK) {
10567 s->
bkmrk != SQL_UB_VARIABLE ||
10570 setstat(s, -1,
"incompatible rowset",
10571 (*s->
ov3) ?
"HY000" :
"S1000");
10574 sql =
dsappend(sql,
"DELETE FROM ");
10587 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10594 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10595 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10601 if (rc != SQLITE_OK) {
10603 sqlite3_finalize(s3stmt);
10607 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10610 if (rc != SQLITE_OK) {
10611 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10612 sqlite3_errmsg(d->
sqlite), rc);
10615 sqlite3_finalize(s3stmt);
10621 sqlite_int64 rowid;
10623 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10631 val = (SQLPOINTER) ((
char *) val + *s->
bind_offs);
10636 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10645 if (*ival !=
sizeof (sqlite_int64)) {
10649 rowid = *(sqlite_int64 *) val;
10650 sqlite3_bind_int64(s3stmt, 1, rowid);
10654 "-- parameter 1: %I64d\n",
10656 "-- parameter 1: %lld\n",
10661 rc = sqlite3_step(s3stmt);
10662 if (rc != SQLITE_DONE) {
10663 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10664 sqlite3_errmsg(d->
sqlite), rc);
10672 sqlite3_finalize(s3stmt);
10675 if (sqlite3_changes(d->
sqlite) > 0) {
10684 sqlite3_reset(s3stmt);
10687 sqlite3_finalize(s3stmt);
10688 return SQL_SUCCESS;
10689 }
else if (op == SQL_UPDATE_BY_BOOKMARK) {
10691 s->
bkmrk != SQL_UB_VARIABLE ||
10694 setstat(s, -1,
"incompatible rowset",
10695 (*s->
ov3) ?
"HY000" :
"S1000");
10699 if (ret != SQL_SUCCESS) {
10708 for (i = 0, k = 0; i < s->
ncols; i++) {
10712 sql =
dsappend(sql, (k > 0) ?
", " :
" SET ");
10724 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10731 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10732 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10738 if (rc != SQLITE_OK) {
10740 sqlite3_finalize(s3stmt);
10744 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10747 if (rc != SQLITE_OK) {
10748 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10749 sqlite3_errmsg(d->
sqlite), rc);
10752 sqlite3_finalize(s3stmt);
10758 sqlite_int64 rowid;
10760 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10768 val = (SQLPOINTER) ((
char *) val + *s->
bind_offs);
10773 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10782 if (*ival !=
sizeof (sqlite_int64)) {
10791 if (ret != SQL_SUCCESS) {
10800 sqlite3_finalize(s3stmt);
10805 rowid = *(sqlite_int64 *) val;
10806 sqlite3_bind_int64(s3stmt, k, rowid);
10810 "-- parameter %d: %I64d\n",
10812 "-- parameter %d: %lld\n",
10817 rc = sqlite3_step(s3stmt);
10818 if (rc != SQLITE_DONE) {
10819 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10820 sqlite3_errmsg(d->
sqlite), rc);
10824 if (sqlite3_changes(d->
sqlite) > 0) {
10833 sqlite3_reset(s3stmt);
10836 sqlite3_finalize(s3stmt);
10837 return SQL_SUCCESS;
10839 setstat(s, -1,
"unsupported operation", (*s->
ov3) ?
"HY000" :
"S1000");
10868 SQLUSMALLINT rowset)
10878 #define strmak(dst, src, max, lenp) { \
10879 int len = strlen(src); \
10880 int cnt = min(len + 1, max); \
10881 strncpy(dst, src, cnt); \
10882 *lenp = (cnt > len) ? len : cnt; \
10897 SQLSMALLINT *valLen)
10902 #if defined(_WIN32) || defined(_WIN64)
10903 char pathbuf[301], *drvname;
10905 static char drvname[] =
"sqlite3odbc.so";
10908 if (dbc == SQL_NULL_HDBC) {
10909 return SQL_INVALID_HANDLE;
10920 valMax =
sizeof (dummyc) - 1;
10923 case SQL_MAX_USER_NAME_LEN:
10924 *((SQLSMALLINT *) val) = 16;
10925 *valLen =
sizeof (SQLSMALLINT);
10927 case SQL_USER_NAME:
10928 strmak(val,
"", valMax, valLen);
10930 case SQL_DRIVER_ODBC_VER:
10932 strmak(val, (*d->
ov3) ?
"03.00" :
"02.50", valMax, valLen);
10934 strmak(val,
"03.00", valMax, valLen);
10937 case SQL_ACTIVE_CONNECTIONS:
10938 case SQL_ACTIVE_STATEMENTS:
10939 *((SQLSMALLINT *) val) = 0;
10940 *valLen =
sizeof (SQLSMALLINT);
10942 #ifdef SQL_ASYNC_MODE
10943 case SQL_ASYNC_MODE:
10944 *((SQLUINTEGER *) val) = SQL_AM_NONE;
10945 *valLen =
sizeof (SQLUINTEGER);
10948 #ifdef SQL_CREATE_TABLE
10949 case SQL_CREATE_TABLE:
10950 *((SQLUINTEGER *) val) = SQL_CT_CREATE_TABLE |
10951 SQL_CT_COLUMN_DEFAULT |
10952 SQL_CT_COLUMN_CONSTRAINT |
10953 SQL_CT_CONSTRAINT_NON_DEFERRABLE;
10954 *valLen =
sizeof (SQLUINTEGER);
10957 #ifdef SQL_CREATE_VIEW
10958 case SQL_CREATE_VIEW:
10959 *((SQLUINTEGER *) val) = SQL_CV_CREATE_VIEW;
10960 *valLen =
sizeof (SQLUINTEGER);
10963 #ifdef SQL_DDL_INDEX
10964 case SQL_DDL_INDEX:
10965 *((SQLUINTEGER *) val) = SQL_DI_CREATE_INDEX | SQL_DI_DROP_INDEX;
10966 *valLen =
sizeof (SQLUINTEGER);
10969 #ifdef SQL_DROP_TABLE
10970 case SQL_DROP_TABLE:
10971 *((SQLUINTEGER *) val) = SQL_DT_DROP_TABLE;
10972 *valLen =
sizeof (SQLUINTEGER);
10975 #ifdef SQL_DROP_VIEW
10976 case SQL_DROP_VIEW:
10977 *((SQLUINTEGER *) val) = SQL_DV_DROP_VIEW;
10978 *valLen =
sizeof (SQLUINTEGER);
10981 #ifdef SQL_INDEX_KEYWORDS
10982 case SQL_INDEX_KEYWORDS:
10983 *((SQLUINTEGER *) val) = SQL_IK_ALL;
10984 *valLen =
sizeof (SQLUINTEGER);
10987 case SQL_DATA_SOURCE_NAME:
10990 case SQL_DRIVER_NAME:
10991 #if defined(_WIN32) || defined(_WIN64)
10992 GetModuleFileName(hModule, pathbuf,
sizeof (pathbuf));
10993 drvname = strrchr(pathbuf,
'\\');
10994 if (drvname == NULL) {
10995 drvname = strrchr(pathbuf,
'/');
10997 if (drvname == NULL) {
11003 strmak(val, drvname, valMax, valLen);
11005 case SQL_DRIVER_VER:
11008 case SQL_FETCH_DIRECTION:
11009 *((SQLUINTEGER *) val) = SQL_FD_FETCH_NEXT | SQL_FD_FETCH_FIRST |
11010 SQL_FD_FETCH_LAST | SQL_FD_FETCH_PRIOR | SQL_FD_FETCH_ABSOLUTE;
11011 *valLen =
sizeof (SQLUINTEGER);
11014 strmak(val, (*d->
ov3) ?
"03.00" :
"02.50", valMax, valLen);
11016 case SQL_ODBC_SAG_CLI_CONFORMANCE:
11017 *((SQLSMALLINT *) val) = SQL_OSCC_NOT_COMPLIANT;
11018 *valLen =
sizeof (SQLSMALLINT);
11020 case SQL_STANDARD_CLI_CONFORMANCE:
11021 *((SQLUINTEGER *) val) = SQL_SCC_XOPEN_CLI_VERSION1;
11022 *valLen =
sizeof (SQLUINTEGER);
11024 case SQL_SQL_CONFORMANCE:
11025 *((SQLUINTEGER *) val) = SQL_SC_SQL92_ENTRY;
11026 *valLen =
sizeof (SQLUINTEGER);
11028 case SQL_SERVER_NAME:
11029 case SQL_DATABASE_NAME:
11032 case SQL_SEARCH_PATTERN_ESCAPE:
11033 strmak(val,
"\\", valMax, valLen);
11035 case SQL_ODBC_SQL_CONFORMANCE:
11036 *((SQLSMALLINT *) val) = SQL_OSC_MINIMUM;
11037 *valLen =
sizeof (SQLSMALLINT);
11039 case SQL_ODBC_API_CONFORMANCE:
11040 *((SQLSMALLINT *) val) = SQL_OAC_LEVEL1;
11041 *valLen =
sizeof (SQLSMALLINT);
11043 case SQL_DBMS_NAME:
11044 strmak(val,
"SQLite", valMax, valLen);
11047 strmak(val, SQLITE_VERSION, valMax, valLen);
11049 case SQL_COLUMN_ALIAS:
11050 case SQL_NEED_LONG_DATA_LEN:
11051 strmak(val,
"Y", valMax, valLen);
11053 case SQL_ROW_UPDATES:
11054 case SQL_ACCESSIBLE_PROCEDURES:
11055 case SQL_PROCEDURES:
11056 case SQL_EXPRESSIONS_IN_ORDERBY:
11057 case SQL_ODBC_SQL_OPT_IEF:
11058 case SQL_LIKE_ESCAPE_CLAUSE:
11059 case SQL_ORDER_BY_COLUMNS_IN_SELECT:
11060 case SQL_OUTER_JOINS:
11061 case SQL_ACCESSIBLE_TABLES:
11062 case SQL_MULT_RESULT_SETS:
11063 case SQL_MULTIPLE_ACTIVE_TXN:
11064 case SQL_MAX_ROW_SIZE_INCLUDES_LONG:
11065 strmak(val,
"N", valMax, valLen);
11067 #ifdef SQL_CATALOG_NAME
11068 case SQL_CATALOG_NAME:
11069 #if defined(_WIN32) || defined(_WIN64)
11070 strmak(val, d->xcelqrx ?
"Y" :
"N", valMax, valLen);
11072 strmak(val,
"N", valMax, valLen);
11076 case SQL_DATA_SOURCE_READ_ONLY:
11077 strmak(val,
"N", valMax, valLen);
11079 #ifdef SQL_OJ_CAPABILITIES
11080 case SQL_OJ_CAPABILITIES:
11081 *((SQLUINTEGER *) val) = 0;
11082 *valLen =
sizeof (SQLUINTEGER);
11085 #ifdef SQL_MAX_IDENTIFIER_LEN
11086 case SQL_MAX_IDENTIFIER_LEN:
11087 *((SQLUSMALLINT *) val) = 255;
11088 *valLen =
sizeof (SQLUSMALLINT);
11091 case SQL_CONCAT_NULL_BEHAVIOR:
11092 *((SQLSMALLINT *) val) = SQL_CB_NULL;
11093 *valLen =
sizeof (SQLSMALLINT);
11095 case SQL_CURSOR_COMMIT_BEHAVIOR:
11096 case SQL_CURSOR_ROLLBACK_BEHAVIOR:
11097 *((SQLSMALLINT *) val) = SQL_CB_PRESERVE;
11098 *valLen =
sizeof (SQLSMALLINT);
11100 #ifdef SQL_CURSOR_SENSITIVITY
11101 case SQL_CURSOR_SENSITIVITY:
11102 *((SQLUINTEGER *) val) = SQL_UNSPECIFIED;
11103 *valLen =
sizeof (SQLUINTEGER);
11106 case SQL_DEFAULT_TXN_ISOLATION:
11107 *((SQLUINTEGER *) val) = SQL_TXN_SERIALIZABLE;
11108 *valLen =
sizeof (SQLUINTEGER);
11110 #ifdef SQL_DESCRIBE_PARAMETER
11111 case SQL_DESCRIBE_PARAMETER:
11112 strmak(val,
"Y", valMax, valLen);
11115 case SQL_TXN_ISOLATION_OPTION:
11116 *((SQLUINTEGER *) val) = SQL_TXN_SERIALIZABLE;
11117 *valLen =
sizeof (SQLUINTEGER);
11119 case SQL_IDENTIFIER_CASE:
11120 *((SQLSMALLINT *) val) = SQL_IC_SENSITIVE;
11121 *valLen =
sizeof (SQLSMALLINT);
11123 case SQL_IDENTIFIER_QUOTE_CHAR:
11124 strmak(val,
"\"", valMax, valLen);
11126 case SQL_MAX_TABLE_NAME_LEN:
11127 case SQL_MAX_COLUMN_NAME_LEN:
11128 *((SQLSMALLINT *) val) = 255;
11129 *valLen =
sizeof (SQLSMALLINT);
11131 case SQL_MAX_CURSOR_NAME_LEN:
11132 *((SQLSMALLINT *) val) = 255;
11133 *valLen =
sizeof (SQLSMALLINT);
11135 case SQL_MAX_PROCEDURE_NAME_LEN:
11136 *((SQLSMALLINT *) val) = 0;
11138 case SQL_MAX_QUALIFIER_NAME_LEN:
11139 case SQL_MAX_OWNER_NAME_LEN:
11140 *((SQLSMALLINT *) val) = 255;
11142 case SQL_OWNER_TERM:
11143 strmak(val,
"", valMax, valLen);
11145 case SQL_PROCEDURE_TERM:
11146 strmak(val,
"PROCEDURE", valMax, valLen);
11148 case SQL_QUALIFIER_NAME_SEPARATOR:
11149 strmak(val,
".", valMax, valLen);
11151 case SQL_QUALIFIER_TERM:
11152 #if defined(_WIN32) || defined(_WIN64)
11153 strmak(val, d->xcelqrx ?
"catalog" :
"", valMax, valLen);
11155 strmak(val,
"", valMax, valLen);
11158 case SQL_QUALIFIER_USAGE:
11159 #if defined(_WIN32) || defined(_WIN64)
11160 *((SQLUINTEGER *) val) = d->xcelqrx ?
11161 (SQL_CU_DML_STATEMENTS | SQL_CU_INDEX_DEFINITION |
11162 SQL_CU_TABLE_DEFINITION) : 0;
11164 *((SQLUINTEGER *) val) = 0;
11166 *valLen =
sizeof (SQLUINTEGER);
11168 case SQL_SCROLL_CONCURRENCY:
11169 *((SQLUINTEGER *) val) = SQL_SCCO_LOCK;
11170 *valLen =
sizeof (SQLUINTEGER);
11172 case SQL_SCROLL_OPTIONS:
11173 *((SQLUINTEGER *) val) = SQL_SO_STATIC | SQL_SO_FORWARD_ONLY;
11174 *valLen =
sizeof (SQLUINTEGER);
11176 case SQL_TABLE_TERM:
11177 strmak(val,
"TABLE", valMax, valLen);
11179 case SQL_TXN_CAPABLE:
11180 *((SQLSMALLINT *) val) = SQL_TC_ALL;
11181 *valLen =
sizeof (SQLSMALLINT);
11183 case SQL_CONVERT_FUNCTIONS:
11184 *((SQLUINTEGER *) val) = 0;
11185 *valLen =
sizeof (SQLUINTEGER);
11187 case SQL_SYSTEM_FUNCTIONS:
11188 case SQL_NUMERIC_FUNCTIONS:
11189 case SQL_STRING_FUNCTIONS:
11190 case SQL_TIMEDATE_FUNCTIONS:
11191 *((SQLUINTEGER *) val) = 0;
11192 *valLen =
sizeof (SQLUINTEGER);
11194 case SQL_CONVERT_BIGINT:
11195 case SQL_CONVERT_BIT:
11196 case SQL_CONVERT_CHAR:
11197 case SQL_CONVERT_DATE:
11198 case SQL_CONVERT_DECIMAL:
11199 case SQL_CONVERT_DOUBLE:
11200 case SQL_CONVERT_FLOAT:
11201 case SQL_CONVERT_INTEGER:
11202 case SQL_CONVERT_LONGVARCHAR:
11203 case SQL_CONVERT_NUMERIC:
11204 case SQL_CONVERT_REAL:
11205 case SQL_CONVERT_SMALLINT:
11206 case SQL_CONVERT_TIME:
11207 case SQL_CONVERT_TIMESTAMP:
11208 case SQL_CONVERT_TINYINT:
11209 case SQL_CONVERT_VARCHAR:
11210 *((SQLUINTEGER *) val) =
11211 SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL |
11212 SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT | SQL_CVT_REAL |
11213 SQL_CVT_DOUBLE | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR |
11214 SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_BIGINT |
11215 SQL_CVT_DATE | SQL_CVT_TIME | SQL_CVT_TIMESTAMP;
11216 *valLen =
sizeof (SQLUINTEGER);
11218 case SQL_CONVERT_BINARY:
11219 case SQL_CONVERT_VARBINARY:
11220 case SQL_CONVERT_LONGVARBINARY:
11221 *((SQLUINTEGER *) val) = 0;
11222 *valLen =
sizeof (SQLUINTEGER);
11224 case SQL_POSITIONED_STATEMENTS:
11225 *((SQLUINTEGER *) val) = 0;
11226 *valLen =
sizeof (SQLUINTEGER);
11228 case SQL_LOCK_TYPES:
11229 *((SQLUINTEGER *) val) = SQL_LCK_NO_CHANGE;
11230 *valLen =
sizeof (SQLUINTEGER);
11232 case SQL_BOOKMARK_PERSISTENCE:
11233 *((SQLUINTEGER *) val) = SQL_BP_SCROLL;
11234 *valLen =
sizeof (SQLUINTEGER);
11237 *((SQLUINTEGER *) val) = SQL_U_UNION | SQL_U_UNION_ALL;
11238 *valLen =
sizeof (SQLUINTEGER);
11240 case SQL_OWNER_USAGE:
11241 case SQL_SUBQUERIES:
11242 case SQL_TIMEDATE_ADD_INTERVALS:
11243 case SQL_TIMEDATE_DIFF_INTERVALS:
11244 *((SQLUINTEGER *) val) = 0;
11245 *valLen =
sizeof (SQLUINTEGER);
11247 case SQL_QUOTED_IDENTIFIER_CASE:
11248 *((SQLUSMALLINT *) val) = SQL_IC_SENSITIVE;
11249 *valLen =
sizeof (SQLUSMALLINT);
11251 case SQL_POS_OPERATIONS:
11252 *((SQLUINTEGER *) val) = SQL_POS_POSITION | SQL_POS_UPDATE |
11253 SQL_POS_DELETE | SQL_POS_ADD | SQL_POS_REFRESH;
11254 *valLen =
sizeof (SQLUINTEGER);
11256 case SQL_ALTER_TABLE:
11257 *((SQLUINTEGER *) val) = 0;
11258 *valLen =
sizeof (SQLUINTEGER);
11260 case SQL_CORRELATION_NAME:
11261 *((SQLSMALLINT *) val) = SQL_CN_DIFFERENT;
11262 *valLen =
sizeof (SQLSMALLINT);
11264 case SQL_NON_NULLABLE_COLUMNS:
11265 *((SQLSMALLINT *) val) = SQL_NNC_NON_NULL;
11266 *valLen =
sizeof (SQLSMALLINT);
11268 case SQL_NULL_COLLATION:
11269 *((SQLSMALLINT *) val) = SQL_NC_START;
11270 *valLen =
sizeof (SQLSMALLINT);
11272 case SQL_MAX_COLUMNS_IN_GROUP_BY:
11273 case SQL_MAX_COLUMNS_IN_ORDER_BY:
11274 case SQL_MAX_COLUMNS_IN_SELECT:
11275 case SQL_MAX_COLUMNS_IN_TABLE:
11276 case SQL_MAX_ROW_SIZE:
11277 case SQL_MAX_TABLES_IN_SELECT:
11278 *((SQLSMALLINT *) val) = 0;
11279 *valLen =
sizeof (SQLSMALLINT);
11281 case SQL_MAX_BINARY_LITERAL_LEN:
11282 case SQL_MAX_CHAR_LITERAL_LEN:
11283 *((SQLUINTEGER *) val) = 0;
11284 *valLen =
sizeof (SQLUINTEGER);
11286 case SQL_MAX_COLUMNS_IN_INDEX:
11287 *((SQLSMALLINT *) val) = 0;
11288 *valLen =
sizeof (SQLSMALLINT);
11290 case SQL_MAX_INDEX_SIZE:
11291 *((SQLUINTEGER *) val) = 0;
11292 *valLen =
sizeof (SQLUINTEGER);
11294 #ifdef SQL_MAX_IDENTIFIER_LENGTH
11295 case SQL_MAX_IDENTIFIER_LENGTH:
11296 *((SQLUINTEGER *) val) = 255;
11297 *valLen =
sizeof (SQLUINTEGER);
11300 case SQL_MAX_STATEMENT_LEN:
11301 *((SQLUINTEGER *) val) = 16384;
11302 *valLen =
sizeof (SQLUINTEGER);
11304 case SQL_QUALIFIER_LOCATION:
11305 *((SQLSMALLINT *) val) = SQL_QL_START;
11306 *valLen =
sizeof (SQLSMALLINT);
11308 case SQL_GETDATA_EXTENSIONS:
11309 *((SQLUINTEGER *) val) =
11310 SQL_GD_ANY_COLUMN | SQL_GD_ANY_ORDER | SQL_GD_BOUND;
11311 *valLen =
sizeof (SQLUINTEGER);
11313 case SQL_STATIC_SENSITIVITY:
11314 *((SQLUINTEGER *) val) = 0;
11315 *valLen =
sizeof (SQLUINTEGER);
11317 case SQL_FILE_USAGE:
11318 #if defined(_WIN32) || defined(_WIN64)
11319 *((SQLSMALLINT *) val) =
11320 d->xcelqrx ? SQL_FILE_CATALOG : SQL_FILE_NOT_SUPPORTED;
11322 *((SQLSMALLINT *) val) = SQL_FILE_NOT_SUPPORTED;
11324 *valLen =
sizeof (SQLSMALLINT);
11327 *((SQLSMALLINT *) val) = SQL_GB_GROUP_BY_EQUALS_SELECT;
11328 *valLen =
sizeof (SQLSMALLINT);
11331 strmak(val,
"CREATE,SELECT,DROP,DELETE,UPDATE,INSERT,"
11332 "INTO,VALUES,TABLE,INDEX,FROM,SET,WHERE,AND,CURRENT,OF",
11335 case SQL_SPECIAL_CHARACTERS:
11336 #ifdef SQL_COLLATION_SEQ
11337 case SQL_COLLATION_SEQ:
11339 strmak(val,
"", valMax, valLen);
11341 case SQL_BATCH_SUPPORT:
11342 case SQL_BATCH_ROW_COUNT:
11343 case SQL_PARAM_ARRAY_ROW_COUNTS:
11344 *((SQLUINTEGER *) val) = 0;
11345 *valLen =
sizeof (SQLUINTEGER);
11347 case SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1:
11348 *((SQLUINTEGER *) val) = SQL_CA1_NEXT | SQL_CA1_BOOKMARK;
11349 *valLen =
sizeof (SQLUINTEGER);
11351 case SQL_STATIC_CURSOR_ATTRIBUTES1:
11352 *((SQLUINTEGER *) val) = SQL_CA1_NEXT | SQL_CA1_ABSOLUTE |
11353 SQL_CA1_RELATIVE | SQL_CA1_BOOKMARK | SQL_CA1_POS_POSITION |
11354 SQL_CA1_POS_DELETE | SQL_CA1_POS_UPDATE | SQL_CA1_POS_REFRESH |
11355 SQL_CA1_LOCK_NO_CHANGE | SQL_CA1_BULK_ADD |
11356 SQL_CA1_BULK_UPDATE_BY_BOOKMARK | SQL_CA1_BULK_DELETE_BY_BOOKMARK;
11357 *valLen =
sizeof (SQLUINTEGER);
11359 case SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2:
11360 case SQL_STATIC_CURSOR_ATTRIBUTES2:
11361 *((SQLUINTEGER *) val) = SQL_CA2_READ_ONLY_CONCURRENCY |
11362 SQL_CA2_LOCK_CONCURRENCY;
11363 *valLen =
sizeof (SQLUINTEGER);
11365 case SQL_KEYSET_CURSOR_ATTRIBUTES1:
11366 case SQL_KEYSET_CURSOR_ATTRIBUTES2:
11367 case SQL_DYNAMIC_CURSOR_ATTRIBUTES1:
11368 case SQL_DYNAMIC_CURSOR_ATTRIBUTES2:
11369 *((SQLUINTEGER *) val) = 0;
11370 *valLen =
sizeof (SQLUINTEGER);
11372 case SQL_ODBC_INTERFACE_CONFORMANCE:
11373 *((SQLUINTEGER *) val) = SQL_OIC_CORE;
11374 *valLen =
sizeof (SQLUINTEGER);
11377 setstatd(d, -1,
"unsupported info option %d",
11378 (*d->
ov3) ?
"HYC00" :
"S1C00", type);
11381 return SQL_SUCCESS;
11384 #if (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC)) || !defined(WINTERFACE)
11396 SQLGetInfo(SQLHDBC
dbc, SQLUSMALLINT type, SQLPOINTER val, SQLSMALLINT valMax,
11397 SQLSMALLINT *valLen)
11402 ret =
drvgetinfo(dbc, type, val, valMax, valLen);
11421 SQLSMALLINT *valLen)
11424 SQLSMALLINT len = 0;
11427 ret =
drvgetinfo(dbc, type, val, valMax, &len);
11429 if (ret == SQL_SUCCESS) {
11430 SQLWCHAR *v = NULL;
11433 case SQL_USER_NAME:
11434 case SQL_DRIVER_ODBC_VER:
11435 case SQL_DATA_SOURCE_NAME:
11436 case SQL_DRIVER_NAME:
11437 case SQL_DRIVER_VER:
11439 case SQL_SERVER_NAME:
11440 case SQL_DATABASE_NAME:
11441 case SQL_SEARCH_PATTERN_ESCAPE:
11442 case SQL_DBMS_NAME:
11444 case SQL_NEED_LONG_DATA_LEN:
11445 case SQL_ROW_UPDATES:
11446 case SQL_ACCESSIBLE_PROCEDURES:
11447 case SQL_PROCEDURES:
11448 case SQL_EXPRESSIONS_IN_ORDERBY:
11449 case SQL_ODBC_SQL_OPT_IEF:
11450 case SQL_LIKE_ESCAPE_CLAUSE:
11451 case SQL_ORDER_BY_COLUMNS_IN_SELECT:
11452 case SQL_OUTER_JOINS:
11453 case SQL_COLUMN_ALIAS:
11454 case SQL_ACCESSIBLE_TABLES:
11455 case SQL_MULT_RESULT_SETS:
11456 case SQL_MULTIPLE_ACTIVE_TXN:
11457 case SQL_MAX_ROW_SIZE_INCLUDES_LONG:
11458 case SQL_DATA_SOURCE_READ_ONLY:
11459 #ifdef SQL_DESCRIBE_PARAMETER
11460 case SQL_DESCRIBE_PARAMETER:
11462 case SQL_IDENTIFIER_QUOTE_CHAR:
11463 case SQL_OWNER_TERM:
11464 case SQL_PROCEDURE_TERM:
11465 case SQL_QUALIFIER_NAME_SEPARATOR:
11466 case SQL_QUALIFIER_TERM:
11467 case SQL_TABLE_TERM:
11469 case SQL_SPECIAL_CHARACTERS:
11470 #ifdef SQL_CATALOG_NAME
11471 case SQL_CATALOG_NAME:
11473 #ifdef SQL_COLLATION_SEQ
11474 case SQL_COLLATION_SEQ:
11480 int vmax = valMax /
sizeof (SQLWCHAR);
11490 len *=
sizeof (SQLWCHAR);
11497 if (valMax >=
sizeof (SQLWCHAR)) {
11498 *((SQLWCHAR *)val) = 0;
11502 len *=
sizeof (SQLWCHAR);
11524 SQLUSMALLINT *flags)
11527 SQLUSMALLINT exists[100];
11529 if (dbc == SQL_NULL_HDBC) {
11530 return SQL_INVALID_HANDLE;
11533 exists[i] = SQL_FALSE;
11535 exists[SQL_API_SQLALLOCCONNECT] = SQL_TRUE;
11536 exists[SQL_API_SQLFETCH] = SQL_TRUE;
11537 exists[SQL_API_SQLALLOCENV] = SQL_TRUE;
11538 exists[SQL_API_SQLFREECONNECT] = SQL_TRUE;
11539 exists[SQL_API_SQLALLOCSTMT] = SQL_TRUE;
11540 exists[SQL_API_SQLFREEENV] = SQL_TRUE;
11541 exists[SQL_API_SQLBINDCOL] = SQL_TRUE;
11542 exists[SQL_API_SQLFREESTMT] = SQL_TRUE;
11543 exists[SQL_API_SQLCANCEL] = SQL_TRUE;
11544 exists[SQL_API_SQLGETCURSORNAME] = SQL_TRUE;
11545 exists[SQL_API_SQLCOLATTRIBUTES] = SQL_TRUE;
11546 exists[SQL_API_SQLNUMRESULTCOLS] = SQL_TRUE;
11547 exists[SQL_API_SQLCONNECT] = SQL_TRUE;
11548 exists[SQL_API_SQLPREPARE] = SQL_TRUE;
11549 exists[SQL_API_SQLDESCRIBECOL] = SQL_TRUE;
11550 exists[SQL_API_SQLROWCOUNT] = SQL_TRUE;
11551 exists[SQL_API_SQLDISCONNECT] = SQL_TRUE;
11552 exists[SQL_API_SQLSETCURSORNAME] = SQL_FALSE;
11553 exists[SQL_API_SQLERROR] = SQL_TRUE;
11554 exists[SQL_API_SQLSETPARAM] = SQL_TRUE;
11555 exists[SQL_API_SQLEXECDIRECT] = SQL_TRUE;
11556 exists[SQL_API_SQLTRANSACT] = SQL_TRUE;
11557 exists[SQL_API_SQLBULKOPERATIONS] = SQL_TRUE;
11558 exists[SQL_API_SQLEXECUTE] = SQL_TRUE;
11559 exists[SQL_API_SQLBINDPARAMETER] = SQL_TRUE;
11560 exists[SQL_API_SQLGETTYPEINFO] = SQL_TRUE;
11561 exists[SQL_API_SQLCOLUMNS] = SQL_TRUE;
11562 exists[SQL_API_SQLPARAMDATA] = SQL_TRUE;
11563 exists[SQL_API_SQLDRIVERCONNECT] = SQL_TRUE;
11564 exists[SQL_API_SQLPUTDATA] = SQL_TRUE;
11565 exists[SQL_API_SQLGETCONNECTOPTION] = SQL_TRUE;
11566 exists[SQL_API_SQLSETCONNECTOPTION] = SQL_TRUE;
11567 exists[SQL_API_SQLGETDATA] = SQL_TRUE;
11568 exists[SQL_API_SQLSETSTMTOPTION] = SQL_TRUE;
11569 exists[SQL_API_SQLGETFUNCTIONS] = SQL_TRUE;
11570 exists[SQL_API_SQLSPECIALCOLUMNS] = SQL_TRUE;
11571 exists[SQL_API_SQLGETINFO] = SQL_TRUE;
11572 exists[SQL_API_SQLSTATISTICS] = SQL_TRUE;
11573 exists[SQL_API_SQLGETSTMTOPTION] = SQL_TRUE;
11574 exists[SQL_API_SQLTABLES] = SQL_TRUE;
11575 exists[SQL_API_SQLBROWSECONNECT] = SQL_FALSE;
11576 exists[SQL_API_SQLNUMPARAMS] = SQL_TRUE;
11577 exists[SQL_API_SQLCOLUMNPRIVILEGES] = SQL_FALSE;
11578 exists[SQL_API_SQLPARAMOPTIONS] = SQL_FALSE;
11579 exists[SQL_API_SQLDATASOURCES] = SQL_TRUE;
11580 exists[SQL_API_SQLPRIMARYKEYS] = SQL_TRUE;
11581 exists[SQL_API_SQLDESCRIBEPARAM] = SQL_TRUE;
11582 exists[SQL_API_SQLPROCEDURECOLUMNS] = SQL_TRUE;
11583 exists[SQL_API_SQLDRIVERS] = SQL_FALSE;
11584 exists[SQL_API_SQLPROCEDURES] = SQL_TRUE;
11585 exists[SQL_API_SQLEXTENDEDFETCH] = SQL_TRUE;
11586 exists[SQL_API_SQLSETPOS] = SQL_TRUE;
11587 exists[SQL_API_SQLFOREIGNKEYS] = SQL_TRUE;
11588 exists[SQL_API_SQLSETSCROLLOPTIONS] = SQL_TRUE;
11589 exists[SQL_API_SQLMORERESULTS] = SQL_TRUE;
11590 exists[SQL_API_SQLTABLEPRIVILEGES] = SQL_TRUE;
11591 exists[SQL_API_SQLNATIVESQL] = SQL_TRUE;
11592 if (func == SQL_API_ALL_FUNCTIONS) {
11593 memcpy(flags, exists,
sizeof (exists));
11594 }
else if (func == SQL_API_ODBC3_ALL_FUNCTIONS) {
11596 #define SET_EXISTS(x) \
11597 flags[(x) >> 4] |= (1 << ((x) & 0xF))
11598 #define CLR_EXISTS(x) \
11599 flags[(x) >> 4] &= ~(1 << ((x) & 0xF))
11602 sizeof (SQLUSMALLINT) * SQL_API_ODBC3_ALL_FUNCTIONS_SIZE);
11605 flags[i >> 4] |= (1 << (i & 0xF));
11618 #if !defined(HAVE_UNIXODBC) || !(HAVE_UNIXODBC)
11631 *flags = exists[func];
11634 case SQL_API_SQLALLOCHANDLE:
11635 case SQL_API_SQLFREEHANDLE:
11636 case SQL_API_SQLGETSTMTATTR:
11637 case SQL_API_SQLSETSTMTATTR:
11638 case SQL_API_SQLGETCONNECTATTR:
11639 case SQL_API_SQLSETCONNECTATTR:
11640 case SQL_API_SQLGETENVATTR:
11641 case SQL_API_SQLSETENVATTR:
11642 case SQL_API_SQLCLOSECURSOR:
11643 case SQL_API_SQLBINDPARAM:
11644 #if !defined(HAVE_UNIXODBC) || !(HAVE_UNIXODBC)
11650 case SQL_API_SQLGETDIAGREC:
11652 case SQL_API_SQLGETDIAGFIELD:
11653 case SQL_API_SQLFETCHSCROLL:
11654 case SQL_API_SQLENDTRAN:
11658 *flags = SQL_FALSE;
11662 return SQL_SUCCESS;
11677 return SQL_INVALID_HANDLE;
11681 *env = SQL_NULL_HENV;
11686 #if defined(_WIN32) || defined(_WIN64)
11687 InitializeCriticalSection(&e->cs);
11689 #if defined(ENABLE_NVFS) && (ENABLE_NVFS)
11694 *env = (SQLHENV) e;
11695 return SQL_SUCCESS;
11721 if (env == SQL_NULL_HENV) {
11722 return SQL_INVALID_HANDLE;
11726 return SQL_SUCCESS;
11728 #if defined(_WIN32) || defined(_WIN64)
11729 EnterCriticalSection(&e->cs);
11732 #if defined(_WIN32) || defined(_WIN64)
11733 LeaveCriticalSection(&e->cs);
11738 #if defined(_WIN32) || defined(_WIN64)
11739 LeaveCriticalSection(&e->cs);
11740 DeleteCriticalSection(&e->cs);
11743 return SQL_SUCCESS;
11770 const char *verstr;
11771 int maj = 0,
min = 0, lev = 0;
11778 *dbc = SQL_NULL_HDBC;
11781 memset(d, 0,
sizeof (
DBC));
11782 d->
curtype = SQL_CURSOR_STATIC;
11784 verstr = sqlite3_libversion();
11785 sscanf(verstr,
"%d.%d.%d", &maj, &
min, &lev);
11788 #if defined(_WIN32) || defined(_WIN64)
11790 EnterCriticalSection(&e->cs);
11810 #if defined(_WIN32) || defined(_WIN64)
11811 InitializeCriticalSection(&d->cs);
11814 LeaveCriticalSection(&e->cs);
11820 *dbc = (SQLHDBC) d;
11822 return SQL_SUCCESS;
11849 SQLRETURN ret = SQL_ERROR;
11851 if (dbc == SQL_NULL_HDBC) {
11852 return SQL_INVALID_HANDLE;
11856 return SQL_INVALID_HANDLE;
11860 #if defined(_WIN32) || defined(_WIN64)
11861 EnterCriticalSection(&e->cs);
11868 setstatd(d, -1,
"not disconnected", (*d->
ov3) ?
"HY000" :
"S1000");
11900 #if defined(_WIN32) || defined(_WIN64)
11902 LeaveCriticalSection(&d->cs);
11903 DeleteCriticalSection(&d->cs);
11908 #if defined(_WIN32) || defined(_WIN64)
11910 LeaveCriticalSection(&e->cs);
11940 SQLINTEGER bufmax, SQLINTEGER *buflen)
11945 if (dbc == SQL_NULL_HDBC) {
11946 return SQL_INVALID_HANDLE;
11950 val = (SQLPOINTER) &dummy;
11956 case SQL_ATTR_CONNECTION_DEAD:
11957 *((SQLINTEGER *) val) = d->
sqlite ? SQL_CD_FALSE : SQL_CD_TRUE;
11958 *buflen =
sizeof (SQLINTEGER);
11960 case SQL_ATTR_ACCESS_MODE:
11961 *((SQLINTEGER *) val) = SQL_MODE_READ_WRITE;
11962 *buflen =
sizeof (SQLINTEGER);
11964 case SQL_ATTR_AUTOCOMMIT:
11965 *((SQLINTEGER *) val) =
11966 d->
autocommit ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF;
11967 *buflen =
sizeof (SQLINTEGER);
11969 case SQL_ATTR_LOGIN_TIMEOUT:
11970 *((SQLINTEGER *) val) = 100;
11971 *buflen =
sizeof (SQLINTEGER);
11973 case SQL_ATTR_ODBC_CURSORS:
11974 *((SQLINTEGER *) val) = SQL_CUR_USE_DRIVER;
11975 *buflen =
sizeof (SQLINTEGER);
11977 case SQL_ATTR_PACKET_SIZE:
11978 *((SQLINTEGER *) val) = 16384;
11979 *buflen =
sizeof (SQLINTEGER);
11981 case SQL_ATTR_TXN_ISOLATION:
11982 *((SQLINTEGER *) val) = SQL_TXN_SERIALIZABLE;
11983 *buflen =
sizeof (SQLINTEGER);
11985 case SQL_ATTR_TRACEFILE:
11986 case SQL_ATTR_TRANSLATE_LIB:
11987 *((SQLCHAR *) val) = 0;
11990 case SQL_ATTR_CURRENT_CATALOG:
11991 #if defined(_WIN32) || defined(_WIN64)
11993 if ((bufmax > 4) && (val != (SQLPOINTER) &dummy)) {
11994 strcpy((
char *) val,
"main");
12000 *((SQLCHAR *) val) = 0;
12003 case SQL_ATTR_TRACE:
12004 case SQL_ATTR_QUIET_MODE:
12005 case SQL_ATTR_TRANSLATE_OPTION:
12006 case SQL_ATTR_KEYSET_SIZE:
12007 case SQL_ATTR_QUERY_TIMEOUT:
12008 *((SQLINTEGER *) val) = 0;
12009 *buflen =
sizeof (SQLINTEGER);
12011 case SQL_ATTR_PARAM_BIND_TYPE:
12012 *((
SQLULEN *) val) = SQL_PARAM_BIND_BY_COLUMN;
12013 *buflen =
sizeof (SQLUINTEGER);
12015 case SQL_ATTR_ROW_BIND_TYPE:
12016 *((
SQLULEN *) val) = SQL_BIND_BY_COLUMN;
12019 case SQL_ATTR_USE_BOOKMARKS:
12020 *((SQLINTEGER *) val) = SQL_UB_OFF;
12021 *buflen =
sizeof (SQLINTEGER);
12023 case SQL_ATTR_ASYNC_ENABLE:
12024 *((SQLINTEGER *) val) = SQL_ASYNC_ENABLE_OFF;
12025 *buflen =
sizeof (SQLINTEGER);
12027 case SQL_ATTR_NOSCAN:
12028 *((SQLINTEGER *) val) = SQL_NOSCAN_ON;
12029 *buflen =
sizeof (SQLINTEGER);
12031 case SQL_ATTR_CONCURRENCY:
12032 *((SQLINTEGER *) val) = SQL_CONCUR_LOCK;
12033 *buflen =
sizeof (SQLINTEGER);
12035 #ifdef SQL_ATTR_CURSOR_SENSITIVITY
12036 case SQL_ATTR_CURSOR_SENSITIVITY:
12037 *((SQLINTEGER *) val) = SQL_UNSPECIFIED;
12038 *buflen =
sizeof (SQLINTEGER);
12041 case SQL_ATTR_SIMULATE_CURSOR:
12042 *((SQLINTEGER *) val) = SQL_SC_NON_UNIQUE;
12043 *buflen =
sizeof (SQLINTEGER);
12045 case SQL_ATTR_MAX_ROWS:
12046 *((SQLINTEGER *) val) = 0;
12047 *buflen =
sizeof (SQLINTEGER);
12048 case SQL_ATTR_MAX_LENGTH:
12049 *((SQLINTEGER *) val) = 1000000000;
12050 *buflen =
sizeof (SQLINTEGER);
12052 case SQL_ATTR_CURSOR_TYPE:
12053 *((SQLINTEGER *) val) = d->
curtype;
12054 *buflen =
sizeof (SQLINTEGER);
12056 case SQL_ATTR_RETRIEVE_DATA:
12057 *((SQLINTEGER *) val) = SQL_RD_ON;
12058 *buflen =
sizeof (SQLINTEGER);
12060 #ifdef SQL_ATTR_METADATA_ID
12061 case SQL_ATTR_METADATA_ID:
12062 *((
SQLULEN *) val) = SQL_FALSE;
12063 return SQL_SUCCESS;
12066 *((SQLINTEGER *) val) = 0;
12067 *buflen =
sizeof (SQLINTEGER);
12068 setstatd(d, -1,
"unsupported connect attribute %d",
12069 (*d->
ov3) ?
"HYC00" :
"S1C00", (
int) attr);
12072 return SQL_SUCCESS;
12087 SQLGetConnectAttr(SQLHDBC
dbc, SQLINTEGER attr, SQLPOINTER val,
12088 SQLINTEGER bufmax, SQLINTEGER *buflen)
12112 SQLINTEGER bufmax, SQLINTEGER *buflen)
12115 SQLINTEGER len = 0;
12119 if (ret == SQL_SUCCESS) {
12120 SQLWCHAR *v = NULL;
12123 case SQL_ATTR_TRACEFILE:
12124 case SQL_ATTR_CURRENT_CATALOG:
12125 case SQL_ATTR_TRANSLATE_LIB:
12130 int vmax = bufmax /
sizeof (SQLWCHAR);
12140 len *=
sizeof (SQLWCHAR);
12147 if (bufmax >=
sizeof (SQLWCHAR)) {
12148 *((SQLWCHAR *)val) = 0;
12152 len *=
sizeof (SQLWCHAR);
12180 if (dbc == SQL_NULL_HDBC) {
12181 return SQL_INVALID_HANDLE;
12185 case SQL_AUTOCOMMIT:
12186 d->
autocommit = val == (SQLPOINTER) SQL_AUTOCOMMIT_ON;
12188 return endtran(d, SQL_COMMIT, 1);
12193 return SQL_SUCCESS;
12194 #ifdef SQL_ATTR_METADATA_ID
12195 case SQL_ATTR_METADATA_ID:
12196 if (val == (SQLPOINTER) SQL_FALSE) {
12202 setstatd(d, -1,
"option value changed",
"01S02");
12203 return SQL_SUCCESS_WITH_INFO;
12205 return SQL_SUCCESS;
12219 SQLSetConnectAttr(SQLHDBC
dbc, SQLINTEGER attr, SQLPOINTER val,
12268 if (dbc == SQL_NULL_HDBC) {
12269 return SQL_INVALID_HANDLE;
12273 param = (SQLPOINTER) &dummy;
12276 case SQL_ACCESS_MODE:
12277 *((SQLINTEGER *) param) = SQL_MODE_READ_WRITE;
12279 case SQL_AUTOCOMMIT:
12280 *((SQLINTEGER *) param) =
12281 d->
autocommit ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF;
12283 case SQL_LOGIN_TIMEOUT:
12284 *((SQLINTEGER *) param) = 100;
12286 case SQL_ODBC_CURSORS:
12287 *((SQLINTEGER *) param) = SQL_CUR_USE_DRIVER;
12289 case SQL_PACKET_SIZE:
12290 *((SQLINTEGER *) param) = 16384;
12292 case SQL_TXN_ISOLATION:
12293 *((SQLINTEGER *) param) = SQL_TXN_SERIALIZABLE;
12295 case SQL_OPT_TRACE:
12296 case SQL_OPT_TRACEFILE:
12297 case SQL_QUIET_MODE:
12298 case SQL_TRANSLATE_DLL:
12299 case SQL_TRANSLATE_OPTION:
12300 case SQL_KEYSET_SIZE:
12301 case SQL_QUERY_TIMEOUT:
12302 case SQL_BIND_TYPE:
12303 case SQL_CURRENT_QUALIFIER:
12304 *((SQLINTEGER *) param) = 0;
12306 case SQL_USE_BOOKMARKS:
12307 *((SQLINTEGER *) param) = SQL_UB_OFF;
12309 case SQL_ASYNC_ENABLE:
12310 *((SQLINTEGER *) param) = SQL_ASYNC_ENABLE_OFF;
12313 *((SQLINTEGER *) param) = SQL_NOSCAN_ON;
12315 case SQL_CONCURRENCY:
12316 *((SQLINTEGER *) param) = SQL_CONCUR_LOCK;
12318 case SQL_SIMULATE_CURSOR:
12319 *((SQLINTEGER *) param) = SQL_SC_NON_UNIQUE;
12322 *((SQLINTEGER *) param) = 0;
12324 case SQL_ROWSET_SIZE:
12325 case SQL_MAX_LENGTH:
12326 *((SQLINTEGER *) param) = 1000000000;
12328 case SQL_CURSOR_TYPE:
12329 *((SQLINTEGER *) param) = d->
curtype;
12331 case SQL_RETRIEVE_DATA:
12332 *((SQLINTEGER *) param) = SQL_RD_ON;
12335 *((SQLINTEGER *) param) = 0;
12336 setstatd(d, -1,
"unsupported connect option %d",
12337 (*d->
ov3) ?
"HYC00" :
"S1C00", opt);
12340 return SQL_SUCCESS;
12353 SQLGetConnectOption(SQLHDBC
dbc, SQLUSMALLINT opt, SQLPOINTER param)
12380 if (SQL_SUCCEEDED(ret)) {
12382 case SQL_OPT_TRACEFILE:
12383 case SQL_CURRENT_QUALIFIER:
12384 case SQL_TRANSLATE_DLL:
12386 *(SQLWCHAR *) param = 0;
12409 if (dbc == SQL_NULL_HDBC) {
12410 return SQL_INVALID_HANDLE;
12414 case SQL_AUTOCOMMIT:
12417 return endtran(d, SQL_COMMIT, 1);
12423 setstatd(d, -1,
"option value changed",
"01S02");
12424 return SQL_SUCCESS_WITH_INFO;
12426 return SQL_SUCCESS;
12439 SQLSetConnectOption(SQLHDBC
dbc, SQLUSMALLINT opt,
SQLULEN param)
12471 #if defined(WITHOUT_DRIVERMGR) || (!defined(_WIN32) && !defined(_WIN64))
12486 char *str = dsn, *start;
12487 int len = strlen(attr);
12490 while (*str && *str ==
';') {
12494 if ((str = strchr(str,
'=')) == NULL) {
12497 if (str - start == len && strncasecmp(start, attr, len) == 0) {
12499 while (*str && *str !=
';') {
12502 len =
min(outLen - 1, str - start);
12503 strncpy(out, start, len);
12507 while (*str && *str !=
';') {
12528 int pwdLen,
int isu)
12533 char buf[SQL_MAX_MESSAGE_LENGTH], dbname[SQL_MAX_MESSAGE_LENGTH / 4];
12534 char busy[SQL_MAX_MESSAGE_LENGTH / 4], tracef[SQL_MAX_MESSAGE_LENGTH];
12535 char loadext[SQL_MAX_MESSAGE_LENGTH];
12536 char sflag[32], spflag[32], ntflag[32], nwflag[32], biflag[32];
12537 char snflag[32], lnflag[32], ncflag[32], fkflag[32], jmode[32];
12539 #if defined(_WIN32) || defined(_WIN64)
12543 if (dbc == SQL_NULL_HDBC) {
12544 return SQL_INVALID_HANDLE;
12548 return SQL_INVALID_HANDLE;
12550 if (d->
sqlite != NULL) {
12551 setstatd(d, -1,
"connection already established",
"08002");
12555 if (dsnLen == SQL_NTS) {
12556 len =
sizeof (buf) - 1;
12558 len =
min(
sizeof (buf) - 1, dsnLen);
12561 strncpy(buf, (
char *) dsn, len);
12564 if (buf[0] ==
'\0') {
12565 setstatd(d, -1,
"invalid DSN", (*d->
ov3) ?
"HY090" :
"S1090");
12568 #if defined(_WIN32) || defined(_WIN64)
12574 char *cdsn = utf_to_wmb(buf, len);
12577 setstatd(d, -1,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
12586 #ifdef WITHOUT_DRIVERMGR
12587 getdsnattr(buf,
"database", dbname,
sizeof (dbname));
12588 if (dbname[0] ==
'\0') {
12589 strncpy(dbname, buf,
sizeof (dbname));
12590 dbname[
sizeof (dbname) - 1] =
'\0';
12592 getdsnattr(buf,
"timeout", busy,
sizeof (busy));
12594 getdsnattr(buf,
"stepapi", sflag,
sizeof (sflag));
12596 getdsnattr(buf,
"syncpragma", spflag,
sizeof (spflag));
12598 getdsnattr(buf,
"notxn", ntflag,
sizeof (ntflag));
12600 getdsnattr(buf,
"nowchar", nwflag,
sizeof (nwflag));
12602 getdsnattr(buf,
"shortnames", snflag,
sizeof (snflag));
12604 getdsnattr(buf,
"longnames", lnflag,
sizeof (lnflag));
12606 getdsnattr(buf,
"nocreat", ncflag,
sizeof (ncflag));
12608 getdsnattr(buf,
"fksupport", fkflag,
sizeof (fkflag));
12610 getdsnattr(buf,
"loadext", loadext,
sizeof (loadext));
12612 getdsnattr(buf,
"journalmode", jmode,
sizeof (jmode));
12614 getdsnattr(buf,
"jdconv", jdflag,
sizeof (jdflag));
12615 #if defined(_WIN32) || defined(_WIN64)
12617 getdsnattr(buf,
"oemcp", oemcp,
sizeof (oemcp));
12620 getdsnattr(buf,
"bigint", biflag,
sizeof (biflag));
12622 SQLGetPrivateProfileString(buf,
"timeout",
"100000",
12624 SQLGetPrivateProfileString(buf,
"database",
"",
12625 dbname,
sizeof (dbname),
ODBC_INI);
12626 #if defined(_WIN32) || defined(_WIN64)
12630 SQLGetPrivateProfileString(buf,
"stepapi",
"",
12632 SQLGetPrivateProfileString(buf,
"syncpragma",
"NORMAL",
12633 spflag,
sizeof (spflag),
ODBC_INI);
12634 SQLGetPrivateProfileString(buf,
"notxn",
"",
12635 ntflag,
sizeof (ntflag),
ODBC_INI);
12636 SQLGetPrivateProfileString(buf,
"nowchar",
"",
12637 nwflag,
sizeof (nwflag),
ODBC_INI);
12638 SQLGetPrivateProfileString(buf,
"shortnames",
"",
12639 snflag,
sizeof (snflag),
ODBC_INI);
12640 SQLGetPrivateProfileString(buf,
"longnames",
"",
12641 lnflag,
sizeof (lnflag),
ODBC_INI);
12642 SQLGetPrivateProfileString(buf,
"nocreat",
"",
12643 ncflag,
sizeof (ncflag),
ODBC_INI);
12644 SQLGetPrivateProfileString(buf,
"fksupport",
"",
12645 fkflag,
sizeof (fkflag),
ODBC_INI);
12646 SQLGetPrivateProfileString(buf,
"loadext",
"",
12647 loadext,
sizeof (loadext),
ODBC_INI);
12648 SQLGetPrivateProfileString(buf,
"journalmode",
"",
12650 SQLGetPrivateProfileString(buf,
"jdconv",
"",
12651 jdflag,
sizeof (jdflag),
ODBC_INI);
12652 #if defined(_WIN32) || defined(_WIN64)
12653 SQLGetPrivateProfileString(buf,
"oemcp",
"1",
12656 SQLGetPrivateProfileString(buf,
"bigint",
"",
12657 biflag,
sizeof (biflag),
ODBC_INI);
12660 #ifdef WITHOUT_DRIVERMGR
12661 getdsnattr(buf,
"tracefile", tracef,
sizeof (tracef));
12663 SQLGetPrivateProfileString(buf,
"tracefile",
"",
12664 tracef,
sizeof (tracef),
ODBC_INI);
12666 if (tracef[0] !=
'\0') {
12667 d->
trace = fopen(tracef,
"a");
12675 #if defined(_WIN32) || defined(_WIN64)
12684 d->
pwdLen = (pwdLen == SQL_NTS) ? strlen(d->
pwd) : pwdLen;
12686 ret =
dbopen(d, dbname, isu, (
char *) dsn, sflag, spflag, ntflag,
12688 if (ret == SQL_SUCCESS) {
12708 SQLConnect(SQLHDBC
dbc, SQLCHAR *dsn, SQLSMALLINT dsnLen,
12709 SQLCHAR *uid, SQLSMALLINT uidLen,
12710 SQLCHAR *pwd, SQLSMALLINT pwdLen)
12715 ret =
drvconnect(dbc, dsn, dsnLen, (
char *) pwd, pwdLen, 0);
12736 SQLWCHAR *uid, SQLSMALLINT uidLen,
12737 SQLWCHAR *pwd, SQLSMALLINT pwdLen)
12749 setstatd(d, -1,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
12759 setstatd(d, -1,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
12764 ret =
drvconnect(dbc, (SQLCHAR *) dsna, SQL_NTS, pwda, SQL_NTS, 1);
12785 if (dbc == SQL_NULL_HDBC) {
12786 return SQL_INVALID_HANDLE;
12790 return SQL_INVALID_HANDLE;
12793 setstatd(d, -1,
"incomplete transaction",
"25000");
12801 fprintf(d->
trace,
"-- sqlite3_close: '%s'\n",
12805 rc = sqlite3_close(d->
sqlite);
12806 if (rc == SQLITE_BUSY) {
12807 setstatd(d, -1,
"unfinished statements",
"25000");
12814 return SQL_SUCCESS;
12834 #if defined(WITHOUT_DRIVERMGR) || (!defined(_WIN32) && !defined(_WIN64))
12851 SQLCHAR *connIn, SQLSMALLINT connInLen,
12852 SQLCHAR *connOut, SQLSMALLINT connOutMax,
12853 SQLSMALLINT *connOutLen, SQLUSMALLINT drvcompl)
12858 char buf[SQL_MAX_MESSAGE_LENGTH * 6], dbname[SQL_MAX_MESSAGE_LENGTH];
12859 char dsn[SQL_MAX_MESSAGE_LENGTH / 4], busy[SQL_MAX_MESSAGE_LENGTH / 4];
12860 char tracef[SQL_MAX_MESSAGE_LENGTH], loadext[SQL_MAX_MESSAGE_LENGTH];
12861 char pwd[SQL_MAX_MESSAGE_LENGTH];
12862 char sflag[32], spflag[32], ntflag[32], snflag[32], lnflag[32];
12863 char ncflag[32], nwflag[32], fkflag[32], jmode[32], biflag[32];
12866 if (dbc == SQL_NULL_HDBC) {
12867 return SQL_INVALID_HANDLE;
12869 if (drvcompl != SQL_DRIVER_COMPLETE &&
12870 drvcompl != SQL_DRIVER_COMPLETE_REQUIRED &&
12871 drvcompl != SQL_DRIVER_PROMPT &&
12872 drvcompl != SQL_DRIVER_NOPROMPT) {
12873 return SQL_NO_DATA;
12877 setstatd(d, -1,
"connection already established",
"08002");
12881 if (connInLen == SQL_NTS) {
12882 len =
sizeof (buf) - 1;
12884 len =
min(connInLen,
sizeof (buf) - 1);
12886 if (connIn != NULL) {
12887 strncpy(buf, (
char *) connIn, len);
12891 setstatd(d, -1,
"invalid connect attributes",
12892 (*d->
ov3) ?
"HY090" :
"S1090");
12899 if (!dsn[0] && !strchr(buf,
';') && !strchr(buf,
'=')) {
12900 strncpy(dsn, buf,
sizeof (dsn) - 1);
12901 dsn[
sizeof (dsn) - 1] =
'\0';
12905 getdsnattr(buf,
"timeout", busy,
sizeof (busy));
12906 #ifndef WITHOUT_DRIVERMGR
12907 if (dsn[0] && !busy[0]) {
12908 SQLGetPrivateProfileString(dsn,
"timeout",
"100000",
12913 getdsnattr(buf,
"database", dbname,
sizeof (dbname));
12914 #ifndef WITHOUT_DRIVERMGR
12915 if (dsn[0] && !dbname[0]) {
12916 SQLGetPrivateProfileString(dsn,
"database",
"",
12917 dbname,
sizeof (dbname),
ODBC_INI);
12921 getdsnattr(buf,
"stepapi", sflag,
sizeof (sflag));
12922 #ifndef WITHOUT_DRIVERMGR
12923 if (dsn[0] && !sflag[0]) {
12924 SQLGetPrivateProfileString(dsn,
"stepapi",
"",
12929 getdsnattr(buf,
"syncpragma", spflag,
sizeof (spflag));
12930 #ifndef WITHOUT_DRIVERMGR
12931 if (dsn[0] && !spflag[0]) {
12932 SQLGetPrivateProfileString(dsn,
"syncpragma",
"NORMAL",
12933 spflag,
sizeof (spflag),
ODBC_INI);
12937 getdsnattr(buf,
"notxn", ntflag,
sizeof (ntflag));
12938 #ifndef WITHOUT_DRIVERMGR
12939 if (dsn[0] && !ntflag[0]) {
12940 SQLGetPrivateProfileString(dsn,
"notxn",
"",
12941 ntflag,
sizeof (ntflag),
ODBC_INI);
12945 getdsnattr(buf,
"shortnames", snflag,
sizeof (snflag));
12946 #ifndef WITHOUT_DRIVERMGR
12947 if (dsn[0] && !snflag[0]) {
12948 SQLGetPrivateProfileString(dsn,
"shortnames",
"",
12949 snflag,
sizeof (snflag),
ODBC_INI);
12953 getdsnattr(buf,
"longnames", lnflag,
sizeof (lnflag));
12954 #ifndef WITHOUT_DRIVERMGR
12955 if (dsn[0] && !lnflag[0]) {
12956 SQLGetPrivateProfileString(dsn,
"longnames",
"",
12957 lnflag,
sizeof (lnflag),
ODBC_INI);
12961 getdsnattr(buf,
"nocreat", ncflag,
sizeof (ncflag));
12962 #ifndef WITHOUT_DRIVERMGR
12963 if (dsn[0] && !ncflag[0]) {
12964 SQLGetPrivateProfileString(dsn,
"nocreat",
"",
12965 ncflag,
sizeof (ncflag),
ODBC_INI);
12969 getdsnattr(buf,
"nowchar", nwflag,
sizeof (nwflag));
12970 #ifndef WITHOUT_DRIVERMGR
12971 if (dsn[0] && !nwflag[0]) {
12972 SQLGetPrivateProfileString(dsn,
"nowchar",
"",
12973 nwflag,
sizeof (nwflag),
ODBC_INI);
12977 getdsnattr(buf,
"fksupport", fkflag,
sizeof (fkflag));
12978 #ifndef WITHOUT_DRIVERMGR
12979 if (dsn[0] && !fkflag[0]) {
12980 SQLGetPrivateProfileString(dsn,
"fksupport",
"",
12981 fkflag,
sizeof (fkflag),
ODBC_INI);
12985 getdsnattr(buf,
"loadext", loadext,
sizeof (loadext));
12986 #ifndef WITHOUT_DRIVERMGR
12987 if (dsn[0] && !loadext[0]) {
12988 SQLGetPrivateProfileString(dsn,
"loadext",
"",
12989 loadext,
sizeof (loadext),
ODBC_INI);
12993 getdsnattr(buf,
"journalmode", jmode,
sizeof (jmode));
12994 #ifndef WITHOUT_DRIVERMGR
12995 if (dsn[0] && !jmode[0]) {
12996 SQLGetPrivateProfileString(dsn,
"journalmode",
"",
13001 getdsnattr(buf,
"bigint", biflag,
sizeof (biflag));
13002 #ifndef WITHOUT_DRIVERMGR
13003 if (dsn[0] && !biflag[0]) {
13004 SQLGetPrivateProfileString(dsn,
"bigint",
"",
13005 biflag,
sizeof (biflag),
ODBC_INI);
13009 getdsnattr(buf,
"jdconv", jdflag,
sizeof (jdflag));
13010 #ifndef WITHOUT_DRIVERMGR
13011 if (dsn[0] && !jdflag[0]) {
13012 SQLGetPrivateProfileString(dsn,
"jdconv",
"",
13013 jdflag,
sizeof (jdflag),
ODBC_INI);
13018 #ifndef WITHOUT_DRIVERMGR
13019 if (dsn[0] && !pwd[0]) {
13020 SQLGetPrivateProfileString(dsn,
"pwd",
"",
13025 if (!dbname[0] && !dsn[0]) {
13026 strcpy(dsn,
"SQLite");
13027 strncpy(dbname, buf,
sizeof (dbname));
13028 dbname[
sizeof (dbname) - 1] =
'\0';
13031 getdsnattr(buf,
"tracefile", tracef,
sizeof (tracef));
13032 #ifndef WITHOUT_DRIVERMGR
13033 if (dsn[0] && !tracef[0]) {
13034 SQLGetPrivateProfileString(dsn,
"tracefile",
"",
13035 tracef,
sizeof (tracef),
ODBC_INI);
13038 if (connOut || connOutLen) {
13042 count = snprintf(buf,
sizeof (buf),
13043 "DSN=%s;Database=%s;StepAPI=%s;Timeout=%s;"
13044 "SyncPragma=%s;NoTXN=%s;ShortNames=%s;LongNames=%s;"
13045 "NoCreat=%s;NoWCHAR=%s;FKSupport=%s;Tracefile=%s;"
13046 "JournalMode=%s;LoadExt=%s;BigInt=%s;JDConv=%s;"
13048 dsn, dbname, sflag, busy, spflag, ntflag,
13049 snflag, lnflag, ncflag, nwflag, fkflag, tracef,
13050 jmode, loadext, biflag, jdflag, pwd);
13052 buf[
sizeof (buf) - 1] =
'\0';
13054 len =
min(connOutMax - 1, strlen(buf));
13056 strncpy((
char *) connOut, buf, len);
13057 connOut[len] =
'\0';
13063 if (tracef[0] !=
'\0') {
13064 d->
trace = fopen(tracef,
"a");
13074 d->
pwdLen = strlen(pwd);
13076 ret =
dbopen(d, dbname, 0, dsn, sflag, spflag, ntflag, jmode, busy);
13077 memset(pwd, 0,
sizeof (pwd));
13078 if (ret == SQL_SUCCESS) {
13097 if (stmt == SQL_NULL_HSTMT) {
13098 return SQL_INVALID_HANDLE;
13133 return SQL_SUCCESS;
13149 if (dbc == SQL_NULL_HDBC) {
13150 return SQL_INVALID_HANDLE;
13154 return SQL_INVALID_HANDLE;
13158 *stmt = SQL_NULL_HSTMT;
13161 *stmt = (SQLHSTMT) s;
13162 memset(s, 0,
sizeof (
STMT));
13165 s->
bkmrk = SQL_UB_OFF;
13186 sprintf((
char *) s->
cursorname,
"CUR_%I64X", (SQLUBIGINT) *stmt);
13188 sprintf((
char *) s->
cursorname,
"CUR_%016lX", (
long) *stmt);
13201 return SQL_SUCCESS;
13233 SQLRETURN ret = SQL_SUCCESS;
13236 if (stmt == SQL_NULL_HSTMT) {
13237 return SQL_INVALID_HANDLE;
13243 case SQL_RESET_PARAMS:
13258 setstat(s, -1,
"unsupported option", (*s->
ov3) ?
"HYC00" :
"S1C00");
13288 if (stmt != SQL_NULL_HSTMT) {
13290 #if defined(_WIN32) || defined(_WIN64)
13292 if (d->
magic ==
DBC_MAGIC && d->owner != GetCurrentThreadId() &&
13295 sqlite3_interrupt(d->
sqlite);
13296 return SQL_SUCCESS;
13301 sqlite3_interrupt(d->
sqlite);
13323 if (stmt == SQL_NULL_HSTMT) {
13324 return SQL_INVALID_HANDLE;
13327 if (lenp && !cursor) {
13329 return SQL_SUCCESS;
13333 strncpy((
char *) cursor, (
char *) s->
cursorname, buflen - 1);
13334 cursor[buflen - 1] =
'\0';
13340 return SQL_SUCCESS;
13354 SQLGetCursorName(SQLHSTMT stmt, SQLCHAR *cursor, SQLSMALLINT buflen,
13358 #if defined(_WIN32) || defined(_WIN64)
13359 SQLSMALLINT len = 0;
13363 #if defined(_WIN32) || defined(_WIN64)
13364 if (!((
STMT *) stmt)->oemcp[0]) {
13369 if (ret == SQL_SUCCESS) {
13373 c = utf_to_wmb((
char *) cursor, len);
13381 strncpy((
char *) cursor, c, buflen - 1);
13382 cursor[buflen - 1] = 0;
13387 *lenp =
min(len, buflen - 1);
13415 SQLSMALLINT len = 0;
13419 if (ret == SQL_SUCCESS) {
13420 SQLWCHAR *c = NULL;
13432 cursor[buflen - 1] = 0;
13437 *lenp =
min(len, buflen - 1);
13459 if (stmt == SQL_NULL_HSTMT) {
13460 return SQL_INVALID_HANDLE;
13464 !((cursor[0] >=
'A' && cursor[0] <=
'Z') ||
13465 (cursor[0] >=
'a' && cursor[0] <=
'z'))) {
13466 setstat(s, -1,
"invalid cursor name", (*s->
ov3) ?
"HYC00" :
"S1C00");
13469 if (len == SQL_NTS) {
13474 strncpy((
char *) s->
cursorname, (
char *) cursor, len);
13476 return SQL_SUCCESS;
13489 SQLSetCursorName(SQLHSTMT stmt, SQLCHAR *cursor, SQLSMALLINT len)
13491 #if defined(_WIN32) || defined(_WIN64)
13497 #if defined(_WIN32) || defined(_WIN64)
13498 if (!((
STMT *) stmt)->oemcp[0]) {
13503 c = wmb_to_utf_c((
char *) cursor, len);
13513 #if defined(_WIN32) || defined(_WIN64)
13581 case SQL_HANDLE_ENV:
13583 if (ret == SQL_SUCCESS) {
13584 ENV *e = (
ENV *) *output;
13591 case SQL_HANDLE_DBC:
13593 case SQL_HANDLE_STMT:
13595 ret =
drvallocstmt((SQLHDBC) input, (SQLHSTMT *) output);
13613 case SQL_HANDLE_ENV:
13615 case SQL_HANDLE_DBC:
13617 case SQL_HANDLE_STMT:
13634 for (i = 0; i < s->
dcols; i++) {
13725 for (i = s->
nbindcols; i < ncols; i++) {
13726 bindcols[i].
type = SQL_UNKNOWN_TYPE;
13727 bindcols[i].
max = 0;
13728 bindcols[i].
lenp = NULL;
13729 bindcols[i].
valp = NULL;
13730 bindcols[i].
index = i;
13731 bindcols[i].
offs = 0;
13736 }
else if (ncols > 0) {
13744 return SQL_SUCCESS;
13762 SQLPOINTER val, SQLINTEGER len,
SQLLEN *lenp,
int partial)
13764 char **data, valdummy[16];
13766 SQLINTEGER *ilenp = NULL;
13769 SQLRETURN sret = SQL_NO_DATA;
13775 if (((SQLINTEGER *) lenp) + 1 == (SQLINTEGER *) val) {
13776 ilenp = (SQLINTEGER *) lenp;
13779 if (col >= s->
ncols) {
13780 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009" :
"S1002");
13784 return SQL_SUCCESS;
13787 *lenp = SQL_NULL_DATA;
13791 *lenp = SQL_NULL_DATA;
13796 #if (defined(_WIN32) || defined(_WIN64)) && defined(WINTERFACE)
13798 if (type == SQL_C_WCHAR && otype == SQL_C_DEFAULT) {
13805 val = (SQLPOINTER) valdummy;
13807 if (*data == NULL) {
13808 *lenp = SQL_NULL_DATA;
13810 case SQL_C_UTINYINT:
13811 case SQL_C_TINYINT:
13812 case SQL_C_STINYINT:
13816 *((SQLCHAR *) val) = 0;
13821 *((SQLSMALLINT *) val) = 0;
13826 *((SQLINTEGER *) val) = 0;
13829 case SQL_C_SBIGINT:
13830 case SQL_C_UBIGINT:
13831 *((SQLBIGINT *) val) = 0;
13835 *((
float *) val) = 0;
13838 *((
double *) val) = 0;
13843 *((SQLCHAR *) val) =
'\0';
13846 #ifdef WCHARSUPPORT
13849 *((SQLWCHAR *) val) =
'\0';
13853 #ifdef SQL_C_TYPE_DATE
13854 case SQL_C_TYPE_DATE:
13857 memset((DATE_STRUCT *) val, 0,
sizeof (DATE_STRUCT));
13859 #ifdef SQL_C_TYPE_TIME
13860 case SQL_C_TYPE_TIME:
13863 memset((TIME_STRUCT *) val, 0,
sizeof (TIME_STRUCT));
13865 #ifdef SQL_C_TYPE_TIMESTAMP
13866 case SQL_C_TYPE_TIMESTAMP:
13868 case SQL_C_TIMESTAMP:
13869 memset((TIMESTAMP_STRUCT *) val, 0,
sizeof (TIMESTAMP_STRUCT));
13876 #if defined(_WIN32) || defined(_WIN64)
13883 case SQL_C_UTINYINT:
13884 case SQL_C_TINYINT:
13885 case SQL_C_STINYINT:
13886 *((SQLCHAR *) val) = strtol(*data, &endp, 0);
13887 if (endp && endp == *data) {
13888 *lenp = SQL_NULL_DATA;
13890 *lenp =
sizeof (SQLCHAR);
13895 *((SQLCHAR *) val) =
getbool(*data);
13896 *lenp =
sizeof (SQLCHAR);
13902 *((SQLSMALLINT *) val) = strtol(*data, &endp, 0);
13903 if (endp && endp == *data) {
13904 *lenp = SQL_NULL_DATA;
13906 *lenp =
sizeof (SQLSMALLINT);
13912 *((SQLINTEGER *) val) = strtol(*data, &endp, 0);
13913 if (endp && endp == *data) {
13914 *lenp = SQL_NULL_DATA;
13916 *lenp =
sizeof (SQLINTEGER);
13920 case SQL_C_UBIGINT:
13921 #if defined(_WIN32) || defined(_WIN64)
13922 if (sscanf(*data,
"%I64u%c", (SQLUBIGINT *) val, &endc) != 1) {
13923 *lenp = SQL_NULL_DATA;
13925 *lenp =
sizeof (SQLUBIGINT);
13929 *((SQLUBIGINT *) val) = strtoul(*data, &endp, 0);
13931 *((SQLUBIGINT *) val) = strtoull(*data, &endp, 0);
13933 if (endp && endp == *data) {
13934 *lenp = SQL_NULL_DATA;
13936 *lenp =
sizeof (SQLUBIGINT);
13940 case SQL_C_SBIGINT:
13941 #if defined(_WIN32) || defined(_WIN64)
13942 if (sscanf(*data,
"%I64d%c", (SQLBIGINT *) val, &endc) != 1) {
13943 *lenp = SQL_NULL_DATA;
13945 *lenp =
sizeof (SQLBIGINT);
13949 *((SQLBIGINT *) val) = strtol(*data, &endp, 0);
13951 *((SQLBIGINT *) val) = strtoll(*data, &endp, 0);
13953 if (endp && endp == *data) {
13954 *lenp = SQL_NULL_DATA;
13956 *lenp =
sizeof (SQLBIGINT);
13962 *((
float *) val) =
ln_strtod(*data, &endp);
13963 if (endp && endp == *data) {
13964 *lenp = SQL_NULL_DATA;
13966 *lenp =
sizeof (float);
13970 *((
double *) val) =
ln_strtod(*data, &endp);
13971 if (endp && endp == *data) {
13972 *lenp = SQL_NULL_DATA;
13974 *lenp =
sizeof (double);
13977 case SQL_C_BINARY: {
13978 int dlen, offs = 0;
14002 if (!(dp[0] ==
'x' || dp[0] ==
'X') || dp[1] !=
'\'' ||
14003 dp[dlen - 1] !=
'\'') {
14014 memset(bin, 0, dlen);
14016 for (i = 0; i < dlen; i++) {
14020 if (!*dp || !(x = strchr(
xdigits, *dp))) {
14024 bin[i] = (v >= 16) ? ((v - 6) << 4) : (v << 4);
14026 if (!*dp || !(x = strchr(xdigits, *dp))) {
14030 setstat(s, -1,
"conversion error",
14031 (*s->
ov3) ?
"HY000" :
"S1000");
14035 bin[i] |= (v >= 16) ? (v - 6) : v;
14040 if (partial && len && s->
bindcols) {
14045 sret = SQL_SUCCESS;
14049 sret = SQL_NO_DATA;
14056 memcpy(val, bin + offs,
min(len, dlen));
14061 *lenp =
min(len, dlen);
14062 if (*lenp == len && *lenp != dlen) {
14063 *lenp = SQL_NO_TOTAL;
14066 if (partial && len && s->
bindcols) {
14067 if (*lenp == SQL_NO_TOTAL) {
14070 setstat(s, -1,
"data right truncated",
"01004");
14074 sret = SQL_SUCCESS_WITH_INFO;
14079 if (*lenp == SQL_NO_TOTAL) {
14081 setstat(s, -1,
"data right truncated",
"01004");
14082 sret = SQL_SUCCESS_WITH_INFO;
14088 #ifdef WCHARSUPPORT
14092 int doz, zlen = len - 1;
14093 int dlen = strlen(*data);
14095 #ifdef WCHARSUPPORT
14096 SQLWCHAR *ucdata = NULL;
14097 SQLCHAR *cdata = (SQLCHAR *) *data;
14100 #if (defined(_WIN32) || defined(_WIN64)) && defined(WINTERFACE)
14103 (s->
cols == statSpec2P || s->
cols == statSpec3P) &&
14104 type == SQL_C_WCHAR) {
14105 if (len > 0 && len <=
sizeof (SQLWCHAR)) {
14106 ((
char *) val)[0] = data[0][0];
14107 memset((
char *) val + 1, 0, len - 1);
14109 sret = SQL_SUCCESS;
14115 #ifdef WCHARSUPPORT
14121 doz =
sizeof (SQLWCHAR);
14127 if (type == SQL_C_WCHAR) {
14132 dlen =
uc_strlen(ucdata) *
sizeof (SQLWCHAR);
14134 #if defined(_WIN32) || defined(_WIN64)
14135 else if (*s->
oemcp && type == SQL_C_CHAR) {
14136 ucdata = (SQLWCHAR *) utf_to_wmb((
char *) cdata, dlen);
14140 cdata = (SQLCHAR *) ucdata;
14141 dlen = strlen((
char *) cdata);
14145 doz = (type == SQL_C_CHAR) ? 1 : 0;
14147 if (partial && len && s->
bindcols) {
14149 #ifdef WCHARSUPPORT
14154 #ifdef WCHARSUPPORT
14155 if (type == SQL_C_WCHAR) {
14156 ((SQLWCHAR *) val)[0] = 0;
14158 ((
char *) val)[0] =
'\0';
14161 ((
char *) val)[0] =
'\0';
14166 sret = SQL_SUCCESS;
14170 sret = SQL_NO_DATA;
14176 if (val && !valnull && len) {
14177 #ifdef WCHARSUPPORT
14178 if (type == SQL_C_WCHAR) {
14179 uc_strncpy(val, ucdata + offs /
sizeof (SQLWCHAR),
14180 (len - doz) /
sizeof (SQLWCHAR));
14182 strncpy(val, (
char *) cdata + offs, len - doz);
14185 strncpy(val, *data + offs, len - doz);
14188 if (valnull || len < 1) {
14191 *lenp =
min(len - doz, dlen);
14192 if (*lenp == len - doz && *lenp != dlen) {
14193 *lenp = SQL_NO_TOTAL;
14194 }
else if (*lenp < zlen) {
14198 if (len && !valnull && doz) {
14199 #ifdef WCHARSUPPORT
14200 if (type == SQL_C_WCHAR) {
14201 ((SQLWCHAR *) val)[zlen /
sizeof (SQLWCHAR)] = 0;
14203 ((
char *) val)[zlen] =
'\0';
14206 ((
char *) val)[zlen] =
'\0';
14209 #ifdef WCHARSUPPORT
14212 if (partial && len && s->
bindcols) {
14213 if (*lenp == SQL_NO_TOTAL) {
14216 setstat(s, -1,
"data right truncated",
"01004");
14220 sret = SQL_SUCCESS_WITH_INFO;
14225 if (*lenp == SQL_NO_TOTAL) {
14227 setstat(s, -1,
"data right truncated",
"01004");
14228 sret = SQL_SUCCESS_WITH_INFO;
14233 #ifdef SQL_C_TYPE_DATE
14234 case SQL_C_TYPE_DATE:
14238 *lenp = SQL_NULL_DATA;
14240 *lenp =
sizeof (DATE_STRUCT);
14243 #ifdef SQL_C_TYPE_TIME
14244 case SQL_C_TYPE_TIME:
14248 *lenp = SQL_NULL_DATA;
14250 *lenp =
sizeof (TIME_STRUCT);
14253 #ifdef SQL_C_TYPE_TIMESTAMP
14254 case SQL_C_TYPE_TIMESTAMP:
14256 case SQL_C_TIMESTAMP:
14258 (TIMESTAMP_STRUCT *) val) < 0) {
14259 *lenp = SQL_NULL_DATA;
14261 *lenp =
sizeof (TIMESTAMP_STRUCT);
14265 ((TIMESTAMP_STRUCT *) val)->fraction = 0;
14268 ((TIMESTAMP_STRUCT *) val)->fraction /= 100000000;
14269 ((TIMESTAMP_STRUCT *) val)->fraction *= 100000000;
14272 ((TIMESTAMP_STRUCT *) val)->fraction /= 10000000;
14273 ((TIMESTAMP_STRUCT *) val)->fraction *= 10000000;
14281 sret = SQL_SUCCESS;
14307 if (stmt == SQL_NULL_HSTMT) {
14308 return SQL_INVALID_HANDLE;
14312 if (col == 0 && s->
bkmrk == SQL_UB_ON &&
14313 type == SQL_C_BOOKMARK) {
14322 return SQL_SUCCESS;
14323 }
else if (col == 0 && s->
bkmrk == SQL_UB_VARIABLE &&
14324 type == SQL_C_VARBOOKMARK &&
14325 max >= sizeof (sqlite_int64)) {
14334 return SQL_SUCCESS;
14336 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009" :
"S1002");
14343 if (type == SQL_C_DEFAULT) {
14351 sz =
sizeof (SQLINTEGER);
14353 case SQL_C_TINYINT:
14354 case SQL_C_UTINYINT:
14355 case SQL_C_STINYINT:
14356 sz =
sizeof (SQLCHAR);
14361 sz =
sizeof (SQLSMALLINT);
14364 sz =
sizeof (SQLFLOAT);
14367 sz =
sizeof (SQLDOUBLE);
14369 case SQL_C_TIMESTAMP:
14370 sz =
sizeof (SQL_TIMESTAMP_STRUCT);
14373 sz =
sizeof (SQL_TIME_STRUCT);
14376 sz =
sizeof (SQL_DATE_STRUCT);
14380 #ifdef WCHARSUPPORT
14384 #ifdef SQL_C_TYPE_DATE
14385 case SQL_C_TYPE_DATE:
14386 sz =
sizeof (SQL_DATE_STRUCT);
14389 #ifdef SQL_C_TYPE_TIME
14390 case SQL_C_TYPE_TIME:
14391 sz =
sizeof (SQL_TIME_STRUCT);
14394 #ifdef SQL_C_TYPE_TIMESTAMP
14395 case SQL_C_TYPE_TIMESTAMP:
14396 sz =
sizeof (SQL_TIMESTAMP_STRUCT);
14401 sz =
sizeof (SQLCHAR);
14407 case SQL_C_SBIGINT:
14408 case SQL_C_UBIGINT:
14409 sz =
sizeof (SQLBIGINT);
14417 setstat(s, -1,
"invalid type %d",
"HY003", type);
14428 if (sz == 0 && max < 0) {
14429 setstat(s, -1,
"invalid length",
"HY090");
14441 return SQL_SUCCESS;
14462 ret =
drvbindcol(stmt, col, type, val, max, lenp);
14472 {
"SYSTEM",
"COLUMN",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
14473 {
"SYSTEM",
"COLUMN",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
14474 {
"SYSTEM",
"COLUMN",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
14475 {
"SYSTEM",
"COLUMN",
"TABLE_TYPE",
SCOL_VARCHAR, 50 },
14480 {
"SYSTEM",
"COLUMN",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
14481 {
"SYSTEM",
"COLUMN",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
14482 {
"SYSTEM",
"COLUMN",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
14483 {
"SYSTEM",
"COLUMN",
"TABLE_TYPE",
SCOL_VARCHAR, 50 },
14503 SQLCHAR *cat, SQLSMALLINT catLen,
14504 SQLCHAR *schema, SQLSMALLINT schemaLen,
14505 SQLCHAR *table, SQLSMALLINT tableLen,
14506 SQLCHAR *type, SQLSMALLINT typeLen)
14511 int ncols, asize, rc, size, npatt;
14512 char *errp = NULL, *sql, tname[512];
14513 char *where =
"(type = 'table' or type = 'view')";
14516 tableSpec3,
array_size(tableSpec3), &asize);
14517 if (ret != SQL_SUCCESS) {
14522 if (type && (typeLen > 0 || typeLen == SQL_NTS) && type[0] ==
'%') {
14523 int size = 3 * asize;
14530 memset(s->
rows, 0, sizeof (
char *) * size);
14540 #ifdef MEMORY_DEBUG
14547 return SQL_SUCCESS;
14549 if (cat && (catLen > 0 || catLen == SQL_NTS) && cat[0] ==
'%') {
14553 if (schema && (schemaLen > 0 || schemaLen == SQL_NTS) &&
14554 schema[0] ==
'%') {
14555 if ((!cat || catLen == 0 || !cat[0]) &&
14556 (!table || tableLen == 0 || !table[0])) {
14561 if (type && (typeLen > 0 || typeLen == SQL_NTS) && type[0] !=
'\0') {
14563 int with_view = 0, with_table = 0;
14565 if (typeLen == SQL_NTS) {
14566 strncpy(tmp, (
char *) type,
sizeof (tmp));
14567 tmp[
sizeof (tmp) - 1] =
'\0';
14569 int len =
min(
sizeof (tmp) - 1, typeLen);
14571 strncpy(tmp, (
char *) type, len);
14582 if (t[0] ==
'\'') {
14585 if (strncmp(t,
"table", 5) == 0) {
14587 }
else if (strncmp(t,
"view", 4) == 0) {
14590 t = strchr(t,
',');
14595 if (with_view && with_table) {
14597 }
else if (with_view && !with_table) {
14598 where =
"type = 'view'";
14599 }
else if (!with_view && with_table) {
14600 where =
"type = 'table'";
14602 return SQL_SUCCESS;
14610 if (tableLen == SQL_NTS) {
14611 size =
sizeof (tname) - 1;
14613 size =
min(
sizeof (tname) - 1, tableLen);
14615 strncpy(tname, (
char *) table, size);
14617 tname[size] =
'\0';
14619 #if defined(_WIN32) || defined(_WIN64)
14620 sql = sqlite3_mprintf(
"select %s as 'TABLE_CAT', "
14621 "%s as 'TABLE_SCHEM', "
14622 "tbl_name as 'TABLE_NAME', "
14623 "upper(type) as 'TABLE_TYPE', "
14624 "NULL as 'REMARKS' "
14625 "from sqlite_master where %s "
14626 "and tbl_name %s %Q",
14627 d->xcelqrx ?
"'main'" :
"NULL",
14628 d->xcelqrx ?
"''" :
"NULL",
14630 npatt ?
"like" :
"=", tname);
14632 sql = sqlite3_mprintf(
"select NULL as 'TABLE_QUALIFIER', "
14633 "NULL as 'TABLE_OWNER', "
14634 "tbl_name as 'TABLE_NAME', "
14635 "upper(type) as 'TABLE_TYPE', "
14636 "NULL as 'REMARKS' "
14637 "from sqlite_master where %s "
14638 "and tbl_name %s %Q", where,
14639 npatt ?
"like" :
"=", tname);
14645 if (ret != SQL_SUCCESS) {
14650 rc = sqlite3_get_table(d->
sqlite, sql, &s->
rows, &s->
nrows, &ncols, &errp);
14652 if (rc == SQLITE_OK) {
14653 if (ncols != s->
ncols) {
14657 s->
rowfree = sqlite3_free_table;
14665 sqlite3_free(errp);
14669 return SQL_SUCCESS;
14688 SQLTables(SQLHSTMT stmt,
14689 SQLCHAR *cat, SQLSMALLINT catLen,
14690 SQLCHAR *schema, SQLSMALLINT schemaLen,
14691 SQLCHAR *table, SQLSMALLINT tableLen,
14692 SQLCHAR *type, SQLSMALLINT typeLen)
14694 #if defined(_WIN32) || defined(_WIN64)
14695 char *c = NULL, *s = NULL, *t = NULL, *y = NULL;
14700 #if defined(_WIN32) || defined(_WIN64)
14701 if (!((
STMT *) stmt)->oemcp[0]) {
14702 ret =
drvtables(stmt, cat, catLen, schema, schemaLen,
14703 table, tableLen, type, typeLen);
14707 c = wmb_to_utf_c((
char *) cat, catLen);
14714 s = wmb_to_utf_c((
char *) schema, schemaLen);
14721 t = wmb_to_utf_c((
char *) table, tableLen);
14728 y = wmb_to_utf_c((
char *) type, typeLen);
14734 ret =
drvtables(stmt, (SQLCHAR *) c, SQL_NTS, (SQLCHAR *) s, SQL_NTS,
14735 (SQLCHAR *) t, SQL_NTS, (SQLCHAR *) y, SQL_NTS);
14737 ret =
drvtables(stmt, cat, catLen, schema, schemaLen,
14738 table, tableLen, type, typeLen);
14740 #if defined(_WIN32) || defined(_WIN64)
14771 SQLWCHAR *cat, SQLSMALLINT catLen,
14772 SQLWCHAR *schema, SQLSMALLINT schemaLen,
14773 SQLWCHAR *table, SQLSMALLINT tableLen,
14774 SQLWCHAR *type, SQLSMALLINT typeLen)
14776 char *c = NULL, *s = NULL, *t = NULL, *y = NULL;
14808 ret =
drvtables(stmt, (SQLCHAR *) c, SQL_NTS, (SQLCHAR *) s, SQL_NTS,
14809 (SQLCHAR *) t, SQL_NTS, (SQLCHAR *) y, SQL_NTS);
14825 {
"SYSTEM",
"COLUMN",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
14826 {
"SYSTEM",
"COLUMN",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
14827 {
"SYSTEM",
"COLUMN",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
14828 {
"SYSTEM",
"COLUMN",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
14829 {
"SYSTEM",
"COLUMN",
"DATA_TYPE", SQL_SMALLINT, 50 },
14830 {
"SYSTEM",
"COLUMN",
"TYPE_NAME",
SCOL_VARCHAR, 50 },
14831 {
"SYSTEM",
"COLUMN",
"PRECISION", SQL_INTEGER, 50 },
14832 {
"SYSTEM",
"COLUMN",
"LENGTH", SQL_INTEGER, 50 },
14833 {
"SYSTEM",
"COLUMN",
"SCALE", SQL_SMALLINT, 50 },
14834 {
"SYSTEM",
"COLUMN",
"RADIX", SQL_SMALLINT, 50 },
14835 {
"SYSTEM",
"COLUMN",
"NULLABLE", SQL_SMALLINT, 50 },
14837 {
"SYSTEM",
"COLUMN",
"COLUMN_DEF",
SCOL_VARCHAR, 50 },
14838 {
"SYSTEM",
"COLUMN",
"SQL_DATA_TYPE", SQL_SMALLINT, 50 },
14839 {
"SYSTEM",
"COLUMN",
"SQL_DATETIME_SUB", SQL_SMALLINT, 50 },
14840 {
"SYSTEM",
"COLUMN",
"CHAR_OCTET_LENGTH", SQL_SMALLINT, 50 },
14841 {
"SYSTEM",
"COLUMN",
"ORDINAL_POSITION", SQL_SMALLINT, 50 },
14842 {
"SYSTEM",
"COLUMN",
"IS_NULLABLE",
SCOL_VARCHAR, 50 }
14846 {
"SYSTEM",
"COLUMN",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
14847 {
"SYSTEM",
"COLUMN",
"TABLE_SCHEM",
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",
"COLUMN_SIZE", SQL_INTEGER, 50 },
14853 {
"SYSTEM",
"COLUMN",
"BUFFER_LENGTH", SQL_INTEGER, 50 },
14854 {
"SYSTEM",
"COLUMN",
"DECIMAL_DIGITS", SQL_SMALLINT, 50 },
14855 {
"SYSTEM",
"COLUMN",
"NUM_PREC_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 }
14882 SQLCHAR *cat, SQLSMALLINT catLen,
14883 SQLCHAR *schema, SQLSMALLINT schemaLen,
14884 SQLCHAR *table, SQLSMALLINT tableLen,
14885 SQLCHAR *col, SQLSMALLINT colLen)
14890 int ret, nrows, ncols, asize, i, k, roffs, namec;
14891 int tnrows, tncols, npatt;
14893 char *errp = NULL, *sql, tname[512], cname[512], **rowp, **trows;
14897 if (sret != SQL_SUCCESS) {
14906 if (tableLen == SQL_NTS) {
14907 size =
sizeof (tname) - 1;
14909 size =
min(
sizeof (tname) - 1, tableLen);
14911 strncpy(tname, (
char *) table, size);
14913 tname[size] =
'\0';
14917 if (colLen == SQL_NTS) {
14918 size =
sizeof (cname) - 1;
14920 size =
min(
sizeof (cname) - 1, colLen);
14922 strncpy(cname, (
char *) col, size);
14924 cname[size] =
'\0';
14925 if (!strcmp(cname,
"%")) {
14928 sql = sqlite3_mprintf(
"select tbl_name from sqlite_master where "
14929 "(type = 'table' or type = 'view') "
14930 "and tbl_name %s %Q", npatt ?
"like" :
"=", tname);
14935 if (sret != SQL_SUCCESS) {
14940 ret = sqlite3_get_table(d->
sqlite, sql, &trows, &tnrows, &tncols, &errp);
14942 if (ret != SQLITE_OK) {
14943 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
14944 errp ? errp :
"unknown error", ret);
14946 sqlite3_free(errp);
14952 sqlite3_free(errp);
14956 if (tncols * tnrows <= 0) {
14957 sqlite3_free_table(trows);
14958 return SQL_SUCCESS;
14961 for (i = 1; i <= tnrows; i++) {
14962 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", trows[i]);
14964 sqlite3_free_table(trows);
14968 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
14970 if (ret != SQLITE_OK) {
14971 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
14972 errp ? errp :
"unknown error", ret);
14974 sqlite3_free(errp);
14977 sqlite3_free_table(trows);
14981 sqlite3_free(errp);
14984 if (ncols * nrows > 0) {
14986 for (k = 0; k < ncols; k++) {
14987 if (strcmp(rowp[k],
"name") == 0) {
14994 for (k = 1; k <= nrows; k++) {
14995 if (
namematch(rowp[k * ncols + namec], cname, 1)) {
15004 sqlite3_free_table(rowp);
15008 sqlite3_free_table(trows);
15009 return SQL_SUCCESS;
15012 size = (size + 1) * asize;
15016 sqlite3_free_table(trows);
15019 s->
rows[0] = (
char *) size;
15021 memset(s->
rows, 0, sizeof (
char *) * size);
15024 for (i = 1; i <= tnrows; i++) {
15025 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", trows[i]);
15027 sqlite3_free_table(trows);
15031 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
15033 if (ret != SQLITE_OK) {
15034 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
15035 errp ? errp :
"unknown error", ret);
15037 sqlite3_free(errp);
15040 sqlite3_free_table(trows);
15044 sqlite3_free(errp);
15047 if (ncols * nrows > 0) {
15048 int m, mr, nr = nrows;
15051 for (k = 0; k < ncols; k++) {
15052 if (strcmp(rowp[k],
"name") == 0) {
15060 for (k = 1; k <= nrows; k++) {
15061 if (
namematch(rowp[k * ncols + namec], cname, 1)) {
15067 for (k = 0; k < nr; k++) {
15068 m = asize * (roffs + k);
15069 #if defined(_WIN32) || defined(_WIN64)
15070 s->
rows[m + 0] =
xstrdup(d->xcelqrx ?
"main" :
"");
15081 for (k = 0; nr && k < ncols; k++) {
15082 if (strcmp(rowp[k],
"cid") == 0) {
15083 for (mr = 0, m = 1; m <= nrows; m++) {
15088 !
namematch(rowp[m * ncols + namec], cname, 1)) {
15091 ir = asize * (roffs + mr);
15092 sscanf(rowp[m * ncols + k],
"%d", &coln);
15093 sprintf(buf,
"%d", coln + 1);
15097 }
else if (k == namec) {
15098 for (mr = 0, m = 1; m <= nrows; m++) {
15102 !
namematch(rowp[m * ncols + namec], cname, 1)) {
15105 ir = asize * (roffs + mr);
15109 }
else if (strcmp(rowp[k],
"notnull") == 0) {
15110 for (mr = 0, m = 1; m <= nrows; m++) {
15114 !
namematch(rowp[m * ncols + namec], cname, 1)) {
15117 ir = asize * (roffs + mr);
15118 if (*rowp[m * ncols + k] !=
'0') {
15124 xstrdup((*rowp[m * ncols + k] !=
'0') ?
15128 }
else if (strcmp(rowp[k],
"dflt_value") == 0) {
15129 for (mr = 0, m = 1; m <= nrows; m++) {
15130 char *dflt =
unquote(rowp[m * ncols + k]);
15134 !
namematch(rowp[m * ncols + namec], cname, 1)) {
15137 ir = asize * (roffs + mr);
15138 s->
rows[ir + 12] =
xstrdup(dflt ? dflt :
"NULL");
15141 }
else if (strcmp(rowp[k],
"type") == 0) {
15142 for (mr = 0, m = 1; m <= nrows; m++) {
15143 char *
typename = rowp[m * ncols + k];
15144 int sqltype, mm, dd, ir;
15148 !
namematch(rowp[m * ncols + namec], cname, 1)) {
15151 ir = asize * (roffs + mr);
15155 getmd(
typename, sqltype, &mm, &dd);
15156 #ifdef SQL_LONGVARCHAR
15157 if (sqltype == SQL_VARCHAR && mm > 255) {
15158 sqltype = SQL_LONGVARCHAR;
15162 #ifdef SQL_WLONGVARCHAR
15163 if (sqltype == SQL_WVARCHAR && mm > 255) {
15164 sqltype = SQL_WLONGVARCHAR;
15168 if (sqltype == SQL_VARBINARY && mm > 255) {
15169 sqltype = SQL_LONGVARBINARY;
15171 sprintf(buf,
"%d", sqltype);
15174 sprintf(buf,
"%d", mm);
15176 sprintf(buf,
"%d", dd);
15184 sqlite3_free_table(rowp);
15186 sqlite3_free_table(trows);
15187 return SQL_SUCCESS;
15206 SQLColumns(SQLHSTMT stmt,
15207 SQLCHAR *cat, SQLSMALLINT catLen,
15208 SQLCHAR *schema, SQLSMALLINT schemaLen,
15209 SQLCHAR *table, SQLSMALLINT tableLen,
15210 SQLCHAR *col, SQLSMALLINT colLen)
15212 #if defined(_WIN32) || defined(_WIN64)
15213 char *c = NULL, *s = NULL, *t = NULL, *k = NULL;
15218 #if defined(_WIN32) || defined(_WIN64)
15219 if (!((
STMT *) stmt)->oemcp[0]) {
15220 ret =
drvcolumns(stmt, cat, catLen, schema, schemaLen,
15221 table, tableLen, col, colLen);
15225 c = wmb_to_utf_c((
char *) cat, catLen);
15232 s = wmb_to_utf_c((
char *) schema, schemaLen);
15239 t = wmb_to_utf_c((
char *) table, tableLen);
15246 k = wmb_to_utf_c((
char *) col, colLen);
15252 ret =
drvcolumns(stmt, (SQLCHAR *) c, SQL_NTS, (SQLCHAR *) s, SQL_NTS,
15253 (SQLCHAR *) t, SQL_NTS, (SQLCHAR *) k, SQL_NTS);
15255 ret =
drvcolumns(stmt, cat, catLen, schema, schemaLen,
15256 table, tableLen, col, colLen);
15258 #if defined(_WIN32) || defined(_WIN64)
15289 SQLWCHAR *cat, SQLSMALLINT catLen,
15290 SQLWCHAR *schema, SQLSMALLINT schemaLen,
15291 SQLWCHAR *table, SQLSMALLINT tableLen,
15292 SQLWCHAR *col, SQLSMALLINT colLen)
15294 char *c = NULL, *s = NULL, *t = NULL, *k = NULL;
15326 ret =
drvcolumns(stmt, (SQLCHAR *) c, SQL_NTS, (SQLCHAR *) s, SQL_NTS,
15327 (SQLCHAR *) t, SQL_NTS, (SQLCHAR *) k, SQL_NTS);
15345 {
"SYSTEM",
"TYPE",
"DATA_TYPE", SQL_SMALLINT, 2 },
15346 {
"SYSTEM",
"TYPE",
"PRECISION", SQL_INTEGER, 9 },
15347 {
"SYSTEM",
"TYPE",
"LITERAL_PREFIX",
SCOL_VARCHAR, 50 },
15348 {
"SYSTEM",
"TYPE",
"LITERAL_SUFFIX",
SCOL_VARCHAR, 50 },
15349 {
"SYSTEM",
"TYPE",
"CREATE_PARAMS",
SCOL_VARCHAR, 50 },
15350 {
"SYSTEM",
"TYPE",
"NULLABLE", SQL_SMALLINT, 2 },
15351 {
"SYSTEM",
"TYPE",
"CASE_SENSITIVE", SQL_SMALLINT, 2 },
15352 {
"SYSTEM",
"TYPE",
"SEARCHABLE", SQL_SMALLINT, 2 },
15353 {
"SYSTEM",
"TYPE",
"UNSIGNED_ATTRIBUTE", SQL_SMALLINT, 2 },
15354 {
"SYSTEM",
"TYPE",
"MONEY", SQL_SMALLINT, 2 },
15355 {
"SYSTEM",
"TYPE",
"AUTO_INCREMENT", SQL_SMALLINT, 2 },
15356 {
"SYSTEM",
"TYPE",
"LOCAL_TYPE_NAME",
SCOL_VARCHAR, 50 },
15357 {
"SYSTEM",
"TYPE",
"MINIMUM_SCALE", SQL_SMALLINT, 2 },
15358 {
"SYSTEM",
"TYPE",
"MAXIMUM_SCALE", SQL_SMALLINT, 2 }
15363 {
"SYSTEM",
"TYPE",
"DATA_TYPE", SQL_SMALLINT, 2 },
15364 {
"SYSTEM",
"TYPE",
"COLUMN_SIZE", SQL_INTEGER, 9 },
15365 {
"SYSTEM",
"TYPE",
"LITERAL_PREFIX",
SCOL_VARCHAR, 50 },
15366 {
"SYSTEM",
"TYPE",
"LITERAL_SUFFIX",
SCOL_VARCHAR, 50 },
15367 {
"SYSTEM",
"TYPE",
"CREATE_PARAMS",
SCOL_VARCHAR, 50 },
15368 {
"SYSTEM",
"TYPE",
"NULLABLE", SQL_SMALLINT, 2 },
15369 {
"SYSTEM",
"TYPE",
"CASE_SENSITIVE", SQL_SMALLINT, 2 },
15370 {
"SYSTEM",
"TYPE",
"SEARCHABLE", SQL_SMALLINT, 2 },
15371 {
"SYSTEM",
"TYPE",
"UNSIGNED_ATTRIBUTE", SQL_SMALLINT, 2 },
15372 {
"SYSTEM",
"TYPE",
"FIXED_PREC_SCALE", SQL_SMALLINT, 2 },
15373 {
"SYSTEM",
"TYPE",
"AUTO_UNIQUE_VALUE", SQL_SMALLINT, 2 },
15374 {
"SYSTEM",
"TYPE",
"LOCAL_TYPE_NAME",
SCOL_VARCHAR, 50 },
15375 {
"SYSTEM",
"TYPE",
"MINIMUM_SCALE", SQL_SMALLINT, 2 },
15376 {
"SYSTEM",
"TYPE",
"MAXIMUM_SCALE", SQL_SMALLINT, 2 },
15377 {
"SYSTEM",
"TYPE",
"SQL_DATA_TYPE", SQL_SMALLINT, 2 },
15378 {
"SYSTEM",
"TYPE",
"SQL_DATETIME_SUB", SQL_SMALLINT, 2 },
15379 {
"SYSTEM",
"TYPE",
"NUM_PREC_RADIX", SQL_INTEGER, 4 },
15380 {
"SYSTEM",
"TYPE",
"INTERVAL_PRECISION", SQL_SMALLINT, 2 }
15396 int offs = row * asize;
15397 char *tcode, *crpar = NULL, *quote = NULL, *sign =
stringify(SQL_FALSE);
15398 static char tcodes[32 * 32];
15403 tcode = tcodes + tind * 32;
15404 sprintf(tcode,
"%d", type);
15405 s->
rows[offs + 0] =
typename;
15406 s->
rows[offs + 1] = tcode;
15408 s->
rows[offs + 15] = tcode;
15409 s->
rows[offs + 16] =
"0";
15413 #ifdef SQL_LONGVARCHAR
15414 case SQL_LONGVARCHAR:
15416 case SQL_WLONGVARCHAR:
15421 s->
rows[offs + 2] =
"65536";
15427 s->
rows[offs + 2] =
"1";
15436 s->
rows[offs + 2] =
"255";
15442 s->
rows[offs + 2] =
"3";
15445 s->
rows[offs + 2] =
"5";
15448 s->
rows[offs + 2] =
"9";
15452 s->
rows[offs + 2] =
"19";
15456 s->
rows[offs + 2] =
"7";
15459 s->
rows[offs + 2] =
"15";
15461 #ifdef SQL_TYPE_DATE
15462 case SQL_TYPE_DATE:
15465 s->
rows[offs + 2] =
"10";
15469 #ifdef SQL_TYPE_TIME
15470 case SQL_TYPE_TIME:
15473 s->
rows[offs + 2] =
"8";
15477 #ifdef SQL_TYPE_TIMESTAMP
15478 case SQL_TYPE_TIMESTAMP:
15480 case SQL_TIMESTAMP:
15481 s->
rows[offs + 2] =
"32";
15485 case SQL_VARBINARY:
15487 s->
rows[offs + 2] =
"255";
15489 case SQL_LONGVARBINARY:
15491 s->
rows[offs + 2] =
"65536";
15494 s->
rows[offs + 3] = s->
rows[offs + 4] = quote;
15495 s->
rows[offs + 5] = crpar;
15499 s->
rows[offs + 9] = sign;
15502 s->
rows[offs + 12] =
typename;
15506 s->
rows[offs + 13] =
"0";
15507 s->
rows[offs + 14] =
"0";
15509 #ifdef SQL_TYPE_TIMESTAMP
15510 case SQL_TYPE_TIMESTAMP:
15512 case SQL_TIMESTAMP:
15513 s->
rows[offs + 13] =
"0";
15514 s->
rows[offs + 14] =
"3";
15517 s->
rows[offs + 13] = NULL;
15518 s->
rows[offs + 14] = NULL;
15534 char **pa = (
char **) a;
15535 char **pb = (
char **) b;
15538 na = strtol(pa[1], NULL, 0);
15539 nb = strtol(pb[1], NULL, 0);
15559 if (ret != SQL_SUCCESS) {
15563 #ifdef SQL_LONGVARCHAR
15564 s->
nrows = (sqltype == SQL_ALL_TYPES) ? 13 : 1;
15566 s->
nrows = (sqltype == SQL_ALL_TYPES) ? 12 : 1;
15568 if (sqltype == SQL_ALL_TYPES) {
15571 #ifdef SQL_WLONGVARCHAR
15576 if (sqltype == SQL_ALL_TYPES) {
15590 #ifdef MEMORY_DEBUG
15595 memset(s->
rows, 0, sizeof (
char *) * (s->
nrows + 1) * asize);
15596 if (sqltype == SQL_ALL_TYPES) {
15599 mktypeinfo(s, cc++, asize,
"varchar", SQL_VARCHAR, 0);
15600 mktypeinfo(s, cc++, asize,
"tinyint", SQL_TINYINT, 0);
15601 mktypeinfo(s, cc++, asize,
"smallint", SQL_SMALLINT, 0);
15602 mktypeinfo(s, cc++, asize,
"integer", SQL_INTEGER, 0);
15603 mktypeinfo(s, cc++, asize,
"float", SQL_FLOAT, 0);
15604 mktypeinfo(s, cc++, asize,
"double", SQL_DOUBLE, 0);
15605 #ifdef SQL_TYPE_DATE
15607 (*s->
ov3) ? SQL_TYPE_DATE : SQL_DATE, 0);
15609 mktypeinfo(s, cc++, asize,
"date", SQL_DATE, 0);
15611 #ifdef SQL_TYPE_TIME
15613 (*s->
ov3) ? SQL_TYPE_TIME : SQL_TIME, 0);
15615 mktypeinfo(s, cc++, asize,
"time", SQL_TIME, 0);
15617 #ifdef SQL_TYPE_TIMESTAMP
15619 (*s->
ov3) ? SQL_TYPE_TIMESTAMP : SQL_TIMESTAMP, 0);
15621 mktypeinfo(s, cc++, asize,
"timestamp", SQL_TIMESTAMP, 0);
15623 mktypeinfo(s, cc++, asize,
"char", SQL_CHAR, 0);
15624 mktypeinfo(s, cc++, asize,
"numeric", SQL_DOUBLE, 0);
15625 #ifdef SQL_LONGVARCHAR
15626 mktypeinfo(s, cc++, asize,
"text", SQL_LONGVARCHAR, 0);
15627 mktypeinfo(s, cc++, asize,
"longvarchar", SQL_LONGVARCHAR, 0);
15629 mktypeinfo(s, cc++, asize,
"text", SQL_VARCHAR, 0);
15631 mktypeinfo(s, cc++, asize,
"varbinary", SQL_VARBINARY, 0);
15632 mktypeinfo(s, cc++, asize,
"longvarbinary", SQL_LONGVARBINARY, 0);
15634 mktypeinfo(s, cc++, asize,
"bit", SQL_BIT, 0);
15637 mktypeinfo(s, cc++, asize,
"bigint", SQL_BIGINT, 0);
15640 mktypeinfo(s, cc++, asize,
"wvarchar", SQL_WVARCHAR, 0);
15641 mktypeinfo(s, cc++, asize,
"wchar", SQL_WCHAR, 0);
15642 #ifdef SQL_WLONGVARCHAR
15643 mktypeinfo(s, cc++, asize,
"wtext", SQL_WLONGVARCHAR, 0);
15644 mktypeinfo(s, cc++, asize,
"longwvarchar", SQL_WLONGVARCHAR, 0);
15647 qsort(s->
rows + asize, s->
nrows, sizeof (
char *) * asize,
15652 mktypeinfo(s, 1, asize,
"char", SQL_CHAR, 10);
15655 mktypeinfo(s, 1, asize,
"varchar", SQL_VARCHAR, 1);
15658 mktypeinfo(s, 1, asize,
"tinyint", SQL_TINYINT, 2);
15661 mktypeinfo(s, 1, asize,
"smallint", SQL_SMALLINT, 3);
15664 mktypeinfo(s, 1, asize,
"integer", SQL_INTEGER, 4);
15667 mktypeinfo(s, 1, asize,
"float", SQL_FLOAT, 5);
15670 mktypeinfo(s, 1, asize,
"double", SQL_DOUBLE, 6);
15672 #ifdef SQL_TYPE_DATE
15673 case SQL_TYPE_DATE:
15674 mktypeinfo(s, 1, asize,
"date", SQL_TYPE_DATE, 25);
15678 mktypeinfo(s, 1, asize,
"date", SQL_DATE, 7);
15680 #ifdef SQL_TYPE_TIME
15681 case SQL_TYPE_TIME:
15682 mktypeinfo(s, 1, asize,
"time", SQL_TYPE_TIME, 26);
15686 mktypeinfo(s, 1, asize,
"time", SQL_TIME, 8);
15688 #ifdef SQL_TYPE_TIMESTAMP
15689 case SQL_TYPE_TIMESTAMP:
15690 mktypeinfo(s, 1, asize,
"timestamp", SQL_TYPE_TIMESTAMP, 27);
15693 case SQL_TIMESTAMP:
15694 mktypeinfo(s, 1, asize,
"timestamp", SQL_TIMESTAMP, 9);
15696 #ifdef SQL_LONGVARCHAR
15697 case SQL_LONGVARCHAR:
15698 mktypeinfo(s, 1, asize,
"longvarchar", SQL_LONGVARCHAR, 12);
15701 case SQL_VARBINARY:
15702 mktypeinfo(s, 1, asize,
"varbinary", SQL_VARBINARY, 30);
15704 case SQL_LONGVARBINARY:
15705 mktypeinfo(s, 1, asize,
"longvarbinary", SQL_LONGVARBINARY, 31);
15709 mktypeinfo(s, 1, asize,
"bit", SQL_BIT, 29);
15714 mktypeinfo(s, 1, asize,
"bigint", SQL_BIGINT, 28);
15720 mktypeinfo(s, 1, asize,
"wchar", SQL_WCHAR, 18);
15723 #ifdef SQL_WVARCHAR
15725 mktypeinfo(s, 1, asize,
"wvarchar", SQL_WVARCHAR, 19);
15728 #ifdef SQL_WLONGVARCHAR
15729 case SQL_WLONGVARCHAR:
15730 mktypeinfo(s, 1, asize,
"longwvarchar", SQL_WLONGVARCHAR, 20);
15738 return SQL_SUCCESS;
15750 SQLGetTypeInfo(SQLHSTMT stmt, SQLSMALLINT sqltype)
15786 {
"SYSTEM",
"STATISTICS",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
15787 {
"SYSTEM",
"STATISTICS",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
15788 {
"SYSTEM",
"STATISTICS",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
15789 {
"SYSTEM",
"STATISTICS",
"NON_UNIQUE", SQL_SMALLINT, 50 },
15790 {
"SYSTEM",
"STATISTICS",
"INDEX_QUALIFIER",
SCOL_VARCHAR, 255 },
15791 {
"SYSTEM",
"STATISTICS",
"INDEX_NAME",
SCOL_VARCHAR, 255 },
15792 {
"SYSTEM",
"STATISTICS",
"TYPE", SQL_SMALLINT, 50 },
15793 {
"SYSTEM",
"STATISTICS",
"SEQ_IN_INDEX", SQL_SMALLINT, 50 },
15794 {
"SYSTEM",
"STATISTICS",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
15795 {
"SYSTEM",
"STATISTICS",
"COLLATION",
SCOL_CHAR, 1 },
15796 {
"SYSTEM",
"STATISTICS",
"CARDINALITY", SQL_INTEGER, 50 },
15797 {
"SYSTEM",
"STATISTICS",
"PAGES", SQL_INTEGER, 50 },
15798 {
"SYSTEM",
"STATISTICS",
"FILTER_CONDITION",
SCOL_VARCHAR, 255 }
15802 {
"SYSTEM",
"STATISTICS",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
15803 {
"SYSTEM",
"STATISTICS",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
15804 {
"SYSTEM",
"STATISTICS",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
15805 {
"SYSTEM",
"STATISTICS",
"NON_UNIQUE", SQL_SMALLINT, 50 },
15806 {
"SYSTEM",
"STATISTICS",
"INDEX_QUALIFIER",
SCOL_VARCHAR, 255 },
15807 {
"SYSTEM",
"STATISTICS",
"INDEX_NAME",
SCOL_VARCHAR, 255 },
15808 {
"SYSTEM",
"STATISTICS",
"TYPE", SQL_SMALLINT, 50 },
15809 {
"SYSTEM",
"STATISTICS",
"ORDINAL_POSITION", SQL_SMALLINT, 50 },
15810 {
"SYSTEM",
"STATISTICS",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
15811 {
"SYSTEM",
"STATISTICS",
"ASC_OR_DESC",
SCOL_CHAR, 1 },
15812 {
"SYSTEM",
"STATISTICS",
"CARDINALITY", SQL_INTEGER, 50 },
15813 {
"SYSTEM",
"STATISTICS",
"PAGES", SQL_INTEGER, 50 },
15814 {
"SYSTEM",
"STATISTICS",
"FILTER_CONDITION",
SCOL_VARCHAR, 255 }
15833 SQLCHAR *schema, SQLSMALLINT schemaLen,
15834 SQLCHAR *table, SQLSMALLINT tableLen,
15835 SQLUSMALLINT itype, SQLUSMALLINT resv)
15840 int i, asize, ret, nrows, ncols, offs, namec, uniquec, addipk = 0;
15842 char **rowp, *errp = NULL, *sql, tname[512];
15846 if (sret != SQL_SUCCESS) {
15851 if (!table || table[0] ==
'\0' || table[0] ==
'%') {
15852 setstat(s, -1,
"need table name", (*s->
ov3) ?
"HY000" :
"S1000");
15855 if (tableLen == SQL_NTS) {
15856 size =
sizeof (tname) - 1;
15858 size =
min(
sizeof (tname) - 1, tableLen);
15860 strncpy(tname, (
char *) table, size);
15861 tname[size] =
'\0';
15864 if (sret != SQL_SUCCESS) {
15870 if (itype == SQL_INDEX_UNIQUE || itype == SQL_INDEX_ALL) {
15872 ret = SQLITE_ERROR;
15873 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", tname);
15876 ret = sqlite3_get_table(d->
sqlite, sql, &rowp,
15877 &nrows, &ncols, NULL);
15880 if (ret == SQLITE_OK) {
15881 int colid, typec, npk = 0;
15883 namec =
findcol(rowp, ncols,
"name");
15884 uniquec =
findcol(rowp, ncols,
"pk");
15885 typec =
findcol(rowp, ncols,
"type");
15886 colid =
findcol(rowp, ncols,
"cid");
15887 if (namec < 0 || uniquec < 0 || typec < 0 || colid < 0) {
15890 for (i = 1; i <= nrows; i++) {
15891 if (*rowp[i * ncols + uniquec] !=
'0' &&
15892 strlen(rowp[i * ncols + typec]) == 7 &&
15893 strncasecmp(rowp[i * ncols + typec],
"integer", 7)
15903 sqlite3_free_table(rowp);
15905 sql = sqlite3_mprintf(
"PRAGMA index_list(%Q)", tname);
15910 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
15912 if (ret != SQLITE_OK) {
15913 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
15914 errp ? errp :
"unknown error", ret);
15916 sqlite3_free(errp);
15922 sqlite3_free(errp);
15926 namec =
findcol(rowp, ncols,
"name");
15927 uniquec =
findcol(rowp, ncols,
"unique");
15928 if (namec < 0 || uniquec < 0) {
15931 for (i = 1; i <= nrows; i++) {
15932 int nnrows, nncols;
15936 isuniq = *rowp[i * ncols + uniquec] !=
'0';
15937 if (isuniq || itype == SQL_INDEX_ALL) {
15938 ret = SQLITE_ERROR;
15939 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
15940 rowp[i * ncols + namec]);
15943 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
15944 &nnrows, &nncols, NULL);
15947 if (ret == SQLITE_OK) {
15949 sqlite3_free_table(rowpp);
15958 sqlite3_free_table(rowp);
15959 return SQL_SUCCESS;
15962 size = (size + 1) * asize;
15968 s->
rows[0] = (
char *) size;
15970 memset(s->
rows, 0, sizeof (
char *) * size);
15975 int nrows2, ncols2;
15977 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", tname);
15980 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
15981 &nrows2, &ncols2, NULL);
15984 if (ret == SQLITE_OK) {
15985 int colid, typec, roffs, namecc, uniquecc;
15987 namecc =
findcol(rowpp, ncols2,
"name");
15988 uniquecc =
findcol(rowpp, ncols2,
"pk");
15989 typec =
findcol(rowpp, ncols2,
"type");
15990 colid =
findcol(rowpp, ncols2,
"cid");
15991 if (namecc < 0 || uniquecc < 0 || typec < 0 || colid < 0) {
15996 for (i = 1; i <= nrows2; i++) {
15997 if (*rowpp[i * ncols2 + uniquecc] !=
'0' &&
15998 strlen(rowpp[i * ncols2 + typec]) == 7 &&
15999 strncasecmp(rowpp[i * ncols2 + typec],
"integer", 7)
16010 #if defined(_WIN32) || defined(_WIN64)
16011 s->
rows[roffs + 0] =
xstrdup(d->xcelqrx ?
"main" :
"");
16019 s->
rows[roffs + 5] =
xstrdup(
"sqlite_autoindex_0");
16022 s->
rows[roffs + 8] =
xstrdup(rowpp[i * ncols2 + namecc]);
16026 sqlite3_free_table(rowpp);
16028 for (i = 1; i <= nrows; i++) {
16029 int nnrows, nncols;
16032 if (*rowp[i * ncols + uniquec] !=
'0' || itype == SQL_INDEX_ALL) {
16035 ret = SQLITE_ERROR;
16036 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
16037 rowp[i * ncols + namec]);
16040 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
16041 &nnrows, &nncols, NULL);
16044 if (ret != SQLITE_OK) {
16047 for (k = 0; nnrows && k < nncols; k++) {
16048 if (strcmp(rowpp[k],
"name") == 0) {
16051 for (m = 1; m <= nnrows; m++) {
16052 int roffs = (offs + addipk + m) * s->
ncols;
16055 isuniq = *rowp[i * ncols + uniquec] !=
'0';
16064 s->
rows[roffs + 5] =
xstrdup(rowp[i * ncols + namec]);
16065 s->
rows[roffs + 6] =
16067 s->
rows[roffs + 8] =
xstrdup(rowpp[m * nncols + k]);
16070 }
else if (strcmp(rowpp[k],
"seqno") == 0) {
16073 for (m = 1; m <= nnrows; m++) {
16074 int roffs = (offs + addipk + m) * s->
ncols;
16078 sscanf(rowpp[m * nncols + k],
"%d", &pos);
16079 sprintf(buf,
"%d", pos + 1);
16085 sqlite3_free_table(rowpp);
16088 sqlite3_free_table(rowp);
16089 return SQL_SUCCESS;
16108 SQLStatistics(SQLHSTMT stmt, SQLCHAR *cat, SQLSMALLINT catLen,
16109 SQLCHAR *schema, SQLSMALLINT schemaLen,
16110 SQLCHAR *table, SQLSMALLINT tableLen,
16111 SQLUSMALLINT itype, SQLUSMALLINT resv)
16113 #if defined(_WIN32) || defined(_WIN64)
16114 char *c = NULL, *s = NULL, *t = NULL;
16119 #if defined(_WIN32) || defined(_WIN64)
16120 if (!((
STMT *) stmt)->oemcp[0]) {
16122 table, tableLen, itype, resv);
16126 c = wmb_to_utf_c((
char *) cat, catLen);
16133 s = wmb_to_utf_c((
char *) schema, schemaLen);
16140 t = wmb_to_utf_c((
char *) table, tableLen);
16146 ret =
drvstatistics(stmt, (SQLCHAR *) c, SQL_NTS, (SQLCHAR *) s, SQL_NTS,
16147 (SQLCHAR *) t, SQL_NTS, itype, resv);
16150 table, tableLen, itype, resv);
16152 #if defined(_WIN32) || defined(_WIN64)
16182 SQLWCHAR *schema, SQLSMALLINT schemaLen,
16183 SQLWCHAR *table, SQLSMALLINT tableLen,
16184 SQLUSMALLINT itype, SQLUSMALLINT resv)
16186 char *c = NULL, *s = NULL, *t = NULL;
16211 ret =
drvstatistics(stmt, (SQLCHAR *) c, SQL_NTS, (SQLCHAR *) s, SQL_NTS,
16212 (SQLCHAR *) t, SQL_NTS, itype, resv);
16238 SQLRETURN ret = SQL_ERROR;
16241 if (stmt == SQL_NULL_HSTMT) {
16242 return SQL_INVALID_HANDLE;
16245 if (col == 0 && s->
bkmrk != SQL_UB_OFF) {
16246 if (s->
bkmrk == SQL_UB_ON && type == SQL_C_BOOKMARK) {
16247 *((SQLINTEGER *) val) = s->
rowp;
16249 *lenp =
sizeof (SQLINTEGER);
16253 }
else if (s->
bkmrk == SQL_UB_VARIABLE && type == SQL_C_VARBOOKMARK) {
16255 char **data, *endp = 0;
16260 *((sqlite_int64 *) val) = strtol(*data, &endp, 0);
16262 *((sqlite_int64 *) val) = strtoll(*data, &endp, 0);
16265 *((sqlite_int64 *) val) = s->
rowp;
16268 *lenp =
sizeof (sqlite_int64);
16274 if (col < 1 || col > s->
ncols) {
16275 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009" :
"S1002");
16279 ret =
getrowdata(s, col, type, val, len, lenp, 1);
16295 int ret, i, withinfo = 0;
16299 int bsize =
sizeof (SQLINTEGER);
16304 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
16312 val = (SQLPOINTER) ((
char *) val + *s->
bind_offs);
16315 char **data, *endp = 0;
16320 *(sqlite_int64 *) val = strtol(*data, &endp, 0);
16322 *(sqlite_int64 *) val = strtoll(*data, &endp, 0);
16325 *(sqlite_int64 *) val = s->
rowp;
16327 bsize =
sizeof (sqlite_int64);
16331 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
16332 val = (SQLINTEGER *)
16338 val = (SQLINTEGER *) ((
char *) val + *s->
bind_offs);
16345 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
16365 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
16368 dp = (SQLPOINTER) ((
char *) b->
valp + b->
max * rsi);
16371 dp = (SQLPOINTER) ((
char *) dp + *s->
bind_offs);
16375 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
16378 lp = b->
lenp + rsi;
16386 if (!SQL_SUCCEEDED(ret)) {
16390 if (ret != SQL_SUCCESS) {
16392 #ifdef SQL_ROW_SUCCESS_WITH_INFO
16398 if (SQL_SUCCEEDED(ret)) {
16399 ret = withinfo ? SQL_SUCCESS_WITH_INFO : SQL_SUCCESS;
16416 int i, withinfo = 0;
16419 if (stmt == SQL_NULL_HSTMT) {
16420 return SQL_INVALID_HANDLE;
16443 setstat(s, -1,
"no result set available",
"24000");
16448 if (s->
curtype == SQL_CURSOR_FORWARD_ONLY && orient != SQL_FETCH_NEXT) {
16449 setstat(s, -1,
"wrong fetch direction",
"01000");
16456 if (((
DBC *) (s->
dbc))->cur_s3stmt == s && s->
s3stmt) {
16460 ret = (i == 0) ? SQL_NO_DATA : SQL_SUCCESS;
16464 if (ret != SQL_SUCCESS) {
16468 if (s->
nrows < 1) {
16472 if (!SQL_SUCCEEDED(ret)) {
16474 }
else if (ret == SQL_SUCCESS_WITH_INFO) {
16478 }
else if (s->
rows) {
16480 case SQL_FETCH_NEXT:
16481 if (s->
nrows < 1) {
16482 return SQL_NO_DATA;
16489 return SQL_NO_DATA;
16492 case SQL_FETCH_PRIOR:
16495 return SQL_NO_DATA;
16498 if (s->
rowp < -1) {
16500 return SQL_NO_DATA;
16503 case SQL_FETCH_FIRST:
16504 if (s->
nrows < 1) {
16505 return SQL_NO_DATA;
16509 case SQL_FETCH_LAST:
16510 if (s->
nrows < 1) {
16511 return SQL_NO_DATA;
16514 if (--s->
rowp < -1) {
16518 case SQL_FETCH_ABSOLUTE:
16521 return SQL_NO_DATA;
16522 }
else if (offset < 0) {
16523 if (0 - offset <= s->nrows) {
16528 return SQL_NO_DATA;
16529 }
else if (offset > s->
nrows) {
16531 return SQL_NO_DATA;
16533 s->
rowp = offset - 1 - 1;
16535 case SQL_FETCH_RELATIVE:
16540 return SQL_NO_DATA;
16544 if (s->
rowp < -1) {
16546 return SQL_NO_DATA;
16550 case SQL_FETCH_BOOKMARK:
16552 if (offset < 0 || offset >= s->
nrows) {
16553 return SQL_NO_DATA;
16555 s->
rowp = offset - 1;
16561 if (s->
bkmrk == SQL_UB_VARIABLE) {
16563 sqlite_int64 bkmrk, rowid;
16565 bkmrk = *(sqlite_int64 *) s->
bkmrkptr;
16566 for (rowp = 0; rowp < s->
nrows; rowp++) {
16567 char **data, *endp = 0;
16572 rowid = strtol(*data, &endp, 0);
16574 rowid = strtoll(*data, &endp, 0);
16576 if (rowid == bkmrk) {
16581 rowp = *(sqlite_int64 *) s->
bkmrkptr;
16586 if (rowp + offset < 0 || rowp + offset >= s->
nrows) {
16587 return SQL_NO_DATA;
16589 s->
rowp = rowp + offset - 1;
16605 if (!SQL_SUCCEEDED(ret)) {
16607 }
else if (ret == SQL_SUCCESS_WITH_INFO) {
16614 if (SQL_SUCCEEDED(ret)) {
16615 return SQL_NO_DATA;
16619 if (SQL_SUCCEEDED(ret)) {
16620 ret = withinfo ? SQL_SUCCESS_WITH_INFO : SQL_SUCCESS;
16687 SQLINTEGER *bkmrkptr;
16690 if (stmt == SQL_NULL_HSTMT) {
16691 return SQL_INVALID_HANDLE;
16726 if (stmt == SQL_NULL_HSTMT) {
16727 return SQL_INVALID_HANDLE;
16734 return SQL_SUCCESS;
16750 if (stmt == SQL_NULL_HSTMT) {
16751 return SQL_INVALID_HANDLE;
16758 return SQL_SUCCESS;
16777 SQLSMALLINT nameMax, SQLSMALLINT *nameLen,
16778 SQLSMALLINT *type,
SQLULEN *size,
16779 SQLSMALLINT *digits, SQLSMALLINT *nullable)
16785 if (stmt == SQL_NULL_HSTMT) {
16786 return SQL_INVALID_HANDLE;
16790 setstat(s, -1,
"no columns", (*s->
ov3) ?
"07009" :
"S1002");
16793 if (col < 1 || col > s->
ncols) {
16794 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009" :
"S1002");
16797 c = s->
cols + col - 1;
16798 if (name && nameMax > 0) {
16799 strncpy((
char *) name, c->
column, nameMax);
16800 name[nameMax - 1] =
'\0';
16805 *nameLen = strlen((
char *) name);
16807 *nameLen = strlen(c->
column);
16819 *type = SQL_VARCHAR;
16821 #ifdef SQL_LONGVARCHAR
16822 case SQL_WLONGVARCHAR:
16823 *type = SQL_LONGVARCHAR;
16839 return SQL_SUCCESS;
16858 SQLDescribeCol(SQLHSTMT stmt, SQLUSMALLINT col, SQLCHAR *name,
16859 SQLSMALLINT nameMax, SQLSMALLINT *nameLen,
16860 SQLSMALLINT *type,
SQLULEN *size,
16861 SQLSMALLINT *digits, SQLSMALLINT *nullable)
16863 #if defined(_WIN32) || defined(_WIN64)
16864 SQLSMALLINT len = 0;
16869 #if defined(_WIN32) || defined(_WIN64)
16870 if (!((
STMT *) stmt)->oemcp[0]) {
16872 type, size, digits, nullable);
16876 &len, type, size, digits, nullable);
16877 if (ret == SQL_SUCCESS) {
16882 n = (SQLCHAR *) utf_to_wmb((
char *) name, len);
16884 strncpy((
char *) name, (
char *) n, nameMax);
16886 len =
min(nameMax, strlen((
char *) n));
16904 len = strlen(c->
column);
16915 type, size, digits, nullable);
16939 SQLSMALLINT nameMax, SQLSMALLINT *nameLen,
16940 SQLSMALLINT *type,
SQLULEN *size,
16941 SQLSMALLINT *digits, SQLSMALLINT *nullable)
16944 SQLSMALLINT len = 0;
16948 (SQLSMALLINT) (nameMax *
sizeof (SQLWCHAR)),
16949 &len, type, size, digits, nullable);
16950 if (ret == SQL_SUCCESS) {
16953 SQLWCHAR *n = NULL;
16977 len = strlen(c->
column);
17003 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17009 char *valc = (
char *) val;
17011 if (stmt == SQL_NULL_HSTMT) {
17012 return SQL_INVALID_HANDLE;
17021 if (
id == SQL_COLUMN_COUNT) {
17025 *valLen =
sizeof (int);
17026 return SQL_SUCCESS;
17028 if (
id == SQL_COLUMN_TYPE && col == 0) {
17030 *val2 = SQL_INTEGER;
17032 *valLen =
sizeof (int);
17033 return SQL_SUCCESS;
17035 #ifdef SQL_DESC_OCTET_LENGTH
17036 if (
id == SQL_DESC_OCTET_LENGTH && col == 0) {
17040 *valLen =
sizeof (int);
17041 return SQL_SUCCESS;
17044 if (col < 1 || col > s->
ncols) {
17045 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009":
"S1002");
17048 c = s->
cols + col - 1;
17051 case SQL_COLUMN_LABEL:
17053 if (valc && valMax > 0) {
17054 strncpy(valc, c->
label, valMax);
17055 valc[valMax - 1] =
'\0';
17057 *valLen = strlen(c->
label);
17061 case SQL_COLUMN_NAME:
17062 case SQL_DESC_NAME:
17063 if (valc && valMax > 0) {
17064 strncpy(valc, c->
column, valMax);
17065 valc[valMax - 1] =
'\0';
17067 *valLen = strlen(c->
column);
17069 if (*valLen >= valMax) {
17070 setstat(s, -1,
"data right truncated",
"01004");
17071 return SQL_SUCCESS_WITH_INFO;
17073 return SQL_SUCCESS;
17074 #ifdef SQL_DESC_BASE_COLUMN_NAME
17075 case SQL_DESC_BASE_COLUMN_NAME:
17076 if (strchr(c->
column,
'(') || strchr(c->
column,
')')) {
17077 if (valc && valMax > 0) {
17081 }
else if (valc && valMax > 0) {
17082 strncpy(valc, c->
column, valMax);
17083 valc[valMax - 1] =
'\0';
17084 *valLen = strlen(c->
column);
17088 case SQL_COLUMN_TYPE:
17089 case SQL_DESC_TYPE:
17092 int type = c->
type;
17100 type = SQL_VARCHAR;
17102 #ifdef SQL_LONGVARCHAR
17103 case SQL_WLONGVARCHAR:
17104 type = SQL_LONGVARCHAR;
17118 *valLen =
sizeof (int);
17119 return SQL_SUCCESS;
17120 case SQL_COLUMN_DISPLAY_SIZE:
17124 *valLen =
sizeof (int);
17125 return SQL_SUCCESS;
17126 case SQL_COLUMN_UNSIGNED:
17128 *val2 = c->
nosign ? SQL_TRUE : SQL_FALSE;
17130 *valLen =
sizeof (int);
17131 return SQL_SUCCESS;
17132 case SQL_COLUMN_SCALE:
17133 case SQL_DESC_SCALE:
17137 *valLen =
sizeof (int);
17138 return SQL_SUCCESS;
17139 case SQL_COLUMN_PRECISION:
17140 case SQL_DESC_PRECISION:
17160 #ifdef SQL_TYPE_TIMESTAMP
17161 case SQL_TYPE_TIMESTAMP:
17163 case SQL_TIMESTAMP:
17171 *valLen =
sizeof (int);
17172 return SQL_SUCCESS;
17173 case SQL_COLUMN_MONEY:
17177 *valLen =
sizeof (int);
17178 return SQL_SUCCESS;
17179 case SQL_COLUMN_AUTO_INCREMENT:
17183 *valLen =
sizeof (int);
17184 return SQL_SUCCESS;
17185 case SQL_COLUMN_LENGTH:
17186 case SQL_DESC_LENGTH:
17190 *valLen =
sizeof (int);
17191 return SQL_SUCCESS;
17192 case SQL_COLUMN_NULLABLE:
17193 case SQL_DESC_NULLABLE:
17197 *valLen =
sizeof (int);
17198 return SQL_SUCCESS;
17199 case SQL_COLUMN_SEARCHABLE:
17201 *val2 = SQL_SEARCHABLE;
17203 *valLen =
sizeof (int);
17204 return SQL_SUCCESS;
17205 case SQL_COLUMN_CASE_SENSITIVE:
17209 *valLen =
sizeof (int);
17210 return SQL_SUCCESS;
17211 case SQL_COLUMN_UPDATABLE:
17215 *valLen =
sizeof (int);
17216 return SQL_SUCCESS;
17217 case SQL_DESC_COUNT:
17221 *valLen =
sizeof (int);
17222 return SQL_SUCCESS;
17223 case SQL_COLUMN_TYPE_NAME: {
17227 if (c->
type == SQL_WCHAR ||
17228 c->
type == SQL_WVARCHAR ||
17229 c->
type == SQL_WLONGVARCHAR) {
17231 if (strcasecmp(tn,
"varchar") == 0) {
17237 if (valc && valMax > 0) {
17238 strncpy(valc, tn, valMax);
17239 valc[valMax - 1] =
'\0';
17240 p = strchr(valc,
'(');
17243 while (p > valc &&
ISSPACE(p[-1])) {
17248 *valLen = strlen(valc);
17250 *valLen = strlen(tn);
17251 p = strchr(tn,
'(');
17254 while (p > tn &&
ISSPACE(p[-1])) {
17262 case SQL_COLUMN_OWNER_NAME:
17263 case SQL_COLUMN_QUALIFIER_NAME: {
17266 if (valc && valMax > 0) {
17267 strncpy(valc, z, valMax);
17268 valc[valMax - 1] =
'\0';
17270 *valLen = strlen(z);
17273 case SQL_COLUMN_TABLE_NAME:
17274 #if (SQL_COLUMN_TABLE_NAME != SQL_DESC_TABLE_NAME)
17275 case SQL_DESC_TABLE_NAME:
17277 #ifdef SQL_DESC_BASE_TABLE_NAME
17278 case SQL_DESC_BASE_TABLE_NAME:
17280 if (valc && valMax > 0) {
17281 strncpy(valc, c->
table, valMax);
17282 valc[valMax - 1] =
'\0';
17284 *valLen = strlen(c->
table);
17286 #ifdef SQL_DESC_NUM_PREC_RADIX
17287 case SQL_DESC_NUM_PREC_RADIX:
17293 #ifdef SQL_LONGVARCHAR
17294 case SQL_WLONGVARCHAR:
17299 #ifdef SQL_LONGVARCHAR
17300 case SQL_LONGVARCHAR:
17303 case SQL_VARBINARY:
17304 case SQL_LONGVARBINARY:
17311 *valLen =
sizeof (int);
17312 return SQL_SUCCESS;
17315 setstat(s, -1,
"unsupported column attributes %d",
"HY091",
id);
17333 SQLColAttributes(SQLHSTMT stmt, SQLUSMALLINT col, SQLUSMALLINT
id,
17334 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17337 #if defined(_WIN32) || defined(_WIN64)
17338 SQLSMALLINT len = 0;
17343 #if defined(_WIN32) || defined(_WIN64)
17344 if (!((
STMT *) stmt)->oemcp[0]) {
17349 if (SQL_SUCCEEDED(ret)) {
17353 case SQL_COLUMN_LABEL:
17354 case SQL_COLUMN_NAME:
17355 case SQL_DESC_NAME:
17356 case SQL_COLUMN_TYPE_NAME:
17357 case SQL_COLUMN_OWNER_NAME:
17358 case SQL_COLUMN_QUALIFIER_NAME:
17359 case SQL_COLUMN_TABLE_NAME:
17360 #if (SQL_COLUMN_TABLE_NAME != SQL_DESC_TABLE_NAME)
17361 case SQL_DESC_TABLE_NAME:
17363 #ifdef SQL_DESC_BASE_COLUMN_NAME
17364 case SQL_DESC_BASE_COLUMN_NAME:
17366 #ifdef SQL_DESC_BASE_TABLE_NAME
17367 case SQL_DESC_BASE_TABLE_NAME:
17369 if (val && valMax > 0) {
17372 v = utf_to_wmb((
char *) val, SQL_NTS);
17374 strncpy(val, v, vmax);
17375 len =
min(vmax, strlen(v));
17380 v[vmax - 1] =
'\0';
17416 SQLColAttributesW(SQLHSTMT stmt, SQLUSMALLINT col, SQLUSMALLINT
id,
17417 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17421 SQLSMALLINT len = 0;
17425 if (SQL_SUCCEEDED(ret)) {
17426 SQLWCHAR *v = NULL;
17429 case SQL_COLUMN_LABEL:
17430 case SQL_COLUMN_NAME:
17431 case SQL_DESC_NAME:
17432 case SQL_COLUMN_TYPE_NAME:
17433 case SQL_COLUMN_OWNER_NAME:
17434 case SQL_COLUMN_QUALIFIER_NAME:
17435 case SQL_COLUMN_TABLE_NAME:
17436 #if (SQL_COLUMN_TABLE_NAME != SQL_DESC_TABLE_NAME)
17437 case SQL_DESC_TABLE_NAME:
17439 #ifdef SQL_DESC_BASE_COLUMN_NAME
17440 case SQL_DESC_BASE_COLUMN_NAME:
17442 #ifdef SQL_DESC_BASE_TABLE_NAME
17443 case SQL_DESC_BASE_TABLE_NAME:
17445 if (val && valMax > 0) {
17446 int vmax = valMax /
sizeof (SQLWCHAR);
17453 len *=
sizeof (SQLWCHAR);
17456 v = (SQLWCHAR *) val;
17457 v[vmax - 1] =
'\0';
17487 drvcolattribute(SQLHSTMT stmt, SQLUSMALLINT col, SQLUSMALLINT
id,
17488 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17494 char *valc = (
char *) val;
17497 if (stmt == SQL_NULL_HSTMT) {
17498 return SQL_INVALID_HANDLE;
17504 if (col < 1 || col > s->
ncols) {
17505 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009" :
"S1002");
17511 c = s->
cols + col - 1;
17513 case SQL_DESC_COUNT:
17516 case SQL_DESC_CATALOG_NAME:
17517 if (valc && valMax > 0) {
17518 strncpy(valc, c->
db, valMax);
17519 valc[valMax - 1] =
'\0';
17521 *valLen = strlen(c->
db);
17523 if (*valLen >= valMax) {
17524 setstat(s, -1,
"data right truncated",
"01004");
17525 return SQL_SUCCESS_WITH_INFO;
17528 case SQL_COLUMN_LENGTH:
17529 case SQL_DESC_LENGTH:
17532 case SQL_COLUMN_LABEL:
17534 if (valc && valMax > 0) {
17535 strncpy(valc, c->
label, valMax);
17536 valc[valMax - 1] =
'\0';
17538 *valLen = strlen(c->
label);
17542 case SQL_COLUMN_NAME:
17543 case SQL_DESC_NAME:
17544 if (valc && valMax > 0) {
17545 strncpy(valc, c->
column, valMax);
17546 valc[valMax - 1] =
'\0';
17548 *valLen = strlen(c->
column);
17550 case SQL_DESC_SCHEMA_NAME: {
17553 if (valc && valMax > 0) {
17554 strncpy(valc, z, valMax);
17555 valc[valMax - 1] =
'\0';
17557 *valLen = strlen(z);
17560 #ifdef SQL_DESC_BASE_COLUMN_NAME
17561 case SQL_DESC_BASE_COLUMN_NAME:
17562 if (strchr(c->
column,
'(') || strchr(c->
column,
')')) {
17565 }
else if (valc && valMax > 0) {
17566 strncpy(valc, c->
column, valMax);
17567 valc[valMax - 1] =
'\0';
17568 *valLen = strlen(c->
column);
17572 case SQL_DESC_TYPE_NAME: {
17576 if (c->
type == SQL_WCHAR ||
17577 c->
type == SQL_WVARCHAR ||
17578 c->
type == SQL_WLONGVARCHAR) {
17580 if (strcasecmp(tn,
"varchar") == 0) {
17586 if (valc && valMax > 0) {
17587 strncpy(valc, tn, valMax);
17588 valc[valMax - 1] =
'\0';
17589 p = strchr(valc,
'(');
17592 while (p > valc &&
ISSPACE(p[-1])) {
17597 *valLen = strlen(valc);
17599 *valLen = strlen(tn);
17600 p = strchr(tn,
'(');
17603 while (p > tn &&
ISSPACE(p[-1])) {
17611 case SQL_DESC_OCTET_LENGTH:
17614 if (c->
type == SQL_WCHAR ||
17615 c->
type == SQL_WVARCHAR ||
17616 c->
type == SQL_WLONGVARCHAR) {
17618 v *=
sizeof (SQLWCHAR);
17623 #if (SQL_COLUMN_TABLE_NAME != SQL_DESC_TABLE_NAME)
17624 case SQL_COLUMN_TABLE_NAME:
17626 #ifdef SQL_DESC_BASE_TABLE_NAME
17627 case SQL_DESC_BASE_TABLE_NAME:
17629 case SQL_DESC_TABLE_NAME:
17630 if (valc && valMax > 0) {
17631 strncpy(valc, c->
table, valMax);
17632 valc[valMax - 1] =
'\0';
17634 *valLen = strlen(c->
table);
17636 case SQL_DESC_TYPE:
17647 #ifdef SQL_LONGVARCHAR
17648 case SQL_WLONGVARCHAR:
17649 v = SQL_LONGVARCHAR;
17656 case SQL_DESC_CONCISE_TYPE:
17673 case SQL_TIMESTAMP:
17674 v = SQL_C_TIMESTAMP;
17682 #ifdef SQL_C_TYPE_TIMESTAMP
17683 case SQL_TYPE_TIMESTAMP:
17684 v = SQL_C_TYPE_TIMESTAMP;
17687 #ifdef SQL_C_TYPE_TIME
17688 case SQL_TYPE_TIME:
17689 v = SQL_C_TYPE_TIME;
17692 #ifdef SQL_C_TYPE_DATE
17693 case SQL_TYPE_DATE:
17694 v = SQL_C_TYPE_DATE;
17709 v = (s->
nowchar[0] || s->
nowchar[1]) ? SQL_C_CHAR : SQL_C_WCHAR;
17716 case SQL_DESC_UPDATABLE:
17719 case SQL_COLUMN_DISPLAY_SIZE:
17722 case SQL_COLUMN_UNSIGNED:
17723 v = c->
nosign ? SQL_TRUE : SQL_FALSE;
17725 case SQL_COLUMN_SEARCHABLE:
17726 v = SQL_SEARCHABLE;
17728 case SQL_COLUMN_SCALE:
17729 case SQL_DESC_SCALE:
17732 case SQL_COLUMN_PRECISION:
17733 case SQL_DESC_PRECISION:
17752 #ifdef SQL_TYPE_TIMESTAMP
17753 case SQL_TYPE_TIMESTAMP:
17755 case SQL_TIMESTAMP:
17763 case SQL_COLUMN_MONEY:
17766 case SQL_COLUMN_AUTO_INCREMENT:
17769 case SQL_DESC_NULLABLE:
17772 #ifdef SQL_DESC_NUM_PREC_RADIX
17773 case SQL_DESC_NUM_PREC_RADIX:
17778 #ifdef SQL_LONGVARCHAR
17779 case SQL_WLONGVARCHAR:
17784 #ifdef SQL_LONGVARCHAR
17785 case SQL_LONGVARCHAR:
17788 case SQL_VARBINARY:
17789 case SQL_LONGVARBINARY:
17798 setstat(s, -1,
"unsupported column attribute %d",
"HY091",
id);
17804 return SQL_SUCCESS;
17821 SQLColAttribute(SQLHSTMT stmt, SQLUSMALLINT col, SQLUSMALLINT
id,
17822 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17825 #if defined(_WIN32) || defined(_WIN64)
17826 SQLSMALLINT len = 0;
17831 #if defined(_WIN32) || defined(_WIN64)
17832 if (!((
STMT *) stmt)->oemcp[0]) {
17833 ret = drvcolattribute(stmt, col,
id, val, valMax, valLen,
17834 (SQLPOINTER) val2);
17837 ret = drvcolattribute(stmt, col,
id, val, valMax, &len,
17838 (SQLPOINTER) val2);
17839 if (SQL_SUCCEEDED(ret)) {
17843 case SQL_DESC_SCHEMA_NAME:
17844 case SQL_DESC_CATALOG_NAME:
17845 case SQL_COLUMN_LABEL:
17846 case SQL_DESC_NAME:
17847 case SQL_DESC_TABLE_NAME:
17848 #ifdef SQL_DESC_BASE_TABLE_NAME
17849 case SQL_DESC_BASE_TABLE_NAME:
17851 #ifdef SQL_DESC_BASE_COLUMN_NAME
17852 case SQL_DESC_BASE_COLUMN_NAME:
17854 case SQL_DESC_TYPE_NAME:
17855 if (val && valMax > 0) {
17858 v = utf_to_wmb((
char *) val, SQL_NTS);
17860 strncpy(val, v, vmax);
17861 len =
min(vmax, strlen(v));
17866 v[vmax - 1] =
'\0';
17881 ret = drvcolattribute(stmt, col,
id, val, valMax, valLen,
17882 (SQLPOINTER) val2);
17903 SQLColAttributeW(SQLHSTMT stmt, SQLUSMALLINT col, SQLUSMALLINT
id,
17904 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17908 SQLSMALLINT len = 0;
17911 ret = drvcolattribute(stmt, col,
id, val, valMax, &len,
17912 (SQLPOINTER) val2);
17913 if (SQL_SUCCEEDED(ret)) {
17914 SQLWCHAR *v = NULL;
17917 case SQL_DESC_SCHEMA_NAME:
17918 case SQL_DESC_CATALOG_NAME:
17919 case SQL_COLUMN_LABEL:
17920 case SQL_DESC_NAME:
17921 case SQL_DESC_TABLE_NAME:
17922 #ifdef SQL_DESC_BASE_TABLE_NAME
17923 case SQL_DESC_BASE_TABLE_NAME:
17925 #ifdef SQL_DESC_BASE_COLUMN_NAME
17926 case SQL_DESC_BASE_COLUMN_NAME:
17928 case SQL_DESC_TYPE_NAME:
17929 if (val && valMax > 0) {
17930 int vmax = valMax /
sizeof (SQLWCHAR);
17937 len *=
sizeof (SQLWCHAR);
17940 v = (SQLWCHAR *) val;
17941 v[vmax - 1] =
'\0';
17972 drverror(SQLHENV env, SQLHDBC dbc, SQLHSTMT stmt,
17973 SQLCHAR *sqlState, SQLINTEGER *nativeErr,
17974 SQLCHAR *errmsg, SQLSMALLINT errmax, SQLSMALLINT *errlen)
17978 SQLSMALLINT dummy2;
17980 if (env == SQL_NULL_HENV &&
17981 dbc == SQL_NULL_HDBC &&
17982 stmt == SQL_NULL_HSTMT) {
17983 return SQL_INVALID_HANDLE;
17986 sqlState[0] =
'\0';
17991 nativeErr = &dummy1;
18010 if (s->
logmsg[0] ==
'\0') {
18015 strcpy((
char *) sqlState, s->
sqlstate);
18016 if (errmax == SQL_NTS) {
18017 strcpy((
char *) errmsg,
"[SQLite]");
18018 strcat((
char *) errmsg, (
char *) s->
logmsg);
18019 *errlen = strlen((
char *) errmsg);
18021 strncpy((
char *) errmsg,
"[SQLite]", errmax);
18022 if (errmax - 8 > 0) {
18023 strncpy((
char *) errmsg + 8, (
char *) s->
logmsg, errmax - 8);
18025 *errlen =
min(strlen((
char *) s->
logmsg) + 8, errmax);
18029 return SQL_SUCCESS;
18040 strcpy((
char *) sqlState, d->
sqlstate);
18041 if (errmax == SQL_NTS) {
18042 strcpy((
char *) errmsg,
"[SQLite]");
18043 strcat((
char *) errmsg, (
char *) d->
logmsg);
18044 *errlen = strlen((
char *) errmsg);
18046 strncpy((
char *) errmsg,
"[SQLite]", errmax);
18047 if (errmax - 8 > 0) {
18048 strncpy((
char *) errmsg + 8, (
char *) d->
logmsg, errmax - 8);
18050 *errlen =
min(strlen((
char *) d->
logmsg) + 8, errmax);
18054 return SQL_SUCCESS;
18057 sqlState[0] =
'\0';
18061 return SQL_NO_DATA;
18079 SQLError(SQLHENV env, SQLHDBC dbc, SQLHSTMT stmt,
18080 SQLCHAR *sqlState, SQLINTEGER *nativeErr,
18081 SQLCHAR *errmsg, SQLSMALLINT errmax, SQLSMALLINT *errlen)
18083 return drverror(env, dbc, stmt, sqlState, nativeErr,
18084 errmsg, errmax, errlen);
18103 SQLErrorW(SQLHENV env, SQLHDBC dbc, SQLHSTMT stmt,
18104 SQLWCHAR *sqlState, SQLINTEGER *nativeErr,
18105 SQLWCHAR *errmsg, SQLSMALLINT errmax, SQLSMALLINT *errlen)
18108 SQLSMALLINT len = 0;
18111 ret = drverror(env, dbc, stmt, (SQLCHAR *) state, nativeErr,
18112 (SQLCHAR *) errmsg, errmax, &len);
18113 if (ret == SQL_SUCCESS) {
18116 6 *
sizeof (SQLWCHAR));
18120 SQLWCHAR *e = NULL;
18148 }
else if (ret == SQL_NO_DATA) {
18172 SQLMoreResults(SQLHSTMT stmt)
18175 if (stmt == SQL_NULL_HSTMT) {
18176 return SQL_INVALID_HANDLE;
18179 return SQL_NO_DATA;
18193 int ncols = *ncolsp, guessed_types = 0;
18194 SQLRETURN ret = SQL_SUCCESS;
18202 const char *colname, *
typename;
18203 #
if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME)
18207 for (i = size = 0; i < ncols; i++) {
18208 colname = sqlite3_column_name(s3stmt, i);
18209 size += 3 + 3 * strlen(colname);
18211 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME)
18212 tblname = (
char *) size;
18213 for (i = 0; i < ncols; i++) {
18214 p = (
char *) sqlite3_column_table_name(s3stmt, i);
18215 size += 2 + (p ? strlen(p) : 0);
18218 dyncols =
xmalloc(ncols *
sizeof (
COL) + size);
18224 p = (
char *) (dyncols + ncols);
18225 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME)
18228 for (i = 0; i < ncols; i++) {
18231 colname = sqlite3_column_name(s3stmt, i);
18233 fprintf(d->
trace,
"-- column %d name: '%s'\n",
18237 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME)
18238 q = (
char *) sqlite3_column_table_name(s3stmt, i);
18239 strcpy(tblname, q ? q :
"");
18241 fprintf(d->
trace,
"-- table %d name: '%s'\n",
18245 dyncols[i].
table = tblname;
18246 tblname += strlen(tblname) + 1;
18249 dyncols[i].
db = ((
DBC *) (s->
dbc))->dbname;
18250 strcpy(p, colname);
18251 dyncols[i].
label = p;
18252 p += strlen(p) + 1;
18253 q = strchr(colname,
'.');
18255 char *q2 = strchr(q + 1,
'.');
18263 #if !defined(HAVE_SQLITE3COLUMNTABLENAME) || !(HAVE_SQLITE3COLUMNTABLENAME)
18264 dyncols[i].
table = p;
18266 strncpy(p, colname, q - colname);
18267 p[q - colname] =
'\0';
18268 p += strlen(p) + 1;
18271 p += strlen(p) + 1;
18273 #if !defined(HAVE_SQLITE3COLUMNTABLENAME) || !(HAVE_SQLITE3COLUMNTABLENAME)
18274 dyncols[i].
table =
"";
18276 strcpy(p, colname);
18278 p += strlen(p) + 1;
18283 #ifdef SQL_LONGVARCHAR
18284 dyncols[i].
type = SQL_LONGVARCHAR;
18285 dyncols[i].
size = 65535;
18287 dyncols[i].
type = SQL_VARCHAR;
18288 dyncols[i].
size = 255;
18290 dyncols[i].
index = i;
18291 dyncols[i].
scale = 0;
18292 dyncols[i].
prec = 0;
18294 #if defined(HAVE_SQLITE3TABLECOLUMNMETADATA) && (HAVE_SQLITE3TABLECOLUMNMETADATA)
18295 s3stmt_addmeta(s3stmt, i, d, &dyncols[i]);
18297 dyncols[i].
autoinc = SQL_FALSE;
18298 dyncols[i].
notnull = SQL_NULLABLE;
18299 dyncols[i].
ispk = -1;
18323 drvprepare(SQLHSTMT stmt, SQLCHAR *query, SQLINTEGER queryLen)
18330 if (stmt == SQL_NULL_HSTMT) {
18331 return SQL_INVALID_HANDLE;
18334 if (s->
dbc == SQL_NULL_HDBC) {
18345 if (sret != SQL_SUCCESS) {
18354 setstat(s, -1,
"%s", (*s->
ov3) ?
"HY000" :
"S1000", errp);
18362 int ret, ncols, nretry = 0;
18364 sqlite3_stmt *s3stmt = NULL;
18366 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
18373 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
18374 ret = sqlite3_prepare_v2(d->
sqlite, (
char *) s->
query, -1,
18377 ret = sqlite3_prepare(d->
sqlite, (
char *) s->
query, -1,
18380 if (ret != SQLITE_OK) {
18382 sqlite3_finalize(s3stmt);
18386 }
while (ret == SQLITE_SCHEMA && (++nretry) < 2);
18388 if (ret != SQLITE_OK) {
18391 sqlite3_finalize(s3stmt);
18393 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
18394 sqlite3_errmsg(d->
sqlite), ret);
18397 if (sqlite3_bind_parameter_count(s3stmt) != s->
nparams) {
18399 sqlite3_finalize(s3stmt);
18400 setstat(s, SQLITE_ERROR,
"parameter marker count incorrect",
18401 (*s->
ov3) ?
"HY000" :
"S1000");
18404 ncols = sqlite3_column_count(s3stmt);
18412 return SQL_SUCCESS;
18428 int rc, i, ncols = 0, nrows = 0, busy_count;
18431 if (stmt == SQL_NULL_HSTMT) {
18432 return SQL_INVALID_HANDLE;
18435 if (s->
dbc == SQL_NULL_HDBC) {
18444 setstat(s, -1,
"no query prepared", (*s->
ov3) ?
"HY000" :
"S1000");
18449 setstat(s, -1,
"unbound parameters in query",
18450 (*s->
ov3) ?
"HY000" :
"S1000");
18453 for (i = 0; i < s->
nparams; i++) {
18462 if (lenp && *lenp < 0 && *lenp > SQL_LEN_DATA_AT_EXEC_OFFSET &&
18463 *lenp != SQL_NTS && *lenp != SQL_NULL_DATA &&
18464 *lenp != SQL_DATA_AT_EXEC) {
18465 setstat(s, -1,
"invalid length reference",
"HY009");
18468 if (lenp && (*lenp <= SQL_LEN_DATA_AT_EXEC_OFFSET ||
18469 *lenp == SQL_DATA_AT_EXEC)) {
18477 if (ret != SQL_SUCCESS) {
18486 for (i = 0; i < s->
nparams; i++) {
18493 if (p->
need <= 0 &&
18494 p->
lenp && (*p->
lenp <= SQL_LEN_DATA_AT_EXEC_OFFSET ||
18495 *p->
lenp == SQL_DATA_AT_EXEC)) {
18503 for (i = 0; i < s->
nparams; i++) {
18505 if (ret != SQL_SUCCESS) {
18512 s->
curtype == SQL_CURSOR_FORWARD_ONLY &&
18516 if (ret == SQL_SUCCESS) {
18523 if (rc == SQLITE_BUSY) {
18526 sqlite3_free(errp);
18529 for (i = 0; i < s->
nparams; i++) {
18536 if (!p->
lenp || (*p->
lenp > SQL_LEN_DATA_AT_EXEC_OFFSET &&
18537 *p->
lenp != SQL_DATA_AT_EXEC)) {
18546 if (rc != SQLITE_OK) {
18547 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
18548 errp ? errp :
"unknown error", rc);
18550 sqlite3_free(errp);
18557 sqlite3_free(errp);
18566 nrows += sqlite3_changes(d->
sqlite);
18570 if (s->
ncols != ncols) {
18574 setstat(s, -1,
"broken result set %d/%d",
18575 (*s->
ov3) ?
"HY000" :
"S1000", s->
ncols, ncols);
18587 for (i = 0; i < s->
nparams; i++) {
18598 }
else if (p->
lenp0 && p->
inc > 0) {
18601 if (!p->
lenp || (*p->
lenp > SQL_LEN_DATA_AT_EXEC_OFFSET &&
18602 *p->
lenp != SQL_DATA_AT_EXEC)) {
18611 }
else if (p->
lenp && (*p->
lenp <= SQL_LEN_DATA_AT_EXEC_OFFSET ||
18612 *p->
lenp == SQL_DATA_AT_EXEC)) {
18621 if (ret != SQL_NEED_DATA) {
18622 for (i = 0; i < s->
nparams; i++) {
18629 if (!p->
lenp || (*p->
lenp > SQL_LEN_DATA_AT_EXEC_OFFSET &&
18630 *p->
lenp != SQL_DATA_AT_EXEC)) {
18647 ret == SQL_SUCCESS && nrows == 0) {
18663 SQLPrepare(SQLHSTMT stmt, SQLCHAR *query, SQLINTEGER queryLen)
18666 #if defined(_WIN32) || defined(_WIN64)
18671 #if defined(_WIN32) || defined(_WIN64)
18672 if (!((
STMT *) stmt)->oemcp[0]) {
18673 ret = drvprepare(stmt, query, queryLen);
18676 q = wmb_to_utf_c((
char *) query, queryLen);
18681 query = (SQLCHAR *) q;
18682 queryLen = SQL_NTS;
18684 ret = drvprepare(stmt, query, queryLen);
18685 #if defined(_WIN32) || defined(_WIN64)
18705 SQLPrepareW(SQLHSTMT stmt, SQLWCHAR *query, SQLINTEGER queryLen)
18715 ret = drvprepare(stmt, (SQLCHAR *) q, SQL_NTS);
18730 SQLExecute(SQLHSTMT stmt)
18750 SQLExecDirect(SQLHSTMT stmt, SQLCHAR *query, SQLINTEGER queryLen)
18753 #if defined(_WIN32) || defined(_WIN64)
18758 #if defined(_WIN32) || defined(_WIN64)
18759 if (!((
STMT *) stmt)->oemcp[0]) {
18760 ret = drvprepare(stmt, query, queryLen);
18761 if (ret == SQL_SUCCESS) {
18766 q = wmb_to_utf_c((
char *) query, queryLen);
18771 query = (SQLCHAR *) q;
18772 queryLen = SQL_NTS;
18774 ret = drvprepare(stmt, query, queryLen);
18775 if (ret == SQL_SUCCESS) {
18778 #if defined(_WIN32) || defined(_WIN64)
18798 SQLExecDirectW(SQLHSTMT stmt, SQLWCHAR *query, SQLINTEGER queryLen)
18808 ret = drvprepare(stmt, (SQLCHAR *) q, SQL_NTS);
18810 if (ret == SQL_SUCCESS) {
18820 #if defined(_WIN32) || defined(_WIN64)
18821 #ifndef WITHOUT_DRIVERMGR
18827 #include <windowsx.h>
18828 #include <winuser.h>
18830 #define MAXPATHLEN (259+1)
18831 #define MAXKEYLEN (15+1)
18832 #define MAXDESC (255+1)
18833 #define MAXDSNAME (32+1)
18834 #define MAXTONAME (32+1)
18835 #define MAXDBNAME MAXPATHLEN
18841 #define KEY_DBNAME 2
18843 #define KEY_DRIVER 4
18844 #define KEY_STEPAPI 5
18845 #define KEY_SYNCP 6
18846 #define KEY_NOTXN 7
18847 #define KEY_SHORTNAM 8
18848 #define KEY_LONGNAM 9
18849 #define KEY_NOCREAT 10
18850 #define KEY_NOWCHAR 11
18851 #define KEY_LOADEXT 12
18852 #define KEY_JMODE 13
18853 #define KEY_FKSUPPORT 14
18854 #define KEY_OEMCP 15
18855 #define KEY_BIGINT 16
18856 #define KEY_PASSWD 17
18857 #define KEY_JDCONV 18
18858 #define NUMOFKEYS 19
18862 char attr[MAXPATHLEN*4];
18868 ATTR attr[NUMOFKEYS];
18869 char DSN[MAXDSNAME];
18878 {
"DSN", KEY_DSN },
18879 {
"DESC", KEY_DESC },
18880 {
"Description", KEY_DESC},
18881 {
"Database", KEY_DBNAME },
18882 {
"Timeout", KEY_BUSY },
18883 {
"Driver", KEY_DRIVER },
18884 {
"StepAPI", KEY_STEPAPI },
18885 {
"SyncPragma", KEY_SYNCP },
18886 {
"NoTXN", KEY_NOTXN },
18887 {
"ShortNames", KEY_SHORTNAM },
18888 {
"LongNames", KEY_LONGNAM },
18889 {
"NoCreat", KEY_NOCREAT },
18890 {
"NoWCHAR", KEY_NOWCHAR },
18891 {
"LoadExt", KEY_LOADEXT },
18892 {
"JournalMode", KEY_JMODE },
18893 {
"FKSupport", KEY_FKSUPPORT },
18894 {
"OEMCP", KEY_OEMCP },
18895 {
"BigInt", KEY_BIGINT },
18896 {
"PWD", KEY_PASSWD },
18897 {
"JDConv", KEY_JDCONV },
18908 ParseAttributes(LPCSTR attribs, SETUPDLG *setupdlg)
18910 char *str = (
char *) attribs, *start, key[MAXKEYLEN];
18915 if ((str = strchr(str,
'=')) == NULL) {
18919 nkey = str - start;
18920 if (nkey <
sizeof (key)) {
18923 memcpy(key, start, nkey);
18925 for (i = 0; attrLookup[i].key; i++) {
18926 if (strcasecmp(attrLookup[i].key, key) == 0) {
18927 elem = attrLookup[i].ikey;
18933 while (*str && *str !=
';') {
18937 int end =
min(str - start,
sizeof (setupdlg->attr[elem].attr) - 1);
18939 setupdlg->attr[elem].supplied = TRUE;
18940 memcpy(setupdlg->attr[elem].attr, start, end);
18941 setupdlg->attr[elem].attr[end] =
'\0';
18955 SetDSNAttributes(HWND parent, SETUPDLG *setupdlg)
18957 char *dsn = setupdlg->attr[KEY_DSN].attr;
18959 if (setupdlg->newDSN && strlen(dsn) == 0) {
18962 if (!SQLWriteDSNToIni(dsn, setupdlg->driver)) {
18964 char buf[MAXPATHLEN], msg[MAXPATHLEN];
18966 LoadString(hModule, IDS_BADDSN, buf,
sizeof (buf));
18967 wsprintf(msg, buf, dsn);
18968 LoadString(hModule, IDS_MSGTITLE, buf,
sizeof (buf));
18969 MessageBox(parent, msg, buf,
18970 MB_ICONEXCLAMATION | MB_OK | MB_TASKMODAL |
18975 if (parent || setupdlg->attr[KEY_DESC].supplied) {
18976 SQLWritePrivateProfileString(dsn,
"Description",
18977 setupdlg->attr[KEY_DESC].attr,
18980 if (parent || setupdlg->attr[KEY_DBNAME].supplied) {
18981 SQLWritePrivateProfileString(dsn,
"Database",
18982 setupdlg->attr[KEY_DBNAME].attr,
18985 if (parent || setupdlg->attr[KEY_BUSY].supplied) {
18986 SQLWritePrivateProfileString(dsn,
"Timeout",
18987 setupdlg->attr[KEY_BUSY].attr,
18990 if (parent || setupdlg->attr[KEY_STEPAPI].supplied) {
18991 SQLWritePrivateProfileString(dsn,
"StepAPI",
18992 setupdlg->attr[KEY_STEPAPI].attr,
18995 if (parent || setupdlg->attr[KEY_SYNCP].supplied) {
18996 SQLWritePrivateProfileString(dsn,
"SyncPragma",
18997 setupdlg->attr[KEY_SYNCP].attr,
19000 if (parent || setupdlg->attr[KEY_NOTXN].supplied) {
19001 SQLWritePrivateProfileString(dsn,
"NoTXN",
19002 setupdlg->attr[KEY_NOTXN].attr,
19005 if (parent || setupdlg->attr[KEY_SHORTNAM].supplied) {
19006 SQLWritePrivateProfileString(dsn,
"ShortNames",
19007 setupdlg->attr[KEY_SHORTNAM].attr,
19010 if (parent || setupdlg->attr[KEY_LONGNAM].supplied) {
19011 SQLWritePrivateProfileString(dsn,
"LongNames",
19012 setupdlg->attr[KEY_LONGNAM].attr,
19015 if (parent || setupdlg->attr[KEY_NOCREAT].supplied) {
19016 SQLWritePrivateProfileString(dsn,
"NoCreat",
19017 setupdlg->attr[KEY_NOCREAT].attr,
19020 if (parent || setupdlg->attr[KEY_NOWCHAR].supplied) {
19021 SQLWritePrivateProfileString(dsn,
"NoWCHAR",
19022 setupdlg->attr[KEY_NOWCHAR].attr,
19025 if (parent || setupdlg->attr[KEY_FKSUPPORT].supplied) {
19026 SQLWritePrivateProfileString(dsn,
"FKSupport",
19027 setupdlg->attr[KEY_FKSUPPORT].attr,
19030 if (parent || setupdlg->attr[KEY_OEMCP].supplied) {
19031 SQLWritePrivateProfileString(dsn,
"OEMCP",
19032 setupdlg->attr[KEY_OEMCP].attr,
19035 if (parent || setupdlg->attr[KEY_LOADEXT].supplied) {
19036 SQLWritePrivateProfileString(dsn,
"LoadExt",
19037 setupdlg->attr[KEY_LOADEXT].attr,
19040 if (parent || setupdlg->attr[KEY_BIGINT].supplied) {
19041 SQLWritePrivateProfileString(dsn,
"BigInt",
19042 setupdlg->attr[KEY_BIGINT].attr,
19045 if (parent || setupdlg->attr[KEY_JDCONV].supplied) {
19046 SQLWritePrivateProfileString(dsn,
"JDConv",
19047 setupdlg->attr[KEY_JDCONV].attr,
19050 if (parent || setupdlg->attr[KEY_PASSWD].supplied) {
19051 SQLWritePrivateProfileString(dsn,
"PWD",
19052 setupdlg->attr[KEY_PASSWD].attr,
19055 if (setupdlg->attr[KEY_DSN].supplied &&
19056 strcasecmp(setupdlg->DSN, setupdlg->attr[KEY_DSN].attr)) {
19057 SQLRemoveDSNFromIni(setupdlg->DSN);
19068 GetAttributes(SETUPDLG *setupdlg)
19070 char *dsn = setupdlg->attr[KEY_DSN].attr;
19072 if (!setupdlg->attr[KEY_DESC].supplied) {
19073 SQLGetPrivateProfileString(dsn,
"Description",
"",
19074 setupdlg->attr[KEY_DESC].attr,
19075 sizeof (setupdlg->attr[KEY_DESC].attr),
19078 if (!setupdlg->attr[KEY_DBNAME].supplied) {
19079 SQLGetPrivateProfileString(dsn,
"Database",
"",
19080 setupdlg->attr[KEY_DBNAME].attr,
19081 sizeof (setupdlg->attr[KEY_DBNAME].attr),
19084 if (!setupdlg->attr[KEY_BUSY].supplied) {
19085 SQLGetPrivateProfileString(dsn,
"Timeout",
"100000",
19086 setupdlg->attr[KEY_BUSY].attr,
19087 sizeof (setupdlg->attr[KEY_BUSY].attr),
19090 if (!setupdlg->attr[KEY_STEPAPI].supplied) {
19091 SQLGetPrivateProfileString(dsn,
"StepAPI",
"0",
19092 setupdlg->attr[KEY_STEPAPI].attr,
19093 sizeof (setupdlg->attr[KEY_STEPAPI].attr),
19096 if (!setupdlg->attr[KEY_SYNCP].supplied) {
19097 SQLGetPrivateProfileString(dsn,
"SyncPragma",
"NORMAL",
19098 setupdlg->attr[KEY_SYNCP].attr,
19099 sizeof (setupdlg->attr[KEY_SYNCP].attr),
19102 if (!setupdlg->attr[KEY_NOTXN].supplied) {
19103 SQLGetPrivateProfileString(dsn,
"NoTXN",
"",
19104 setupdlg->attr[KEY_NOTXN].attr,
19105 sizeof (setupdlg->attr[KEY_NOTXN].attr),
19108 if (!setupdlg->attr[KEY_SHORTNAM].supplied) {
19109 SQLGetPrivateProfileString(dsn,
"ShortNames",
"",
19110 setupdlg->attr[KEY_SHORTNAM].attr,
19111 sizeof (setupdlg->attr[KEY_SHORTNAM].attr),
19114 if (!setupdlg->attr[KEY_LONGNAM].supplied) {
19115 SQLGetPrivateProfileString(dsn,
"LongNames",
"",
19116 setupdlg->attr[KEY_LONGNAM].attr,
19117 sizeof (setupdlg->attr[KEY_LONGNAM].attr),
19120 if (!setupdlg->attr[KEY_NOCREAT].supplied) {
19121 SQLGetPrivateProfileString(dsn,
"NoCreat",
"",
19122 setupdlg->attr[KEY_NOCREAT].attr,
19123 sizeof (setupdlg->attr[KEY_NOCREAT].attr),
19126 if (!setupdlg->attr[KEY_NOWCHAR].supplied) {
19127 SQLGetPrivateProfileString(dsn,
"NoWCHAR",
"",
19128 setupdlg->attr[KEY_NOWCHAR].attr,
19129 sizeof (setupdlg->attr[KEY_NOWCHAR].attr),
19132 if (!setupdlg->attr[KEY_FKSUPPORT].supplied) {
19133 SQLGetPrivateProfileString(dsn,
"FKSupport",
"",
19134 setupdlg->attr[KEY_FKSUPPORT].attr,
19135 sizeof (setupdlg->attr[KEY_FKSUPPORT].attr),
19138 if (!setupdlg->attr[KEY_OEMCP].supplied) {
19139 SQLGetPrivateProfileString(dsn,
"OEMCP",
"",
19140 setupdlg->attr[KEY_OEMCP].attr,
19141 sizeof (setupdlg->attr[KEY_OEMCP].attr),
19144 if (!setupdlg->attr[KEY_LOADEXT].supplied) {
19145 SQLGetPrivateProfileString(dsn,
"LoadExt",
"",
19146 setupdlg->attr[KEY_LOADEXT].attr,
19147 sizeof (setupdlg->attr[KEY_LOADEXT].attr),
19150 if (!setupdlg->attr[KEY_JMODE].supplied) {
19151 SQLGetPrivateProfileString(dsn,
"JournalMode",
"",
19152 setupdlg->attr[KEY_JMODE].attr,
19153 sizeof (setupdlg->attr[KEY_JMODE].attr),
19156 if (!setupdlg->attr[KEY_BIGINT].supplied) {
19157 SQLGetPrivateProfileString(dsn,
"BigInt",
"",
19158 setupdlg->attr[KEY_BIGINT].attr,
19159 sizeof (setupdlg->attr[KEY_BIGINT].attr),
19162 if (!setupdlg->attr[KEY_PASSWD].supplied) {
19163 SQLGetPrivateProfileString(dsn,
"PWD",
"",
19164 setupdlg->attr[KEY_PASSWD].attr,
19165 sizeof (setupdlg->attr[KEY_PASSWD].attr),
19168 if (!setupdlg->attr[KEY_JDCONV].supplied) {
19169 SQLGetPrivateProfileString(dsn,
"JDConv",
"",
19170 setupdlg->attr[KEY_JDCONV].attr,
19171 sizeof (setupdlg->attr[KEY_JDCONV].attr),
19182 GetDBFile(HWND hdlg)
19185 SETUPDLG *setupdlg = (SETUPDLG *) GetWindowLongPtr(hdlg, DWLP_USER);
19187 SETUPDLG *setupdlg = (SETUPDLG *) GetWindowLong(hdlg, DWL_USER);
19191 memset(&ofn, 0,
sizeof (ofn));
19192 ofn.lStructSize =
sizeof (ofn);
19193 ofn.hwndOwner = hdlg;
19195 ofn.hInstance = (HINSTANCE) GetWindowLongPtr(hdlg, GWLP_HINSTANCE);
19197 ofn.hInstance = (HINSTANCE) GetWindowLong(hdlg, GWL_HINSTANCE);
19199 ofn.lpstrFile = (LPTSTR) setupdlg->attr[KEY_DBNAME].attr;
19200 ofn.nMaxFile = MAXPATHLEN;
19201 ofn.Flags = OFN_HIDEREADONLY | OFN_PATHMUSTEXIST |
19202 OFN_NOCHANGEDIR | OFN_EXPLORER | OFN_FILEMUSTEXIST;
19203 if (GetOpenFileName(&ofn)) {
19204 SetDlgItemText(hdlg, IDC_DBNAME, setupdlg->attr[KEY_DBNAME].attr);
19205 setupdlg->attr[KEY_DBNAME].supplied = TRUE;
19218 static BOOL CALLBACK
19219 ConfigDlgProc(HWND hdlg, WORD wmsg, WPARAM wparam, LPARAM lparam)
19221 SETUPDLG *setupdlg = NULL;
19225 case WM_INITDIALOG:
19227 SetWindowLongPtr(hdlg, DWLP_USER, lparam);
19229 SetWindowLong(hdlg, DWL_USER, lparam);
19231 setupdlg = (SETUPDLG *) lparam;
19232 GetAttributes(setupdlg);
19233 SetDlgItemText(hdlg, IDC_DSNAME, setupdlg->attr[KEY_DSN].attr);
19234 SetDlgItemText(hdlg, IDC_DESC, setupdlg->attr[KEY_DESC].attr);
19235 SetDlgItemText(hdlg, IDC_DBNAME, setupdlg->attr[KEY_DBNAME].attr);
19236 SetDlgItemText(hdlg, IDC_TONAME, setupdlg->attr[KEY_BUSY].attr);
19237 SetDlgItemText(hdlg, IDC_LOADEXT, setupdlg->attr[KEY_LOADEXT].attr);
19238 SendDlgItemMessage(hdlg, IDC_DSNAME, EM_LIMITTEXT,
19239 (WPARAM) (MAXDSNAME - 1), (LPARAM) 0);
19240 SendDlgItemMessage(hdlg, IDC_DESC, EM_LIMITTEXT,
19241 (WPARAM) (MAXDESC - 1), (LPARAM) 0);
19242 SendDlgItemMessage(hdlg, IDC_DBNAME, EM_LIMITTEXT,
19243 (WPARAM) (MAXDBNAME - 1), (LPARAM) 0);
19244 SendDlgItemMessage(hdlg, IDC_TONAME, EM_LIMITTEXT,
19245 (WPARAM) (MAXTONAME - 1), (LPARAM) 0);
19246 SendDlgItemMessage(hdlg, IDC_LOADEXT, EM_LIMITTEXT,
19247 (WPARAM) (MAXPATHLEN*4 - 1), (LPARAM) 0);
19248 CheckDlgButton(hdlg, IDC_STEPAPI,
19249 getbool(setupdlg->attr[KEY_STEPAPI].attr) ?
19250 BST_CHECKED : BST_UNCHECKED);
19251 CheckDlgButton(hdlg, IDC_NOTXN,
19252 getbool(setupdlg->attr[KEY_NOTXN].attr) ?
19253 BST_CHECKED : BST_UNCHECKED);
19254 CheckDlgButton(hdlg, IDC_SHORTNAM,
19255 getbool(setupdlg->attr[KEY_SHORTNAM].attr) ?
19256 BST_CHECKED : BST_UNCHECKED);
19257 CheckDlgButton(hdlg, IDC_LONGNAM,
19258 getbool(setupdlg->attr[KEY_LONGNAM].attr) ?
19259 BST_CHECKED : BST_UNCHECKED);
19260 CheckDlgButton(hdlg, IDC_NOCREAT,
19261 getbool(setupdlg->attr[KEY_NOCREAT].attr) ?
19262 BST_CHECKED : BST_UNCHECKED);
19263 CheckDlgButton(hdlg, IDC_NOWCHAR,
19264 getbool(setupdlg->attr[KEY_NOWCHAR].attr) ?
19265 BST_CHECKED : BST_UNCHECKED);
19266 CheckDlgButton(hdlg, IDC_FKSUPPORT,
19267 getbool(setupdlg->attr[KEY_FKSUPPORT].attr) ?
19268 BST_CHECKED : BST_UNCHECKED);
19269 CheckDlgButton(hdlg, IDC_OEMCP,
19270 getbool(setupdlg->attr[KEY_OEMCP].attr) ?
19271 BST_CHECKED : BST_UNCHECKED);
19272 CheckDlgButton(hdlg, IDC_BIGINT,
19273 getbool(setupdlg->attr[KEY_BIGINT].attr) ?
19274 BST_CHECKED : BST_UNCHECKED);
19275 CheckDlgButton(hdlg, IDC_JDCONV,
19276 getbool(setupdlg->attr[KEY_JDCONV].attr) ?
19277 BST_CHECKED : BST_UNCHECKED);
19278 SendDlgItemMessage(hdlg, IDC_SYNCP,
19279 CB_LIMITTEXT, (WPARAM) 10, (LPARAM) 0);
19280 SendDlgItemMessage(hdlg, IDC_SYNCP,
19281 CB_ADDSTRING, 0, (LPARAM)
"NORMAL");
19282 SendDlgItemMessage(hdlg, IDC_SYNCP,
19283 CB_ADDSTRING, 0, (LPARAM)
"OFF");
19284 SendDlgItemMessage(hdlg, IDC_SYNCP,
19285 CB_ADDSTRING, 0, (LPARAM)
"FULL");
19286 SendDlgItemMessage(hdlg, IDC_SYNCP,
19287 CB_SELECTSTRING, (WPARAM) -1,
19288 (LPARAM) setupdlg->attr[KEY_SYNCP].attr);
19289 if (setupdlg->defDSN) {
19290 EnableWindow(GetDlgItem(hdlg, IDC_DSNAME), FALSE);
19291 EnableWindow(GetDlgItem(hdlg, IDC_DSNAMETEXT), FALSE);
19295 switch (GET_WM_COMMAND_ID(wparam, lparam)) {
19297 if (GET_WM_COMMAND_CMD(wparam, lparam) == EN_CHANGE) {
19298 char item[MAXDSNAME];
19300 EnableWindow(GetDlgItem(hdlg, IDOK),
19301 GetDlgItemText(hdlg, IDC_DSNAME,
19302 item,
sizeof (item)));
19311 setupdlg = (SETUPDLG *) GetWindowLongPtr(hdlg, DWLP_USER);
19313 setupdlg = (SETUPDLG *) GetWindowLong(hdlg, DWL_USER);
19315 if (!setupdlg->defDSN) {
19316 GetDlgItemText(hdlg, IDC_DSNAME,
19317 setupdlg->attr[KEY_DSN].attr,
19318 sizeof (setupdlg->attr[KEY_DSN].attr));
19320 GetDlgItemText(hdlg, IDC_DESC,
19321 setupdlg->attr[KEY_DESC].attr,
19322 sizeof (setupdlg->attr[KEY_DESC].attr));
19323 GetDlgItemText(hdlg, IDC_DBNAME,
19324 setupdlg->attr[KEY_DBNAME].attr,
19325 sizeof (setupdlg->attr[KEY_DBNAME].attr));
19326 GetDlgItemText(hdlg, IDC_TONAME,
19327 setupdlg->attr[KEY_BUSY].attr,
19328 sizeof (setupdlg->attr[KEY_BUSY].attr));
19329 GetDlgItemText(hdlg, IDC_LOADEXT,
19330 setupdlg->attr[KEY_LOADEXT].attr,
19331 sizeof (setupdlg->attr[KEY_LOADEXT].attr));
19332 index = SendDlgItemMessage(hdlg, IDC_SYNCP,
19333 CB_GETCURSEL, (WPARAM) 0, (LPARAM) 0);
19334 if (index != (WORD) CB_ERR) {
19335 SendDlgItemMessage(hdlg, IDC_SYNCP,
19336 CB_GETLBTEXT, index,
19337 (LPARAM) setupdlg->attr[KEY_SYNCP].attr);
19339 strcpy(setupdlg->attr[KEY_STEPAPI].attr,
19340 (IsDlgButtonChecked(hdlg, IDC_STEPAPI) == BST_CHECKED) ?
19342 strcpy(setupdlg->attr[KEY_NOTXN].attr,
19343 (IsDlgButtonChecked(hdlg, IDC_NOTXN) == BST_CHECKED) ?
19345 strcpy(setupdlg->attr[KEY_SHORTNAM].attr,
19346 (IsDlgButtonChecked(hdlg, IDC_SHORTNAM) == BST_CHECKED) ?
19348 strcpy(setupdlg->attr[KEY_LONGNAM].attr,
19349 (IsDlgButtonChecked(hdlg, IDC_LONGNAM) == BST_CHECKED) ?
19351 strcpy(setupdlg->attr[KEY_NOCREAT].attr,
19352 (IsDlgButtonChecked(hdlg, IDC_NOCREAT) == BST_CHECKED) ?
19354 strcpy(setupdlg->attr[KEY_NOWCHAR].attr,
19355 (IsDlgButtonChecked(hdlg, IDC_NOWCHAR) == BST_CHECKED) ?
19357 strcpy(setupdlg->attr[KEY_FKSUPPORT].attr,
19358 (IsDlgButtonChecked(hdlg, IDC_FKSUPPORT) == BST_CHECKED) ?
19360 strcpy(setupdlg->attr[KEY_OEMCP].attr,
19361 (IsDlgButtonChecked(hdlg, IDC_OEMCP) == BST_CHECKED) ?
19363 strcpy(setupdlg->attr[KEY_BIGINT].attr,
19364 (IsDlgButtonChecked(hdlg, IDC_BIGINT) == BST_CHECKED) ?
19366 strcpy(setupdlg->attr[KEY_JDCONV].attr,
19367 (IsDlgButtonChecked(hdlg, IDC_JDCONV) == BST_CHECKED) ?
19369 SetDSNAttributes(hdlg, setupdlg);
19372 EndDialog(hdlg, wparam);
19390 ConfigDSN(HWND hwnd, WORD request, LPCSTR driver, LPCSTR attribs)
19393 SETUPDLG *setupdlg;
19395 setupdlg = (SETUPDLG *)
xmalloc(
sizeof (SETUPDLG));
19396 if (setupdlg == NULL) {
19399 memset(setupdlg, 0,
sizeof (SETUPDLG));
19401 ParseAttributes(attribs, setupdlg);
19403 if (setupdlg->attr[KEY_DSN].supplied) {
19404 strcpy(setupdlg->DSN, setupdlg->attr[KEY_DSN].attr);
19406 setupdlg->DSN[0] =
'\0';
19408 if (request == ODBC_REMOVE_DSN) {
19409 if (!setupdlg->attr[KEY_DSN].supplied) {
19412 success = SQLRemoveDSNFromIni(setupdlg->attr[KEY_DSN].attr);
19415 setupdlg->parent = hwnd;
19416 setupdlg->driver = driver;
19417 setupdlg->newDSN = request == ODBC_ADD_DSN;
19418 setupdlg->defDSN = strcasecmp(setupdlg->attr[KEY_DSN].attr,
19421 success = DialogBoxParam(hModule, MAKEINTRESOURCE(CONFIGDSN),
19422 hwnd, (DLGPROC) ConfigDlgProc,
19423 (LPARAM) setupdlg) == IDOK;
19424 }
else if (setupdlg->attr[KEY_DSN].supplied) {
19425 success = SetDSNAttributes(hwnd, setupdlg);
19443 static BOOL CALLBACK
19444 DriverConnectProc(HWND hdlg, WORD wmsg, WPARAM wparam, LPARAM lparam)
19446 SETUPDLG *setupdlg;
19450 case WM_INITDIALOG:
19452 SetWindowLongPtr(hdlg, DWLP_USER, lparam);
19454 SetWindowLong(hdlg, DWL_USER, lparam);
19456 setupdlg = (SETUPDLG *) lparam;
19457 SetDlgItemText(hdlg, IDC_DSNAME, setupdlg->attr[KEY_DSN].attr);
19458 SetDlgItemText(hdlg, IDC_DESC, setupdlg->attr[KEY_DESC].attr);
19459 SetDlgItemText(hdlg, IDC_DBNAME, setupdlg->attr[KEY_DBNAME].attr);
19460 SetDlgItemText(hdlg, IDC_TONAME, setupdlg->attr[KEY_BUSY].attr);
19461 SetDlgItemText(hdlg, IDC_LOADEXT, setupdlg->attr[KEY_LOADEXT].attr);
19462 SendDlgItemMessage(hdlg, IDC_DSNAME, EM_LIMITTEXT,
19463 (WPARAM) (MAXDSNAME - 1), (LPARAM) 0);
19464 SendDlgItemMessage(hdlg, IDC_DESC, EM_LIMITTEXT,
19465 (WPARAM) (MAXDESC - 1), (LPARAM) 0);
19466 SendDlgItemMessage(hdlg, IDC_DBNAME, EM_LIMITTEXT,
19467 (WPARAM) (MAXDBNAME - 1), (LPARAM) 0);
19468 SendDlgItemMessage(hdlg, IDC_TONAME, EM_LIMITTEXT,
19469 (WPARAM) (MAXTONAME - 1), (LPARAM) 0);
19470 SendDlgItemMessage(hdlg, IDC_LOADEXT, EM_LIMITTEXT,
19471 (WPARAM) (MAXPATHLEN*4 - 1), (LPARAM) 0);
19472 CheckDlgButton(hdlg, IDC_STEPAPI,
19473 getbool(setupdlg->attr[KEY_STEPAPI].attr) ?
19474 BST_CHECKED : BST_UNCHECKED);
19475 CheckDlgButton(hdlg, IDC_NOTXN,
19476 getbool(setupdlg->attr[KEY_NOTXN].attr) ?
19477 BST_CHECKED : BST_UNCHECKED);
19478 CheckDlgButton(hdlg, IDC_SHORTNAM,
19479 getbool(setupdlg->attr[KEY_SHORTNAM].attr) ?
19480 BST_CHECKED : BST_UNCHECKED);
19481 CheckDlgButton(hdlg, IDC_LONGNAM,
19482 getbool(setupdlg->attr[KEY_LONGNAM].attr) ?
19483 BST_CHECKED : BST_UNCHECKED);
19484 CheckDlgButton(hdlg, IDC_NOCREAT,
19485 getbool(setupdlg->attr[KEY_NOCREAT].attr) ?
19486 BST_CHECKED : BST_UNCHECKED);
19487 CheckDlgButton(hdlg, IDC_NOWCHAR,
19488 getbool(setupdlg->attr[KEY_NOWCHAR].attr) ?
19489 BST_CHECKED : BST_UNCHECKED);
19490 CheckDlgButton(hdlg, IDC_FKSUPPORT,
19491 getbool(setupdlg->attr[KEY_FKSUPPORT].attr) ?
19492 BST_CHECKED : BST_UNCHECKED);
19493 CheckDlgButton(hdlg, IDC_OEMCP,
19494 getbool(setupdlg->attr[KEY_OEMCP].attr) ?
19495 BST_CHECKED : BST_UNCHECKED);
19496 CheckDlgButton(hdlg, IDC_BIGINT,
19497 getbool(setupdlg->attr[KEY_BIGINT].attr) ?
19498 BST_CHECKED : BST_UNCHECKED);
19499 CheckDlgButton(hdlg, IDC_JDCONV,
19500 getbool(setupdlg->attr[KEY_JDCONV].attr) ?
19501 BST_CHECKED : BST_UNCHECKED);
19502 SendDlgItemMessage(hdlg, IDC_SYNCP,
19503 CB_LIMITTEXT, (WPARAM) 10, (LPARAM) 0);
19504 SendDlgItemMessage(hdlg, IDC_SYNCP,
19505 CB_ADDSTRING, 0, (LPARAM)
"NORMAL");
19506 SendDlgItemMessage(hdlg, IDC_SYNCP,
19507 CB_ADDSTRING, 0, (LPARAM)
"OFF");
19508 SendDlgItemMessage(hdlg, IDC_SYNCP,
19509 CB_ADDSTRING, 0, (LPARAM)
"FULL");
19510 SendDlgItemMessage(hdlg, IDC_SYNCP,
19511 CB_SELECTSTRING, (WORD) -1,
19512 (LPARAM) setupdlg->attr[KEY_SYNCP].attr);
19513 if (setupdlg->defDSN) {
19514 EnableWindow(GetDlgItem(hdlg, IDC_DSNAME), FALSE);
19515 EnableWindow(GetDlgItem(hdlg, IDC_DSNAMETEXT), FALSE);
19519 switch (GET_WM_COMMAND_ID(wparam, lparam)) {
19525 setupdlg = (SETUPDLG *) GetWindowLongPtr(hdlg, DWLP_USER);
19527 setupdlg = (SETUPDLG *) GetWindowLong(hdlg, DWL_USER);
19529 GetDlgItemText(hdlg, IDC_DSNAME,
19530 setupdlg->attr[KEY_DSN].attr,
19531 sizeof (setupdlg->attr[KEY_DSN].attr));
19532 GetDlgItemText(hdlg, IDC_DBNAME,
19533 setupdlg->attr[KEY_DBNAME].attr,
19534 sizeof (setupdlg->attr[KEY_DBNAME].attr));
19535 GetDlgItemText(hdlg, IDC_TONAME,
19536 setupdlg->attr[KEY_BUSY].attr,
19537 sizeof (setupdlg->attr[KEY_BUSY].attr));
19538 GetDlgItemText(hdlg, IDC_LOADEXT,
19539 setupdlg->attr[KEY_LOADEXT].attr,
19540 sizeof (setupdlg->attr[KEY_LOADEXT].attr));
19541 index = SendDlgItemMessage(hdlg, IDC_SYNCP,
19542 CB_GETCURSEL, (WPARAM) 0, (LPARAM) 0);
19543 if (index != (WORD) CB_ERR) {
19544 SendDlgItemMessage(hdlg, IDC_SYNCP,
19545 CB_GETLBTEXT, index,
19546 (LPARAM) setupdlg->attr[KEY_SYNCP].attr);
19548 strcpy(setupdlg->attr[KEY_STEPAPI].attr,
19549 (IsDlgButtonChecked(hdlg, IDC_STEPAPI) == BST_CHECKED) ?
19551 strcpy(setupdlg->attr[KEY_NOTXN].attr,
19552 (IsDlgButtonChecked(hdlg, IDC_NOTXN) == BST_CHECKED) ?
19554 strcpy(setupdlg->attr[KEY_SHORTNAM].attr,
19555 (IsDlgButtonChecked(hdlg, IDC_SHORTNAM) == BST_CHECKED) ?
19557 strcpy(setupdlg->attr[KEY_LONGNAM].attr,
19558 (IsDlgButtonChecked(hdlg, IDC_LONGNAM) == BST_CHECKED) ?
19560 strcpy(setupdlg->attr[KEY_NOCREAT].attr,
19561 (IsDlgButtonChecked(hdlg, IDC_NOCREAT) == BST_CHECKED) ?
19563 strcpy(setupdlg->attr[KEY_NOWCHAR].attr,
19564 (IsDlgButtonChecked(hdlg, IDC_NOWCHAR) == BST_CHECKED) ?
19566 strcpy(setupdlg->attr[KEY_FKSUPPORT].attr,
19567 (IsDlgButtonChecked(hdlg, IDC_FKSUPPORT) == BST_CHECKED) ?
19569 strcpy(setupdlg->attr[KEY_OEMCP].attr,
19570 (IsDlgButtonChecked(hdlg, IDC_OEMCP) == BST_CHECKED) ?
19572 strcpy(setupdlg->attr[KEY_BIGINT].attr,
19573 (IsDlgButtonChecked(hdlg, IDC_BIGINT) == BST_CHECKED) ?
19575 strcpy(setupdlg->attr[KEY_JDCONV].attr,
19576 (IsDlgButtonChecked(hdlg, IDC_JDCONV) == BST_CHECKED) ?
19580 EndDialog(hdlg, GET_WM_COMMAND_ID(wparam, lparam) == IDOK);
19602 SQLCHAR *connIn, SQLSMALLINT connInLen,
19603 SQLCHAR *connOut, SQLSMALLINT connOutMax,
19604 SQLSMALLINT *connOutLen, SQLUSMALLINT drvcompl)
19606 BOOL maybeprompt, prompt = FALSE, defaultdsn = FALSE;
19608 SETUPDLG *setupdlg;
19610 char *dsn = NULL, *driver = NULL, *dbname = NULL;
19612 if (dbc == SQL_NULL_HDBC) {
19613 return SQL_INVALID_HANDLE;
19617 setstatd(d, -1,
"connection already established",
"08002");
19620 setupdlg = (SETUPDLG *)
xmalloc(
sizeof (SETUPDLG));
19621 if (setupdlg == NULL) {
19624 memset(setupdlg, 0,
sizeof (SETUPDLG));
19625 maybeprompt = drvcompl == SQL_DRIVER_COMPLETE ||
19626 drvcompl == SQL_DRIVER_COMPLETE_REQUIRED;
19627 if (connIn == NULL || !connInLen ||
19628 (connInLen == SQL_NTS && !connIn[0])) {
19631 ParseAttributes((LPCSTR) connIn, setupdlg);
19632 if (!setupdlg->attr[KEY_DSN].attr[0] &&
19633 drvcompl == SQL_DRIVER_COMPLETE_REQUIRED) {
19634 strcpy(setupdlg->attr[KEY_DSN].attr,
"DEFAULT");
19637 GetAttributes(setupdlg);
19638 if (drvcompl == SQL_DRIVER_PROMPT ||
19640 !setupdlg->attr[KEY_DBNAME].attr[0])) {
19648 setupdlg->defDSN = setupdlg->attr[KEY_DRIVER].attr[0] !=
'\0';
19649 dlgret = DialogBoxParam(hModule, MAKEINTRESOURCE(DRIVERCONNECT),
19650 hwnd, (DLGPROC) DriverConnectProc,
19651 (LPARAM) setupdlg);
19653 if (!dlgret || dlgret == -1) {
19655 return SQL_NO_DATA;
19658 dsn = setupdlg->attr[KEY_DSN].attr;
19659 driver = setupdlg->attr[KEY_DRIVER].attr;
19660 dbname = setupdlg->attr[KEY_DBNAME].attr;
19661 if (connOut || connOutLen) {
19662 char buf[SQL_MAX_MESSAGE_LENGTH * 4];
19664 char dsn_0 = (dsn && !defaultdsn) ? dsn[0] :
'\0';
19665 char drv_0 = driver ? driver[0] :
'\0';
19668 count = snprintf(buf,
sizeof (buf),
19669 "%s%s%s%s%s%sDatabase=%s;StepAPI=%s;"
19670 "SyncPragma=%s;NoTXN=%s;Timeout=%s;"
19671 "ShortNames=%s;LongNames=%s;"
19672 "NoCreat=%s;NoWCHAR=%s;"
19673 "FKSupport=%s;JournalMode=%s;OEMCP=%s;LoadExt=%s;"
19674 "BigInt=%s;JDConv=%s;PWD=%s",
19675 dsn_0 ?
"DSN=" :
"",
19678 drv_0 ?
"Driver=" :
"",
19679 drv_0 ? driver :
"",
19681 dbname ? dbname :
"",
19682 setupdlg->attr[KEY_STEPAPI].attr,
19683 setupdlg->attr[KEY_SYNCP].attr,
19684 setupdlg->attr[KEY_NOTXN].attr,
19685 setupdlg->attr[KEY_BUSY].attr,
19686 setupdlg->attr[KEY_SHORTNAM].attr,
19687 setupdlg->attr[KEY_LONGNAM].attr,
19688 setupdlg->attr[KEY_NOCREAT].attr,
19689 setupdlg->attr[KEY_NOWCHAR].attr,
19690 setupdlg->attr[KEY_FKSUPPORT].attr,
19691 setupdlg->attr[KEY_JMODE].attr,
19692 setupdlg->attr[KEY_OEMCP].attr,
19693 setupdlg->attr[KEY_LOADEXT].attr,
19694 setupdlg->attr[KEY_BIGINT].attr,
19695 setupdlg->attr[KEY_JDCONV].attr,
19696 setupdlg->attr[KEY_PASSWD].attr);
19698 buf[
sizeof (buf) - 1] =
'\0';
19700 len =
min(connOutMax - 1, strlen(buf));
19702 strncpy((
char *) connOut, buf, len);
19703 connOut[len] =
'\0';
19710 char tracef[SQL_MAX_MESSAGE_LENGTH];
19713 SQLGetPrivateProfileString(setupdlg->attr[KEY_DSN].attr,
19714 "tracefile",
"", tracef,
19716 if (tracef[0] !=
'\0') {
19717 d->
trace = fopen(tracef,
"a");
19728 d->
pwdLen = strlen(setupdlg->attr[KEY_PASSWD].attr);
19729 d->
pwd = (d->
pwdLen > 0) ? setupdlg->attr[KEY_PASSWD].attr : NULL;
19730 ret =
dbopen(d, dbname ? dbname :
"", 0,
19732 setupdlg->attr[KEY_STEPAPI].attr,
19733 setupdlg->attr[KEY_SYNCP].attr,
19734 setupdlg->attr[KEY_NOTXN].attr,
19735 setupdlg->attr[KEY_JMODE].attr,
19736 setupdlg->attr[KEY_BUSY].attr);
19737 if (ret != SQL_SUCCESS) {
19738 if (maybeprompt && !prompt) {
19743 memset(setupdlg->attr[KEY_PASSWD].attr, 0,
19744 sizeof (setupdlg->attr[KEY_PASSWD].attr));
19745 if (ret == SQL_SUCCESS) {
19746 dbloadext(d, setupdlg->attr[KEY_LOADEXT].attr);
19770 SQLDriverConnect(SQLHDBC dbc, SQLHWND hwnd,
19771 SQLCHAR *connIn, SQLSMALLINT connInLen,
19772 SQLCHAR *connOut, SQLSMALLINT connOutMax,
19773 SQLSMALLINT *connOutLen, SQLUSMALLINT drvcompl)
19779 connOut, connOutMax, connOutLen, drvcompl);
19800 SQLDriverConnectW(SQLHDBC dbc, SQLHWND hwnd,
19801 SQLWCHAR *connIn, SQLSMALLINT connInLen,
19802 SQLWCHAR *connOut, SQLSMALLINT connOutMax,
19803 SQLSMALLINT *connOutLen, SQLUSMALLINT drvcompl)
19807 SQLSMALLINT len = 0;
19811 #if defined(_WIN32) || defined(_WIN64)
19812 if (connInLen == SQL_NTS) {
19815 ci = uc_to_wmb(connIn, connInLen);
19822 setstatd(d, -1,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
19828 (SQLCHAR *) connOut, connOutMax, &len, drvcompl);
19831 if (ret == SQL_SUCCESS) {
19832 SQLWCHAR *co = NULL;
19836 #if defined(_WIN32) || defined(_WIN64)
19837 co = wmb_to_uc((
char *) connOut, len);
19842 uc_strncpy(connOut, co, connOutMax /
sizeof (SQLWCHAR));
19843 len =
min(connOutMax /
sizeof (SQLWCHAR),
uc_strlen(co));
19864 #if defined(_WIN32) || defined(_WIN64)
19875 LibMain(HANDLE hinst, DWORD reason, LPVOID reserved)
19880 case DLL_PROCESS_ATTACH:
19881 if (!initialized++) {
19888 #ifdef SQLITE_DYNLOAD
19891 #ifdef SQLITE_HAS_CODEC
19892 sqlite3_activate_see(SQLITE_ACTIVATION_KEY);
19895 #if defined(ENABLE_NVFS) && (ENABLE_NVFS)
19899 case DLL_THREAD_ATTACH:
19901 case DLL_PROCESS_DETACH:
19902 if (--initialized <= 0) {
19903 #ifdef SQLITE_DYNLOAD
19908 case DLL_THREAD_DETACH:
19925 DllMain(HANDLE hinst, DWORD reason, LPVOID reserved)
19927 return LibMain(hinst, reason, reserved);
19930 #ifndef WITHOUT_INSTALLER
19939 InUnError(
char *name)
19944 WORD errlen, errmax =
sizeof (errmsg) - 1;
19950 sqlret = SQLInstallerError(err, &code, errmsg, errmax, &errlen);
19951 if (SQL_SUCCEEDED(sqlret)) {
19952 MessageBox(NULL, errmsg, name,
19953 MB_ICONSTOP | MB_OK | MB_TASKMODAL | MB_SETFOREGROUND);
19957 }
while (sqlret != SQL_NO_DATA);
19968 InUn(
int remove,
char *cmdline)
19970 #ifdef SQLITE_HAS_CODEC
19971 static char *drivername =
"SQLite3 ODBC Driver (SEE)";
19972 static char *dsname =
"SQLite3 SEE Datasource";
19974 static char *drivername =
"SQLite3 ODBC Driver";
19975 static char *dsname =
"SQLite3 Datasource";
19978 char dllbuf[301], path[301], driver[300], attr[300], inst[400];
19979 WORD pathmax =
sizeof (path) - 1, pathlen;
19980 DWORD usecnt, mincnt;
19984 GetModuleFileName(hModule, dllbuf,
sizeof (dllbuf));
19985 p = strrchr(dllbuf,
'\\');
19986 dllname = p ? (p + 1) : dllbuf;
19987 quiet = cmdline && strstr(cmdline,
"quiet");
19988 if (SQLInstallDriverManager(path, pathmax, &pathlen)) {
19989 sprintf(driver,
"%s;Driver=%s;Setup=%s;",
19990 drivername, dllname, dllname);
20000 SQLInstallDriverEx(driver, NULL, path, pathmax, NULL,
20001 ODBC_INSTALL_INQUIRY, &usecnt);
20002 pathlen = strlen(path);
20003 while (pathlen > 0 && path[pathlen - 1] ==
'\\') {
20005 path[pathlen] =
'\0';
20007 sprintf(driver,
"%s;Driver=%s\\%s;Setup=%s\\%s;",
20008 drivername, path, dllname, path, dllname);
20016 sprintf(inst,
"%s\\%s", path, dllname);
20017 if (!
remove && usecnt > 0) {
20019 if (GetFileAttributesA(dllbuf) != INVALID_FILE_ATTRIBUTES &&
20020 CopyFile(dllbuf, inst, 0)) {
20024 sprintf(buf,
"%s replaced.", drivername);
20025 MessageBox(NULL, buf,
"Info",
20026 MB_ICONINFORMATION | MB_OK | MB_TASKMODAL |
20032 mincnt =
remove ? 1 : 0;
20033 while (usecnt != mincnt) {
20034 if (!SQLRemoveDriver(driver, TRUE, &usecnt)) {
20039 if (usecnt && !SQLRemoveDriver(driver, TRUE, &usecnt)) {
20040 InUnError(
"SQLRemoveDriver");
20048 sprintf(buf,
"%s uninstalled.", drivername);
20049 MessageBox(NULL, buf,
"Info",
20050 MB_ICONINFORMATION |MB_OK | MB_TASKMODAL |
20054 sprintf(attr,
"DSN=%s;Database=;", dsname);
20062 SQLConfigDataSource(NULL, ODBC_REMOVE_SYS_DSN, drivername, attr);
20065 if (GetFileAttributesA(dllbuf) == INVALID_FILE_ATTRIBUTES) {
20068 if (strcasecmp(dllbuf, inst) != 0 && !CopyFile(dllbuf, inst, 0)) {
20071 sprintf(buf,
"Copy %s to %s failed.", dllbuf, inst);
20072 MessageBox(NULL, buf,
"CopyFile",
20073 MB_ICONSTOP |MB_OK | MB_TASKMODAL | MB_SETFOREGROUND);
20076 if (!SQLInstallDriverEx(driver, path, path, pathmax, &pathlen,
20077 ODBC_INSTALL_COMPLETE, &usecnt)) {
20078 InUnError(
"SQLInstallDriverEx");
20081 sprintf(attr,
"DSN=%s;Database=;", dsname);
20089 SQLConfigDataSource(NULL, ODBC_REMOVE_SYS_DSN, drivername, attr);
20090 if (!SQLConfigDataSource(NULL, ODBC_ADD_SYS_DSN, drivername, attr)) {
20091 InUnError(
"SQLConfigDataSource");
20097 sprintf(buf,
"%s installed.", drivername);
20098 MessageBox(NULL, buf,
"Info",
20099 MB_ICONINFORMATION | MB_OK | MB_TASKMODAL |
20103 InUnError(
"SQLInstallDriverManager");
20118 install(HWND hwnd, HINSTANCE hinst, LPSTR lpszCmdLine,
int nCmdShow)
20120 InUn(0, lpszCmdLine);
20132 uninstall(HWND hwnd, HINSTANCE hinst, LPSTR lpszCmdLine,
int nCmdShow)
20134 InUn(1, lpszCmdLine);
20139 #ifndef WITHOUT_SHELL
20150 setargv(
int *argcp,
char ***argvp,
char *cmdline,
char *argv0)
20152 char *p, *arg, *argspace, **argv;
20153 int argc, size, inquote, copy, slashes;
20155 size = 2 + (argv0 ? 1 : 0);
20156 for (p = cmdline; *p !=
'\0'; p++) {
20167 argspace = malloc(size *
sizeof (
char *) + strlen(cmdline) + 1);
20168 argv = (
char **) argspace;
20169 argspace += size *
sizeof (
char *);
20173 argv[argc++] = argv0;
20176 for (; argc < size; argc++) {
20177 argv[argc] = arg = argspace;
20188 while (*p ==
'\\') {
20193 if ((slashes & 1) == 0) {
20195 if (inquote && p[1] ==
'"') {
20199 inquote = !inquote;
20209 if (*p ==
'\0' || (!inquote &&
ISSPACE(*p))) {
20219 argspace = arg + 1;
20235 shell(HWND hwnd, HINSTANCE hinst, LPSTR lpszCmdLine,
int nCmdShow)
20237 int argc, needcon = 0;
20239 extern int sqlite3_main(
int,
char **);
20240 static const char *name =
"SQLite3 Shell";
20241 DWORD ftype0, ftype1, ftype2;
20243 ftype0 = GetFileType(GetStdHandle(STD_INPUT_HANDLE));
20244 ftype1 = GetFileType(GetStdHandle(STD_OUTPUT_HANDLE));
20245 ftype2 = GetFileType(GetStdHandle(STD_ERROR_HANDLE));
20246 if (ftype0 != FILE_TYPE_DISK && ftype0 != FILE_TYPE_CHAR &&
20247 ftype0 != FILE_TYPE_PIPE) {
20250 ftype0 = FILE_TYPE_UNKNOWN;
20252 if (ftype1 != FILE_TYPE_DISK && ftype1 != FILE_TYPE_CHAR &&
20253 ftype1 != FILE_TYPE_PIPE) {
20256 ftype1 = FILE_TYPE_UNKNOWN;
20258 if (ftype2 != FILE_TYPE_DISK && ftype2 != FILE_TYPE_CHAR &&
20259 ftype2 != FILE_TYPE_PIPE) {
20262 ftype2 = FILE_TYPE_UNKNOWN;
20266 SetConsoleTitle(name);
20268 if (ftype0 == FILE_TYPE_UNKNOWN) {
20269 freopen(
"CONIN$",
"r", stdin);
20271 if (ftype1 == FILE_TYPE_UNKNOWN) {
20272 freopen(
"CONOUT$",
"w", stdout);
20274 if (ftype2 == FILE_TYPE_UNKNOWN) {
20275 freopen(
"CONOUT$",
"w", stderr);
20277 setargv(&argc, &argv, lpszCmdLine, (
char *) name);
20278 #if defined(ENABLE_NVFS) && (ENABLE_NVFS)
20281 sqlite3_main(argc, argv);
20288 #if defined(HAVE_ODBCINSTEXT_H) && (HAVE_ODBCINSTEXT_H)
20295 #include <odbcinstext.h>
20298 ODBCINSTGetProperties(HODBCINSTPROPERTY prop)
20300 static const char *instYN[] = {
"No",
"Yes", NULL };
20301 static const char *syncPragma[] = {
"NORMAL",
"OFF",
"FULL", NULL };
20302 static const char *jmPragma[] = {
20303 "DELETE",
"PERSIST",
"OFF",
"TRUNCATE",
"MEMORY",
"WAL", NULL
20306 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20307 prop = prop->pNext;
20308 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20309 prop->nPromptType = ODBCINST_PROMPTTYPE_FILENAME;
20310 strncpy(prop->szName,
"Database", INI_MAX_PROPERTY_NAME);
20311 strncpy(prop->szValue,
"", INI_MAX_PROPERTY_VALUE);
20312 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20313 prop = prop->pNext;
20314 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20315 prop->nPromptType = ODBCINST_PROMPTTYPE_TEXTEDIT;
20316 strncpy(prop->szName,
"Timeout", INI_MAX_PROPERTY_NAME);
20317 strncpy(prop->szValue,
"100000", INI_MAX_PROPERTY_VALUE);
20318 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20319 prop = prop->pNext;
20320 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20321 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20322 prop->aPromptData = malloc(
sizeof (instYN));
20323 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20324 strncpy(prop->szName,
"StepAPI", INI_MAX_PROPERTY_NAME);
20325 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20326 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20327 prop = prop->pNext;
20328 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20329 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20330 prop->aPromptData = malloc(
sizeof (instYN));
20331 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20332 strncpy(prop->szName,
"ShortNames", INI_MAX_PROPERTY_NAME);
20333 strncpy(prop->szValue,
"No", 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_COMBOBOX;
20338 prop->aPromptData = malloc(
sizeof (instYN));
20339 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20340 strncpy(prop->szName,
"LongNames", INI_MAX_PROPERTY_NAME);
20341 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20342 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20343 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20344 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20345 prop->aPromptData = malloc(
sizeof (instYN));
20346 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20347 strncpy(prop->szName,
"NoCreat", INI_MAX_PROPERTY_NAME);
20348 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20350 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20351 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20352 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20353 prop->aPromptData = malloc(
sizeof (instYN));
20354 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20355 strncpy(prop->szName,
"NoWCHAR", INI_MAX_PROPERTY_NAME);
20356 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20358 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20359 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20360 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20361 prop->aPromptData = malloc(
sizeof (instYN));
20362 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20363 strncpy(prop->szName,
"FKSupport", INI_MAX_PROPERTY_NAME);
20364 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20365 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20366 prop = prop->pNext;
20367 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20368 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20369 prop->aPromptData = malloc(
sizeof (syncPragma));
20370 memcpy(prop->aPromptData, syncPragma, sizeof (syncPragma));
20371 strncpy(prop->szName,
"SyncPragma", INI_MAX_PROPERTY_NAME);
20372 strncpy(prop->szValue,
"NORMAL", INI_MAX_PROPERTY_VALUE);
20373 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20374 prop = prop->pNext;
20375 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20376 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20377 prop->aPromptData = malloc(
sizeof (jmPragma));
20378 memcpy(prop->aPromptData, jmPragma, sizeof (jmPragma));
20379 strncpy(prop->szName,
"JournalMode", INI_MAX_PROPERTY_NAME);
20380 strncpy(prop->szValue,
"DELETE", INI_MAX_PROPERTY_VALUE);
20381 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20382 prop = prop->pNext;
20383 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20384 prop->nPromptType = ODBCINST_PROMPTTYPE_TEXTEDIT;
20385 strncpy(prop->szName,
"LoadExt", INI_MAX_PROPERTY_NAME);
20386 strncpy(prop->szValue,
"", INI_MAX_PROPERTY_VALUE);
20387 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20388 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20389 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20390 prop->aPromptData = malloc(
sizeof (instYN));
20391 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20392 strncpy(prop->szName,
"BigInt", INI_MAX_PROPERTY_NAME);
20393 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20399 #ifdef SQLITE_DYNLOAD
20413 return SQLITE_ERROR;
20422 static sqlite_int64
20440 static const char *
20449 return SQLITE_NULL;
20452 #define DLS_ENT(name, func) \
20453 { "sqlite3_" #name, offsetof(struct dl_sqlite3_funcs, name), \
20456 #define DLS_ENT3(name, off, func) \
20457 { "sqlite3_" #name, offsetof(struct dl_sqlite3_funcs, off), \
20460 #define DLS_END { NULL, 0, NULL }
20466 } dls_nametab[] = {
20467 DLS_ENT(activate_see, dls_void),
20468 DLS_ENT(bind_blob, dls_error),
20469 DLS_ENT(bind_double, dls_error),
20470 DLS_ENT(bind_int, dls_error),
20471 DLS_ENT(bind_int64, dls_error),
20472 DLS_ENT(bind_null, dls_error),
20473 DLS_ENT(bind_parameter_count, dls_0),
20474 DLS_ENT(bind_text, dls_error),
20476 DLS_ENT(changes, dls_0),
20477 DLS_ENT(close, dls_error),
20478 DLS_ENT(column_blob, dls_null),
20479 DLS_ENT(column_bytes, dls_0),
20480 DLS_ENT(column_count, dls_0),
20481 DLS_ENT(column_database_name, dls_empty),
20482 DLS_ENT(column_decltype, dls_empty),
20483 DLS_ENT(column_double, dls_00),
20484 DLS_ENT(column_name, dls_empty),
20485 DLS_ENT(column_origin_name, dls_null),
20486 DLS_ENT(column_table_name, dls_null),
20487 DLS_ENT(column_text, dls_null),
20488 DLS_ENT(column_type, dls_snull),
20489 DLS_ENT(create_function, dls_error),
20490 DLS_ENT(enable_load_extension, dls_error),
20491 DLS_ENT(errcode, dls_error),
20492 DLS_ENT(errmsg, dls_empty),
20493 DLS_ENT(exec, dls_error),
20494 DLS_ENT(finalize, dls_error),
20495 DLS_ENT(free, free),
20496 DLS_ENT(free_table, dls_void),
20497 DLS_ENT(get_table, dls_error),
20498 DLS_ENT(interrupt, dls_void),
20499 DLS_ENT(key, dls_error),
20500 DLS_ENT(last_insert_rowid, dls_0LL),
20501 DLS_ENT(libversion, dls_empty),
20502 DLS_ENT(load_extension, dls_error),
20503 DLS_ENT(malloc, malloc),
20504 DLS_ENT(mprintf, dls_null),
20505 DLS_ENT(open, dls_error),
20506 DLS_ENT(open16, dls_error),
20507 DLS_ENT(open_v2, dls_error),
20508 DLS_ENT(prepare, dls_error),
20509 DLS_ENT(prepare_v2, dls_error),
20510 DLS_ENT(profile, dls_null),
20511 DLS_ENT(realloc, realloc),
20512 DLS_ENT(rekey, dls_error),
20513 DLS_ENT(reset, dls_error),
20514 DLS_ENT(result_blob, dls_void),
20515 DLS_ENT(result_error, dls_void),
20516 DLS_ENT(result_int, dls_void),
20517 DLS_ENT(result_null, dls_void),
20518 DLS_ENT(step, dls_error),
20519 #if defined(_WIN32) || defined(_WIN64)
20520 DLS_ENT3(strnicmp, xstrnicmp, _strnicmp),
20522 DLS_ENT3(strnicmp, xstrnicmp, strncasecmp),
20524 DLS_ENT(table_column_metadata, dls_error),
20525 DLS_ENT(trace, dls_null),
20526 DLS_ENT(user_data, dls_null),
20527 DLS_ENT(value_blob, dls_null),
20528 DLS_ENT(value_bytes, dls_0),
20529 DLS_ENT(value_text, dls_empty),
20530 DLS_ENT(value_type, dls_snull),
20534 #if defined(_WIN32) || defined(_WIN64)
20536 static HMODULE sqlite3_dll = 0;
20542 static const char *dll_names[] = {
20543 "System.Data.SQLite.dll",
20549 while (dll_names[i]) {
20550 sqlite3_dll = LoadLibrary(dll_names[i]);
20557 while (dls_nametab[i].name) {
20558 void *func = 0, **loc;
20561 func = (
void *) GetProcAddress(sqlite3_dll, dls_nametab[i].name);
20564 func = dls_nametab[i].func;
20566 loc = (
void **) ((
char *) &dls_funcs + dls_nametab[i].offset);
20570 if (!sqlite3_dll) {
20571 char buf[MAXPATHLEN], msg[MAXPATHLEN];
20573 LoadString(hModule, IDS_DRVTITLE, buf,
sizeof (buf));
20574 LoadString(hModule, IDS_DLLERR, msg,
sizeof (msg));
20575 MessageBox(NULL, msg, buf,
20576 MB_ICONEXCLAMATION | MB_OK | MB_TASKMODAL |
20585 FreeLibrary(sqlite3_dll);
20594 static void *libsqlite3_so = 0;
20601 libsqlite3_so = dlopen(
"libsqlite3.so.0", RTLD_NOW | RTLD_GLOBAL);
20603 while (dls_nametab[i].name) {
20604 void *func = 0, **loc;
20606 if (libsqlite3_so) {
20607 func = dlsym(libsqlite3_so, dls_nametab[i].name);
20610 func = dls_nametab[i].func;
20612 loc = (
void **) ((
char *) &dls_funcs + dls_nametab[i].offset);
20616 if (!libsqlite3_so) {
20617 const char errmsg[] =
"SQLite3 shared library not found.\n";
20619 write(2, errmsg,
sizeof (errmsg) - 1);
20626 if (libsqlite3_so) {
20627 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.
void(* rowfree)()
Free function for rows.
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.
static int TOLOWER(int c)
static SQLRETURN drvgetconnectattr(SQLHDBC dbc, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER bufmax, SQLINTEGER *buflen)
Internal get connect attribute of HDBC.
STMT * s
Driver statement pointer.
static COL colSpec2[]
Columns for result set of SQLColumns().
int ncol
number of columns in result array
int scale
from SQLBindParameter()
COL * dyncols
Column array, but malloc()ed.
int dobigint
Force SQL_BIGINT for INTEGER columns.
SQLRETURN SQL_API SQLBindParameter(SQLHSTMT stmt, SQLUSMALLINT pnum, SQLSMALLINT iotype, SQLSMALLINT buftype, SQLSMALLINT ptype, SQLULEN coldef, SQLSMALLINT scale, SQLPOINTER data, SQLLEN buflen, SQLLEN *len)
Bind parameter on HSTMT.
int index
Index of column in result.
int bkmrk
True when bookmarks used.
SQLULEN * parm_proc
SQL_ATTR_PARAMS_PROCESSED_PTR.
SQLULEN * bind_offs
SQL_ATTR_ROW_BIND_OFFSET_PTR.
static SQLRETURN getrowdata(STMT *s, SQLUSMALLINT col, SQLSMALLINT otype, SQLPOINTER val, SQLINTEGER len, SQLLEN *lenp, int partial)
Internal function to retrieve row data, used by SQLFetch() and friends and SQLGetData().
static SQLRETURN setposrefr(STMT *s, int rsi)
Internal handler to refresh user buffers from driver side result set.
static int dserr(dstr *dsp)
Check error on dynamic string.
static SQLRETURN drvconnect(SQLHDBC dbc, SQLCHAR *dsn, SQLSMALLINT dsnLen, char *pwd, int pwdLen, int isu)
Internal connect to SQLite database.
static void convJD2YMD(double jd, DATE_STRUCT *ds)
Convert julian day to year/month/day.
static dstr * dsappendq(dstr *dsp, const char *str)
Append string quoted to dynamic string.
SQLRETURN SQL_API SQLSetParam(SQLHSTMT stmt, SQLUSMALLINT par, SQLSMALLINT type, SQLSMALLINT sqltype, SQLULEN coldef, SQLSMALLINT scale, SQLPOINTER val, SQLLEN *nval)
Set information on parameter.
static COL colPrivSpec2[]
Columns for result set of SQLColumnPrivileges().
static SQLRETURN drvunimplstmt(HSTMT stmt)
Report IM001 (not implemented) SQL error code for HSTMT.
SQLRETURN SQL_API SQLSetEnvAttr(SQLHENV env, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER len)
Set information in HENV.
static char * s3stmt_coltype(sqlite3_stmt *s3stmt, int col, DBC *d, int *guessed_types)
Find out column type.
SQLRETURN SQL_API SQLDataSourcesW(SQLHENV env, SQLUSMALLINT dir, SQLWCHAR *srvname, SQLSMALLINT buflen1, SQLSMALLINT *lenp1, SQLWCHAR *desc, SQLSMALLINT buflen2, SQLSMALLINT *lenp2)
Function not implemented.
BINDCOL * bindcols
Array of bound columns.
int rowp
Current result row.
SQLRETURN SQL_API SQLGetDescFieldW(SQLHDESC handle, SQLSMALLINT recno, SQLSMALLINT fieldid, SQLPOINTER value, SQLINTEGER buflen, SQLINTEGER *strlen)
Function not implemented.
int ov3val
True for SQL_OV_ODBC3.
int scale
Scale of column.
static void dsfree(dstr *dsp)
Free dynamic string.
SQLRETURN SQL_API SQLAllocConnect(SQLHENV env, SQLHDBC *dbc)
Allocate HDBC.
static SQLRETURN freestmt(HSTMT stmt)
char * typename
Column type name or NULL.
SQLUSMALLINT * parm_status
SQL_ATTR_PARAMS_STATUS_PTR.
static SQLRETURN s3stmt_start(STMT *s)
Start sqlite statement for execution of SELECT statement.
int jdconv
True for julian day conversion.
int has_rowid
Flag for ROWID (>= 0 or -1)
BINDCOL bkmrkcol
Bookmark bound column.
SQLULEN rowset_size
Size of rowset.
static SQLRETURN drvstatistics(SQLHSTMT stmt, SQLCHAR *cat, SQLSMALLINT catLen, SQLCHAR *schema, SQLSMALLINT schemaLen, SQLCHAR *table, SQLSMALLINT tableLen, SQLUSMALLINT itype, SQLUSMALLINT resv)
Internal return statistic information on table indices.
static SQLRETURN drvcolattributes(SQLHSTMT stmt, SQLUSMALLINT col, SQLUSMALLINT id, SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen, SQLLEN *val2)
Internal retrieve column attributes.
SQLRETURN SQL_API SQLNumParams(SQLHSTMT stmt, SQLSMALLINT *nparam)
Return number of parameters.
char strbuf[64]
String buffer for scalar data.
int oemcp
True for Win32 OEM CP translation.
SQLRETURN SQL_API SQLGetTypeInfoW(SQLHSTMT stmt, SQLSMALLINT sqltype)
Return data type information (UNICODE version).
static SQLRETURN drvendtran(SQLSMALLINT type, SQLHANDLE handle, SQLSMALLINT comptype)
Internal commit or rollback transaction.
char * bincell
Cache for blob data.
int nparams
Number of parameters in query.
static void setstat(STMT *s, int naterr, char *msg, char *st,...)
Set error message and SQL state on statement.
int stype
ODBC and SQL types.
Internal structure for bound parameter (SQLBindParameter).
static void s3stmt_drop(STMT *s)
Drop running sqlite statement in STMT.
int nbindparms
Number bound parameters.
static COL typeSpec2[]
Columns for result set of SQLGetTypeInfo().
SQLRETURN SQL_API SQLBindCol(SQLHSTMT stmt, SQLUSMALLINT col, SQLSMALLINT type, SQLPOINTER val, SQLLEN max, SQLLEN *lenp)
Bind C variable to column of result set.
Internal structure to describe a column in a result set.
char * errmsg
error message or NULL
SQLRETURN SQL_API SQLAllocStmt(SQLHDBC dbc, SQLHSTMT *stmt)
Allocate HSTMT given HDBC.
int has_pk
Flag for primary key (> 0)
static SQLRETURN drvgetstmtattr(SQLHSTMT stmt, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER bufmax, SQLINTEGER *buflen)
Internal get option of HSTMT.
static SQLRETURN dbopen(DBC *d, char *name, int isu, char *dsn, char *sflag, char *spflag, char *ntflag, char *jmode, char *busy)
Open SQLite database file given file name and flags.
static int uc_strlen(SQLWCHAR *str)
Return length of UNICODE string.
int offs
Byte offset for SQLGetData()
SQLULEN paramset_count
Internal for paramset.
int pdcount
SQLParamData() counter.
struct stmt * stmt
STMT list of this DBC.
#define HDBC_UNLOCK(hdbc)
static SQLRETURN drvdescribecol(SQLHSTMT stmt, SQLUSMALLINT col, SQLCHAR *name, SQLSMALLINT nameMax, SQLSMALLINT *nameLen, SQLSMALLINT *type, SQLULEN *size, SQLSMALLINT *digits, SQLSMALLINT *nullable)
Internal describe column information.
static char * unquote(char *str)
Strip quotes from quoted string in-place.
static SQLRETURN drvbindcol(SQLHSTMT stmt, SQLUSMALLINT col, SQLSMALLINT type, SQLPOINTER val, SQLLEN max, SQLLEN *lenp)
Internal bind C variable to column of result set.
SQLRETURN SQL_API SQLAllocHandle(SQLSMALLINT type, SQLHANDLE input, SQLHANDLE *output)
Allocate a HENV, HDBC, or HSTMT handle.
SQLRETURN SQL_API SQLColumnPrivilegesW(SQLHSTMT stmt, SQLWCHAR *catalog, SQLSMALLINT catalogLen, SQLWCHAR *schema, SQLSMALLINT schemaLen, SQLWCHAR *table, SQLSMALLINT tableLen, SQLWCHAR *column, SQLSMALLINT columnLen)
Retrieve privileges on columns (UNICODE version).
static void convJD2HMS(double jd, TIME_STRUCT *ts, int *fp)
Convert julian day to hour/minute/second.
char ** resarr
result array
#define verinfo(maj, min, lev)
int s3stmt_noreset
False when sqlite3_reset() needed.
static void dbtracerc(DBC *d, int rc, char *err)
Trace function for SQLite return codes.
int trans_disable
True for no transaction support.
static SQLRETURN drvspecialcolumns(SQLHSTMT stmt, SQLUSMALLINT id, SQLCHAR *cat, SQLSMALLINT catLen, SQLCHAR *schema, SQLSMALLINT schemaLen, SQLCHAR *table, SQLSMALLINT tableLen, SQLUSMALLINT scope, SQLUSMALLINT nullable)
Internal retrieve information about indexed columns.
static const char * dsval(dstr *dsp)
Return dynamic string's value.
int dcols
Number of entries in dyncols.
static SQLRETURN drvbindparam(SQLHSTMT stmt, SQLUSMALLINT pnum, SQLSMALLINT iotype, SQLSMALLINT buftype, SQLSMALLINT ptype, SQLUINTEGER coldef, SQLSMALLINT scale, SQLPOINTER data, SQLINTEGER buflen, SQLLEN *len)
Internal bind parameter on HSTMT.
SQLRETURN SQL_API SQLProceduresW(SQLHSTMT stmt, SQLWCHAR *catalog, SQLSMALLINT catalogLen, SQLWCHAR *schema, SQLSMALLINT schemaLen, SQLWCHAR *proc, SQLSMALLINT procLen)
Retrieve information about stored procedures (UNICODE version).
static char * fixupsql(char *sql, int sqlLen, int cte, int *nparam, int *isselect, char **errmsg)
Fixup query string with optional parameter markers.
SQLRETURN SQL_API SQLParamOptions(SQLHSTMT stmt, SQLULEN rows, SQLULEN *rowp)
Function not implemented.
int naterr
Native error code.
int len
Offset/length for SQLParamData()/SQLPutData()
static SQLRETURN drvgetdiagrec(SQLSMALLINT htype, SQLHANDLE handle, SQLSMALLINT recno, SQLCHAR *sqlstate, SQLINTEGER *nativeerr, SQLCHAR *msg, SQLSMALLINT buflen, SQLSMALLINT *msglen)
Internal get error message given handle (HENV, HDBC, or HSTMT).
Header file for SQLite3 ODBC driver.
int max
Maximum length of buffer.
static int unescpat(char *str)
Unescape search pattern for e.g.