14 #if defined(SQLITE_HAS_CODEC) && defined(SQLITE_API)
15 #undef WITH_SQLITE_DLLS
20 #if defined(WITH_SQLITE_DLLS) && (WITH_SQLITE_DLLS > 1)
21 #define SQLITE_DYNLOAD 1
22 #undef HAVE_SQLITE3CLOSEV2
31 #if defined(_WIN32) || defined(_WIN64)
32 static void dls_init(
void);
33 static void dls_fini(
void);
39 static struct dl_sqlite3_funcs {
40 void (*activate_see)(
const char *p0);
41 int (*bind_blob)(sqlite3_stmt *p0,
int p1,
const void *p2,
int p3,
43 int (*bind_double)(sqlite3_stmt *p0,
int p1,
double p2);
44 int (*bind_int)(sqlite3_stmt *p0,
int p1,
int p2);
45 int (*bind_int64)(sqlite3_stmt *p0,
int p1, sqlite_int64 p2);
46 int (*bind_null)(sqlite3_stmt *p0,
int p1);
47 int (*bind_parameter_count)(sqlite3_stmt *p0);
48 int (*bind_text)(sqlite3_stmt *p0,
int p1,
const char *p2,
int p3,
50 int (*
busy_handler)(sqlite3 *p0, int (*p2)(
void *, int),
void *p3);
51 int (*changes)(sqlite3 *p0);
52 int (*close)(sqlite3 *p0);
53 const void * (*column_blob)(sqlite3_stmt *p0,
int p1);
54 int (*column_bytes)(sqlite3_stmt *p0,
int p1);
55 int (*column_count)(sqlite3_stmt *p0);
56 const char * (*column_database_name)(sqlite3_stmt *p0,
int p1);
57 const char * (*column_decltype)(sqlite3_stmt *p0,
int p1);
58 double (*column_double)(sqlite3_stmt *p0,
int p1);
59 const char * (*column_name)(sqlite3_stmt *p0,
int p1);
60 const char * (*column_origin_name)(sqlite3_stmt *p0,
int p1);
61 const char * (*column_table_name)(sqlite3_stmt *p0,
int p1);
62 const unsigned char * (*column_text)(sqlite3_stmt *p0,
int p1);
63 int (*column_type)(sqlite3_stmt *p0,
int p1);
64 int (*create_function)(sqlite3 *p0,
const char *p1,
int p2,
int p3,
66 void (*p5)(sqlite3_context *, int, sqlite3_value **),
67 void (*p6)(sqlite3_context *, int, sqlite3_value **),
68 void (*p7)(sqlite3_context *));
69 int (*enable_load_extension)(sqlite3 *p0,
int p1);
70 int (*errcode)(sqlite3 *p0);
71 const char * (*errmsg)(sqlite3 *p0);
72 int (*exec)(sqlite3 *p0,
const char *p1,
73 int (*p2)(
void *, int,
char **,
char **),
75 int (*finalize)(sqlite3_stmt *p0);
76 void (*free)(
void *p0);
77 void (*free_table)(
char **p0);
78 int (*get_table)(sqlite3 *p0,
const char *p1,
char ***p2,
79 int *p3,
int *p4,
char **p5);
80 void (*interrupt)(sqlite3 *p0);
81 int (*key)(sqlite3 *p0,
const void *p1,
int p2);
82 sqlite_int64 (*last_insert_rowid)(sqlite3 *p0);
83 const char * (*libversion)(void);
84 int (*load_extension)(sqlite3 *p0,
const char *p1,
const char *p2,
86 void * (*malloc)(
int p0);
87 char * (*mprintf)(
const char *p0, ...);
88 int (*open)(
const char *p0, sqlite3 **p1);
89 int (*open16)(
const void *p0, sqlite3 **p1);
90 int (*open_v2)(
const char *p0, sqlite3 **p1,
int p2,
const char *p3);
91 int (*prepare)(sqlite3 *p0,
const char *p1,
int p2, sqlite3_stmt **p3,
93 int (*prepare_v2)(sqlite3 *p0,
const char *p1,
int p2, sqlite3_stmt **p3,
95 void * (*profile)(sqlite3 *p0,
96 void (*p1)(
void *,
const char *, sqlite3_uint64),
98 void * (*realloc)(
void *p0,
int p1);
99 int (*rekey)(sqlite3 *p0,
const void *p1,
int p2);
100 int (*reset)(sqlite3_stmt *p0);
101 void (*result_blob)(sqlite3_context *p0,
const void *p1,
102 int p2, void (*p3)(
void *));
103 void (*result_error)(sqlite3_context *p0,
const char *p1,
int p2);
104 void (*result_int)(sqlite3_context *p0,
int p1);
105 void (*result_null)(sqlite3_context *p0);
106 int (*step)(sqlite3_stmt *p0);
107 int (*xstrnicmp)(
const char *p0,
const char *p1,
int p2);
108 int (*table_column_metadata)(sqlite3 *p0,
const char *p1,
109 const char *p2,
const char *p3,
110 char const **p4,
char const **p5,
111 int *p6,
int *p7,
int *p8);
112 void * (*trace)(sqlite3 *p0, void (*p1)(
void *,
const char *),
void *p2);
113 void * (*user_data)(sqlite3_context *p0);
114 const void * (*value_blob)(sqlite3_value *p0);
115 int (*value_bytes)(sqlite3_value *p0);
116 const unsigned char * (*value_text)(sqlite3_value *p0);
117 int (*value_type)(sqlite3_value *p0);
120 #define sqlite3_activate_see dls_funcs.activate_see
121 #define sqlite3_bind_blob dls_funcs.bind_blob
122 #define sqlite3_bind_double dls_funcs.bind_double
123 #define sqlite3_bind_int dls_funcs.bind_int
124 #define sqlite3_bind_int64 dls_funcs.bind_int64
125 #define sqlite3_bind_null dls_funcs.bind_null
126 #define sqlite3_bind_parameter_count dls_funcs.bind_parameter_count
127 #define sqlite3_bind_text dls_funcs.bind_text
128 #define sqlite3_busy_handler dls_funcs.busy_handler
129 #define sqlite3_changes dls_funcs.changes
130 #define sqlite3_close dls_funcs.close
131 #define sqlite3_column_blob dls_funcs.column_blob
132 #define sqlite3_column_bytes dls_funcs.column_bytes
133 #define sqlite3_column_count dls_funcs.column_count
134 #define sqlite3_column_database_name dls_funcs.column_database_name
135 #define sqlite3_column_decltype dls_funcs.column_decltype
136 #define sqlite3_column_double dls_funcs.column_double
137 #define sqlite3_column_name dls_funcs.column_name
138 #define sqlite3_column_origin_name dls_funcs.column_origin_name
139 #define sqlite3_column_table_name dls_funcs.column_table_name
140 #define sqlite3_column_text dls_funcs.column_text
141 #define sqlite3_column_type dls_funcs.column_type
142 #define sqlite3_create_function dls_funcs.create_function
143 #define sqlite3_enable_load_extension dls_funcs.enable_load_extension
144 #define sqlite3_errcode dls_funcs.errcode
145 #define sqlite3_errmsg dls_funcs.errmsg
146 #define sqlite3_exec dls_funcs.exec
147 #define sqlite3_finalize dls_funcs.finalize
148 #define sqlite3_free dls_funcs.free
149 #define sqlite3_free_table dls_funcs.free_table
150 #define sqlite3_get_table dls_funcs.get_table
151 #define sqlite3_interrupt dls_funcs.interrupt
152 #define sqlite3_key dls_funcs.key
153 #define sqlite3_last_insert_rowid dls_funcs.last_insert_rowid
154 #define sqlite3_libversion dls_funcs.libversion
155 #define sqlite3_load_extension dls_funcs.load_extension
156 #define sqlite3_malloc dls_funcs.malloc
157 #define sqlite3_mprintf dls_funcs.mprintf
158 #define sqlite3_open dls_funcs.open
159 #define sqlite3_open16 dls_funcs.open16
160 #define sqlite3_open_v2 dls_funcs.open_v2
161 #define sqlite3_prepare dls_funcs.prepare
162 #define sqlite3_prepare_v2 dls_funcs.prepare_v2
163 #define sqlite3_profile dls_funcs.profile
164 #define sqlite3_realloc dls_funcs.realloc
165 #define sqlite3_rekey dls_funcs.rekey
166 #define sqlite3_reset dls_funcs.reset
167 #define sqlite3_result_blob dls_funcs.result_blob
168 #define sqlite3_result_error dls_funcs.result_error
169 #define sqlite3_result_int dls_funcs.result_int
170 #define sqlite3_result_null dls_funcs.result_null
171 #define sqlite3_step dls_funcs.step
172 #define sqlite3_strnicmp dls_funcs.xstrnicmp
173 #define sqlite3_table_column_metadata dls_funcs.table_column_metadata
174 #define sqlite3_trace dls_funcs.trace
175 #define sqlite3_user_data dls_funcs.user_data
176 #define sqlite3_value_blob dls_funcs.value_blob
177 #define sqlite3_value_bytes dls_funcs.value_bytes
178 #define sqlite3_value_text dls_funcs.value_text
179 #define sqlite3_value_type dls_funcs.value_type
183 #ifndef WITHOUT_WINTERFACE
188 #if !defined(_WIN32) && !defined(_WIN64)
189 #if !defined(WCHARSUPPORT) && defined(HAVE_SQLWCHAR) && (HAVE_SQLWCHAR)
194 #if defined(WINTERFACE)
195 #include <sqlucode.h>
198 #if defined(_WIN32) || defined(_WIN64)
199 #include "resource3.h"
200 #define ODBC_INI "ODBC.INI"
201 #ifndef DRIVER_VER_INFO
202 #define DRIVER_VER_INFO VERSION
205 #define ODBC_INI ".odbc.ini"
208 #ifndef DRIVER_VER_INFO
209 #define DRIVER_VER_INFO "0.0"
212 #ifndef COLATTRIBUTE_LAST_ARG_TYPE
214 #define COLATTRIBUTE_LAST_ARG_TYPE SQLLEN *
216 #define COLATTRIBUTE_LAST_ARG_TYPE SQLPOINTER
220 #ifndef SETSTMTOPTION_LAST_ARG_TYPE
221 #define SETSTMTOPTION_LAST_ARG_TYPE SQLROWCOUNT
225 #define min(a, b) ((a) < (b) ? (a) : (b))
227 #define max(a, b) ((a) < (b) ? (b) : (a))
230 #define PTRDIFF_T int
233 #define array_size(x) (sizeof (x) / sizeof (x[0]))
235 #define stringify1(s) #s
236 #define stringify(s) stringify1(s)
238 #define verinfo(maj, min, lev) ((maj) << 16 | (min) << 8 | (lev))
242 #if defined(HAVE_SQLITE3TABLECOLUMNMETADATA) && (HAVE_SQLITE3TABLECOLUMNMETADATA)
243 #if defined(HAVE_SQLITE3COLUMNDATABASENAME) && (HAVE_SQLITE3COLUMNDATABASENAME)
244 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME)
245 #if defined(HAVE_SQLITE3COLUMNORIGINNAME) && (HAVE_SQLITE3COLUMNORIGINNAME)
246 #define FULL_METADATA 1
254 #if defined(WINTERFACE) && !defined(_WIN32) && !defined(_WIN64)
255 #define SCOL_VARCHAR SQL_WVARCHAR
256 #define SCOL_CHAR SQL_WCHAR
258 #define SCOL_VARCHAR SQL_VARCHAR
259 #define SCOL_CHAR SQL_CHAR
262 #define ENV_MAGIC 0x53544145
263 #define DBC_MAGIC 0x53544144
264 #define DEAD_MAGIC 0xdeadbeef
279 static const char *
xdigits =
"0123456789ABCDEFabcdef";
284 xmalloc_(
int n,
char *file,
int line)
286 int nn = n + 4 *
sizeof (long);
291 #if (MEMORY_DEBUG > 1)
292 fprintf(stderr,
"malloc\t%d\tNULL\t%s:%d\n", n, file, line);
297 nn = nn /
sizeof (long) - 1;
300 #if (MEMORY_DEBUG > 1)
301 fprintf(stderr,
"malloc\t%d\t%p\t%s:%d\n", n, &p[2], file, line);
303 return (
void *) &p[2];
307 xrealloc_(
void *old,
int n,
char *file,
int line)
309 int nn = n + 4 *
sizeof (long), nnn;
312 if (n == 0 || !old) {
313 return xmalloc_(n, file, line);
315 p = &((
long *) old)[-2];
316 if (p[0] != 0xdead1234) {
317 fprintf(stderr,
"*** low end corruption @ %p\n", old);
320 nnn = p[1] + 4 *
sizeof (long);
321 nnn = nnn /
sizeof (long) - 1;
322 if (p[nnn] != 0xdead5678) {
323 fprintf(stderr,
"*** high end corruption @ %p\n", old);
328 #if (MEMORY_DEBUG > 1)
329 fprintf(stderr,
"realloc\t%p,%d\tNULL\t%s:%d\n", old, n, file, line);
333 #if (MEMORY_DEBUG > 1)
334 fprintf(stderr,
"realloc\t%p,%d\t%p\t%s:%d\n", old, n, &pp[2], file, line);
338 nn = nn /
sizeof (long) - 1;
340 return (
void *) &p[2];
344 xfree_(
void *x,
char *file,
int line)
352 p = &((
long *) x)[-2];
353 if (p[0] != 0xdead1234) {
354 fprintf(stderr,
"*** low end corruption @ %p\n", x);
357 n = p[1] + 4 *
sizeof (long);
358 n = n /
sizeof (long) - 1;
359 if (p[n] != 0xdead5678) {
360 fprintf(stderr,
"*** high end corruption @ %p\n", x);
363 #if (MEMORY_DEBUG > 1)
364 fprintf(stderr,
"free\t%p\t\t%s:%d\n", x, file, line);
372 xfree_(x,
"unknown location", 0);
376 xstrdup_(
const char *str,
char *file,
int line)
381 #if (MEMORY_DEBUG > 1)
382 fprintf(stderr,
"strdup\tNULL\tNULL\t%s:%d\n", file, line);
386 p = xmalloc_(strlen(str) + 1, file, line);
390 #if (MEMORY_DEBUG > 1)
391 fprintf(stderr,
"strdup\t%p\t%p\t%s:%d\n", str, p, file, line);
396 #define xmalloc(x) xmalloc_(x, __FILE__, __LINE__)
397 #define xrealloc(x,y) xrealloc_(x, y, __FILE__, __LINE__)
398 #define xfree(x) xfree_(x, __FILE__, __LINE__)
399 #define xstrdup(x) xstrdup_(x, __FILE__, __LINE__)
403 #define xmalloc(x) sqlite3_malloc(x)
404 #define xrealloc(x,y) sqlite3_realloc(x, y)
405 #define xfree(x) sqlite3_free(x)
406 #define xstrdup(x) strdup_(x)
410 #if defined(_WIN32) || defined(_WIN64)
412 #define vsnprintf _vsnprintf
413 #define snprintf _snprintf
414 #define strcasecmp _stricmp
415 #define strncasecmp _strnicmp
418 #define strtoll _strtoi64
419 #define strtoull _strtoui64
422 static HINSTANCE NEAR hModule;
426 #ifdef HAVE_SQLITE3STRNICMP
428 #define strncasecmp(A,B,C) sqlite3_strnicmp(A,B,C)
430 #define strcasecmp(A,B) strcasecmp_(A,B)
432 #if defined(__GNUC__) && (__GNUC__ >= 2)
433 static int strcasecmp_(
const char *a,
const char *b)
434 __attribute__((__unused__));
437 static int strcasecmp_(
const char *a,
const char *b)
439 int c = strlen(a), d = strlen(b);
442 return strncasecmp(a, b, c);
444 return strncasecmp(a, b, d);
448 #if defined(_WIN32) || defined(_WIN64)
456 #define HDBC_LOCK(hdbc) \
460 if ((hdbc) == SQL_NULL_HDBC) { \
461 return SQL_INVALID_HANDLE; \
463 d = (DBC *) (hdbc); \
464 if (d->magic != DBC_MAGIC) { \
465 return SQL_INVALID_HANDLE; \
467 EnterCriticalSection(&d->cs); \
468 d->owner = GetCurrentThreadId(); \
471 #define HDBC_UNLOCK(hdbc) \
472 if ((hdbc) != SQL_NULL_HDBC) { \
475 d = (DBC *) (hdbc); \
476 if (d->magic == DBC_MAGIC) { \
478 LeaveCriticalSection(&d->cs); \
482 #define HSTMT_LOCK(hstmt) \
486 if ((hstmt) == SQL_NULL_HSTMT) { \
487 return SQL_INVALID_HANDLE; \
489 d = (DBC *) ((STMT *) (hstmt))->dbc; \
490 if (d->magic != DBC_MAGIC) { \
491 return SQL_INVALID_HANDLE; \
493 EnterCriticalSection(&d->cs); \
494 d->owner = GetCurrentThreadId(); \
497 #define HSTMT_UNLOCK(hstmt) \
498 if ((hstmt) != SQL_NULL_HSTMT) { \
501 d = (DBC *) ((STMT *) (hstmt))->dbc; \
502 if (d->magic == DBC_MAGIC) { \
504 LeaveCriticalSection(&d->cs); \
530 #define HDBC_LOCK(hdbc)
531 #define HDBC_UNLOCK(hdbc)
532 #define HSTMT_LOCK(hdbc)
533 #define HSTMT_UNLOCK(hdbc)
537 #if defined(ENABLE_NVFS) && (ENABLE_NVFS)
538 extern void nvfs_init(
void);
539 extern const char *nvfs_makevfs(
const char *);
569 ((c) && strchr(digit_chars, (c)) != NULL)
578 ((c) && strchr(space_chars, (c)) != NULL)
599 static SQLRETURN
getrowdata(
STMT *s, SQLUSMALLINT col, SQLSMALLINT otype,
600 SQLPOINTER val, SQLINTEGER len,
SQLLEN *lenp,
603 #if (defined(_WIN32) || defined(_WIN64)) && defined(WINTERFACE)
605 static COL *statSpec2P, *statSpec3P;
608 #if (MEMORY_DEBUG < 1)
663 if (dsp->
len + len > dsp->
max) {
664 int max = dsp->
max + len + 256;
668 strcpy(dsp->
buffer,
"OUT OF MEMORY");
700 for (p = str; *p; ++p) {
723 if (dsp->
len + len > dsp->
max) {
724 int max = dsp->
max + len + 256;
728 strcpy(dsp->
buffer,
"OUT OF MEMORY");
739 for (p = str; *p; ++p) {
761 return (
const char *) dsp->
buffer;
775 return !dsp || dsp->
oom;
850 ucLen = ucLen /
sizeof (SQLWCHAR);
851 if (!uc || ucLen < 0) {
861 while (i < len && *str && i < ucLen) {
862 unsigned char c = str[0];
867 }
else if (c <= 0xc1 || c >= 0xf5) {
870 }
else if (c < 0xe0) {
871 if ((str[1] & 0xc0) == 0x80) {
872 unsigned long t = ((c & 0x1f) << 6) | (str[1] & 0x3f);
880 }
else if (c < 0xf0) {
881 if ((str[1] & 0xc0) == 0x80 && (str[2] & 0xc0) == 0x80) {
882 unsigned long t = ((c & 0x0f) << 12) |
883 ((str[1] & 0x3f) << 6) | (str[2] & 0x3f);
891 }
else if (c < 0xf8) {
892 if ((str[1] & 0xc0) == 0x80 && (str[2] & 0xc0) == 0x80 &&
893 (str[3] & 0xc0) == 0x80) {
894 unsigned long t = ((c & 0x03) << 18) |
895 ((str[1] & 0x3f) << 12) | ((str[2] & 0x3f) << 6) |
898 if (
sizeof (SQLWCHAR) == 2 *
sizeof (char) &&
901 uc[i++] = 0xd800 | ((t >> 10) & 0x3ff);
905 t = 0xdc00 | (t & 0x3ff);
938 if (len == SQL_NTS) {
939 len = strlen((
char *) str);
941 ucLen =
sizeof (SQLWCHAR) * (len + 1);
961 char *cp, *ret = NULL;
966 if (len == SQL_NTS) {
969 len = len /
sizeof (SQLWCHAR);
976 for (i = 0; i < len; i++) {
977 unsigned long c = str[i];
979 if (
sizeof (SQLWCHAR) == 2 *
sizeof (
char)) {
984 }
else if (c < 0x800) {
985 *cp++ = 0xc0 | ((c >> 6) & 0x1f);
986 *cp++ = 0x80 | (c & 0x3f);
987 }
else if (c < 0x10000) {
988 if (
sizeof (SQLWCHAR) == 2 *
sizeof (char) &&
989 c >= 0xd800 && c <= 0xdbff && i + 1 < len) {
990 unsigned long c2 = str[i + 1] & 0xffff;
992 if (c2 >= 0xdc00 && c2 <= 0xdfff) {
993 c = (((c & 0x3ff) << 10) | (c2 & 0x3ff)) + 0x10000;
994 *cp++ = 0xf0 | ((c >> 18) & 0x07);
995 *cp++ = 0x80 | ((c >> 12) & 0x3f);
996 *cp++ = 0x80 | ((c >> 6) & 0x3f);
997 *cp++ = 0x80 | (c & 0x3f);
1002 *cp++ = 0xe0 | ((c >> 12) & 0x0f);
1003 *cp++ = 0x80 | ((c >> 6) & 0x3f);
1004 *cp++ = 0x80 | (c & 0x3f);
1005 }
else if (c <= 0x10ffff) {
1006 *cp++ = 0xf0 | ((c >> 18) & 0x07);
1007 *cp++ = 0x80 | ((c >> 12) & 0x3f);
1008 *cp++ = 0x80 | ((c >> 6) & 0x3f);
1009 *cp++ = 0x80 | (c & 0x3f);
1030 if (len != SQL_NTS) {
1031 len = len *
sizeof (SQLWCHAR);
1038 #if defined(WCHARSUPPORT) || defined(_WIN32) || defined(_WIN64)
1055 #if defined(_WIN32) || defined(_WIN64)
1065 wmb_to_utf(
char *str,
int len)
1069 int nchar, is2k, cp = CP_OEMCP;
1071 ovi.dwOSVersionInfoSize =
sizeof (ovi);
1073 is2k = ovi.dwPlatformId == VER_PLATFORM_WIN32_NT && ovi.dwMajorVersion > 4;
1074 if (AreFileApisANSI()) {
1075 cp = is2k ? CP_THREAD_ACP : CP_ACP;
1077 nchar = MultiByteToWideChar(cp, 0, str, len, NULL, 0);
1078 wstr =
xmalloc((nchar + 1) *
sizeof (WCHAR));
1083 nchar = MultiByteToWideChar(cp, 0, str, len, wstr, nchar);
1085 str =
xmalloc((nchar + 1) * 7);
1091 nchar = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, str, nchar * 7, 0, 0);
1107 wmb_to_utf_c(
char *str,
int len)
1109 if (len == SQL_NTS) {
1112 return wmb_to_utf(str, len);
1125 utf_to_wmb(
char *str,
int len)
1129 int nchar, is2k, cp = CP_OEMCP;
1131 ovi.dwOSVersionInfoSize =
sizeof (ovi);
1133 is2k = ovi.dwPlatformId == VER_PLATFORM_WIN32_NT && ovi.dwMajorVersion > 4;
1134 if (AreFileApisANSI()) {
1135 cp = is2k ? CP_THREAD_ACP : CP_ACP;
1137 nchar = MultiByteToWideChar(CP_UTF8, 0, str, len, NULL, 0);
1138 wstr =
xmalloc((nchar + 1) *
sizeof (WCHAR));
1143 nchar = MultiByteToWideChar(CP_UTF8, 0, str, len, wstr, nchar);
1145 str =
xmalloc((nchar + 1) * 7);
1151 nchar = WideCharToMultiByte(cp, 0, wstr, -1, str, nchar * 7, 0, 0);
1167 wmb_to_uc(
char *str,
int len)
1171 int nchar, is2k, cp = CP_OEMCP;
1173 ovi.dwOSVersionInfoSize =
sizeof (ovi);
1175 is2k = ovi.dwPlatformId == VER_PLATFORM_WIN32_NT && ovi.dwMajorVersion > 4;
1176 if (AreFileApisANSI()) {
1177 cp = is2k ? CP_THREAD_ACP : CP_ACP;
1179 nchar = MultiByteToWideChar(cp, 0, str, len, NULL, 0);
1180 wstr =
xmalloc((nchar + 1) *
sizeof (WCHAR));
1185 nchar = MultiByteToWideChar(cp, 0, str, len, wstr, nchar);
1198 uc_to_wmb(WCHAR *wstr,
int len)
1202 int nchar, is2k, cp = CP_OEMCP;
1204 ovi.dwOSVersionInfoSize =
sizeof (ovi);
1206 is2k = ovi.dwPlatformId == VER_PLATFORM_WIN32_NT && ovi.dwMajorVersion > 4;
1207 if (AreFileApisANSI()) {
1208 cp = is2k ? CP_THREAD_ACP : CP_ACP;
1210 nchar = WideCharToMultiByte(cp, 0, wstr, len, NULL, 0, 0, 0);
1211 str =
xmalloc((nchar + 1) * 2);
1216 nchar = WideCharToMultiByte(cp, 0, wstr, len, str, nchar * 2, 0, 0);
1226 #ifdef USE_DLOPEN_FOR_GPPS
1230 #define SQLGetPrivateProfileString(A,B,C,D,E,F) drvgpps(d,A,B,C,D,E,F)
1245 lib = dlopen(
"libodbcinst.so.2", RTLD_LAZY);
1247 lib = dlopen(
"libodbcinst.so.1", RTLD_LAZY);
1250 lib = dlopen(
"libodbcinst.so", RTLD_LAZY);
1253 lib = dlopen(
"libiodbcinst.so.2", RTLD_LAZY);
1256 lib = dlopen(
"libiodbcinst.so", RTLD_LAZY);
1259 gpps = (int (*)()) dlsym(lib,
"SQLGetPrivateProfileString");
1273 dlclose(d->instlib);
1279 drvgpps(
DBC *d,
char *sect,
char *ent,
char *def,
char *buf,
1280 int bufsiz,
char *fname)
1283 return d->gpps(sect, ent, def, buf, bufsiz, fname);
1285 strncpy(buf, def, bufsiz);
1286 buf[bufsiz - 1] =
'\0';
1290 #include <odbcinst.h>
1291 #define drvgetgpps(d)
1292 #define drvrelgpps(d)
1304 if (
stmt && p && nparams > 0) {
1305 for (i = 0; i < nparams; i++, p++) {
1309 sqlite3_bind_null(
stmt, i + 1);
1311 fprintf(d->
trace,
"-- parameter %d: NULL\n", i + 1);
1319 fprintf(d->
trace,
"-- parameter %d: '%*s'\n", i + 1,
1328 fprintf(d->
trace,
"-- parameter %d: [BLOB]'\n", i + 1);
1335 fprintf(d->
trace,
"-- parameter %d: %g\n",
1340 case SQLITE_INTEGER:
1341 if (p->
s3size > sizeof (
int)) {
1346 "-- parameter %d: %I64d\n",
1348 "-- parameter %d: %lld\n",
1356 fprintf(d->
trace,
"-- parameter %d: %d\n",
1398 if (t->
nrow == 0 && rc == SQLITE_ROW) {
1405 int nalloc = t->
nalloc * 2 + need + 1;
1410 t->
rc = SQLITE_NOMEM;
1419 for (i = 0; i < ncol; i++) {
1420 p = (
char *) sqlite3_column_name(t->
stmt, i);
1422 char *q =
xmalloc(strlen(p) + 1);
1439 }
else if (t->
ncol != ncol) {
1440 t->
errmsg = sqlite3_mprintf(
"drvgettable() called with two or"
1441 " more incompatible queries");
1442 t->
rc = SQLITE_ERROR;
1446 if (rc == SQLITE_ROW) {
1447 for (i = 0; i < ncol; i++) {
1448 int coltype = sqlite3_column_type(t->
stmt, i);
1451 if (coltype == SQLITE_BLOB) {
1452 int k, nbytes = sqlite3_column_bytes(t->
stmt, i);
1454 unsigned const char *bp;
1456 bp = sqlite3_column_blob(t->
stmt, i);
1464 for (k = 0; k < nbytes; k++) {
1465 *qp++ =
xdigits[(bp[k] >> 4)];
1466 *qp++ =
xdigits[(bp[k] & 0xF)];
1471 }
else if (coltype == SQLITE_FLOAT) {
1472 struct lconv *lc = 0;
1473 double val = sqlite3_column_double(t->
stmt, i);
1481 snprintf(buffer,
sizeof (buffer),
"%.15g", val);
1483 if (lc && lc->decimal_point && lc->decimal_point[0] &&
1484 lc->decimal_point[0] !=
'.') {
1485 p = strchr(buffer, lc->decimal_point[0]);
1495 }
else if (coltype != SQLITE_NULL) {
1496 p =
xstrdup((
char *) sqlite3_column_text(t->
stmt, i));
1510 int *ncolp,
char **errp,
int nparam,
BINDPARM *p)
1513 int rc = SQLITE_OK, keep = sql == NULL;
1515 const char *sqlleft = 0;
1516 int nretry = 0, haveerr = 0;
1519 return SQLITE_ERROR;
1533 tres.rc = SQLITE_OK;
1534 tres.resarr =
xmalloc(
sizeof (
char *) * tres.nalloc);
1538 return SQLITE_NOMEM;
1543 if (tres.stmt == NULL) {
1544 return SQLITE_NOMEM;
1548 while (sql && *sql && (rc == SQLITE_OK ||
1549 (rc == SQLITE_SCHEMA && (++nretry) < 2))) {
1553 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
1555 rc = sqlite3_prepare_v2(d->
sqlite, sql, -1, &tres.stmt, &sqlleft);
1558 rc = sqlite3_prepare(d->
sqlite, sql, -1, &tres.stmt, &sqlleft);
1560 if (rc != SQLITE_OK) {
1563 sqlite3_finalize(tres.stmt);
1574 if (sqlite3_bind_parameter_count(tres.stmt) != nparam) {
1577 sqlite3_mprintf(
"%s",
"parameter marker count incorrect");
1584 ncol = sqlite3_column_count(tres.stmt);
1590 rc = sqlite3_step(tres.stmt);
1591 if (rc == SQLITE_ROW || rc == SQLITE_DONE) {
1597 if (rc != SQLITE_ROW) {
1600 rc = sqlite3_reset(tres.stmt);
1604 rc = sqlite3_finalize(tres.stmt);
1607 if (rc != SQLITE_SCHEMA) {
1610 while (sql &&
ISSPACE(*sql)) {
1614 if (rc == SQLITE_DONE) {
1626 sqlite3_reset(tres.stmt);
1631 sqlite3_finalize(tres.stmt);
1636 }
else if (rc != SQLITE_OK && rc == sqlite3_errcode(d->
sqlite) && errp) {
1637 *errp = sqlite3_mprintf(
"%s", sqlite3_errmsg(d->
sqlite));
1642 tres.resarr[0] = (
char *) (tres.ndata - 1);
1644 if (rc == SQLITE_ABORT) {
1649 sqlite3_free(*errp);
1651 *errp = tres.errmsg;
1653 sqlite3_free(tres.errmsg);
1658 sqlite3_free(tres.errmsg);
1659 if (rc != SQLITE_OK) {
1663 *resp = &tres.resarr[1];
1681 #if defined(__GNUC__) && (__GNUC__ >= 2)
1682 static void setstatd(
DBC *,
int,
char *,
char *, ...)
1683 __attribute__((format (printf, 3, 5)));
1700 count = vsnprintf((
char *) d->
logmsg, sizeof (d->
logmsg), msg, ap);
1721 #if defined(__GNUC__) && (__GNUC__ >= 2)
1722 static void setstat(
STMT *,
int,
char *,
char *, ...)
1723 __attribute__((format (printf, 3, 5)));
1740 count = vsnprintf((
char *) s->
logmsg, sizeof (s->
logmsg), msg, ap);
1764 if (
dbc == SQL_NULL_HDBC) {
1765 return SQL_INVALID_HANDLE;
1768 setstatd(d, -1,
"not supported",
"IM001");
1783 if (
stmt == SQL_NULL_HSTMT) {
1784 return SQL_INVALID_HANDLE;
1787 setstat(s, -1,
"not supported",
"IM001");
1799 if (x && ((
char **) x)[0]) {
1800 xfree(((
char **) x)[0]);
1801 ((
char **) x)[0] = NULL;
1814 setstat(s, -1,
"out of memory", (*s->
ov3) ?
"HY000" :
"S1000");
1827 setstat(s, -1,
"not connected", (*s->
ov3) ?
"HY000" :
"S1000");
1838 #if defined(HAVE_LOCALECONV) || defined(_WIN32) || defined(_WIN64)
1843 struct lconv *lc = 0;
1844 char buf[128], *p, *end;
1848 if (lc && lc->decimal_point && lc->decimal_point[0] &&
1849 lc->decimal_point[0] !=
'.') {
1850 strncpy(buf, data,
sizeof (buf) - 1);
1851 buf[
sizeof (buf) - 1] =
'\0';
1852 p = strchr(buf,
'.');
1854 *p = lc->decimal_point[0];
1860 value = strtod(p, &end);
1861 end = (
char *) data + (end - p);
1870 #define ln_strtod(A,B) strtod(A,B)
1883 int len = strlen(str);
1888 if ((str[0] ==
'\'' && str[end] ==
'\'') ||
1889 (str[0] ==
'"' && str[end] ==
'"') ||
1890 (str[0] ==
'[' && str[end] ==
']')) {
1891 memmove(str, str + 1, end - 1);
1892 str[end - 1] =
'\0';
1913 while ((q = strchr(p,
'_')) != NULL) {
1914 if (q == str || q[-1] !=
'\\') {
1920 while ((q = strchr(p,
'%')) != NULL) {
1921 if (q == str || q[-1] !=
'\\') {
1927 while ((q = strchr(p,
'\\')) != NULL) {
1928 if (q[1] ==
'\\' || q[1] ==
'_' || q[1] ==
'%') {
1929 memmove(q, q + 1, strlen(q));
1957 if (*str ==
'\0' && cp !=
'%') {
1961 while (*pat ==
'%') {
1969 if (cp !=
'_' && cp !=
'\\') {
1993 if (esc && cp ==
'\\' &&
1994 (pat[1] ==
'\\' || pat[1] ==
'%' || pat[1] ==
'_')) {
2023 #if !defined(_WIN32) && !defined(_WIN64)
2025 #ifdef HAVE_NANOSLEEP
2038 #if defined(_WIN32) || defined(_WIN64)
2039 d->
t0 = GetTickCount();
2041 gettimeofday(&tv, NULL);
2042 d->
t0 = tv.tv_sec * 1000 + tv.tv_usec / 1000;
2045 #if defined(_WIN32) || defined(_WIN64)
2046 t1 = GetTickCount();
2048 gettimeofday(&tv, NULL);
2049 t1 = tv.tv_sec * 1000 + tv.tv_usec / 1000;
2054 #if defined(_WIN32) || defined(_WIN64)
2057 #ifdef HAVE_NANOSLEEP
2059 ts.tv_nsec = 10000000;
2061 ret = nanosleep(&ts, &ts);
2062 if (ret < 0 && errno != EINTR) {
2072 select(0, NULL, NULL, NULL, &tv);
2095 int count = 0, step = 0,
max, rc = SQLITE_ERROR;
2097 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME)
2105 while (step <
max) {
2107 rc = sqlite3_exec(x,
"PRAGMA empty_result_callbacks = on;",
2109 if (rc == SQLITE_OK) {
2111 "PRAGMA foreign_keys = on;" :
2112 "PRAGMA foreign_keys = off;",
2115 }
else if (step < 2) {
2117 "PRAGMA full_column_names = off;" :
2118 "PRAGMA full_column_names = on;",
2120 }
else if (step < 3) {
2122 "PRAGMA short_column_names = on;" :
2123 "PRAGMA short_column_names = off;",
2126 if (rc != SQLITE_OK) {
2127 if (rc != SQLITE_BUSY ||
2159 for (i = 1; i <= size; i++) {
2176 mapsqltype(
const char *
typename,
int *nosign,
int ov3,
int nowchar,
2180 int testsign = 0, result;
2183 result = nowchar ? SQL_VARCHAR : SQL_WVARCHAR;
2185 result = SQL_VARCHAR;
2190 q = p =
xmalloc(strlen(
typename) + 1);
2194 strcpy(p,
typename);
2199 if (strncmp(p,
"inter", 5) == 0) {
2200 }
else if (strncmp(p,
"int", 3) == 0 ||
2201 strncmp(p,
"mediumint", 9) == 0) {
2203 result = SQL_INTEGER;
2204 }
else if (strncmp(p,
"numeric", 7) == 0) {
2205 result = SQL_DOUBLE;
2206 }
else if (strncmp(p,
"tinyint", 7) == 0) {
2208 result = SQL_TINYINT;
2209 }
else if (strncmp(p,
"smallint", 8) == 0) {
2211 result = SQL_SMALLINT;
2212 }
else if (strncmp(p,
"float", 5) == 0) {
2213 result = SQL_DOUBLE;
2214 }
else if (strncmp(p,
"double", 6) == 0 ||
2215 strncmp(p,
"real", 4) == 0) {
2216 result = SQL_DOUBLE;
2217 }
else if (strncmp(p,
"timestamp", 9) == 0) {
2218 #ifdef SQL_TYPE_TIMESTAMP
2219 result = ov3 ? SQL_TYPE_TIMESTAMP : SQL_TIMESTAMP;
2221 result = SQL_TIMESTAMP;
2223 }
else if (strncmp(p,
"datetime", 8) == 0) {
2224 #ifdef SQL_TYPE_TIMESTAMP
2225 result = ov3 ? SQL_TYPE_TIMESTAMP : SQL_TIMESTAMP;
2227 result = SQL_TIMESTAMP;
2229 }
else if (strncmp(p,
"time", 4) == 0) {
2230 #ifdef SQL_TYPE_TIME
2231 result = ov3 ? SQL_TYPE_TIME : SQL_TIME;
2235 }
else if (strncmp(p,
"date", 4) == 0) {
2236 #ifdef SQL_TYPE_DATE
2237 result = ov3 ? SQL_TYPE_DATE : SQL_DATE;
2241 #ifdef SQL_LONGVARCHAR
2242 }
else if (strncmp(p,
"text", 4) == 0 ||
2243 strncmp(p,
"memo", 4) == 0 ||
2244 strncmp(p,
"longvarchar", 11) == 0) {
2246 result = nowchar ? SQL_LONGVARCHAR : SQL_WLONGVARCHAR;
2248 result = SQL_LONGVARCHAR;
2251 }
else if (strncmp(p,
"wtext", 5) == 0 ||
2252 strncmp(p,
"wvarchar", 8) == 0 ||
2253 strncmp(p,
"longwvarchar", 12) == 0) {
2254 result = SQL_WLONGVARCHAR;
2258 }
else if (strncmp(p,
"bool", 4) == 0 ||
2259 strncmp(p,
"bit", 3) == 0) {
2263 }
else if (strncmp(p,
"bigint", 6) == 0) {
2265 result = SQL_BIGINT;
2267 }
else if (strncmp(p,
"blob", 4) == 0) {
2268 result = SQL_BINARY;
2269 }
else if (strncmp(p,
"varbinary", 9) == 0) {
2270 result = SQL_VARBINARY;
2271 }
else if (strncmp(p,
"longvarbinary", 13) == 0) {
2272 result = SQL_LONGVARBINARY;
2276 *nosign = strstr(p,
"unsigned") != NULL;
2282 if (dobigint && result == SQL_INTEGER) {
2283 result = SQL_BIGINT;
2300 getmd(
const char *
typename,
int sqltype,
int *mp,
int *dp)
2305 case SQL_INTEGER: m = 10; d = 9;
break;
2306 case SQL_TINYINT: m = 4; d = 3;
break;
2307 case SQL_SMALLINT: m = 6; d = 5;
break;
2308 case SQL_FLOAT: m = 25; d = 24;
break;
2309 case SQL_DOUBLE: m = 54; d = 53;
break;
2310 case SQL_VARCHAR: m = 255; d = 0;
break;
2313 case SQL_WVARCHAR: m = 255; d = 0;
break;
2316 #ifdef SQL_TYPE_DATE
2319 case SQL_DATE: m = 10; d = 0;
break;
2320 #ifdef SQL_TYPE_TIME
2323 case SQL_TIME: m = 8; d = 0;
break;
2324 #ifdef SQL_TYPE_TIMESTAMP
2325 case SQL_TYPE_TIMESTAMP:
2327 case SQL_TIMESTAMP: m = 32; d = 3;
break;
2328 #ifdef SQL_LONGVARCHAR
2329 case SQL_LONGVARCHAR : m = 65536; d = 0;
break;
2332 #ifdef SQL_WLONGVARCHAR
2333 case SQL_WLONGVARCHAR: m = 65536; d = 0;
break;
2337 case SQL_VARBINARY: m = 255; d = 0;
break;
2338 case SQL_LONGVARBINARY: m = 65536; d = 0;
break;
2340 case SQL_BIGINT: m = 20; d = 19;
break;
2343 case SQL_BIT: m = 1; d = 1;
break;
2346 if (m &&
typename) {
2350 if (sscanf(
typename,
"%*[^(](%d,%d %1[)]", &mm, &dd, clbr) == 3) {
2353 }
else if (sscanf(
typename,
"%*[^(](%d %1[)]", &mm, clbr) == 2) {
2354 if (sqltype == SQL_TIMESTAMP) {
2357 #ifdef SQL_TYPE_TIMESTAMP
2358 else if (sqltype == SQL_TYPE_TIMESTAMP) {
2387 if (type == SQL_C_DEFAULT) {
2390 type = (nosign > 0) ? SQL_C_ULONG : SQL_C_LONG;
2393 type = (nosign > 0) ? SQL_C_UTINYINT : SQL_C_TINYINT;
2396 type = (nosign > 0) ? SQL_C_USHORT : SQL_C_SHORT;
2402 type = SQL_C_DOUBLE;
2405 type = SQL_C_TIMESTAMP;
2413 #ifdef SQL_C_TYPE_TIMESTAMP
2414 case SQL_TYPE_TIMESTAMP:
2415 type = SQL_C_TYPE_TIMESTAMP;
2418 #ifdef SQL_C_TYPE_TIME
2420 type = SQL_C_TYPE_TIME;
2423 #ifdef SQL_C_TYPE_DATE
2425 type = SQL_C_TYPE_DATE;
2431 #ifdef SQL_WLONGVARCHAR
2432 case SQL_WLONGVARCHAR:
2434 type = nowchar ? SQL_C_CHAR : SQL_C_WCHAR;
2439 case SQL_LONGVARBINARY:
2440 type = SQL_C_BINARY;
2454 type = nowchar ? SQL_C_CHAR : SQL_C_WCHAR;
2475 while (*sql &&
ISSPACE(*sql)) {
2478 if (*sql && *sql !=
';') {
2480 static const struct {
2502 if (size >= ddlstr[i].len &&
2503 strncasecmp(sql, ddlstr[i].str, ddlstr[i].len) == 0) {
2524 fixupsql(
char *sql,
int sqlLen,
int cte,
int *nparam,
int *isselect,
2527 char *q = sql, *qz = NULL, *p, *inq = NULL, *out;
2528 int np = 0, isddl = -1, size;
2533 if (sqlLen != SQL_NTS) {
2538 memcpy(q, sql, sqlLen);
2542 size = strlen(sql) * 4;
2544 size +=
sizeof (
char *) - 1;
2545 size &= ~(
sizeof (
char *) - 1);
2592 }
while (*qq &&
ISSPACE(*qq));
2593 if (*qq && *qq !=
';') {
2596 *errmsg =
"only one SQL statement allowed";
2611 int ojfn = 0, brc = 0;
2612 char *inq2 = NULL, *end = q + 1, *start;
2614 while (*end &&
ISSPACE(*end)) {
2617 if (*end !=
'd' && *end !=
'D' &&
2618 *end !=
't' && *end !=
'T') {
2623 if (inq2 && *end == *inq2) {
2625 }
else if (inq2 == NULL && *end ==
'{') {
2626 char *nerr = 0, *nsql;
2628 nsql =
fixupsql(end, SQL_NTS, cte, 0, 0, &nerr);
2629 if (nsql && !nerr) {
2635 }
else if (inq2 == NULL && *end ==
'}') {
2639 }
else if (inq2 == NULL && (*end ==
'\'' || *end ==
'"')) {
2641 }
else if (inq2 == NULL && *end ==
'?') {
2647 char *end2 = end - 1;
2650 while (start < end) {
2656 while (start < end) {
2663 while (start < end2 && *start !=
'\'') {
2666 while (end2 > start && *end2 !=
'\'') {
2669 if (*start ==
'\'' && *end2 ==
'\'') {
2670 while (start <= end2) {
2704 if (!incom && p[1] ==
'-') {
2714 if (incom > 0 && p[-1] ==
'*') {
2718 }
else if (!incom && p[1] ==
'*') {
2730 (strncasecmp(p,
"select", 6) == 0 ||
2731 strncasecmp(p,
"pragma", 6) == 0)) {
2733 }
else if (cte && size >= 4 && strncasecmp(p,
"with", 4) == 0) {
2735 }
else if (size >= 7 && strncasecmp(p,
"explain", 7) == 0) {
2759 for (i = 0; i < ncols; i++) {
2760 if (strcmp(cols[i], name) == 0) {
2788 #ifndef FULL_METADATA
2789 int pk, nn, t, r, nrows, ncols;
2790 char **rowp, *flagp, flags[128];
2801 for (i = 1; table[0] && i < s->
dcols; i++) {
2806 if (i >= s->
dcols) {
2807 for (i = 0; i < s->
dcols; i++) {
2811 }
else if (s->
dcols == 1) {
2815 for (i = 0; i < s->
dcols; i++) {
2821 #ifdef SQL_LONGVARCHAR
2828 #ifdef SQL_WLONGVARCHAR
2840 #ifndef FULL_METADATA
2843 if (flagp == NULL) {
2849 memset(flagp, 0,
sizeof (flags[0]) * s->
dcols);
2850 for (i = 0; i < s->
dcols; i++) {
2854 for (i = 0; i < s->
dcols; i++) {
2855 int ret, lastpk = -1, autoinccount = 0;
2864 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", s->
dyncols[i].
table);
2869 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, NULL);
2871 if (ret != SQLITE_OK) {
2874 k =
findcol(rowp, ncols,
"name");
2875 t =
findcol(rowp, ncols,
"type");
2876 pk =
findcol(rowp, ncols,
"pk");
2877 nn =
findcol(rowp, ncols,
"notnull");
2878 if (k < 0 || t < 0) {
2881 for (r = 1; r <= nrows; r++) {
2884 for (m = i; m < s->
dcols; m++) {
2888 char *dotp = strchr(colname,
'.');
2895 strcmp(colname, rowp[r * ncols + k]) == 0 &&
2897 char *
typename = rowp[r * ncols + t];
2908 #ifdef SQL_LONGVARCHAR
2915 #ifdef SQL_WLONGVARCHAR
2926 if (pk >= 0 && strcmp(rowp[r * ncols + pk],
"1") == 0) {
2928 if (++autoinccount > 1) {
2935 if (strlen(
typename) == 7 &&
2936 strncasecmp(
typename,
"integer", 7) == 0) {
2943 if (nn >= 0 && rowp[r * ncols + nn][0] !=
'0') {
2950 sqlite3_free_table(rowp);
2952 for (i = k = 0; i < s->
dcols; i++) {
2953 if (flagp[i] == 0) {
2958 }
else if (flagp[i] != k) {
2966 for (i = 0; i < s->
dcols; i++) {
2973 if (flagp != flags) {
2977 for (i = 1, k = 0; i < s->
dcols; i++) {
2985 for (i = 0; i < s->
dcols; i++) {
3007 int z, a, b, c, d, e, x1;
3010 ijd = jd * 86400000.0 + 0.5;
3011 z = (int) ((ijd + 43200000) / 86400000);
3012 a = (int) ((z - 1867216.25) / 36524.25);
3013 a = z + 1 + a - (a / 4);
3015 c = (int) ((b - 122.1) / 365.25);
3016 d = (36525 * c) / 100;
3017 e = (int) ((b - d) / 30.6001);
3018 x1 = (int) (30.6001 * e);
3019 ds->day = b - d - x1;
3020 ds->month = (e < 14) ? (e - 1) : (e - 13);
3021 ds->year = (ds->month > 2) ? (c - 4716) : (c - 4715);
3039 ijd = jd * 86400000.0 + 0.5;
3040 s = (int)((ijd + 43200000) % 86400000);
3043 *fp = (s % 1000) * 1000000;
3047 ts->hour = s / 3600;
3048 s -= ts->hour * 3600;
3049 ts->minute = s / 60;
3050 ds += s - ts->minute *60;
3051 ts->second = (int) ds;
3064 static const int mdays[] = {
3065 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
3072 mday = mdays[(month - 1) % 12];
3073 if (mday == 28 && year % 4 == 0 &&
3074 (!(year % 100 == 0) || year % 400 == 0)) {
3100 char *p, *q, sepc =
'\0';
3102 ds->year = ds->month = ds->day = 0;
3104 p = strchr(str,
'.');
3128 strncpy(buf, p + 0, 4); buf[4] =
'\0';
3129 ds->year = strtol(buf, NULL, 10);
3130 strncpy(buf, p + 4, 2); buf[2] =
'\0';
3131 ds->month = strtol(buf, NULL, 10);
3132 strncpy(buf, p + 6, 2); buf[2] =
'\0';
3133 ds->day = strtol(buf, NULL, 10);
3141 n = strtol(p, &q, 10);
3153 if (*q ==
'-' || *q ==
'/' || *q ==
'\0' || i == 2) {
3155 case 0: ds->year = n;
break;
3156 case 1: ds->month = n;
break;
3157 case 2: ds->day = n;
break;
3174 ds->month < 1 || ds->month > 12 ||
3175 ds->day < 1 || ds->day >
getmdays(ds->year, ds->month)) {
3186 if (ds->month >= 1 && ds->month <= 12 &&
3187 (ds->day >= 1 || ds->day <=
getmdays(ds->year, ds->month))) {
3213 int i, err = 0, ampm = -1;
3217 ts->hour = ts->minute = ts->second = 0;
3219 p = strchr(str,
'.');
3243 strncpy(buf, p + 0, 2); buf[2] =
'\0';
3244 ts->hour = strtol(buf, NULL, 10);
3245 strncpy(buf, p + 2, 2); buf[2] =
'\0';
3246 ts->minute = strtol(buf, NULL, 10);
3247 strncpy(buf, p + 4, 2); buf[2] =
'\0';
3248 ts->second = strtol(buf, NULL, 10);
3256 n = strtol(p, &q, 10);
3265 if (*q ==
':' || *q ==
'\0' || i == 2) {
3267 case 0: ts->hour = n;
break;
3268 case 1: ts->minute = n;
break;
3269 case 2: ts->second = n;
break;
3285 if ((p[0] ==
'p' || p[0] ==
'P') &&
3286 (p[1] ==
'm' || p[1] ==
'M')) {
3288 }
else if ((p[0] ==
'a' || p[0] ==
'A') &&
3289 (p[1] ==
'm' || p[1] ==
'M')) {
3295 if (ts->hour < 12) {
3298 }
else if (ampm == 0) {
3299 if (ts->hour == 12) {
3306 if (err || ts->hour > 23 || ts->minute > 59 || ts->second > 59) {
3334 int i, m, n, err = 0, ampm = -1;
3336 char *p, *q, in =
'\0', sepc =
'\0';
3338 tss->year = tss->month = tss->day = 0;
3339 tss->hour = tss->minute = tss->second = 0;
3342 p = strchr(str,
'.');
3344 q = strchr(str,
'-');
3349 q = strchr(str,
'/');
3351 q = strchr(str,
':');
3364 tss->year = ds.year;
3365 tss->month = ds.month;
3367 tss->hour = ts.hour;
3368 tss->minute = ts.minute;
3369 tss->second = ts.second;
3389 strncpy(buf, p + 0, 4); buf[4] =
'\0';
3390 tss->year = strtol(buf, NULL, 10);
3391 strncpy(buf, p + 4, 2); buf[2] =
'\0';
3392 tss->month = strtol(buf, NULL, 10);
3393 strncpy(buf, p + 6, 2); buf[2] =
'\0';
3394 tss->day = strtol(buf, NULL, 10);
3395 strncpy(buf, p + 8, 2); buf[2] =
'\0';
3396 tss->hour = strtol(buf, NULL, 10);
3397 strncpy(buf, p + 10, 2); buf[2] =
'\0';
3398 tss->minute = strtol(buf, NULL, 10);
3399 strncpy(buf, p + 12, 2); buf[2] =
'\0';
3400 tss->second = strtol(buf, NULL, 10);
3403 strncpy(buf, p + 14, m);
3409 tss->fraction = strtol(buf, NULL, 10);
3415 while ((m & 7) != 7) {
3417 n = strtol(p, &q, 10);
3457 case 0: tss->year = n;
break;
3458 case 1: tss->month = n;
break;
3459 case 2: tss->day = n;
break;
3474 case 0: tss->hour = n;
break;
3475 case 1: tss->minute = n;
break;
3476 case 2: tss->second = n;
break;
3489 (void) strtol(q + 1, &e, 10);
3490 if (e && *e ==
'-') {
3506 if (p[0] ==
'+' || p[0] ==
'-') {
3522 if ((q[0] ==
'a' || q[0] ==
'A') &&
3523 (q[1] ==
'm' || q[1] ==
'M')) {
3526 }
else if ((q[0] ==
'p' || q[0] ==
'P') &&
3527 (q[1] ==
'm' || q[1] ==
'M')) {
3536 if ((m & 7) > 1 && (m & 8)) {
3542 if (*q !=
'+' && *q !=
'-') {
3545 sign = (*q ==
'+') ? -1 : 1;
3547 n = strtol(p, &q, 10);
3548 if (!q || *q++ !=
':' || !
ISDIGIT(*q)) {
3553 nn = strtol(p, &q, 10);
3554 tss->minute += nn * sign;
3555 if ((SQLSMALLINT) tss->minute < 0) {
3558 }
else if (tss->minute >= 60) {
3562 tss->hour += n * sign;
3563 if ((SQLSMALLINT) tss->hour < 0) {
3566 }
else if (tss->hour >= 24) {
3570 if ((
short) tss->day < 1 || tss->day >= 28) {
3571 int mday, pday, pmon;
3573 mday =
getmdays(tss->year, tss->month);
3574 pmon = tss->month - 1;
3579 if ((SQLSMALLINT) tss->day < 1) {
3582 }
else if (tss->day > mday) {
3586 if ((SQLSMALLINT) tss->month < 1) {
3589 }
else if (tss->month > 12) {
3598 (tss->month < 1 || tss->month > 12 ||
3599 tss->day < 1 || tss->day >
getmdays(tss->year, tss->month))) {
3613 if (!err && (m & 1) == 0) {
3618 tss->year = t.wYear;
3619 tss->month = t.wMonth;
3625 gettimeofday(&tv, NULL);
3626 tm = *localtime(&tv.tv_sec);
3627 tss->year = tm.tm_year + 1900;
3628 tss->month = tm.tm_mon + 1;
3629 tss->day = tm.tm_mday;
3633 if (tss->fraction < 0) {
3638 tss->month < 1 || tss->month > 12 ||
3639 tss->day < 1 || tss->day >
getmdays(tss->year, tss->month) ||
3640 tss->hour > 23 || tss->minute > 59 || tss->second > 59) {
3645 if (tss->hour < 12) {
3648 }
else if (ampm == 0) {
3649 if (tss->hour == 12) {
3654 return ((m & 7) < 1) ? -1 : 0;
3667 return string[0] && strchr(
"Yy123456789Tt",
string[0]) != NULL;
3683 DBC *d = (
DBC *) sqlite3_user_data(ctx);
3688 if (sqlite3_value_type(args[0]) != SQLITE_NULL) {
3689 filename = (
char *) sqlite3_value_text(args[0]);
3694 char *wname = utf_to_wmb(filename, -1);
3697 FILE *f = fopen(filename,
"r");
3704 f = fopen(wname,
"rb");
3706 sqlite3_result_error(ctx,
"out of memory", -1);
3712 if (fseek(f, 0, SEEK_END) == 0) {
3714 if (fseek(f, 0, SEEK_SET) == 0) {
3715 p = sqlite3_malloc(n);
3717 nn = fread(p, 1, n, f);
3719 sqlite3_result_error(ctx,
"read error", -1);
3722 sqlite3_result_blob(ctx, p, n, sqlite3_free);
3725 sqlite3_result_error(ctx,
"out of memory", -1);
3728 sqlite3_result_error(ctx,
"seek error", -1);
3731 sqlite3_result_error(ctx,
"seek error", -1);
3735 sqlite3_result_error(ctx,
"cannot open file", -1);
3738 sqlite3_result_error(ctx,
"no filename given", -1);
3753 DBC *d = (
DBC *) sqlite3_user_data(ctx);
3760 p = (
char *) sqlite3_value_blob(args[0]);
3761 n = sqlite3_value_bytes(args[0]);
3764 if (sqlite3_value_type(args[1]) != SQLITE_NULL) {
3765 filename = (
char *) sqlite3_value_text(args[1]);
3771 char *wname = utf_to_wmb(filename, -1);
3774 FILE *f = fopen(filename,
"w");
3780 f = fopen(wname,
"wb");
3782 sqlite3_result_error(ctx,
"out of memory", -1);
3788 nn = fwrite(p, 1, n, f);
3791 sqlite3_result_error(ctx,
"write error", -1);
3793 sqlite3_result_int(ctx, nn);
3796 sqlite3_result_error(ctx,
"cannot open file", -1);
3799 sqlite3_result_error(ctx,
"no filename given", -1);
3802 sqlite3_result_null(ctx);
3814 #if defined(HAVE_SQLITE3PROFILE) && (HAVE_SQLITE3PROFILE)
3815 dbtrace(
void *arg,
const char *msg, sqlite_uint64 et)
3817 dbtrace(
void *arg,
const char *msg)
3822 if (msg && d->
trace) {
3823 int len = strlen(msg);
3824 #if defined(HAVE_SQLITE3PROFILE) && (HAVE_SQLITE3PROFILE)
3831 if (msg[len - 1] !=
';') {
3834 fprintf(d->
trace,
"%s%s", msg, end);
3835 #if defined(HAVE_SQLITE3PROFILE) && (HAVE_SQLITE3PROFILE)
3836 s = et / 1000000000LL;
3837 f = et % 1000000000LL;
3838 fprintf(d->
trace,
"-- took %lu.%09lu seconds\n", s, f);
3855 if (fn && d->
trace) {
3857 fprintf(d->
trace,
"-- %s: %s\n", fn, sql);
3859 fprintf(d->
trace,
"-- %s\n", fn);
3875 if (rc != SQLITE_OK && d->
trace) {
3876 fprintf(d->
trace,
"-- SQLITE ERROR CODE %d", rc);
3877 fprintf(d->
trace, err ?
": %s\n" :
"\n", err);
3898 char *spflag,
char *ntflag,
char *jmode,
char *busy)
3901 int rc, tmp, busyto = 100000;
3902 #if defined(HAVE_SQLITE3VFS) && (HAVE_SQLITE3VFS)
3903 int flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
3905 const char *vfs_name = NULL;
3910 fprintf(d->
trace,
"-- sqlite3_close (deferred): '%s'\n",
3914 #if defined(HAVE_SQLITE3CLOSEV2) && (HAVE_SQLITE3CLOSEV2)
3915 sqlite3_close_v2(d->
sqlite);
3917 sqlite3_close(d->
sqlite);
3921 #if defined(HAVE_SQLITE3VFS) && (HAVE_SQLITE3VFS)
3923 flags &= ~ SQLITE_OPEN_CREATE;
3925 #if defined(_WIN32) || defined(_WIN64)
3927 char expname[SQL_MAX_MESSAGE_LENGTH * 2];
3930 rc = ExpandEnvironmentStrings(name, expname,
sizeof (expname));
3931 if (rc <=
sizeof (expname)) {
3932 uname = wmb_to_utf(expname, rc - 1);
3934 uname = wmb_to_utf(name, -1);
3938 setstatd(d, rc,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
3943 #if defined(ENABLE_NVFS) && (ENABLE_NVFS)
3944 vfs_name = nvfs_makevfs(uname);
3946 #ifdef SQLITE_OPEN_URI
3947 flags |= SQLITE_OPEN_URI;
3949 rc = sqlite3_open_v2(uname, &d->
sqlite, flags, vfs_name);
3950 #if defined(WINTERFACE) || defined(_WIN32) || defined(_WIN64)
3951 if (uname != name) {
3956 #if defined(_WIN32) || defined(_WIN64)
3961 cname = utf_to_wmb(name, -1);
3963 if (GetFileAttributesA(cname ? cname : name) ==
3964 INVALID_FILE_ATTRIBUTES) {
3966 rc = SQLITE_CANTOPEN;
3967 setstatd(d, rc,
"cannot open database",
3968 (*d->
ov3) ?
"HY000" :
"S1000");
3974 if (d->
nocreat && access(name, 004) < 0) {
3975 rc = SQLITE_CANTOPEN;
3976 setstatd(d, rc,
"cannot open database", (*d->
ov3) ?
"HY000" :
"S1000");
3980 #if defined(_WIN32) || defined(_WIN64)
3982 WCHAR *wname = wmb_to_uc(name, -1);
3986 setstatd(d, rc,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
3989 rc = sqlite3_open16(wname, &d->
sqlite);
3993 rc = sqlite3_open(name, &d->
sqlite);
3995 if (rc != SQLITE_OK) {
3997 setstatd(d, rc,
"connect failed", (*d->
ov3) ?
"HY000" :
"S1000");
3999 sqlite3_close(d->
sqlite);
4004 #if defined(SQLITE_DYNLOAD) || defined(SQLITE_HAS_CODEC)
4012 #if defined(HAVE_SQLITE3PROFILE) && (HAVE_SQLITE3PROFILE)
4021 SQL_CURSOR_FORWARD_ONLY : SQL_CURSOR_STATIC;
4022 tmp = strtol(busy, &endp, 0);
4023 if (endp && *endp ==
'\0' && endp != busy) {
4026 if (busyto < 1 || busyto > 1000000) {
4036 fprintf(d->
trace,
"-- sqlite3_close: '%s'\n",
4040 sqlite3_close(d->
sqlite);
4044 if (!spflag || spflag[0] ==
'\0') {
4047 if (spflag[0] !=
'\0') {
4050 sprintf(syncp,
"PRAGMA synchronous = %8.8s;", spflag);
4051 sqlite3_exec(d->
sqlite, syncp, NULL, NULL, NULL);
4053 if (jmode[0] !=
'\0') {
4056 sprintf(jourp,
"PRAGMA journal_mode = %16.16s;", jmode);
4057 sqlite3_exec(d->
sqlite, jourp, NULL, NULL, NULL);
4060 fprintf(d->
trace,
"-- sqlite3_open: '%s'\n", d->
dbname);
4063 #if defined(_WIN32) || defined(_WIN64)
4065 char pname[MAX_PATH];
4066 HANDLE h = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
4067 FALSE, GetCurrentProcessId());
4071 HMODULE m = NULL, l = LoadLibrary(
"psapi.dll");
4073 typedef BOOL (WINAPI *epmfunc)(HANDLE, HMODULE *, DWORD, LPDWORD);
4074 typedef BOOL (WINAPI *gmbfunc)(HANDLE, HMODULE, LPSTR, DWORD);
4079 epm = (epmfunc) GetProcAddress(l,
"EnumProcessModules");
4080 gmb = (gmbfunc) GetProcAddress(l,
"GetModuleBaseNameA");
4081 if (epm && gmb && epm(h, &m,
sizeof (m), &need)) {
4082 gmb(h, m, pname,
sizeof (pname));
4088 d->xcelqrx = strncasecmp(pname,
"EXCEL", 5) == 0 ||
4089 strncasecmp(pname,
"MSQRY", 5) == 0;
4090 if (d->
trace && d->xcelqrx) {
4092 fprintf(d->
trace,
"-- enabled EXCEL quirks\n");
4097 sqlite3_create_function(d->
sqlite,
"blob_import", 1, SQLITE_UTF8,
4099 sqlite3_create_function(d->
sqlite,
"blob_export", 2, SQLITE_UTF8,
4113 #if defined(HAVE_SQLITE3LOADEXTENSION) && (HAVE_SQLITE3LOADEXTENSION)
4115 char path[SQL_MAX_MESSAGE_LENGTH];
4121 sqlite3_enable_load_extension(d->
sqlite, 1);
4122 #if defined(_WIN32) || defined(_WIN64)
4123 GetModuleFileName(hModule, path,
sizeof (path));
4124 p = strrchr(path,
'\\');
4125 plen = p ? ((p + 1) - path) : 0;
4128 p = strchr(exts,
',');
4130 strncpy(path + plen, exts, p - exts);
4131 path[plen + (p - exts)] =
'\0';
4133 strcpy(path + plen, exts);
4136 char *errmsg = NULL;
4138 #if defined(_WIN32) || defined(_WIN64)
4144 ((q[1] ==
':' && (q[2] ==
'\\' || q[2] ==
'/')) ||
4145 q[0] ==
'\\' || q[0] ==
'/' || q[0] ==
'.'))) {
4149 for (i = 0; q[i] !=
'\0'; i++) {
4154 rc = sqlite3_load_extension(d->
sqlite, q, 0, &errmsg);
4156 rc = sqlite3_load_extension(d->
sqlite, path, 0, &errmsg);
4158 if (rc != SQLITE_OK) {
4159 #if defined(_WIN32) || defined(_WIN64)
4160 char buf[512], msg[512];
4162 LoadString(hModule, IDS_EXTERR, buf,
sizeof (buf));
4163 wsprintf(msg, buf, q, errmsg ?
4164 errmsg :
"no error info available");
4165 LoadString(hModule, IDS_EXTTITLE, buf,
sizeof (buf));
4166 MessageBox(NULL, msg, buf,
4167 MB_ICONEXCLAMATION | MB_OK | MB_TASKMODAL |
4170 fprintf(stderr,
"extension '%s' did not load%s%s\n",
4171 path, errmsg ?
": " :
"", errmsg ? errmsg :
"");
4194 char *
typename = (
char *) sqlite3_column_decltype(s3stmt, col);
4199 int coltype = sqlite3_column_type(s3stmt, col);
4201 if (guessed_types) {
4205 sprintf(guess,
" (guessed from %d)", coltype);
4208 case SQLITE_INTEGER:
typename =
"integer";
break;
4209 case SQLITE_FLOAT:
typename =
"double";
break;
4211 case SQLITE_TEXT:
typename =
"varchar";
break;
4212 case SQLITE_BLOB:
typename =
"blob";
break;
4214 case SQLITE_NULL:
typename =
"null";
break;
4219 fprintf(d->
trace,
"-- column %d type%s: '%s'\n", col + 1,
4226 #ifdef FULL_METADATA
4237 s3stmt_addmeta(sqlite3_stmt *s3stmt,
int col,
DBC *d,
COL *ci)
4239 int nn = 0, pk = 0, ai = 0;
4240 const char *dn = NULL, *tn = NULL, *cn = NULL, *dummy[4];
4242 dn = sqlite3_column_database_name(s3stmt, col);
4243 tn = sqlite3_column_table_name(s3stmt, col);
4244 cn = sqlite3_column_origin_name(s3stmt, col);
4245 dummy[0] = dummy[1] = 0;
4247 sqlite3_table_column_metadata(d->
sqlite, dn, tn, cn,
4251 ci->
autoinc = ai ? SQL_TRUE: SQL_FALSE;
4252 ci->
notnull = nn ? SQL_NO_NULLS : SQL_NULLABLE;
4253 ci->
ispk = pk ? 1 : 0;
4255 fprintf(d->
trace,
"-- column %d %s\n",
4256 col + 1, nn ?
"notnull" :
"nullable");
4258 fprintf(d->
trace,
"-- column %d autoincrement\n", col + 1);
4263 if (ci->
ispk && tn) {
4265 dummy[2] = dummy[3] = 0;
4267 sqlite3_table_column_metadata(d->
sqlite, dn, tn,
"rowid",
4268 dummy + 2, dummy + 3,
4270 if (pk && dummy[0] && dummy[0] == dummy[2]) {
4289 const char *errp = NULL;
4293 setstat(s, -1,
"stale statement", (*s->
ov3) ?
"HY000" :
"S1000");
4296 rc = sqlite3_step(s->
s3stmt);
4297 if (rc == SQLITE_ROW || rc == SQLITE_DONE) {
4299 ncols = sqlite3_column_count(s->
s3stmt);
4304 const char *colname, *
typename;
4305 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME)
4308 #if defined(HAVE_SQLITE3COLUMNDATABASENAME) && (HAVE_SQLITE3COLUMNDATABASENAME)
4312 for (i = size = 0; i < ncols; i++) {
4313 colname = sqlite3_column_name(s->
s3stmt, i);
4314 size += 3 + 3 * strlen(colname);
4316 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME)
4317 tblname = (
char *) size;
4318 for (i = 0; i < ncols; i++) {
4319 p = (
char *) sqlite3_column_table_name(s->
s3stmt, i);
4320 size += 2 + (p ? strlen(p) : 0);
4323 #if defined(HAVE_SQLITE3COLUMNDATABASENAME) && (HAVE_SQLITE3COLUMNDATABASENAME)
4324 dbname = (
char *) size;
4325 for (i = 0; i < ncols; i++) {
4326 p = (
char *) sqlite3_column_database_name(s->
s3stmt, i);
4327 size += 2 + (p ? strlen(p) : 0);
4330 dyncols =
xmalloc(ncols *
sizeof (
COL) + size);
4335 sqlite3_finalize(s->
s3stmt);
4340 p = (
char *) (dyncols + ncols);
4341 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME)
4344 #if defined(HAVE_SQLITE3COLUMNDATABASENAME) && (HAVE_SQLITE3COLUMNDATABASENAME)
4347 for (i = 0; i < ncols; i++) {
4350 colname = sqlite3_column_name(s->
s3stmt, i);
4352 fprintf(d->
trace,
"-- column %d name: '%s'\n",
4356 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME)
4357 q = (
char *) sqlite3_column_table_name(s->
s3stmt, i);
4358 strcpy(tblname, q ? q :
"");
4360 fprintf(d->
trace,
"-- table %d name: '%s'\n",
4364 dyncols[i].
table = tblname;
4365 tblname += strlen(tblname) + 1;
4367 #if defined(HAVE_SQLITE3COLUMNDATABASENAME) && (HAVE_SQLITE3COLUMNDATABASENAME)
4368 q = (
char *) sqlite3_column_database_name(s->
s3stmt, i);
4369 strcpy(dbname, q ? q :
"");
4371 fprintf(d->
trace,
"-- database %d name: '%s'\n",
4375 dyncols[i].
db = dbname;
4376 dbname += strlen(dbname) + 1;
4378 dyncols[i].
db = ((
DBC *) (s->
dbc))->dbname;
4382 dyncols[i].
label = p;
4384 q = strchr(colname,
'.');
4386 char *q2 = strchr(q + 1,
'.');
4394 #if !defined(HAVE_SQLITE3COLUMNTABLENAME) || !(HAVE_SQLITE3COLUMNTABLENAME)
4395 dyncols[i].
table = p;
4397 strncpy(p, colname, q - colname);
4398 p[q - colname] =
'\0';
4404 #if !defined(HAVE_SQLITE3COLUMNTABLENAME) || !(HAVE_SQLITE3COLUMNTABLENAME)
4405 dyncols[i].
table =
"";
4414 #ifdef SQL_LONGVARCHAR
4415 dyncols[i].
type = SQL_LONGVARCHAR;
4416 dyncols[i].
size = 65535;
4418 dyncols[i].
type = SQL_VARCHAR;
4419 dyncols[i].
size = 255;
4421 dyncols[i].
index = i;
4422 dyncols[i].
scale = 0;
4423 dyncols[i].
prec = 0;
4425 dyncols[i].
autoinc = SQL_FALSE;
4426 dyncols[i].
notnull = SQL_NULLABLE;
4427 dyncols[i].
ispk = -1;
4429 #ifdef FULL_METADATA
4430 s3stmt_addmeta(s->
s3stmt, i, d, &dyncols[i]);
4444 if (rc == SQLITE_DONE) {
4448 sqlite3_finalize(s->
s3stmt);
4453 rowd =
xmalloc((1 + 2 * ncols) *
sizeof (
char *));
4455 const unsigned char *value;
4457 rowd[0] = (
char *) ((
PTRDIFF_T) (ncols * 2));
4459 for (i = 0; i < ncols; i++) {
4460 int coltype = sqlite3_column_type(s->
s3stmt, i);
4462 rowd[i] = rowd[i + ncols] = NULL;
4463 if (coltype == SQLITE_BLOB) {
4464 int k, nbytes = sqlite3_column_bytes(s->
s3stmt, i);
4466 unsigned const char *bp;
4468 bp = sqlite3_column_blob(s->
s3stmt, i);
4471 rowd[i + ncols] = qp;
4474 for (k = 0; k < nbytes; k++) {
4475 *qp++ =
xdigits[(bp[k] >> 4)];
4476 *qp++ =
xdigits[(bp[k] & 0xF)];
4482 }
else if (coltype == SQLITE_FLOAT) {
4483 struct lconv *lc = 0;
4484 double d = sqlite3_column_double(s->
s3stmt, i);
4485 char *p, buffer[128];
4492 snprintf(buffer,
sizeof (buffer),
"%.15g", d);
4494 if (lc && lc->decimal_point && lc->decimal_point[0] &&
4495 lc->decimal_point[0] !=
'.') {
4496 p = strchr(buffer, lc->decimal_point[0]);
4501 rowd[i + ncols] =
xstrdup(buffer);
4503 }
else if (coltype != SQLITE_NULL) {
4504 value = sqlite3_column_text(s->
s3stmt, i);
4505 rowd[i + ncols] =
xstrdup((
char *) value);
4508 for (i = 0; i < ncols; i++) {
4509 int coltype = sqlite3_column_type(s->
s3stmt, i);
4512 if (coltype == SQLITE_BLOB) {
4513 value = sqlite3_column_blob(s->
s3stmt, i);
4514 }
else if (coltype != SQLITE_NULL) {
4515 value = sqlite3_column_text(s->
s3stmt, i);
4517 if (value && !rowd[i + ncols]) {
4529 if (rc == SQLITE_DONE) {
4531 sqlite3_finalize(s->
s3stmt);
4540 rc = sqlite3_reset(s->
s3stmt);
4542 errp = sqlite3_errmsg(d->
sqlite);
4546 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
4547 errp ? errp :
"unknown error", rc);
4570 sqlite3_reset(s->
s3stmt);
4611 sqlite3_finalize(s->
s3stmt);
4628 sqlite3_stmt *s3stmt = NULL;
4633 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
4640 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
4641 rc = sqlite3_prepare_v2(d->
sqlite, (
char *) s->
query, -1,
4644 rc = sqlite3_prepare(d->
sqlite, (
char *) s->
query, -1,
4647 if (rc != SQLITE_OK) {
4649 sqlite3_finalize(s3stmt);
4653 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
4655 if (rc != SQLITE_OK) {
4658 sqlite3_finalize(s3stmt);
4660 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
4661 sqlite3_errmsg(d->
sqlite), rc);
4664 if (sqlite3_bind_parameter_count(s3stmt) != s->
nparams) {
4666 sqlite3_finalize(s3stmt);
4667 setstat(s, SQLITE_ERROR,
"parameter marker count incorrect",
4668 (*s->
ov3) ?
"HY000" :
"S1000");
4687 SQLDataSources(SQLHENV env, SQLUSMALLINT dir, SQLCHAR *srvname,
4688 SQLSMALLINT buflen1, SQLSMALLINT *lenp1,
4689 SQLCHAR *desc, SQLSMALLINT buflen2, SQLSMALLINT *lenp2)
4691 if (env == SQL_NULL_HENV) {
4692 return SQL_INVALID_HANDLE;
4705 SQLSMALLINT buflen1, SQLSMALLINT *lenp1,
4706 SQLWCHAR *desc, SQLSMALLINT buflen2, SQLSMALLINT *lenp2)
4708 if (env == SQL_NULL_HENV) {
4709 return SQL_INVALID_HANDLE;
4721 SQLDrivers(SQLHENV env, SQLUSMALLINT dir, SQLCHAR *drvdesc,
4722 SQLSMALLINT descmax, SQLSMALLINT *desclenp,
4723 SQLCHAR *drvattr, SQLSMALLINT attrmax, SQLSMALLINT *attrlenp)
4725 if (env == SQL_NULL_HENV) {
4726 return SQL_INVALID_HANDLE;
4739 SQLSMALLINT descmax, SQLSMALLINT *desclenp,
4740 SQLWCHAR *drvattr, SQLSMALLINT attrmax, SQLSMALLINT *attrlenp)
4742 if (env == SQL_NULL_HENV) {
4743 return SQL_INVALID_HANDLE;
4755 SQLBrowseConnect(SQLHDBC
dbc, SQLCHAR *connin, SQLSMALLINT conninLen,
4756 SQLCHAR *connout, SQLSMALLINT connoutMax,
4757 SQLSMALLINT *connoutLen)
4775 SQLWCHAR *connout, SQLSMALLINT connoutMax,
4776 SQLSMALLINT *connoutLen)
4799 int i, dlen, done = 0;
4802 if (
stmt == SQL_NULL_HSTMT) {
4803 return SQL_INVALID_HANDLE;
4808 setstat(s, -1,
"sequence error",
"HY010");
4811 for (i = (s->
pdcount < 0) ? 0 : s->
pdcount; i < s->nparams; i++) {
4816 if (len == SQL_NULL_DATA) {
4819 p->
len = SQL_NULL_DATA;
4821 }
else if (type != SQL_C_CHAR
4823 && type != SQL_C_WCHAR
4825 && type != SQL_C_BINARY) {
4830 case SQL_C_UTINYINT:
4831 case SQL_C_STINYINT:
4835 size =
sizeof (SQLCHAR);
4840 size =
sizeof (SQLSMALLINT);
4845 size =
sizeof (SQLINTEGER);
4850 size =
sizeof (SQLBIGINT);
4854 size =
sizeof (float);
4857 size =
sizeof (double);
4859 #ifdef SQL_C_TYPE_DATE
4860 case SQL_C_TYPE_DATE:
4863 size =
sizeof (DATE_STRUCT);
4865 #ifdef SQL_C_TYPE_DATE
4866 case SQL_C_TYPE_TIME:
4869 size =
sizeof (TIME_STRUCT);
4871 #ifdef SQL_C_TYPE_DATE
4872 case SQL_C_TYPE_TIMESTAMP:
4874 case SQL_C_TIMESTAMP:
4875 size =
sizeof (TIMESTAMP_STRUCT);
4884 memcpy(p->
param, data, size);
4887 }
else if (len == SQL_NTS && (
4890 || type == SQL_C_WCHAR
4896 if (type == SQL_C_WCHAR) {
4903 #if defined(_WIN32) || defined(_WIN64)
4905 dp = wmb_to_utf(data, strlen (data));
4921 strcpy(p->
param, dp);
4927 }
else if (len < 0) {
4928 setstat(s, -1,
"invalid length",
"HY090");
4933 setstat(s, -1,
"no memory for parameter",
"HY013");
4936 memcpy((
char *) p->
param + p->
offs, data, dlen);
4940 if (type == SQL_C_WCHAR) {
4962 *((
char *) p->
param + p->
len) =
'\0';
4964 p->
need = (type == SQL_C_CHAR || type == SQL_C_WCHAR)
4967 *((
char *) p->
param + p->
len) =
'\0';
4968 p->
need = (type == SQL_C_CHAR) ? -1 : 0;
4970 #if defined(_WIN32) || defined(_WIN64)
4971 if (type == SQL_C_CHAR && *s->
oemcp &&
4972 !(p->
stype == SQL_BINARY ||
4973 p->
stype == SQL_VARBINARY ||
4974 p->
stype == SQL_LONGVARBINARY)) {
4975 char *dp = wmb_to_utf(p->
param, p->
len);
4984 p->
len = strlen(dp);
4986 if (p->
type == SQL_C_WCHAR &&
4987 (p->
stype == SQL_VARCHAR ||
4988 p->
stype == SQL_LONGVARCHAR) &&
4989 p->
len == p->
coldef * sizeof (SQLWCHAR)) {
5058 int type, len = 0, needalloc = 0;
5066 #if (defined(_WIN32) || defined(_WIN64)) && defined(WINTERFACE)
5068 if (type == SQL_C_WCHAR && p->
type == SQL_C_DEFAULT) {
5081 if (type == SQL_C_CHAR &&
5082 (p->
stype == SQL_BINARY ||
5083 p->
stype == SQL_VARBINARY ||
5084 p->
stype == SQL_LONGVARBINARY)) {
5085 type = SQL_C_BINARY;
5097 }
else if (*p->
lenp == SQL_DATA_AT_EXEC) {
5101 if (len <= SQL_LEN_DATA_AT_EXEC_OFFSET) {
5102 len = SQL_LEN_DATA_AT_EXEC(len);
5106 setstat(s, -1,
"invalid length",
"HY009");
5123 if (type == SQL_C_WCHAR) {
5124 if (!p->
lenp || *p->
lenp == SQL_NTS) {
5126 }
else if (*p->
lenp >= 0) {
5131 if (type == SQL_C_CHAR) {
5132 if (!p->
lenp || *p->
lenp == SQL_NTS) {
5134 #if defined(_WIN32) || defined(_WIN64)
5137 }
else if (*p->
lenp >= 0) {
5147 if (type == SQL_C_WCHAR) {
5163 if (type == SQL_C_CHAR) {
5168 #if defined(_WIN32) || defined(_WIN64)
5180 #if defined(_WIN32) || defined(_WIN64)
5182 p->
len = strlen(dp);
5201 case SQL_C_UTINYINT:
5203 case SQL_C_STINYINT:
5204 p->
s3type = SQLITE_INTEGER;
5205 p->
s3size =
sizeof (int);
5209 p->
s3type = SQLITE_INTEGER;
5210 p->
s3size =
sizeof (int);
5215 p->
s3type = SQLITE_INTEGER;
5216 p->
s3size =
sizeof (int);
5220 p->
s3type = SQLITE_INTEGER;
5221 p->
s3size =
sizeof (int);
5226 p->
s3type = SQLITE_INTEGER;
5227 p->
s3size =
sizeof (int);
5232 p->
s3type = SQLITE_INTEGER;
5233 p->
s3size =
sizeof (int);
5239 p->
s3type = SQLITE_INTEGER;
5240 p->
s3size =
sizeof (sqlite_int64);
5244 p->
s3type = SQLITE_INTEGER;
5245 p->
s3size =
sizeof (sqlite_int64);
5250 p->
s3type = SQLITE_FLOAT;
5251 p->
s3size =
sizeof (double);
5255 p->
s3type = SQLITE_FLOAT;
5256 p->
s3size =
sizeof (double);
5259 #ifdef SQL_C_TYPE_DATE
5260 case SQL_C_TYPE_DATE:
5264 int a, b, x1, x2, y, m, d;
5266 p->
s3type = SQLITE_FLOAT;
5267 p->
s3size =
sizeof (double);
5268 y = ((DATE_STRUCT *) p->
param)->year;
5269 m = ((DATE_STRUCT *) p->
param)->month;
5270 d = ((DATE_STRUCT *) p->
param)->day;
5276 b = 2 - a + (a / 4);
5277 x1 = 36525 * (y + 4716) / 100;
5278 x2 = 306001 * (m + 1) / 10000;
5279 p->
s3dval = x1 + x2 + d + b - 1524.5;
5282 sprintf(p->
strbuf,
"%04d-%02d-%02d",
5283 ((DATE_STRUCT *) p->
param)->year,
5284 ((DATE_STRUCT *) p->
param)->month,
5285 ((DATE_STRUCT *) p->
param)->day);
5290 #ifdef SQL_C_TYPE_TIME
5291 case SQL_C_TYPE_TIME:
5295 p->
s3type = SQLITE_FLOAT;
5296 p->
s3size =
sizeof (double);
5298 (((TIME_STRUCT *) p->
param)->hour * 3600000.0 +
5299 ((TIME_STRUCT *) p->
param)->minute * 60000.0 +
5300 ((TIME_STRUCT *) p->
param)->second * 1000.0) / 86400000.0;
5303 sprintf(p->
strbuf,
"%02d:%02d:%02d",
5304 ((TIME_STRUCT *) p->
param)->hour,
5305 ((TIME_STRUCT *) p->
param)->minute,
5306 ((TIME_STRUCT *) p->
param)->second);
5311 #ifdef SQL_C_TYPE_TIMESTAMP
5312 case SQL_C_TYPE_TIMESTAMP:
5314 case SQL_C_TIMESTAMP:
5316 int a, b, x1, x2, y, m, d;
5318 p->
s3type = SQLITE_FLOAT;
5319 p->
s3size =
sizeof (double);
5320 y = ((TIMESTAMP_STRUCT *) p->
param)->year;
5321 m = ((TIMESTAMP_STRUCT *) p->
param)->month;
5322 d = ((TIMESTAMP_STRUCT *) p->
param)->day;
5328 b = 2 - a + (a / 4);
5329 x1 = 36525 * (y + 4716) / 100;
5330 x2 = 306001 * (m + 1) / 10000;
5331 p->
s3dval = x1 + x2 + d + b - 1524.5 +
5332 (((TIMESTAMP_STRUCT *) p->
param)->hour * 3600000.0 +
5333 ((TIMESTAMP_STRUCT *) p->
param)->minute * 60000.0 +
5334 ((TIMESTAMP_STRUCT *) p->
param)->second * 1000.0 +
5335 ((TIMESTAMP_STRUCT *) p->
param)->fraction / 1.0E6)
5339 len = (int) ((TIMESTAMP_STRUCT *) p->
param)->fraction;
5346 sprintf(p->
strbuf,
"%04d-%02d-%02d %02d:%02d:00.000",
5347 ((TIMESTAMP_STRUCT *) p->
param)->year,
5348 ((TIMESTAMP_STRUCT *) p->
param)->month,
5349 ((TIMESTAMP_STRUCT *) p->
param)->day,
5350 ((TIMESTAMP_STRUCT *) p->
param)->hour,
5351 ((TIMESTAMP_STRUCT *) p->
param)->minute);
5353 sprintf(p->
strbuf,
"%04d-%02d-%02d %02d:%02d:%02d.000",
5354 ((TIMESTAMP_STRUCT *) p->
param)->year,
5355 ((TIMESTAMP_STRUCT *) p->
param)->month,
5356 ((TIMESTAMP_STRUCT *) p->
param)->day,
5357 ((TIMESTAMP_STRUCT *) p->
param)->hour,
5358 ((TIMESTAMP_STRUCT *) p->
param)->minute,
5359 ((TIMESTAMP_STRUCT *) p->
param)->second);
5361 sprintf(p->
strbuf,
"%04d-%02d-%02d %02d:%02d:%02d.%03d",
5362 ((TIMESTAMP_STRUCT *) p->
param)->year,
5363 ((TIMESTAMP_STRUCT *) p->
param)->month,
5364 ((TIMESTAMP_STRUCT *) p->
param)->day,
5365 ((TIMESTAMP_STRUCT *) p->
param)->hour,
5366 ((TIMESTAMP_STRUCT *) p->
param)->minute,
5367 ((TIMESTAMP_STRUCT *) p->
param)->second,
5376 setstat(s, -1,
"unsupported parameter type",
5377 (*s->
ov3) ?
"07009" :
"S1093");
5400 SQLSMALLINT buftype, SQLSMALLINT ptype, SQLUINTEGER coldef,
5402 SQLPOINTER data, SQLINTEGER buflen,
SQLLEN *len)
5407 if (
stmt == SQL_NULL_HSTMT) {
5408 return SQL_INVALID_HANDLE;
5412 setstat(s, -1,
"invalid parameter", (*s->
ov3) ?
"07009" :
"S1093");
5415 if (!data && !len) {
5416 setstat(s, -1,
"invalid buffer",
"HY003");
5436 int npar =
max(10, pnum + 1);
5446 case SQL_C_STINYINT:
5447 case SQL_C_UTINYINT:
5452 buflen =
sizeof (SQLCHAR);
5457 buflen =
sizeof (SQLSMALLINT);
5462 buflen =
sizeof (SQLINTEGER);
5465 buflen =
sizeof (float);
5468 buflen =
sizeof (double);
5470 case SQL_C_TIMESTAMP:
5471 #ifdef SQL_C_TYPE_TIMESTAMP
5472 case SQL_C_TYPE_TIMESTAMP:
5474 buflen =
sizeof (TIMESTAMP_STRUCT);
5477 #ifdef SQL_C_TYPE_TIME
5478 case SQL_C_TYPE_TIME:
5480 buflen =
sizeof (TIME_STRUCT);
5483 #ifdef SQL_C_TYPE_DATE
5484 case SQL_C_TYPE_DATE:
5486 buflen =
sizeof (DATE_STRUCT);
5488 #ifdef SQL_C_UBIGINT
5490 buflen =
sizeof (SQLBIGINT);
5493 #ifdef SQL_C_SBIGINT
5495 buflen =
sizeof (SQLBIGINT);
5500 buflen =
sizeof (SQLBIGINT);
5539 SQLSMALLINT buftype, SQLSMALLINT ptype,
SQLULEN coldef,
5547 scale, data, buflen, len);
5568 SQLSMALLINT ptype,
SQLULEN lenprec,
5569 SQLSMALLINT scale, SQLPOINTER val,
5576 lenprec, scale, val, 0, lenp);
5596 if (
stmt == SQL_NULL_HSTMT) {
5597 return SQL_INVALID_HANDLE;
5619 if (*p->
lenp == SQL_DATA_AT_EXEC) {
5622 p->
len = SQL_LEN_DATA_AT_EXEC(*p->
lenp);
5624 if (p->
len < 0 && p->
len != SQL_NTS &&
5625 p->
len != SQL_NULL_DATA) {
5626 setstat(s, -1,
"invalid length",
"HY009");
5639 return SQL_NEED_DATA;
5659 if (
stmt == SQL_NULL_HSTMT) {
5660 return SQL_INVALID_HANDLE;
5669 for (i = 0; i < s->
pdcount; i++) {
5674 p->
need = (type == SQL_C_CHAR || type == SQL_C_WCHAR) ? -1 : 0;
5680 *pind = (SQLPOINTER) p->
param0;
5705 SQLULEN *size, SQLSMALLINT *decdigits, SQLSMALLINT *nullable)
5708 SQLRETURN ret = SQL_ERROR;
5711 if (
stmt == SQL_NULL_HSTMT) {
5712 return SQL_INVALID_HANDLE;
5717 setstat(s, -1,
"invalid parameter index",
5718 (*s->
ov3) ?
"HY000" :
"S1000");
5722 #ifdef SQL_LONGVARCHAR
5724 *dtype = s->
nowchar[0] ? SQL_LONGVARCHAR : SQL_WLONGVARCHAR;
5726 *dtype = SQL_LONGVARCHAR;
5730 *dtype = s->
nowchar[0] ? SQL_VARCHAR : SQL_WVARCHAR;
5732 *dtype = SQL_VARCHAR;
5737 #ifdef SQL_LONGVARCHAR
5747 *nullable = SQL_NULLABLE;
5770 SQLSMALLINT sqltype,
SQLULEN coldef,
5771 SQLSMALLINT scale, SQLPOINTER val,
SQLLEN *nval)
5777 type, sqltype, coldef, scale, val,
5778 SQL_SETPARAM_VALUE_MAX, nval);
5804 SQLGetDescField(SQLHDESC handle, SQLSMALLINT recno,
5805 SQLSMALLINT fieldid, SQLPOINTER value,
5806 SQLINTEGER buflen, SQLINTEGER *strlen)
5819 SQLSMALLINT fieldid, SQLPOINTER value,
5820 SQLINTEGER buflen, SQLINTEGER *strlen)
5832 SQLSetDescField(SQLHDESC handle, SQLSMALLINT recno,
5833 SQLSMALLINT fieldid, SQLPOINTER value,
5847 SQLSMALLINT fieldid, SQLPOINTER value,
5860 SQLGetDescRec(SQLHDESC handle, SQLSMALLINT recno,
5861 SQLCHAR *name, SQLSMALLINT buflen,
5862 SQLSMALLINT *strlen, SQLSMALLINT *type,
5863 SQLSMALLINT *subtype,
SQLLEN *len,
5864 SQLSMALLINT *prec, SQLSMALLINT *scale,
5865 SQLSMALLINT *nullable)
5878 SQLWCHAR *name, SQLSMALLINT buflen,
5879 SQLSMALLINT *strlen, SQLSMALLINT *type,
5880 SQLSMALLINT *subtype,
SQLLEN *len,
5881 SQLSMALLINT *prec, SQLSMALLINT *scale,
5882 SQLSMALLINT *nullable)
5894 SQLSMALLINT type, SQLSMALLINT subtype,
5895 SQLLEN len, SQLSMALLINT prec,
5896 SQLSMALLINT scale, SQLPOINTER data,
5915 int ncols3,
int *nret)
5920 if (
stmt == SQL_NULL_HSTMT) {
5921 return SQL_INVALID_HANDLE;
5924 if (s->
dbc == SQL_NULL_HDBC) {
5934 if (colspec3 && *s->
ov3) {
5957 {
"SYSTEM",
"TABLEPRIV",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
5958 {
"SYSTEM",
"TABLEPRIV",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
5959 {
"SYSTEM",
"TABLEPRIV",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
5960 {
"SYSTEM",
"TABLEPRIV",
"GRANTOR",
SCOL_VARCHAR, 50 },
5961 {
"SYSTEM",
"TABLEPRIV",
"GRANTEE",
SCOL_VARCHAR, 50 },
5962 {
"SYSTEM",
"TABLEPRIV",
"PRIVILEGE",
SCOL_VARCHAR, 50 },
5963 {
"SYSTEM",
"TABLEPRIV",
"IS_GRANTABLE",
SCOL_VARCHAR, 50 }
5967 {
"SYSTEM",
"TABLEPRIV",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
5968 {
"SYSTEM",
"TABLEPRIV",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
5969 {
"SYSTEM",
"TABLEPRIV",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
5970 {
"SYSTEM",
"TABLEPRIV",
"GRANTOR",
SCOL_VARCHAR, 50 },
5971 {
"SYSTEM",
"TABLEPRIV",
"GRANTEE",
SCOL_VARCHAR, 50 },
5972 {
"SYSTEM",
"TABLEPRIV",
"PRIVILEGE",
SCOL_VARCHAR, 50 },
5973 {
"SYSTEM",
"TABLEPRIV",
"IS_GRANTABLE",
SCOL_VARCHAR, 50 }
5990 SQLCHAR *cat, SQLSMALLINT catLen,
5991 SQLCHAR *schema, SQLSMALLINT schemaLen,
5992 SQLCHAR *table, SQLSMALLINT tableLen)
5997 int ncols, rc, size, npatt;
5998 char *errp = NULL, *sql, tname[512];
6002 if (ret != SQL_SUCCESS) {
6007 if (cat && (catLen > 0 || catLen == SQL_NTS) && cat[0] ==
'%') {
6011 if (schema && (schemaLen > 0 || schemaLen == SQL_NTS) &&
6013 if ((!cat || catLen == 0 || !cat[0]) &&
6014 (!table || tableLen == 0 || !table[0])) {
6024 if (tableLen == SQL_NTS) {
6025 size =
sizeof (tname) - 1;
6027 size =
min(
sizeof (tname) - 1, tableLen);
6029 strncpy(tname, (
char *) table, size);
6033 #if defined(_WIN32) || defined(_WIN64)
6035 sql = sqlite3_mprintf(
"select %s as 'TABLE_QUALIFIER', "
6036 "%s as 'TABLE_OWNER', "
6037 "tbl_name as 'TABLE_NAME', "
6040 "'SELECT' AS 'PRIVILEGE', "
6041 "NULL as 'IS_GRANTABLE' "
6042 "from sqlite_master where "
6043 "(type = 'table' or type = 'view') "
6044 "and tbl_name like %Q "
6046 "select %s as 'TABLE_QUALIFIER', "
6047 "%s as 'TABLE_OWNER', "
6048 "tbl_name as 'TABLE_NAME', "
6051 "'UPDATE' AS 'PRIVILEGE', "
6052 "NULL as 'IS_GRANTABLE' "
6053 "from sqlite_master where "
6054 "(type = 'table' or type = 'view') "
6055 "and tbl_name like %Q "
6057 "select %s as 'TABLE_QUALIFIER', "
6058 "%s as 'TABLE_OWNER', "
6059 "tbl_name as 'TABLE_NAME', "
6062 "'DELETE' AS 'PRIVILEGE', "
6063 "NULL as 'IS_GRANTABLE' "
6064 "from sqlite_master where "
6065 "(type = 'table' or type = 'view') "
6066 "and tbl_name like %Q "
6068 "select %s as 'TABLE_QUALIFIER', "
6069 "%s as 'TABLE_OWNER', "
6070 "tbl_name as 'TABLE_NAME', "
6073 "'INSERT' AS 'PRIVILEGE', "
6074 "NULL as 'IS_GRANTABLE' "
6075 "from sqlite_master where "
6076 "(type = 'table' or type = 'view') "
6077 "and tbl_name like %Q "
6079 "select %s as 'TABLE_QUALIFIER', "
6080 "%s as 'TABLE_OWNER', "
6081 "tbl_name as 'TABLE_NAME', "
6084 "'REFERENCES' AS 'PRIVILEGE', "
6085 "NULL as 'IS_GRANTABLE' "
6086 "from sqlite_master where "
6087 "(type = 'table' or type = 'view') "
6088 "and tbl_name like %Q",
6089 d->xcelqrx ?
"'main'" :
"NULL",
6090 d->xcelqrx ?
"''" :
"NULL",
6092 d->xcelqrx ?
"'main'" :
"NULL",
6093 d->xcelqrx ?
"''" :
"NULL",
6095 d->xcelqrx ?
"'main'" :
"NULL",
6096 d->xcelqrx ?
"''" :
"NULL",
6098 d->xcelqrx ?
"'main'" :
"NULL",
6099 d->xcelqrx ?
"''" :
"NULL",
6101 d->xcelqrx ?
"'main'" :
"NULL",
6102 d->xcelqrx ?
"''" :
"NULL",
6105 sql = sqlite3_mprintf(
"select %s as 'TABLE_QUALIFIER', "
6106 "%s as 'TABLE_OWNER', "
6107 "tbl_name as 'TABLE_NAME', "
6110 "'SELECT' AS 'PRIVILEGE', "
6111 "NULL as 'IS_GRANTABLE' "
6112 "from sqlite_master where "
6113 "(type = 'table' or type = 'view') "
6114 "and lower(tbl_name) = lower(%Q) "
6116 "select %s as 'TABLE_QUALIFIER', "
6117 "%s as 'TABLE_OWNER', "
6118 "tbl_name as 'TABLE_NAME', "
6121 "'UPDATE' AS 'PRIVILEGE', "
6122 "NULL as 'IS_GRANTABLE' "
6123 "from sqlite_master where "
6124 "(type = 'table' or type = 'view') "
6125 "and lower(tbl_name) = lower(%Q) "
6127 "select %s as 'TABLE_QUALIFIER', "
6128 "%s as 'TABLE_OWNER', "
6129 "tbl_name as 'TABLE_NAME', "
6132 "'DELETE' AS 'PRIVILEGE', "
6133 "NULL as 'IS_GRANTABLE' "
6134 "from sqlite_master where "
6135 "(type = 'table' or type = 'view') "
6136 "and lower(tbl_name) = lower(%Q) "
6138 "select %s as 'TABLE_QUALIFIER', "
6139 "%s as 'TABLE_OWNER', "
6140 "tbl_name as 'TABLE_NAME', "
6143 "'INSERT' AS 'PRIVILEGE', "
6144 "NULL as 'IS_GRANTABLE' "
6145 "from sqlite_master where "
6146 "(type = 'table' or type = 'view') "
6147 "and lower(tbl_name) = lower(%Q) "
6149 "select %s as 'TABLE_QUALIFIER', "
6150 "%s as 'TABLE_OWNER', "
6151 "tbl_name as 'TABLE_NAME', "
6154 "'REFERENCES' AS 'PRIVILEGE', "
6155 "NULL as 'IS_GRANTABLE' "
6156 "from sqlite_master where "
6157 "(type = 'table' or type = 'view') "
6158 "and lower(tbl_name) = lower(%Q)",
6159 d->xcelqrx ?
"'main'" :
"NULL",
6160 d->xcelqrx ?
"''" :
"NULL",
6162 d->xcelqrx ?
"'main'" :
"NULL",
6163 d->xcelqrx ?
"''" :
"NULL",
6165 d->xcelqrx ?
"'main'" :
"NULL",
6166 d->xcelqrx ?
"''" :
"NULL",
6168 d->xcelqrx ?
"'main'" :
"NULL",
6169 d->xcelqrx ?
"''" :
"NULL",
6171 d->xcelqrx ?
"'main'" :
"NULL",
6172 d->xcelqrx ?
"''" :
"NULL",
6177 sql = sqlite3_mprintf(
"select NULL as 'TABLE_QUALIFIER', "
6178 "NULL as 'TABLE_OWNER', "
6179 "tbl_name as 'TABLE_NAME', "
6182 "'SELECT' AS 'PRIVILEGE', "
6183 "NULL as 'IS_GRANTABLE' "
6184 "from sqlite_master where "
6185 "(type = 'table' or type = 'view') "
6186 "and tbl_name like %Q "
6188 "select NULL as 'TABLE_QUALIFIER', "
6189 "NULL as 'TABLE_OWNER', "
6190 "tbl_name as 'TABLE_NAME', "
6193 "'UPDATE' AS 'PRIVILEGE', "
6194 "NULL as 'IS_GRANTABLE' "
6195 "from sqlite_master where "
6196 "(type = 'table' or type = 'view') "
6197 "and tbl_name like %Q "
6199 "select NULL as 'TABLE_QUALIFIER', "
6200 "NULL as 'TABLE_OWNER', "
6201 "tbl_name as 'TABLE_NAME', "
6204 "'DELETE' AS 'PRIVILEGE', "
6205 "NULL as 'IS_GRANTABLE' "
6206 "from sqlite_master where "
6207 "(type = 'table' or type = 'view') "
6208 "and tbl_name like %Q "
6210 "select NULL as 'TABLE_QUALIFIER', "
6211 "NULL as 'TABLE_OWNER', "
6212 "tbl_name as 'TABLE_NAME', "
6215 "'INSERT' AS 'PRIVILEGE', "
6216 "NULL as 'IS_GRANTABLE' "
6217 "from sqlite_master where "
6218 "(type = 'table' or type = 'view') "
6219 "and tbl_name like %Q "
6221 "select NULL as 'TABLE_QUALIFIER', "
6222 "NULL as 'TABLE_OWNER', "
6223 "tbl_name as 'TABLE_NAME', "
6226 "'REFERENCES' AS 'PRIVILEGE', "
6227 "NULL as 'IS_GRANTABLE' "
6228 "from sqlite_master where "
6229 "(type = 'table' or type = 'view') "
6230 "and tbl_name like %Q",
6231 tname, tname, tname, tname, tname);
6233 sql = sqlite3_mprintf(
"select NULL as 'TABLE_QUALIFIER', "
6234 "NULL as 'TABLE_OWNER', "
6235 "tbl_name as 'TABLE_NAME', "
6238 "'SELECT' AS 'PRIVILEGE', "
6239 "NULL as 'IS_GRANTABLE' "
6240 "from sqlite_master where "
6241 "(type = 'table' or type = 'view') "
6242 "and lower(tbl_name) = lower(%Q) "
6244 "select NULL as 'TABLE_QUALIFIER', "
6245 "NULL as 'TABLE_OWNER', "
6246 "tbl_name as 'TABLE_NAME', "
6249 "'UPDATE' AS 'PRIVILEGE', "
6250 "NULL as 'IS_GRANTABLE' "
6251 "from sqlite_master where "
6252 "(type = 'table' or type = 'view') "
6253 "and lower(tbl_name) = lower(%Q) "
6255 "select NULL as 'TABLE_QUALIFIER', "
6256 "NULL as 'TABLE_OWNER', "
6257 "tbl_name as 'TABLE_NAME', "
6260 "'DELETE' AS 'PRIVILEGE', "
6261 "NULL as 'IS_GRANTABLE' "
6262 "from sqlite_master where "
6263 "(type = 'table' or type = 'view') "
6264 "and lower(tbl_name) = lower(%Q) "
6266 "select NULL as 'TABLE_QUALIFIER', "
6267 "NULL as 'TABLE_OWNER', "
6268 "tbl_name as 'TABLE_NAME', "
6271 "'INSERT' AS 'PRIVILEGE', "
6272 "NULL as 'IS_GRANTABLE' "
6273 "from sqlite_master where "
6274 "(type = 'table' or type = 'view') "
6275 "and lower(tbl_name) = lower(%Q) "
6277 "select NULL as 'TABLE_QUALIFIER', "
6278 "NULL as 'TABLE_OWNER', "
6279 "tbl_name as 'TABLE_NAME', "
6282 "'REFERENCES' AS 'PRIVILEGE', "
6283 "NULL as 'IS_GRANTABLE' "
6284 "from sqlite_master where "
6285 "(type = 'table' or type = 'view') "
6286 "and lower(tbl_name) = lower(%Q)",
6287 tname, tname, tname, tname, tname);
6294 if (ret != SQL_SUCCESS) {
6299 rc = sqlite3_get_table(d->
sqlite, sql, &s->
rows, &s->
nrows, &ncols, &errp);
6301 if (rc == SQLITE_OK) {
6302 if (ncols != s->
ncols) {
6306 s->
rowfree = sqlite3_free_table;
6322 #if !defined(WINTERFACE) || (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC))
6336 SQLTablePrivileges(SQLHSTMT
stmt,
6337 SQLCHAR *catalog, SQLSMALLINT catalogLen,
6338 SQLCHAR *schema, SQLSMALLINT schemaLen,
6339 SQLCHAR *table, SQLSMALLINT tableLen)
6341 #if defined(_WIN32) || defined(_WIN64)
6342 char *c = NULL, *s = NULL, *t = NULL;
6347 #if defined(_WIN32) || defined(_WIN64)
6354 c = wmb_to_utf_c((
char *) catalog, catalogLen);
6361 s = wmb_to_utf_c((
char *) schema, schemaLen);
6368 t = wmb_to_utf_c((
char *) table, tableLen);
6375 (SQLCHAR *) s, SQL_NTS,
6376 (SQLCHAR *) t, SQL_NTS);
6381 #if defined(_WIN32) || defined(_WIN64)
6394 #if !defined(HAVE_UNIXODBC) || !(HAVE_UNIXODBC)
6410 SQLWCHAR *catalog, SQLSMALLINT catalogLen,
6411 SQLWCHAR *schema, SQLSMALLINT schemaLen,
6412 SQLWCHAR *table, SQLSMALLINT tableLen)
6414 char *c = NULL, *s = NULL, *t = NULL;
6440 (SQLCHAR *) s, SQL_NTS,
6441 (SQLCHAR *) t, SQL_NTS);
6457 {
"SYSTEM",
"COLPRIV",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
6458 {
"SYSTEM",
"COLPRIV",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
6459 {
"SYSTEM",
"COLPRIV",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
6460 {
"SYSTEM",
"COLPRIV",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6467 {
"SYSTEM",
"COLPRIV",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
6468 {
"SYSTEM",
"COLPRIV",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
6469 {
"SYSTEM",
"COLPRIV",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
6470 {
"SYSTEM",
"COLPRIV",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6476 #if !defined(WINTERFACE) || (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC))
6492 SQLColumnPrivileges(SQLHSTMT
stmt,
6493 SQLCHAR *catalog, SQLSMALLINT catalogLen,
6494 SQLCHAR *schema, SQLSMALLINT schemaLen,
6495 SQLCHAR *table, SQLSMALLINT tableLen,
6496 SQLCHAR *column, SQLSMALLINT columnLen)
6508 #if !defined(HAVE_UNIXODBC) || !(HAVE_UNIXODBC)
6526 SQLWCHAR *catalog, SQLSMALLINT catalogLen,
6527 SQLWCHAR *schema, SQLSMALLINT schemaLen,
6528 SQLWCHAR *table, SQLSMALLINT tableLen,
6529 SQLWCHAR *column, SQLSMALLINT columnLen)
6547 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
6548 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
6549 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
6550 {
"SYSTEM",
"PRIMARYKEY",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6551 {
"SYSTEM",
"PRIMARYKEY",
"KEY_SEQ", SQL_SMALLINT, 50 },
6552 {
"SYSTEM",
"PRIMARYKEY",
"PK_NAME",
SCOL_VARCHAR, 50 }
6556 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
6557 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
6558 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
6559 {
"SYSTEM",
"PRIMARYKEY",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6560 {
"SYSTEM",
"PRIMARYKEY",
"KEY_SEQ", SQL_SMALLINT, 50 },
6561 {
"SYSTEM",
"PRIMARYKEY",
"PK_NAME",
SCOL_VARCHAR, 50 }
6578 SQLCHAR *cat, SQLSMALLINT catLen,
6579 SQLCHAR *schema, SQLSMALLINT schemaLen,
6580 SQLCHAR *table, SQLSMALLINT tableLen)
6585 int i, asize, ret, nrows, ncols, nrows2 = 0, ncols2 = 0;
6586 int namec = -1, uniquec = -1, namec2 = -1, uniquec2 = -1, offs, seq = 1;
6588 char **rowp = NULL, **rowp2 = NULL, *errp = NULL, *sql, tname[512];
6592 if (sret != SQL_SUCCESS) {
6597 if (!table || table[0] ==
'\0' || table[0] ==
'%') {
6598 setstat(s, -1,
"need table name", (*s->
ov3) ?
"HY000" :
"S1000");
6601 if (tableLen == SQL_NTS) {
6602 size =
sizeof (tname) - 1;
6604 size =
min(
sizeof (tname) - 1, tableLen);
6606 strncpy(tname, (
char *) table, size);
6609 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", tname);
6614 if (sret != SQL_SUCCESS) {
6619 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
6621 if (ret != SQLITE_OK) {
6622 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
6623 errp ? errp :
"unknown error", ret);
6635 if (ncols * nrows > 0) {
6638 namec =
findcol(rowp, ncols,
"name");
6639 uniquec =
findcol(rowp, ncols,
"pk");
6640 typec =
findcol(rowp, ncols,
"type");
6641 if (namec >= 0 && uniquec >= 0 && typec >= 0) {
6642 for (i = 1; i <= nrows; i++) {
6643 if (*rowp[i * ncols + uniquec] !=
'0') {
6650 sql = sqlite3_mprintf(
"PRAGMA index_list(%Q)", tname);
6652 sqlite3_free_table(rowp);
6656 ret = sqlite3_get_table(d->
sqlite, sql, &rowp2, &nrows2, &ncols2,
6659 if (ret != SQLITE_OK) {
6660 sqlite3_free_table(rowp);
6661 sqlite3_free_table(rowp2);
6662 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
6663 errp ? errp :
"unknown error", ret);
6675 if (ncols2 * nrows2 > 0) {
6676 namec2 =
findcol(rowp2, ncols2,
"name");
6677 uniquec2 =
findcol(rowp2, ncols2,
"unique");
6678 if (namec2 >= 0 && uniquec2 >= 0) {
6679 for (i = 1; i <= nrows2; i++) {
6680 int nnrows, nncols, nlen = 0;
6683 if (rowp2[i * ncols2 + namec2]) {
6684 nlen = strlen(rowp2[i * ncols2 + namec2]);
6687 strncmp(rowp2[i * ncols2 + namec2],
6688 "sqlite_autoindex_", 17)) {
6691 if (*rowp2[i * ncols2 + uniquec2] !=
'0') {
6693 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
6694 rowp2[i * ncols2 + namec2]);
6697 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
6698 &nnrows, &nncols, NULL);
6701 if (ret == SQLITE_OK) {
6703 sqlite3_free_table(rowpp);
6710 sqlite3_free_table(rowp);
6711 sqlite3_free_table(rowp2);
6715 size = (size + 1) * asize;
6719 sqlite3_free_table(rowp);
6720 sqlite3_free_table(rowp2);
6723 s->
rows[0] = (
char *) size;
6725 memset(s->
rows, 0, sizeof (
char *) * size);
6729 for (i = 1; i <= nrows; i++) {
6730 if (*rowp[i * ncols + uniquec] !=
'0') {
6733 #if defined(_WIN32) || defined(_WIN64)
6734 s->
rows[offs + 0] =
xstrdup(d->xcelqrx ?
"main" :
"");
6741 s->
rows[offs + 3] =
xstrdup(rowp[i * ncols + namec]);
6742 sprintf(buf,
"%d", seq++);
6749 for (i = 1; i <= nrows2; i++) {
6750 int nnrows, nncols, nlen = 0;
6753 if (rowp2[i * ncols2 + namec2]) {
6754 nlen = strlen(rowp2[i * ncols2 + namec2]);
6757 strncmp(rowp2[i * ncols2 + namec2],
"sqlite_autoindex_", 17)) {
6760 if (*rowp2[i * ncols2 + uniquec2] !=
'0') {
6764 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
6765 rowp2[i * ncols2 + namec2]);
6768 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
6769 &nnrows, &nncols, NULL);
6772 if (ret != SQLITE_OK) {
6775 for (k = 0; nnrows && k < nncols; k++) {
6776 if (strcmp(rowpp[k],
"name") == 0) {
6779 for (m = 1; m <= nnrows; m++) {
6780 int roffs = offs + (m - 1) * s->
ncols;
6782 #
if defined(_WIN32) || defined(_WIN64)
6783 s->
rows[roffs + 0] =
6784 xstrdup(d->xcelqrx ?
"main" :
"");
6791 s->
rows[roffs + 3] =
6792 xstrdup(rowpp[m * nncols + k]);
6793 s->
rows[roffs + 5] =
6794 xstrdup(rowp2[i * ncols2 + namec2]);
6796 }
else if (strcmp(rowpp[k],
"seqno") == 0) {
6799 for (m = 1; m <= nnrows; m++) {
6800 int roffs = offs + (m - 1) * s->
ncols;
6804 sscanf(rowpp[m * nncols + k],
"%d", &pos);
6805 sprintf(buf,
"%d", pos + 1);
6810 offs += nnrows * s->
ncols;
6811 sqlite3_free_table(rowpp);
6815 sqlite3_free_table(rowp);
6816 sqlite3_free_table(rowp2);
6834 SQLPrimaryKeys(SQLHSTMT
stmt,
6835 SQLCHAR *cat, SQLSMALLINT catLen,
6836 SQLCHAR *schema, SQLSMALLINT schemaLen,
6837 SQLCHAR *table, SQLSMALLINT tableLen)
6839 #if defined(_WIN32) || defined(_WIN64)
6840 char *c = NULL, *s = NULL, *t = NULL;
6845 #if defined(_WIN32) || defined(_WIN64)
6852 c = wmb_to_utf_c((
char *) cat, catLen);
6859 s = wmb_to_utf_c((
char *) schema, schemaLen);
6866 t = wmb_to_utf_c((
char *) table, tableLen);
6873 (SQLCHAR *) s, SQL_NTS, (SQLCHAR *) t, SQL_NTS);
6878 #if defined(_WIN32) || defined(_WIN64)
6906 SQLWCHAR *cat, SQLSMALLINT catLen,
6907 SQLWCHAR *schema, SQLSMALLINT schemaLen,
6908 SQLWCHAR *table, SQLSMALLINT tableLen)
6910 char *c = NULL, *s = NULL, *t = NULL;
6936 (SQLCHAR *) s, SQL_NTS, (SQLCHAR *) t, SQL_NTS);
6951 {
"SYSTEM",
"COLUMN",
"SCOPE", SQL_SMALLINT, 1 },
6952 {
"SYSTEM",
"COLUMN",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6953 {
"SYSTEM",
"COLUMN",
"DATA_TYPE", SQL_SMALLINT, 50 },
6955 {
"SYSTEM",
"COLUMN",
"PRECISION", SQL_INTEGER, 50 },
6956 {
"SYSTEM",
"COLUMN",
"LENGTH", SQL_INTEGER, 50 },
6957 {
"SYSTEM",
"COLUMN",
"DECIMAL_DIGITS", SQL_INTEGER, 50 },
6958 {
"SYSTEM",
"COLUMN",
"PSEUDO_COLUMN", SQL_SMALLINT, 1 },
6959 {
"SYSTEM",
"COLUMN",
"NULLABLE", SQL_SMALLINT, 1 }
6963 {
"SYSTEM",
"COLUMN",
"SCOPE", SQL_SMALLINT, 1 },
6964 {
"SYSTEM",
"COLUMN",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6965 {
"SYSTEM",
"COLUMN",
"DATA_TYPE", SQL_SMALLINT, 50 },
6967 {
"SYSTEM",
"COLUMN",
"COLUMN_SIZE", SQL_INTEGER, 50 },
6968 {
"SYSTEM",
"COLUMN",
"BUFFER_LENGTH", SQL_INTEGER, 50 },
6969 {
"SYSTEM",
"COLUMN",
"DECIMAL_DIGITS", SQL_INTEGER, 50 },
6970 {
"SYSTEM",
"COLUMN",
"PSEUDO_COLUMN", SQL_SMALLINT, 1 },
6971 {
"SYSTEM",
"COLUMN",
"NULLABLE", SQL_SMALLINT, 1 }
6991 SQLCHAR *cat, SQLSMALLINT catLen,
6992 SQLCHAR *schema, SQLSMALLINT schemaLen,
6993 SQLCHAR *table, SQLSMALLINT tableLen,
6994 SQLUSMALLINT scope, SQLUSMALLINT nullable)
6999 int i, asize, ret, nrows, ncols, nnnrows, nnncols, offs;
7001 int namec = -1, uniquec = -1, namecc = -1, typecc = -1;
7002 int notnullcc = -1, mkrowid = 0;
7003 char *errp = NULL, *sql, tname[512];
7004 char **rowp = NULL, **rowppp = NULL;
7008 if (sret != SQL_SUCCESS) {
7013 if (!table || table[0] ==
'\0' || table[0] ==
'%') {
7014 setstat(s, -1,
"need table name", (*s->
ov3) ?
"HY000" :
"S1000");
7017 if (tableLen == SQL_NTS) {
7018 size =
sizeof (tname) - 1;
7020 size =
min(
sizeof (tname) - 1, tableLen);
7022 strncpy(tname, (
char *) table, size);
7025 if (
id != SQL_BEST_ROWID) {
7028 sql = sqlite3_mprintf(
"PRAGMA index_list(%Q)", tname);
7033 if (sret != SQL_SUCCESS) {
7038 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
7040 if (ret != SQLITE_OK) {
7042 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
7043 errp ? errp :
"unknown error", ret);
7055 if (ncols * nrows <= 0) {
7056 goto nodata_but_rowid;
7058 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", tname);
7063 ret = sqlite3_get_table(d->
sqlite, sql, &rowppp, &nnnrows, &nnncols,
7066 if (ret != SQLITE_OK) {
7067 sqlite3_free_table(rowp);
7074 namec =
findcol(rowp, ncols,
"name");
7075 uniquec =
findcol(rowp, ncols,
"unique");
7076 if (namec < 0 || uniquec < 0) {
7077 goto nodata_but_rowid;
7079 namecc =
findcol(rowppp, nnncols,
"name");
7080 typecc =
findcol(rowppp, nnncols,
"type");
7081 notnullcc =
findcol(rowppp, nnncols,
"notnull");
7082 for (i = 1; i <= nrows; i++) {
7084 char **rowpp = NULL;
7086 if (*rowp[i * ncols + uniquec] !=
'0') {
7088 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
7089 rowp[i * ncols + namec]);
7092 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
7093 &nnrows, &nncols, NULL);
7096 if (ret == SQLITE_OK) {
7098 sqlite3_free_table(rowpp);
7108 size = (size + 1) * asize;
7112 sqlite3_free_table(rowp);
7113 sqlite3_free_table(rowppp);
7116 s->
rows[0] = (
char *) size;
7118 memset(s->
rows, 0, sizeof (
char *) * size);
7125 for (i = 1; i <= nrows; i++) {
7127 char **rowpp = NULL;
7129 if (*rowp[i * ncols + uniquec] !=
'0') {
7133 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
7134 rowp[i * ncols + namec]);
7137 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
7138 &nnrows, &nncols, NULL);
7141 if (ret != SQLITE_OK) {
7144 for (k = 0; nnrows && k < nncols; k++) {
7145 if (strcmp(rowpp[k],
"name") == 0) {
7148 for (m = 1; m <= nnrows; m++) {
7149 int roffs = (offs + m) * s->
ncols;
7151 s->
rows[roffs + 0] =
7153 s->
rows[roffs + 1] =
xstrdup(rowpp[m * nncols + k]);
7155 s->
rows[roffs + 7] =
7157 if (namecc >= 0 && typecc >= 0) {
7160 for (ii = 1; ii <= nnnrows; ii++) {
7161 if (strcmp(rowppp[ii * nnncols + namecc],
7162 rowpp[m * nncols + k]) == 0) {
7163 char *typen = rowppp[ii * nnncols + typecc];
7164 int sqltype, mm, dd, isnullable = 0;
7171 getmd(typen, sqltype, &mm, &dd);
7172 #ifdef SQL_LONGVARCHAR
7173 if (sqltype == SQL_VARCHAR && mm > 255) {
7174 sqltype = SQL_LONGVARCHAR;
7178 #ifdef SQL_WLONGVARCHAR
7179 if (sqltype == SQL_WVARCHAR && mm > 255) {
7180 sqltype = SQL_WLONGVARCHAR;
7184 if (sqltype == SQL_VARBINARY && mm > 255) {
7185 sqltype = SQL_LONGVARBINARY;
7187 sprintf(buf,
"%d", sqltype);
7189 sprintf(buf,
"%d", mm);
7191 sprintf(buf,
"%d", dd);
7193 if (notnullcc >= 0) {
7195 rowppp[ii * nnncols + notnullcc];
7197 isnullable = inp[0] !=
'0';
7199 sprintf(buf,
"%d", isnullable);
7208 sqlite3_free_table(rowpp);
7211 if (nullable == SQL_NO_NULLS) {
7212 for (i = 1; i < s->
nrows; i++) {
7213 if (s->
rows[i * s->
ncols + 8][0] ==
'0') {
7216 for (m = 0; m < s->
ncols; m++) {
7219 size = s->
ncols *
sizeof (
char *) * (s->
nrows - i1);
7225 s->
ncols * sizeof (
char *));
7233 sqlite3_free_table(rowp);
7234 sqlite3_free_table(rowppp);
7235 if (s->
nrows == 0) {
7267 SQLSpecialColumns(SQLHSTMT
stmt, SQLUSMALLINT
id,
7268 SQLCHAR *cat, SQLSMALLINT catLen,
7269 SQLCHAR *schema, SQLSMALLINT schemaLen,
7270 SQLCHAR *table, SQLSMALLINT tableLen,
7271 SQLUSMALLINT scope, SQLUSMALLINT nullable)
7273 #if defined(_WIN32) || defined(_WIN64)
7274 char *c = NULL, *s = NULL, *t = NULL;
7279 #if defined(_WIN32) || defined(_WIN64)
7282 table, tableLen, scope, nullable);
7286 c = wmb_to_utf_c((
char *) cat, catLen);
7293 s = wmb_to_utf_c((
char *) schema, schemaLen);
7300 t = wmb_to_utf_c((
char *) table, tableLen);
7307 (SQLCHAR *) s, SQL_NTS, (SQLCHAR *) t, SQL_NTS,
7311 table, tableLen, scope, nullable);
7313 #if defined(_WIN32) || defined(_WIN64)
7344 SQLWCHAR *cat, SQLSMALLINT catLen,
7345 SQLWCHAR *schema, SQLSMALLINT schemaLen,
7346 SQLWCHAR *table, SQLSMALLINT tableLen,
7347 SQLUSMALLINT scope, SQLUSMALLINT nullable)
7349 char *c = NULL, *s = NULL, *t = NULL;
7375 (SQLCHAR *) s, SQL_NTS, (SQLCHAR *) t, SQL_NTS,
7391 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
7392 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_OWNER",
SCOL_VARCHAR, 50 },
7393 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_NAME",
SCOL_VARCHAR, 255 },
7394 {
"SYSTEM",
"FOREIGNKEY",
"PKCOLUMN_NAME",
SCOL_VARCHAR, 255 },
7395 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
7396 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_OWNER",
SCOL_VARCHAR, 50 },
7397 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_NAME",
SCOL_VARCHAR, 255 },
7398 {
"SYSTEM",
"FOREIGNKEY",
"FKCOLUMN_NAME",
SCOL_VARCHAR, 255 },
7399 {
"SYSTEM",
"FOREIGNKEY",
"KEY_SEQ", SQL_SMALLINT, 5 },
7400 {
"SYSTEM",
"FOREIGNKEY",
"UPDATE_RULE", SQL_SMALLINT, 5 },
7401 {
"SYSTEM",
"FOREIGNKEY",
"DELETE_RULE", SQL_SMALLINT, 5 },
7402 {
"SYSTEM",
"FOREIGNKEY",
"FK_NAME",
SCOL_VARCHAR, 255 },
7403 {
"SYSTEM",
"FOREIGNKEY",
"PK_NAME",
SCOL_VARCHAR, 255 },
7404 {
"SYSTEM",
"FOREIGNKEY",
"DEFERRABILITY", SQL_SMALLINT, 5 }
7408 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_CAT",
SCOL_VARCHAR, 50 },
7409 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_SCHEM",
SCOL_VARCHAR, 50 },
7410 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_NAME",
SCOL_VARCHAR, 255 },
7411 {
"SYSTEM",
"FOREIGNKEY",
"PKCOLUMN_NAME",
SCOL_VARCHAR, 255 },
7412 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_CAT",
SCOL_VARCHAR, 50 },
7413 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_SCHEM",
SCOL_VARCHAR, 50 },
7414 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_NAME",
SCOL_VARCHAR, 255 },
7415 {
"SYSTEM",
"FOREIGNKEY",
"FKCOLUMN_NAME",
SCOL_VARCHAR, 255 },
7416 {
"SYSTEM",
"FOREIGNKEY",
"KEY_SEQ", SQL_SMALLINT, 5 },
7417 {
"SYSTEM",
"FOREIGNKEY",
"UPDATE_RULE", SQL_SMALLINT, 5 },
7418 {
"SYSTEM",
"FOREIGNKEY",
"DELETE_RULE", SQL_SMALLINT, 5 },
7419 {
"SYSTEM",
"FOREIGNKEY",
"FK_NAME",
SCOL_VARCHAR, 255 },
7420 {
"SYSTEM",
"FOREIGNKEY",
"PK_NAME",
SCOL_VARCHAR, 255 },
7421 {
"SYSTEM",
"FOREIGNKEY",
"DEFERRABILITY", SQL_SMALLINT, 5 }
7444 SQLCHAR *PKcatalog, SQLSMALLINT PKcatalogLen,
7445 SQLCHAR *PKschema, SQLSMALLINT PKschemaLen,
7446 SQLCHAR *PKtable, SQLSMALLINT PKtableLen,
7447 SQLCHAR *FKcatalog, SQLSMALLINT FKcatalogLen,
7448 SQLCHAR *FKschema, SQLSMALLINT FKschemaLen,
7449 SQLCHAR *FKtable, SQLSMALLINT FKtableLen)
7454 int i, asize, ret, nrows, ncols, offs, namec, seqc, fromc, toc;
7457 char **rowp, *errp = NULL, *sql, pname[512], fname[512];
7461 if (sret != SQL_SUCCESS) {
7466 if (sret != SQL_SUCCESS) {
7470 if ((!PKtable || PKtable[0] ==
'\0' || PKtable[0] ==
'%') &&
7471 (!FKtable || FKtable[0] ==
'\0' || FKtable[0] ==
'%')) {
7472 setstat(s, -1,
"need table name", (*s->
ov3) ?
"HY000" :
"S1000");
7477 if (PKtableLen == SQL_NTS) {
7478 size =
sizeof (pname) - 1;
7480 size =
min(
sizeof (pname) - 1, PKtableLen);
7482 strncpy(pname, (
char *) PKtable, size);
7488 if (FKtableLen == SQL_NTS) {
7489 size =
sizeof (fname) - 1;
7491 size =
min(
sizeof (fname) - 1, FKtableLen);
7493 strncpy(fname, (
char *) FKtable, size);
7496 if (fname[0] !=
'\0') {
7500 sql = sqlite3_mprintf(
"PRAGMA foreign_key_list(%Q)", fname);
7503 ret = sqlite3_get_table(d->
sqlite, sql, &rowp,
7504 &nrows, &ncols, &errp);
7507 if (ret != SQLITE_OK) {
7508 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
7509 errp ? errp :
"unknown error", ret);
7520 if (ncols * nrows <= 0) {
7522 sqlite3_free_table(rowp);
7526 namec =
findcol(rowp, ncols,
"table");
7527 seqc =
findcol(rowp, ncols,
"seq");
7528 fromc =
findcol(rowp, ncols,
"from");
7529 toc =
findcol(rowp, ncols,
"to");
7530 onu =
findcol(rowp, ncols,
"on_update");
7531 ond =
findcol(rowp, ncols,
"on_delete");
7532 if (namec < 0 || seqc < 0 || fromc < 0 || toc < 0) {
7535 plen = strlen(pname);
7536 for (i = 1; i <= nrows; i++) {
7537 char *ptab =
unquote(rowp[i * ncols + namec]);
7540 int len = strlen(ptab);
7542 if (plen != len || strncasecmp(pname, ptab, plen) != 0) {
7552 size = (size + 1) * asize;
7558 s->
rows[0] = (
char *) size;
7560 memset(s->
rows, 0, sizeof (
char *) * size);
7563 for (i = 1; i <= nrows; i++) {
7564 int pos = 0, roffs = (offs + 1) * s->
ncols;
7565 char *ptab = rowp[i * ncols + namec];
7569 int len = strlen(ptab);
7571 if (plen != len || strncasecmp(pname, ptab, plen) != 0) {
7575 #if defined(_WIN32) || defined(_WIN64)
7576 s->
rows[roffs + 0] =
xstrdup(d->xcelqrx ?
"main" :
"");
7583 s->
rows[roffs + 3] =
xstrdup(rowp[i * ncols + toc]);
7587 s->
rows[roffs + 7] =
xstrdup(rowp[i * ncols + fromc]);
7588 sscanf(rowp[i * ncols + seqc],
"%d", &pos);
7589 sprintf(buf,
"%d", pos + 1);
7594 if (strcmp(rowp[i * ncols + onu],
"SET NULL") == 0) {
7596 }
else if (strcmp(rowp[i * ncols + onu],
"SET DEFAULT") == 0) {
7598 }
else if (strcmp(rowp[i * ncols + onu],
"CASCADE") == 0) {
7600 }
else if (strcmp(rowp[i * ncols + onu],
"RESTRICT") == 0) {
7609 if (strcmp(rowp[i * ncols + ond],
"SET NULL") == 0) {
7611 }
else if (strcmp(rowp[i * ncols + ond],
"SET DEFAULT") == 0) {
7613 }
else if (strcmp(rowp[i * ncols + ond],
"CASCADE") == 0) {
7615 }
else if (strcmp(rowp[i * ncols + ond],
"RESTRICT") == 0) {
7621 s->
rows[roffs + 11] = NULL;
7622 s->
rows[roffs + 12] = NULL;
7626 sqlite3_free_table(rowp);
7628 int nnrows, nncols, plen = strlen(pname);
7631 sql =
"select name from sqlite_master where type='table'";
7633 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
7634 if (ret != SQLITE_OK) {
7635 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
7636 errp ? errp :
"unknown error", ret);
7647 if (ncols * nrows <= 0) {
7651 for (i = 1; i <= nrows; i++) {
7659 sql = sqlite3_mprintf(
"PRAGMA foreign_key_list(%Q)", rowp[i]);
7662 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
7663 &nnrows, &nncols, NULL);
7666 if (ret != SQLITE_OK || nncols * nnrows <= 0) {
7667 sqlite3_free_table(rowpp);
7670 namec =
findcol(rowpp, nncols,
"table");
7671 seqc =
findcol(rowpp, nncols,
"seq");
7672 fromc =
findcol(rowpp, nncols,
"from");
7673 toc =
findcol(rowpp, nncols,
"to");
7674 if (namec < 0 || seqc < 0 || fromc < 0 || toc < 0) {
7675 sqlite3_free_table(rowpp);
7678 for (k = 1; k <= nnrows; k++) {
7679 char *ptab =
unquote(rowpp[k * nncols + namec]);
7682 int len = strlen(ptab);
7684 if (len != plen || strncasecmp(pname, ptab, plen) != 0) {
7690 sqlite3_free_table(rowpp);
7696 size = (size + 1) * asize;
7702 s->
rows[0] = (
char *) size;
7704 memset(s->
rows, 0, sizeof (
char *) * size);
7707 for (i = 1; i <= nrows; i++) {
7715 sql = sqlite3_mprintf(
"PRAGMA foreign_key_list(%Q)", rowp[i]);
7718 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
7719 &nnrows, &nncols, NULL);
7722 if (ret != SQLITE_OK || nncols * nnrows <= 0) {
7723 sqlite3_free_table(rowpp);
7726 namec =
findcol(rowpp, nncols,
"table");
7727 seqc =
findcol(rowpp, nncols,
"seq");
7728 fromc =
findcol(rowpp, nncols,
"from");
7729 toc =
findcol(rowpp, nncols,
"to");
7730 onu =
findcol(rowpp, nncols,
"on_update");
7731 ond =
findcol(rowpp, nncols,
"on_delete");
7732 if (namec < 0 || seqc < 0 || fromc < 0 || toc < 0) {
7733 sqlite3_free_table(rowpp);
7736 for (k = 1; k <= nnrows; k++) {
7737 int pos = 0, roffs = (offs + 1) * s->
ncols;
7738 char *ptab =
unquote(rowpp[k * nncols + namec]);
7742 int len = strlen(ptab);
7744 if (len != plen || strncasecmp(pname, ptab, plen) != 0) {
7748 #if defined(_WIN32) || defined(_WIN64)
7749 s->
rows[roffs + 0] =
xstrdup(d->xcelqrx ?
"main" :
"");
7756 s->
rows[roffs + 3] =
xstrdup(rowpp[k * nncols + toc]);
7760 s->
rows[roffs + 7] =
xstrdup(rowpp[k * nncols + fromc]);
7761 sscanf(rowpp[k * nncols + seqc],
"%d", &pos);
7762 sprintf(buf,
"%d", pos + 1);
7767 if (strcmp(rowpp[k * nncols + onu],
"SET NULL") == 0) {
7769 }
else if (strcmp(rowpp[k * nncols + onu],
"SET DEFAULT")
7771 s->
rows[roffs + 9] =
7773 }
else if (strcmp(rowpp[k * nncols + onu],
"CASCADE")
7776 }
else if (strcmp(rowpp[k * nncols + onu],
"RESTRICT")
7780 s->
rows[roffs + 9] =
7787 if (strcmp(rowpp[k * nncols + ond],
"SET NULL") == 0) {
7789 }
else if (strcmp(rowpp[k * nncols + ond],
"SET DEFAULT")
7791 s->
rows[roffs + 10] =
7793 }
else if (strcmp(rowpp[k * nncols + ond],
"CASCADE")
7796 }
else if (strcmp(rowpp[k * nncols + ond],
"RESTRICT")
7800 s->
rows[roffs + 10] =
7804 s->
rows[roffs + 11] = NULL;
7805 s->
rows[roffs + 12] = NULL;
7809 sqlite3_free_table(rowpp);
7811 sqlite3_free_table(rowp);
7836 SQLForeignKeys(SQLHSTMT
stmt,
7837 SQLCHAR *PKcatalog, SQLSMALLINT PKcatalogLen,
7838 SQLCHAR *PKschema, SQLSMALLINT PKschemaLen,
7839 SQLCHAR *PKtable, SQLSMALLINT PKtableLen,
7840 SQLCHAR *FKcatalog, SQLSMALLINT FKcatalogLen,
7841 SQLCHAR *FKschema, SQLSMALLINT FKschemaLen,
7842 SQLCHAR *FKtable, SQLSMALLINT FKtableLen)
7844 #if defined(_WIN32) || defined(_WIN64)
7845 char *pc = NULL, *ps = NULL, *pt = NULL;
7846 char *fc = NULL, *fs = NULL, *ft = NULL;
7851 #if defined(_WIN32) || defined(_WIN64)
7854 PKcatalog, PKcatalogLen,
7855 PKschema, PKschemaLen, PKtable, PKtableLen,
7856 FKcatalog, FKcatalogLen,
7857 FKschema, FKschemaLen,
7858 FKtable, FKtableLen);
7862 pc = wmb_to_utf_c((
char *) PKcatalog, PKcatalogLen);
7869 ps = wmb_to_utf_c((
char *) PKschema, PKschemaLen);
7876 pt = wmb_to_utf_c((
char *) PKtable, PKtableLen);
7883 fc = wmb_to_utf_c((
char *) FKcatalog, FKcatalogLen);
7890 fs = wmb_to_utf_c((
char *) FKschema, FKschemaLen);
7897 ft = wmb_to_utf_c((
char *) FKtable, FKtableLen);
7904 (SQLCHAR *) ps, SQL_NTS, (SQLCHAR *) pt, SQL_NTS,
7905 (SQLCHAR *) fc, SQL_NTS, (SQLCHAR *) fs, SQL_NTS,
7906 (SQLCHAR *) ft, SQL_NTS);
7909 PKcatalog, PKcatalogLen,
7910 PKschema, PKschemaLen, PKtable, PKtableLen,
7911 FKcatalog, FKcatalogLen,
7912 FKschema, FKschemaLen,
7913 FKtable, FKtableLen);
7915 #if defined(_WIN32) || defined(_WIN64)
7952 SQLWCHAR *PKcatalog, SQLSMALLINT PKcatalogLen,
7953 SQLWCHAR *PKschema, SQLSMALLINT PKschemaLen,
7954 SQLWCHAR *PKtable, SQLSMALLINT PKtableLen,
7955 SQLWCHAR *FKcatalog, SQLSMALLINT FKcatalogLen,
7956 SQLWCHAR *FKschema, SQLSMALLINT FKschemaLen,
7957 SQLWCHAR *FKtable, SQLSMALLINT FKtableLen)
7959 char *pc = NULL, *ps = NULL, *pt = NULL;
7960 char *fc = NULL, *fs = NULL, *ft = NULL;
8007 (SQLCHAR *) ps, SQL_NTS, (SQLCHAR *) pt, SQL_NTS,
8008 (SQLCHAR *) fc, SQL_NTS, (SQLCHAR *) fs, SQL_NTS,
8009 (SQLCHAR *) ft, SQL_NTS);
8031 int ret = SQL_SUCCESS, rc, busy_count = 0;
8037 rc = sqlite3_exec(d->
sqlite,
"BEGIN TRANSACTION", NULL, NULL, &errp);
8038 if (rc == SQLITE_BUSY) {
8048 if (rc != SQLITE_OK) {
8049 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
8050 errp ? errp :
"unknown error", rc);
8074 int ret, busy_count = 0;
8075 char *sql, *errp = NULL;
8078 setstatd(d, -1,
"not connected", (*d->
ov3) ?
"HY000" :
"S1000");
8086 sql =
"COMMIT TRANSACTION";
8089 sql =
"ROLLBACK TRANSACTION";
8091 ret = sqlite3_exec(d->
sqlite, sql, NULL, NULL, &errp);
8093 if (ret == SQLITE_BUSY && busy_count < 10) {
8102 if (ret != SQLITE_OK) {
8103 setstatd(d, ret,
"%s", (*d->
ov3) ?
"HY000" :
"S1000",
8104 errp ? errp :
"transaction failed");
8118 setstatd(d, -1,
"invalid completion type", (*d->
ov3) ?
"HY000" :
"S1000");
8131 drvendtran(SQLSMALLINT type, SQLHANDLE handle, SQLSMALLINT comptype)
8136 #if defined(_WIN32) || defined(_WIN64)
8141 case SQL_HANDLE_DBC:
8143 if (handle == SQL_NULL_HDBC) {
8144 return SQL_INVALID_HANDLE;
8150 case SQL_HANDLE_ENV:
8151 if (handle == SQL_NULL_HENV) {
8152 return SQL_INVALID_HANDLE;
8154 #if defined(_WIN32) || defined(_WIN64)
8155 env = (
ENV *) handle;
8157 return SQL_INVALID_HANDLE;
8159 EnterCriticalSection(&env->cs);
8161 dbc = ((
ENV *) handle)->dbcs;
8166 if (ret != SQL_SUCCESS) {
8171 #if defined(_WIN32) || defined(_WIN64)
8172 LeaveCriticalSection(&env->cs);
8174 return fail ? SQL_ERROR : SQL_SUCCESS;
8176 return SQL_INVALID_HANDLE;
8188 SQLEndTran(SQLSMALLINT type, SQLHANDLE handle, SQLSMALLINT comptype)
8204 if (
dbc != SQL_NULL_HDBC) {
8207 return drvendtran(SQL_HANDLE_ENV, (SQLHANDLE) env, type);
8233 SQLNativeSql(SQLHSTMT
stmt, SQLCHAR *sqlin, SQLINTEGER sqlinLen,
8234 SQLCHAR *sql, SQLINTEGER sqlMax, SQLINTEGER *sqlLen)
8237 SQLRETURN ret = SQL_SUCCESS;
8240 if (sqlinLen == SQL_NTS) {
8241 sqlinLen = strlen((
char *) sqlin);
8245 strncpy((
char *) sql, (
char *) sqlin, sqlMax - 1);
8246 sqlin[sqlMax - 1] =
'\0';
8247 outLen =
min(sqlMax - 1, sqlinLen);
8255 if (sql && outLen < sqlinLen) {
8257 ret = SQL_SUCCESS_WITH_INFO;
8278 SQLWCHAR *sql, SQLINTEGER sqlMax, SQLINTEGER *sqlLen)
8281 SQLRETURN ret = SQL_SUCCESS;
8284 if (sqlinLen == SQL_NTS) {
8290 sqlin[sqlMax - 1] = 0;
8291 outLen =
min(sqlMax - 1, sqlinLen);
8299 if (sql && outLen < sqlinLen) {
8301 ret = SQL_SUCCESS_WITH_INFO;
8313 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_QUALIFIER",
SCOL_VARCHAR, 50 },
8314 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_OWNER",
SCOL_VARCHAR, 50 },
8315 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_NAME",
SCOL_VARCHAR, 255 },
8316 {
"SYSTEM",
"PROCEDURE",
"NUM_INPUT_PARAMS", SQL_SMALLINT, 5 },
8317 {
"SYSTEM",
"PROCEDURE",
"NUM_OUTPUT_PARAMS", SQL_SMALLINT, 5 },
8318 {
"SYSTEM",
"PROCEDURE",
"NUM_RESULT_SETS", SQL_SMALLINT, 5 },
8319 {
"SYSTEM",
"PROCEDURE",
"REMARKS",
SCOL_VARCHAR, 255 },
8320 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_TYPE", SQL_SMALLINT, 5 }
8324 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_CAT",
SCOL_VARCHAR, 50 },
8325 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_SCHEM",
SCOL_VARCHAR, 50 },
8326 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_NAME",
SCOL_VARCHAR, 255 },
8327 {
"SYSTEM",
"PROCEDURE",
"NUM_INPUT_PARAMS", SQL_SMALLINT, 5 },
8328 {
"SYSTEM",
"PROCEDURE",
"NUM_OUTPUT_PARAMS", SQL_SMALLINT, 5 },
8329 {
"SYSTEM",
"PROCEDURE",
"NUM_RESULT_SETS", SQL_SMALLINT, 5 },
8330 {
"SYSTEM",
"PROCEDURE",
"REMARKS",
SCOL_VARCHAR, 255 },
8331 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_TYPE", SQL_SMALLINT, 5 }
8348 SQLProcedures(SQLHSTMT
stmt,
8349 SQLCHAR *catalog, SQLSMALLINT catalogLen,
8350 SQLCHAR *schema, SQLSMALLINT schemaLen,
8351 SQLCHAR *proc, SQLSMALLINT procLen)
8378 SQLWCHAR *catalog, SQLSMALLINT catalogLen,
8379 SQLWCHAR *schema, SQLSMALLINT schemaLen,
8380 SQLWCHAR *proc, SQLSMALLINT procLen)
8397 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_QUALIFIER",
SCOL_VARCHAR, 50 },
8398 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_OWNER",
SCOL_VARCHAR, 50 },
8399 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_NAME",
SCOL_VARCHAR, 255 },
8400 {
"SYSTEM",
"PROCCOL",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
8401 {
"SYSTEM",
"PROCCOL",
"COLUMN_TYPE", SQL_SMALLINT, 5 },
8402 {
"SYSTEM",
"PROCCOL",
"DATA_TYPE", SQL_SMALLINT, 5 },
8403 {
"SYSTEM",
"PROCCOL",
"TYPE_NAME",
SCOL_VARCHAR, 50 },
8404 {
"SYSTEM",
"PROCCOL",
"PRECISION", SQL_INTEGER, 10 },
8405 {
"SYSTEM",
"PROCCOL",
"LENGTH", SQL_INTEGER, 10 },
8406 {
"SYSTEM",
"PROCCOL",
"SCALE", SQL_SMALLINT, 5 },
8407 {
"SYSTEM",
"PROCCOL",
"RADIX", SQL_SMALLINT, 5 },
8408 {
"SYSTEM",
"PROCCOL",
"NULLABLE", SQL_SMALLINT, 5 },
8410 {
"SYSTEM",
"PROCCOL",
"COLUMN_DEF",
SCOL_VARCHAR, 50 },
8411 {
"SYSTEM",
"PROCCOL",
"SQL_DATA_TYPE", SQL_SMALLINT, 5 },
8412 {
"SYSTEM",
"PROCCOL",
"SQL_DATETIME_SUB", SQL_SMALLINT, 5 },
8413 {
"SYSTEM",
"PROCCOL",
"CHAR_OCTET_LENGTH", SQL_SMALLINT, 5 },
8414 {
"SYSTEM",
"PROCCOL",
"ORDINAL_POSITION", SQL_SMALLINT, 5 },
8415 {
"SYSTEM",
"PROCCOL",
"IS_NULLABLE",
SCOL_VARCHAR, 50 }
8419 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_CAT",
SCOL_VARCHAR, 50 },
8420 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_SCHEM",
SCOL_VARCHAR, 50 },
8421 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_NAME",
SCOL_VARCHAR, 255 },
8422 {
"SYSTEM",
"PROCCOL",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
8423 {
"SYSTEM",
"PROCCOL",
"COLUMN_TYPE", SQL_SMALLINT, 5 },
8424 {
"SYSTEM",
"PROCCOL",
"DATA_TYPE", SQL_SMALLINT, 5 },
8425 {
"SYSTEM",
"PROCCOL",
"TYPE_NAME",
SCOL_VARCHAR, 50 },
8426 {
"SYSTEM",
"PROCCOL",
"COLUMN_SIZE", SQL_INTEGER, 10 },
8427 {
"SYSTEM",
"PROCCOL",
"BUFFER_LENGTH", SQL_INTEGER, 10 },
8428 {
"SYSTEM",
"PROCCOL",
"DECIMAL_DIGITS", SQL_SMALLINT, 5 },
8429 {
"SYSTEM",
"PROCCOL",
"NUM_PREC_RADIX", SQL_SMALLINT, 5 },
8430 {
"SYSTEM",
"PROCCOL",
"NULLABLE", SQL_SMALLINT, 5 },
8432 {
"SYSTEM",
"PROCCOL",
"COLUMN_DEF",
SCOL_VARCHAR, 50 },
8433 {
"SYSTEM",
"PROCCOL",
"SQL_DATA_TYPE", SQL_SMALLINT, 5 },
8434 {
"SYSTEM",
"PROCCOL",
"SQL_DATETIME_SUB", SQL_SMALLINT, 5 },
8435 {
"SYSTEM",
"PROCCOL",
"CHAR_OCTET_LENGTH", SQL_SMALLINT, 5 },
8436 {
"SYSTEM",
"PROCCOL",
"ORDINAL_POSITION", SQL_SMALLINT, 5 },
8437 {
"SYSTEM",
"PROCCOL",
"IS_NULLABLE",
SCOL_VARCHAR, 50 }
8456 SQLProcedureColumns(SQLHSTMT
stmt,
8457 SQLCHAR *catalog, SQLSMALLINT catalogLen,
8458 SQLCHAR *schema, SQLSMALLINT schemaLen,
8459 SQLCHAR *proc, SQLSMALLINT procLen,
8460 SQLCHAR *column, SQLSMALLINT columnLen)
8490 SQLWCHAR *catalog, SQLSMALLINT catalogLen,
8491 SQLWCHAR *schema, SQLSMALLINT schemaLen,
8492 SQLWCHAR *proc, SQLSMALLINT procLen,
8493 SQLWCHAR *column, SQLSMALLINT columnLen)
8517 SQLINTEGER len, SQLINTEGER *lenp)
8520 SQLRETURN ret = SQL_ERROR;
8522 if (env == SQL_NULL_HENV) {
8523 return SQL_INVALID_HANDLE;
8527 return SQL_INVALID_HANDLE;
8529 #if defined(_WIN32) || defined(_WIN64)
8530 EnterCriticalSection(&e->cs);
8533 case SQL_ATTR_CONNECTION_POOLING:
8535 *((SQLINTEGER *) val) = e->
pool ?
8536 SQL_CP_ONE_PER_DRIVER : SQL_CP_OFF;
8539 *lenp =
sizeof (SQLINTEGER);
8543 case SQL_ATTR_CP_MATCH:
8544 *((SQLINTEGER *) val) = SQL_CP_RELAXED_MATCH;
8546 *lenp =
sizeof (SQLINTEGER);
8550 case SQL_ATTR_OUTPUT_NTS:
8552 *((SQLINTEGER *) val) = SQL_TRUE;
8555 *lenp =
sizeof (SQLINTEGER);
8559 case SQL_ATTR_ODBC_VERSION:
8561 *((SQLINTEGER *) val) = e->
ov3 ? SQL_OV_ODBC3 : SQL_OV_ODBC2;
8564 *lenp =
sizeof (SQLINTEGER);
8569 #if defined(_WIN32) || defined(_WIN64)
8570 LeaveCriticalSection(&e->cs);
8588 SQLRETURN ret = SQL_ERROR;
8590 if (env == SQL_NULL_HENV) {
8591 return SQL_INVALID_HANDLE;
8595 return SQL_INVALID_HANDLE;
8597 #if defined(_WIN32) || defined(_WIN64)
8598 EnterCriticalSection(&e->cs);
8601 case SQL_ATTR_CONNECTION_POOLING:
8602 if (val == (SQLPOINTER) SQL_CP_ONE_PER_DRIVER) {
8605 }
else if (val == (SQLPOINTER) SQL_CP_OFF) {
8610 case SQL_ATTR_CP_MATCH:
8613 case SQL_ATTR_OUTPUT_NTS:
8614 if (val == (SQLPOINTER) SQL_TRUE) {
8618 case SQL_ATTR_ODBC_VERSION:
8622 if (val == (SQLPOINTER) SQL_OV_ODBC2) {
8625 }
else if (val == (SQLPOINTER) SQL_OV_ODBC3) {
8631 #if defined(_WIN32) || defined(_WIN64)
8632 LeaveCriticalSection(&e->cs);
8652 SQLCHAR *sqlstate, SQLINTEGER *nativeerr, SQLCHAR *msg,
8653 SQLSMALLINT buflen, SQLSMALLINT *msglen)
8658 char *logmsg, *sqlst;
8659 SQLRETURN ret = SQL_ERROR;
8661 if (handle == SQL_NULL_HANDLE) {
8662 return SQL_INVALID_HANDLE;
8667 if (msg && buflen > 0) {
8677 case SQL_HANDLE_ENV:
8678 case SQL_HANDLE_DESC:
8680 case SQL_HANDLE_DBC:
8683 logmsg = (
char *) d->
logmsg;
8687 case SQL_HANDLE_STMT:
8689 s = (
STMT *) handle;
8690 logmsg = (
char *) s->
logmsg;
8695 return SQL_INVALID_HANDLE;
8704 len = strlen(logmsg);
8710 *nativeerr = naterr;
8713 strcpy((
char *) sqlstate, sqlst);
8718 if (len >= buflen) {
8719 if (msg && buflen > 0) {
8720 strncpy((
char *) msg, logmsg, buflen);
8721 msg[buflen - 1] =
'\0';
8725 strcpy((
char *) msg, logmsg);
8731 case SQL_HANDLE_DBC:
8734 case SQL_HANDLE_STMT:
8741 #if !defined(WINTERFACE) || (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC))
8756 SQLGetDiagRec(SQLSMALLINT htype, SQLHANDLE handle, SQLSMALLINT recno,
8757 SQLCHAR *sqlstate, SQLINTEGER *nativeerr, SQLCHAR *msg,
8758 SQLSMALLINT buflen, SQLSMALLINT *msglen)
8761 nativeerr, msg, buflen, msglen);
8765 #if !defined(HAVE_UNIXODBC) || !(HAVE_UNIXODBC)
8783 SQLWCHAR *sqlstate, SQLINTEGER *nativeerr, SQLWCHAR *msg,
8784 SQLSMALLINT buflen, SQLSMALLINT *msglen)
8790 ret =
drvgetdiagrec(htype, handle, recno, (SQLCHAR *) state,
8791 nativeerr, (SQLCHAR *) msg, buflen, &len);
8792 if (ret == SQL_SUCCESS) {
8795 6 *
sizeof (SQLWCHAR));
8804 buflen /=
sizeof (SQLWCHAR);
8824 len *=
sizeof (SQLWCHAR);
8829 }
else if (ret == SQL_NO_DATA) {
8861 SQLSMALLINT
id, SQLPOINTER info,
8862 SQLSMALLINT buflen, SQLSMALLINT *stringlen)
8866 int len, naterr,
strbuf = 1;
8867 char *logmsg, *sqlst, *clrmsg = NULL;
8868 SQLRETURN ret = SQL_ERROR;
8870 if (handle == SQL_NULL_HANDLE) {
8871 return SQL_INVALID_HANDLE;
8877 case SQL_HANDLE_ENV:
8878 case SQL_HANDLE_DESC:
8880 case SQL_HANDLE_DBC:
8883 logmsg = (
char *) d->
logmsg;
8887 case SQL_HANDLE_STMT:
8889 s = (
STMT *) handle;
8891 logmsg = (
char *) s->
logmsg;
8896 return SQL_INVALID_HANDLE;
8900 case SQL_IS_POINTER:
8901 case SQL_IS_UINTEGER:
8902 case SQL_IS_INTEGER:
8903 case SQL_IS_USMALLINT:
8904 case SQL_IS_SMALLINT:
8917 case SQL_DIAG_CLASS_ORIGIN:
8918 logmsg =
"ISO 9075";
8919 if (sqlst[0] ==
'I' && sqlst[1] ==
'M') {
8920 logmsg =
"ODBC 3.0";
8923 case SQL_DIAG_SUBCLASS_ORIGIN:
8924 logmsg =
"ISO 9075";
8925 if (sqlst[0] ==
'I' && sqlst[1] ==
'M') {
8926 logmsg =
"ODBC 3.0";
8927 }
else if (sqlst[0] ==
'H' && sqlst[1] ==
'Y') {
8928 logmsg =
"ODBC 3.0";
8929 }
else if (sqlst[0] ==
'2' || sqlst[0] ==
'0' || sqlst[0] ==
'4') {
8930 logmsg =
"ODBC 3.0";
8933 case SQL_DIAG_CONNECTION_NAME:
8934 case SQL_DIAG_SERVER_NAME:
8935 logmsg = d->
dsn ? d->
dsn :
"No DSN";
8937 case SQL_DIAG_SQLSTATE:
8940 case SQL_DIAG_MESSAGE_TEXT:
8945 case SQL_DIAG_NUMBER:
8948 case SQL_DIAG_NATIVE:
8949 len = strlen(logmsg);
8955 *((SQLINTEGER *) info) = naterr;
8959 case SQL_DIAG_DYNAMIC_FUNCTION:
8962 case SQL_DIAG_CURSOR_ROW_COUNT:
8963 if (htype == SQL_HANDLE_STMT) {
8971 case SQL_DIAG_ROW_COUNT:
8972 if (htype == SQL_HANDLE_STMT) {
8983 if (info && buflen > 0) {
8984 ((
char *) info)[0] =
'\0';
8986 len = strlen(logmsg);
8995 if (len >= buflen) {
8996 if (info && buflen > 0) {
8998 *stringlen = buflen - 1;
9000 strncpy((
char *) info, logmsg, buflen);
9001 ((
char *) info)[buflen - 1] =
'\0';
9004 strcpy((
char *) info, logmsg);
9013 case SQL_HANDLE_DBC:
9016 case SQL_HANDLE_STMT:
9037 SQLGetDiagField(SQLSMALLINT htype, SQLHANDLE handle, SQLSMALLINT recno,
9038 SQLSMALLINT
id, SQLPOINTER info,
9039 SQLSMALLINT buflen, SQLSMALLINT *stringlen)
9041 return drvgetdiagfield(htype, handle, recno,
id, info, buflen, stringlen);
9060 SQLSMALLINT
id, SQLPOINTER info,
9061 SQLSMALLINT buflen, SQLSMALLINT *stringlen)
9067 if (ret == SQL_SUCCESS) {
9070 case SQL_DIAG_CLASS_ORIGIN:
9071 case SQL_DIAG_SUBCLASS_ORIGIN:
9072 case SQL_DIAG_CONNECTION_NAME:
9073 case SQL_DIAG_SERVER_NAME:
9074 case SQL_DIAG_SQLSTATE:
9075 case SQL_DIAG_MESSAGE_TEXT:
9076 case SQL_DIAG_DYNAMIC_FUNCTION:
9083 buflen /=
sizeof (SQLWCHAR);
9091 len *=
sizeof (SQLWCHAR);
9099 ((SQLWCHAR *) info)[0] = 0;
9105 case SQL_DIAG_CLASS_ORIGIN:
9106 case SQL_DIAG_SUBCLASS_ORIGIN:
9107 case SQL_DIAG_CONNECTION_NAME:
9108 case SQL_DIAG_SERVER_NAME:
9109 case SQL_DIAG_SQLSTATE:
9110 case SQL_DIAG_MESSAGE_TEXT:
9111 case SQL_DIAG_DYNAMIC_FUNCTION:
9112 len *=
sizeof (SQLWCHAR);
9136 SQLINTEGER bufmax, SQLINTEGER *buflen)
9147 uval = (SQLPOINTER) dummybuf;
9150 case SQL_QUERY_TIMEOUT:
9154 case SQL_ATTR_CURSOR_TYPE:
9158 case SQL_ATTR_CURSOR_SCROLLABLE:
9159 *uval = (s->
curtype != SQL_CURSOR_FORWARD_ONLY) ?
9160 SQL_SCROLLABLE : SQL_NONSCROLLABLE;
9163 #ifdef SQL_ATTR_CURSOR_SENSITIVITY
9164 case SQL_ATTR_CURSOR_SENSITIVITY:
9165 *uval = SQL_UNSPECIFIED;
9169 case SQL_ATTR_ROW_NUMBER:
9174 *uval = (s->
rowp < 0) ? SQL_ROW_NUMBER_UNKNOWN : (s->
rowp + 1);
9178 case SQL_ATTR_ASYNC_ENABLE:
9179 *uval = SQL_ASYNC_ENABLE_OFF;
9182 case SQL_CONCURRENCY:
9183 *uval = SQL_CONCUR_LOCK;
9186 case SQL_ATTR_RETRIEVE_DATA:
9190 case SQL_ROWSET_SIZE:
9191 case SQL_ATTR_ROW_ARRAY_SIZE:
9196 case SQL_ATTR_IMP_ROW_DESC:
9197 case SQL_ATTR_APP_ROW_DESC:
9198 case SQL_ATTR_IMP_PARAM_DESC:
9199 case SQL_ATTR_APP_PARAM_DESC:
9200 *((SQLHDESC *) uval) = (SQLHDESC)
DEAD_MAGIC;
9201 *buflen =
sizeof (SQLHDESC);
9203 case SQL_ATTR_ROW_STATUS_PTR:
9205 *buflen =
sizeof (SQLUSMALLINT *);
9207 case SQL_ATTR_ROWS_FETCHED_PTR:
9211 case SQL_ATTR_USE_BOOKMARKS: {
9214 *(SQLUINTEGER *) uval = s->
bkmrk;
9215 *buflen = sizeof (SQLUINTEGER);
9218 case SQL_ATTR_FETCH_BOOKMARK_PTR:
9219 *(SQLPOINTER *) uval = s->
bkmrkptr;
9220 *buflen = sizeof (SQLPOINTER);
9222 case SQL_ATTR_PARAM_BIND_OFFSET_PTR:
9226 case SQL_ATTR_PARAM_BIND_TYPE:
9230 case SQL_ATTR_PARAM_OPERATION_PTR:
9231 *((SQLUSMALLINT **) uval) = s->
parm_oper;
9232 *buflen =
sizeof (SQLUSMALLINT *);
9234 case SQL_ATTR_PARAM_STATUS_PTR:
9236 *buflen =
sizeof (SQLUSMALLINT *);
9238 case SQL_ATTR_PARAMS_PROCESSED_PTR:
9242 case SQL_ATTR_PARAMSET_SIZE:
9246 case SQL_ATTR_ROW_BIND_TYPE:
9250 case SQL_ATTR_ROW_BIND_OFFSET_PTR:
9254 case SQL_ATTR_MAX_ROWS:
9258 case SQL_ATTR_MAX_LENGTH:
9259 *((
SQLULEN *) uval) = 1000000000;
9262 #ifdef SQL_ATTR_METADATA_ID
9263 case SQL_ATTR_METADATA_ID:
9264 *((
SQLULEN *) uval) = SQL_FALSE;
9272 #if (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC)) || !defined(WINTERFACE)
9284 SQLGetStmtAttr(SQLHSTMT
stmt, SQLINTEGER attr, SQLPOINTER val,
9285 SQLINTEGER bufmax, SQLINTEGER *buflen)
9309 SQLINTEGER bufmax, SQLINTEGER *buflen)
9334 #if defined(SQL_BIGINT) && defined(__WORDSIZE) && (__WORDSIZE == 64)
9337 uval = (SQLBIGINT) val;
9344 case SQL_ATTR_CURSOR_TYPE:
9345 if (val == (SQLPOINTER) SQL_CURSOR_FORWARD_ONLY) {
9346 s->
curtype = SQL_CURSOR_FORWARD_ONLY;
9348 s->
curtype = SQL_CURSOR_STATIC;
9350 if (val != (SQLPOINTER) SQL_CURSOR_FORWARD_ONLY &&
9351 val != (SQLPOINTER) SQL_CURSOR_STATIC) {
9355 case SQL_ATTR_CURSOR_SCROLLABLE:
9356 if (val == (SQLPOINTER) SQL_NONSCROLLABLE) {
9357 s->
curtype = SQL_CURSOR_FORWARD_ONLY;
9359 s->
curtype = SQL_CURSOR_STATIC;
9362 case SQL_ATTR_ASYNC_ENABLE:
9363 if (val != (SQLPOINTER) SQL_ASYNC_ENABLE_OFF) {
9365 setstat(s, -1,
"option value changed",
"01S02");
9366 return SQL_SUCCESS_WITH_INFO;
9369 case SQL_CONCURRENCY:
9370 if (val != (SQLPOINTER) SQL_CONCUR_LOCK) {
9374 #ifdef SQL_ATTR_CURSOR_SENSITIVITY
9375 case SQL_ATTR_CURSOR_SENSITIVITY:
9376 if (val != (SQLPOINTER) SQL_UNSPECIFIED) {
9381 case SQL_ATTR_QUERY_TIMEOUT:
9383 case SQL_ATTR_RETRIEVE_DATA:
9384 if (val != (SQLPOINTER) SQL_RD_ON &&
9385 val != (SQLPOINTER) SQL_RD_OFF) {
9390 case SQL_ROWSET_SIZE:
9391 case SQL_ATTR_ROW_ARRAY_SIZE:
9393 setstat(s, -1,
"invalid rowset size",
"HY000");
9399 rst =
xmalloc(
sizeof (SQLUSMALLINT) * uval);
9411 case SQL_ATTR_ROW_STATUS_PTR:
9414 case SQL_ATTR_ROWS_FETCHED_PTR:
9417 case SQL_ATTR_PARAM_BIND_OFFSET_PTR:
9420 case SQL_ATTR_PARAM_BIND_TYPE:
9423 case SQL_ATTR_PARAM_OPERATION_PTR:
9426 case SQL_ATTR_PARAM_STATUS_PTR:
9429 case SQL_ATTR_PARAMS_PROCESSED_PTR:
9432 case SQL_ATTR_PARAMSET_SIZE:
9439 case SQL_ATTR_ROW_BIND_TYPE:
9442 case SQL_ATTR_ROW_BIND_OFFSET_PTR:
9445 case SQL_ATTR_USE_BOOKMARKS:
9446 if (val != (SQLPOINTER) SQL_UB_OFF &&
9447 val != (SQLPOINTER) SQL_UB_ON &&
9448 val != (SQLPOINTER) SQL_UB_VARIABLE) {
9451 if (*s->
ov3 && val == (SQLPOINTER) SQL_UB_VARIABLE) {
9452 s->
bkmrk = SQL_UB_VARIABLE;
9455 if (val == (SQLPOINTER) SQL_UB_VARIABLE) {
9456 s->
bkmrk = SQL_UB_ON;
9459 s->
bkmrk = (val == (SQLPOINTER) SQL_UB_ON) ? SQL_UB_ON : SQL_UB_OFF;
9461 case SQL_ATTR_FETCH_BOOKMARK_PTR:
9464 case SQL_ATTR_MAX_ROWS:
9467 case SQL_ATTR_MAX_LENGTH:
9468 if (val != (SQLPOINTER) 1000000000) {
9472 #ifdef SQL_ATTR_METADATA_ID
9473 case SQL_ATTR_METADATA_ID:
9474 if (val != (SQLPOINTER) SQL_FALSE) {
9483 #if (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC)) || !defined(WINTERFACE)
9494 SQLSetStmtAttr(SQLHSTMT
stmt, SQLINTEGER attr, SQLPOINTER val,
9541 SQLUINTEGER *ret = (SQLUINTEGER *) param;
9544 case SQL_QUERY_TIMEOUT:
9547 case SQL_CURSOR_TYPE:
9550 case SQL_ROW_NUMBER:
9555 *ret = (s->
rowp < 0) ? SQL_ROW_NUMBER_UNKNOWN : (s->
rowp + 1);
9558 case SQL_ASYNC_ENABLE:
9559 *ret = SQL_ASYNC_ENABLE_OFF;
9561 case SQL_CONCURRENCY:
9562 *ret = SQL_CONCUR_LOCK;
9564 case SQL_ATTR_RETRIEVE_DATA:
9567 case SQL_ROWSET_SIZE:
9568 case SQL_ATTR_ROW_ARRAY_SIZE:
9571 case SQL_ATTR_MAX_ROWS:
9574 case SQL_ATTR_MAX_LENGTH:
9635 case SQL_CURSOR_TYPE:
9636 if (param == SQL_CURSOR_FORWARD_ONLY) {
9639 s->
curtype = SQL_CURSOR_STATIC;
9641 if (param != SQL_CURSOR_FORWARD_ONLY &&
9642 param != SQL_CURSOR_STATIC) {
9646 case SQL_ASYNC_ENABLE:
9647 if (param != SQL_ASYNC_ENABLE_OFF) {
9651 case SQL_CONCURRENCY:
9652 if (param != SQL_CONCUR_LOCK) {
9656 case SQL_QUERY_TIMEOUT:
9658 case SQL_RETRIEVE_DATA:
9659 if (param != SQL_RD_ON && param != SQL_RD_OFF) {
9661 setstat(s, -1,
"option value changed",
"01S02");
9662 return SQL_SUCCESS_WITH_INFO;
9666 case SQL_ROWSET_SIZE:
9667 case SQL_ATTR_ROW_ARRAY_SIZE:
9669 setstat(s, -1,
"invalid rowset size",
"HY000");
9675 rst =
xmalloc(
sizeof (SQLUSMALLINT) * param);
9687 case SQL_ATTR_MAX_ROWS:
9690 case SQL_ATTR_MAX_LENGTH:
9691 if (param != 1000000000) {
9754 setstat(s, -1,
"unbound columns", (*s->
ov3) ?
"HY000" :
"S1000");
9757 for (i = 0; i < s->
ncols; i++) {
9760 if (b->
type == SQL_UNKNOWN_TYPE || !b->
valp) {
9789 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
9790 dp = (SQLPOINTER) ((
char *) b->valp + s->
bind_type * rsi);
9792 dp = (SQLPOINTER) ((
char *) b->valp + b->max * rsi);
9795 dp = (SQLPOINTER) ((
char *) dp + *s->
bind_offs);
9799 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
9809 setstat(s, -1,
"unbound column in positional update",
9810 (*s->
ov3) ?
"HY000" :
"S1000");
9813 if (*lp == SQL_NULL_DATA) {
9814 sqlite3_bind_null(
stmt, si);
9816 fprintf(d->
trace,
"-- parameter %d: NULL\n", si);
9822 case SQL_C_UTINYINT:
9824 case SQL_C_STINYINT:
9825 sqlite3_bind_int(
stmt, si, *(SQLCHAR *) dp);
9827 fprintf(d->
trace,
"-- parameter %d: %d\n", si, *(SQLCHAR *) dp);
9833 sqlite3_bind_int(
stmt, si, (*(SQLCHAR *) dp) ? 1 : 0);
9835 fprintf(d->
trace,
"-- parameter %d: %d\n", si,
9836 (*(SQLCHAR *) dp) ? 1 : 0);
9842 sqlite3_bind_int(
stmt, si, *(SQLUSMALLINT *) dp);
9844 fprintf(d->
trace,
"-- parameter %d: %d\n", si,
9845 *(SQLUSMALLINT *) dp);
9851 sqlite3_bind_int(
stmt, si, *(SQLSMALLINT *) dp);
9853 fprintf(d->
trace,
"-- parameter %d: %d\n", si,
9854 *(SQLSMALLINT *) dp);
9859 sqlite3_bind_int(
stmt, si, *(SQLUINTEGER *) dp);
9861 fprintf(d->
trace,
"-- parameter %d: %ld\n", si,
9862 (
long) *(SQLUINTEGER *) dp);
9868 sqlite3_bind_int(
stmt, si, *(SQLINTEGER *) dp);
9870 fprintf(d->
trace,
"-- parameter %d: %ld\n", si,
9871 (
long) *(SQLINTEGER *) dp);
9878 sqlite3_bind_int64(
stmt, si, *(SQLBIGINT *) dp);
9882 "-- parameter %d: %I64d\n",
9884 "-- parameter %d: %lld\n",
9886 si, (sqlite_int64) *(SQLBIGINT *) dp);
9892 sqlite3_bind_double(
stmt, si, *(
float *) dp);
9894 fprintf(d->
trace,
"-- parameter %d: %g\n", si,
9900 sqlite3_bind_double(
stmt, si, *(
double *) dp);
9902 fprintf(d->
trace,
"-- parameter %d: %g\n", si,
9908 sqlite3_bind_blob(
stmt, si, (
char *) dp, *lp, SQLITE_STATIC);
9910 fprintf(d->
trace,
"-- parameter %d: [BLOB]\n", si);
9920 sqlite3_bind_text(
stmt, si, cp, -1, SQLITE_TRANSIENT);
9922 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si, cp);
9929 #if defined(_WIN32) || defined(_WIN64)
9931 cp = wmb_to_utf((
char *) dp, *lp);
9935 sqlite3_bind_text(
stmt, si, cp, -1, SQLITE_TRANSIENT);
9937 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si, cp);
9944 if (*lp == SQL_NTS) {
9945 sqlite3_bind_text(
stmt, si, (
char *) dp, -1,
9948 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si,
9953 sqlite3_bind_text(
stmt, si, (
char *) dp, *lp,
9956 fprintf(d->
trace,
"-- parameter %d: '%*s'\n", si,
9957 (
int) *lp, (
char *) dp);
9963 #ifdef SQL_C_TYPE_DATE
9964 case SQL_C_TYPE_DATE:
9968 int a, b, x1, x2, y, m, dd;
9971 y = ((DATE_STRUCT *) dp)->year;
9972 m = ((DATE_STRUCT *) dp)->month;
9973 dd = ((DATE_STRUCT *) dp)->day;
9979 b = 2 - a + (a / 4);
9980 x1 = 36525 * (y + 4716) / 100;
9981 x2 = 306001 * (m + 1) / 10000;
9982 v = x1 + x2 + dd + b - 1524.5;
9983 sqlite3_bind_double(
stmt, si, v);
9985 fprintf(d->
trace,
"-- parameter %d: %g\n", si, v);
9989 sprintf(
strbuf,
"%04d-%02d-%02d",
9990 ((DATE_STRUCT *) dp)->year,
9991 ((DATE_STRUCT *) dp)->month,
9992 ((DATE_STRUCT *) dp)->day);
9993 sqlite3_bind_text(
stmt, si,
strbuf, -1, SQLITE_TRANSIENT);
9995 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si,
strbuf);
10000 #ifdef SQL_C_TYPE_TIME
10001 case SQL_C_TYPE_TIME:
10008 (((TIME_STRUCT *) dp)->hour * 3600000.0 +
10009 ((TIME_STRUCT *) dp)->minute * 60000.0 +
10010 ((TIME_STRUCT *) dp)->second * 1000.0) / 86400000.0;
10011 sqlite3_bind_double(
stmt, si, v);
10013 fprintf(d->
trace,
"-- parameter %d: %g\n", si, v);
10017 sprintf(
strbuf,
"%02d:%02d:%02d",
10018 ((TIME_STRUCT *) dp)->hour,
10019 ((TIME_STRUCT *) dp)->minute,
10020 ((TIME_STRUCT *) dp)->second);
10021 sqlite3_bind_text(
stmt, si,
strbuf, -1, SQLITE_TRANSIENT);
10023 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si,
strbuf);
10028 #ifdef SQL_C_TYPE_TIMESTAMP
10029 case SQL_C_TYPE_TIMESTAMP:
10031 case SQL_C_TIMESTAMP:
10033 int a, b, x1, x2, y, m, dd;
10036 y = ((TIMESTAMP_STRUCT *) dp)->year;
10037 m = ((TIMESTAMP_STRUCT *) dp)->month;
10038 dd = ((TIMESTAMP_STRUCT *) dp)->day;
10044 b = 2 - a + (a / 4);
10045 x1 = 36525 * (y + 4716) / 100;
10046 x2 = 306001 * (m + 1) / 10000;
10047 v = x1 + x2 + dd + b - 1524.5 +
10048 (((TIMESTAMP_STRUCT *) dp)->hour * 3600000.0 +
10049 ((TIMESTAMP_STRUCT *) dp)->minute * 60000.0 +
10050 ((TIMESTAMP_STRUCT *) dp)->second * 1000.0 +
10051 ((TIMESTAMP_STRUCT *) dp)->fraction / 1.0E6)
10053 sqlite3_bind_double(
stmt, si, v);
10055 fprintf(d->
trace,
"-- parameter %d: %g\n", si, v);
10061 frac = (int) ((TIMESTAMP_STRUCT *) dp)->fraction;
10063 frac = frac % 1000;
10067 if (c->prec && c->prec <= 16) {
10068 sprintf(
strbuf,
"%04d-%02d-%02d %02d:%02d:00.000",
10069 ((TIMESTAMP_STRUCT *) dp)->year,
10070 ((TIMESTAMP_STRUCT *) dp)->month,
10071 ((TIMESTAMP_STRUCT *) dp)->day,
10072 ((TIMESTAMP_STRUCT *) dp)->hour,
10073 ((TIMESTAMP_STRUCT *) dp)->minute);
10074 }
else if (c->prec && c->prec <= 19) {
10075 sprintf(
strbuf,
"%04d-%02d-%02d %02d:%02d:%02d.000",
10076 ((TIMESTAMP_STRUCT *) dp)->year,
10077 ((TIMESTAMP_STRUCT *) dp)->month,
10078 ((TIMESTAMP_STRUCT *) dp)->day,
10079 ((TIMESTAMP_STRUCT *) dp)->hour,
10080 ((TIMESTAMP_STRUCT *) dp)->minute,
10081 ((TIMESTAMP_STRUCT *) dp)->second);
10083 sprintf(
strbuf,
"%04d-%02d-%02d %02d:%02d:%02d.%03d",
10084 ((TIMESTAMP_STRUCT *) dp)->year,
10085 ((TIMESTAMP_STRUCT *) dp)->month,
10086 ((TIMESTAMP_STRUCT *) dp)->day,
10087 ((TIMESTAMP_STRUCT *) dp)->hour,
10088 ((TIMESTAMP_STRUCT *) dp)->minute,
10089 ((TIMESTAMP_STRUCT *) dp)->second,
10092 sqlite3_bind_text(
stmt, si,
strbuf, -1, SQLITE_TRANSIENT);
10094 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si,
strbuf);
10100 setstat(s, -1,
"unsupported column type in positional update",
10101 (*s->
ov3) ?
"HY000" :
"S1000");
10104 return SQL_SUCCESS;
10127 setstat(s, -1,
"row out of range", (*s->
ov3) ?
"HY107" :
"S1107");
10132 if (*data == NULL) {
10133 sqlite3_bind_null(
stmt, si);
10135 fprintf(d->
trace,
"-- parameter %d: NULL\n", si);
10139 sqlite3_bind_text(
stmt, si, *data, -1, SQLITE_STATIC);
10141 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si, *data);
10145 return SQL_SUCCESS;
10158 int i, withinfo = 0;
10159 SQLRETURN ret = SQL_SUCCESS;
10168 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10171 dp = (SQLPOINTER) ((
char *) b->
valp + b->
max * rsi);
10174 dp = (SQLPOINTER) ((
char *) dp + *s->
bind_offs);
10178 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10181 lp = b->
lenp + rsi;
10188 int rowp = s->
rowp;
10194 if (!SQL_SUCCEEDED(ret)) {
10198 if (ret != SQL_SUCCESS) {
10200 #ifdef SQL_ROW_SUCCESS_WITH_INFO
10206 if (SQL_SUCCEEDED(ret)) {
10207 ret = withinfo ? SQL_SUCCESS_WITH_INFO : SQL_SUCCESS;
10226 int rowp, i, k, rc, nretry = 0;
10229 sqlite3_stmt *s3stmt = NULL;
10232 if (lock != SQL_LOCK_NO_CHANGE) {
10233 setstat(s, -1,
"unsupported locking mode",
10234 (*s->
ov3) ?
"HY000" :
"S1000");
10238 setstat(s, -1,
"incompatible statement",
10239 (*s->
ov3) ?
"HY000" :
"S1000");
10242 if (op == SQL_ADD) {
10244 setstat(s, -1,
"incompatible rowset",
10245 (*s->
ov3) ?
"HY000" :
"S1000");
10252 if (ret != SQL_SUCCESS) {
10255 sql =
dsappend(sql,
"INSERT INTO ");
10261 for (i = 0; i < s->
ncols; i++) {
10262 sql =
dsappend(sql, (i > 0) ?
"," :
"(");
10266 for (i = 0; i < s->
ncols; i++) {
10267 sql =
dsappend(sql, (i > 0) ?
",?" :
"(?");
10274 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10281 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10282 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10288 if (rc != SQLITE_OK) {
10290 sqlite3_finalize(s3stmt);
10294 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10297 if (rc != SQLITE_OK) {
10299 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10300 sqlite3_errmsg(d->
sqlite), rc);
10303 sqlite3_finalize(s3stmt);
10309 if (ret != SQL_SUCCESS) {
10311 sqlite3_finalize(s3stmt);
10316 rc = sqlite3_step(s3stmt);
10317 if (rc != SQLITE_DONE) {
10320 sqlite3_finalize(s3stmt);
10321 if (sqlite3_changes(d->
sqlite) > 0 && row <= s->rowset_size) {
10329 return SQL_SUCCESS;
10330 }
else if (op == SQL_UPDATE || op == SQL_DELETE) {
10332 setstat(s, -1,
"incompatible rowset",
10333 (*s->
ov3) ?
"HY000" :
"S1000");
10340 if (!SQL_SUCCEEDED(ret)) {
10350 if (op != SQL_POSITION && op != SQL_REFRESH &&
10351 op != SQL_DELETE && op != SQL_UPDATE) {
10354 if (op == SQL_POSITION) {
10355 rowp = s->
rowp + row - 1;
10356 if (!s->
rows || row == 0 || rowp < -1 || rowp >= s->
nrows) {
10358 setstat(s, -1,
"row out of range", (*s->
ov3) ?
"HY107" :
"S1107");
10362 }
else if (op == SQL_REFRESH) {
10370 if (!SQL_SUCCEEDED(ret)) {
10377 }
else if (op == SQL_DELETE) {
10378 sql =
dsappend(sql,
"DELETE FROM ");
10384 for (i = k = 0; i < s->
ncols; i++) {
10388 sql =
dsappend(sql, (k > 0) ?
" AND " :
" WHERE ");
10397 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10404 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10405 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10411 if (rc != SQLITE_OK) {
10413 sqlite3_finalize(s3stmt);
10417 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10420 if (rc != SQLITE_OK) {
10422 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10423 sqlite3_errmsg(d->
sqlite), rc);
10426 sqlite3_finalize(s3stmt);
10435 if (ret != SQL_SUCCESS) {
10437 sqlite3_finalize(s3stmt);
10442 rc = sqlite3_step(s3stmt);
10443 if (rc != SQLITE_DONE) {
10446 sqlite3_finalize(s3stmt);
10447 if (sqlite3_changes(d->
sqlite) > 0) {
10455 return SQL_SUCCESS;
10456 }
else if (op == SQL_UPDATE) {
10458 if (ret != SQL_SUCCESS) {
10467 for (i = 0; i < s->
ncols; i++) {
10468 sql =
dsappend(sql, (i > 0) ?
", " :
" SET ");
10472 for (i = k = 0; i < s->
ncols; i++) {
10476 sql =
dsappend(sql, (k > 0) ?
" AND " :
" WHERE ");
10485 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10492 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10493 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10499 if (rc != SQLITE_OK) {
10501 sqlite3_finalize(s3stmt);
10505 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10508 if (rc != SQLITE_OK) {
10510 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10511 sqlite3_errmsg(d->
sqlite), rc);
10514 sqlite3_finalize(s3stmt);
10520 if (ret != SQL_SUCCESS) {
10522 sqlite3_finalize(s3stmt);
10532 if (ret != SQL_SUCCESS) {
10534 sqlite3_finalize(s3stmt);
10539 rc = sqlite3_step(s3stmt);
10540 if (rc != SQLITE_DONE) {
10543 sqlite3_finalize(s3stmt);
10544 if (sqlite3_changes(d->
sqlite) > 0) {
10552 return SQL_SUCCESS;
10554 return SQL_SUCCESS;
10589 int row, i, k, rc, nretry = 0;
10592 sqlite3_stmt *s3stmt = NULL;
10596 setstat(s, -1,
"incompatible statement",
10597 (*s->
ov3) ?
"HY000" :
"S1000");
10600 if (op == SQL_ADD) {
10602 setstat(s, -1,
"incompatible rowset",
10603 (*s->
ov3) ?
"HY000" :
"S1000");
10607 if (ret != SQL_SUCCESS) {
10610 sql =
dsappend(sql,
"INSERT INTO ");
10616 for (i = 0; i < s->
ncols; i++) {
10617 sql =
dsappend(sql, (i > 0) ?
"," :
"(");
10621 for (i = 0; i < s->
ncols; i++) {
10622 sql =
dsappend(sql, (i > 0) ?
",?" :
"(?");
10629 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10636 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10637 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10643 if (rc != SQLITE_OK) {
10645 sqlite3_finalize(s3stmt);
10649 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10652 if (rc != SQLITE_OK) {
10653 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10654 sqlite3_errmsg(d->
sqlite), rc);
10657 sqlite3_finalize(s3stmt);
10664 if (ret != SQL_SUCCESS) {
10673 sqlite3_finalize(s3stmt);
10678 rc = sqlite3_step(s3stmt);
10679 if (rc != SQLITE_DONE) {
10680 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10681 sqlite3_errmsg(d->
sqlite), rc);
10685 if (sqlite3_changes(d->
sqlite) > 0) {
10693 if (s->
bkmrk == SQL_UB_VARIABLE &&
10698 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10706 val = (SQLPOINTER) ((
char *) val + *s->
bind_offs);
10708 *(sqlite_int64 *) val = sqlite3_last_insert_rowid(d->
sqlite);
10712 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10721 *ival =
sizeof (sqlite_int64);
10725 sqlite3_reset(s3stmt);
10728 sqlite3_finalize(s3stmt);
10729 return SQL_SUCCESS;
10730 }
else if (op == SQL_DELETE_BY_BOOKMARK) {
10732 s->
bkmrk != SQL_UB_VARIABLE ||
10735 setstat(s, -1,
"incompatible rowset",
10736 (*s->
ov3) ?
"HY000" :
"S1000");
10739 sql =
dsappend(sql,
"DELETE FROM ");
10752 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10759 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10760 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10766 if (rc != SQLITE_OK) {
10768 sqlite3_finalize(s3stmt);
10772 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10775 if (rc != SQLITE_OK) {
10776 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10777 sqlite3_errmsg(d->
sqlite), rc);
10780 sqlite3_finalize(s3stmt);
10786 sqlite_int64 rowid;
10788 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10796 val = (SQLPOINTER) ((
char *) val + *s->
bind_offs);
10801 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10810 if (*ival !=
sizeof (sqlite_int64)) {
10814 rowid = *(sqlite_int64 *) val;
10815 sqlite3_bind_int64(s3stmt, 1, rowid);
10819 "-- parameter 1: %I64d\n",
10821 "-- parameter 1: %lld\n",
10826 rc = sqlite3_step(s3stmt);
10827 if (rc != SQLITE_DONE) {
10828 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10829 sqlite3_errmsg(d->
sqlite), rc);
10837 sqlite3_finalize(s3stmt);
10840 if (sqlite3_changes(d->
sqlite) > 0) {
10849 sqlite3_reset(s3stmt);
10852 sqlite3_finalize(s3stmt);
10853 return SQL_SUCCESS;
10854 }
else if (op == SQL_UPDATE_BY_BOOKMARK) {
10856 s->
bkmrk != SQL_UB_VARIABLE ||
10859 setstat(s, -1,
"incompatible rowset",
10860 (*s->
ov3) ?
"HY000" :
"S1000");
10864 if (ret != SQL_SUCCESS) {
10873 for (i = 0, k = 0; i < s->
ncols; i++) {
10874 sql =
dsappend(sql, (k > 0) ?
", " :
" SET ");
10886 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10893 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10894 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10900 if (rc != SQLITE_OK) {
10902 sqlite3_finalize(s3stmt);
10906 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10909 if (rc != SQLITE_OK) {
10910 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10911 sqlite3_errmsg(d->
sqlite), rc);
10914 sqlite3_finalize(s3stmt);
10920 sqlite_int64 rowid;
10922 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10930 val = (SQLPOINTER) ((
char *) val + *s->
bind_offs);
10935 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10944 if (*ival !=
sizeof (sqlite_int64)) {
10950 if (ret != SQL_SUCCESS) {
10959 sqlite3_finalize(s3stmt);
10964 rowid = *(sqlite_int64 *) val;
10965 sqlite3_bind_int64(s3stmt, k, rowid);
10969 "-- parameter %d: %I64d\n",
10971 "-- parameter %d: %lld\n",
10976 rc = sqlite3_step(s3stmt);
10977 if (rc != SQLITE_DONE) {
10978 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10979 sqlite3_errmsg(d->
sqlite), rc);
10983 if (sqlite3_changes(d->
sqlite) > 0) {
10992 sqlite3_reset(s3stmt);
10995 sqlite3_finalize(s3stmt);
10996 return SQL_SUCCESS;
10998 setstat(s, -1,
"unsupported operation", (*s->
ov3) ?
"HY000" :
"S1000");
11027 SQLUSMALLINT rowset)
11037 #define strmak(dst, src, max, lenp) { \
11038 int len = strlen(src); \
11039 int cnt = min(len + 1, max); \
11040 strncpy(dst, src, cnt); \
11041 *lenp = (cnt > len) ? len : cnt; \
11056 SQLSMALLINT *valLen)
11061 #if defined(_WIN32) || defined(_WIN64)
11062 char pathbuf[301], *drvname;
11064 static char drvname[] =
"sqlite3odbc.so";
11067 if (
dbc == SQL_NULL_HDBC) {
11068 return SQL_INVALID_HANDLE;
11079 valMax =
sizeof (dummyc) - 1;
11082 case SQL_MAX_USER_NAME_LEN:
11083 *((SQLSMALLINT *) val) = 16;
11084 *valLen =
sizeof (SQLSMALLINT);
11086 case SQL_USER_NAME:
11087 strmak(val,
"", valMax, valLen);
11089 case SQL_DRIVER_ODBC_VER:
11091 strmak(val, (*d->
ov3) ?
"03.00" :
"02.50", valMax, valLen);
11093 strmak(val,
"03.00", valMax, valLen);
11096 case SQL_ACTIVE_CONNECTIONS:
11097 case SQL_ACTIVE_STATEMENTS:
11098 *((SQLSMALLINT *) val) = 0;
11099 *valLen =
sizeof (SQLSMALLINT);
11101 #ifdef SQL_ASYNC_MODE
11102 case SQL_ASYNC_MODE:
11103 *((SQLUINTEGER *) val) = SQL_AM_NONE;
11104 *valLen =
sizeof (SQLUINTEGER);
11107 #ifdef SQL_CREATE_TABLE
11108 case SQL_CREATE_TABLE:
11109 *((SQLUINTEGER *) val) = SQL_CT_CREATE_TABLE |
11110 SQL_CT_COLUMN_DEFAULT |
11111 SQL_CT_COLUMN_CONSTRAINT |
11112 SQL_CT_CONSTRAINT_NON_DEFERRABLE;
11113 *valLen =
sizeof (SQLUINTEGER);
11116 #ifdef SQL_CREATE_VIEW
11117 case SQL_CREATE_VIEW:
11118 *((SQLUINTEGER *) val) = SQL_CV_CREATE_VIEW;
11119 *valLen =
sizeof (SQLUINTEGER);
11122 #ifdef SQL_DDL_INDEX
11123 case SQL_DDL_INDEX:
11124 *((SQLUINTEGER *) val) = SQL_DI_CREATE_INDEX | SQL_DI_DROP_INDEX;
11125 *valLen =
sizeof (SQLUINTEGER);
11128 #ifdef SQL_DROP_TABLE
11129 case SQL_DROP_TABLE:
11130 *((SQLUINTEGER *) val) = SQL_DT_DROP_TABLE;
11131 *valLen =
sizeof (SQLUINTEGER);
11134 #ifdef SQL_DROP_VIEW
11135 case SQL_DROP_VIEW:
11136 *((SQLUINTEGER *) val) = SQL_DV_DROP_VIEW;
11137 *valLen =
sizeof (SQLUINTEGER);
11140 #ifdef SQL_INDEX_KEYWORDS
11141 case SQL_INDEX_KEYWORDS:
11142 *((SQLUINTEGER *) val) = SQL_IK_ALL;
11143 *valLen =
sizeof (SQLUINTEGER);
11146 case SQL_DATA_SOURCE_NAME:
11149 case SQL_DRIVER_NAME:
11150 #if defined(_WIN32) || defined(_WIN64)
11151 GetModuleFileName(hModule, pathbuf,
sizeof (pathbuf));
11152 drvname = strrchr(pathbuf,
'\\');
11153 if (drvname == NULL) {
11154 drvname = strrchr(pathbuf,
'/');
11156 if (drvname == NULL) {
11162 strmak(val, drvname, valMax, valLen);
11164 case SQL_DRIVER_VER:
11167 case SQL_FETCH_DIRECTION:
11168 *((SQLUINTEGER *) val) = SQL_FD_FETCH_NEXT | SQL_FD_FETCH_FIRST |
11169 SQL_FD_FETCH_LAST | SQL_FD_FETCH_PRIOR | SQL_FD_FETCH_ABSOLUTE;
11170 *valLen =
sizeof (SQLUINTEGER);
11173 strmak(val, (*d->
ov3) ?
"03.00" :
"02.50", valMax, valLen);
11175 case SQL_ODBC_SAG_CLI_CONFORMANCE:
11176 *((SQLSMALLINT *) val) = SQL_OSCC_NOT_COMPLIANT;
11177 *valLen =
sizeof (SQLSMALLINT);
11179 case SQL_STANDARD_CLI_CONFORMANCE:
11180 *((SQLUINTEGER *) val) = SQL_SCC_XOPEN_CLI_VERSION1;
11181 *valLen =
sizeof (SQLUINTEGER);
11183 case SQL_SQL_CONFORMANCE:
11184 *((SQLUINTEGER *) val) = SQL_SC_SQL92_ENTRY;
11185 *valLen =
sizeof (SQLUINTEGER);
11187 case SQL_SERVER_NAME:
11188 case SQL_DATABASE_NAME:
11191 case SQL_SEARCH_PATTERN_ESCAPE:
11192 strmak(val,
"\\", valMax, valLen);
11194 case SQL_ODBC_SQL_CONFORMANCE:
11195 *((SQLSMALLINT *) val) = SQL_OSC_MINIMUM;
11196 *valLen =
sizeof (SQLSMALLINT);
11198 case SQL_ODBC_API_CONFORMANCE:
11199 *((SQLSMALLINT *) val) = SQL_OAC_LEVEL1;
11200 *valLen =
sizeof (SQLSMALLINT);
11202 case SQL_DBMS_NAME:
11203 strmak(val,
"SQLite", valMax, valLen);
11206 strmak(val, SQLITE_VERSION, valMax, valLen);
11208 case SQL_COLUMN_ALIAS:
11209 case SQL_NEED_LONG_DATA_LEN:
11210 case SQL_OUTER_JOINS:
11211 strmak(val,
"Y", valMax, valLen);
11213 case SQL_ROW_UPDATES:
11214 case SQL_ACCESSIBLE_PROCEDURES:
11215 case SQL_PROCEDURES:
11216 case SQL_EXPRESSIONS_IN_ORDERBY:
11217 case SQL_ODBC_SQL_OPT_IEF:
11218 case SQL_LIKE_ESCAPE_CLAUSE:
11219 case SQL_ORDER_BY_COLUMNS_IN_SELECT:
11220 case SQL_ACCESSIBLE_TABLES:
11221 case SQL_MULT_RESULT_SETS:
11222 case SQL_MULTIPLE_ACTIVE_TXN:
11223 case SQL_MAX_ROW_SIZE_INCLUDES_LONG:
11224 strmak(val,
"N", valMax, valLen);
11226 #ifdef SQL_CATALOG_NAME
11227 case SQL_CATALOG_NAME:
11228 #if defined(_WIN32) || defined(_WIN64)
11229 strmak(val, d->xcelqrx ?
"Y" :
"N", valMax, valLen);
11231 strmak(val,
"N", valMax, valLen);
11235 case SQL_DATA_SOURCE_READ_ONLY:
11236 strmak(val,
"N", valMax, valLen);
11238 #ifdef SQL_OJ_CAPABILITIES
11239 case SQL_OJ_CAPABILITIES:
11240 *((SQLUINTEGER *) val) = SQL_OJ_LEFT;
11241 *valLen =
sizeof (SQLUINTEGER);
11244 #ifdef SQL_MAX_IDENTIFIER_LEN
11245 case SQL_MAX_IDENTIFIER_LEN:
11246 *((SQLUSMALLINT *) val) = 255;
11247 *valLen =
sizeof (SQLUSMALLINT);
11250 case SQL_CONCAT_NULL_BEHAVIOR:
11251 *((SQLSMALLINT *) val) = SQL_CB_NULL;
11252 *valLen =
sizeof (SQLSMALLINT);
11254 case SQL_CURSOR_COMMIT_BEHAVIOR:
11255 case SQL_CURSOR_ROLLBACK_BEHAVIOR:
11256 *((SQLSMALLINT *) val) = SQL_CB_PRESERVE;
11257 *valLen =
sizeof (SQLSMALLINT);
11259 #ifdef SQL_CURSOR_SENSITIVITY
11260 case SQL_CURSOR_SENSITIVITY:
11261 *((SQLUINTEGER *) val) = SQL_UNSPECIFIED;
11262 *valLen =
sizeof (SQLUINTEGER);
11265 case SQL_DEFAULT_TXN_ISOLATION:
11266 *((SQLUINTEGER *) val) = SQL_TXN_SERIALIZABLE;
11267 *valLen =
sizeof (SQLUINTEGER);
11269 #ifdef SQL_DESCRIBE_PARAMETER
11270 case SQL_DESCRIBE_PARAMETER:
11271 strmak(val,
"Y", valMax, valLen);
11274 case SQL_TXN_ISOLATION_OPTION:
11275 *((SQLUINTEGER *) val) = SQL_TXN_SERIALIZABLE;
11276 *valLen =
sizeof (SQLUINTEGER);
11278 case SQL_IDENTIFIER_CASE:
11279 *((SQLSMALLINT *) val) = SQL_IC_SENSITIVE;
11280 *valLen =
sizeof (SQLSMALLINT);
11282 case SQL_IDENTIFIER_QUOTE_CHAR:
11283 strmak(val,
"\"", valMax, valLen);
11285 case SQL_MAX_TABLE_NAME_LEN:
11286 case SQL_MAX_COLUMN_NAME_LEN:
11287 *((SQLSMALLINT *) val) = 255;
11288 *valLen =
sizeof (SQLSMALLINT);
11290 case SQL_MAX_CURSOR_NAME_LEN:
11291 *((SQLSMALLINT *) val) = 255;
11292 *valLen =
sizeof (SQLSMALLINT);
11294 case SQL_MAX_PROCEDURE_NAME_LEN:
11295 *((SQLSMALLINT *) val) = 0;
11297 case SQL_MAX_QUALIFIER_NAME_LEN:
11298 case SQL_MAX_OWNER_NAME_LEN:
11299 *((SQLSMALLINT *) val) = 255;
11301 case SQL_OWNER_TERM:
11302 strmak(val,
"", valMax, valLen);
11304 case SQL_PROCEDURE_TERM:
11305 strmak(val,
"PROCEDURE", valMax, valLen);
11307 case SQL_QUALIFIER_NAME_SEPARATOR:
11308 strmak(val,
".", valMax, valLen);
11310 case SQL_QUALIFIER_TERM:
11311 #if defined(_WIN32) || defined(_WIN64)
11312 strmak(val, d->xcelqrx ?
"catalog" :
"", valMax, valLen);
11314 strmak(val,
"", valMax, valLen);
11317 case SQL_QUALIFIER_USAGE:
11318 #if defined(_WIN32) || defined(_WIN64)
11319 *((SQLUINTEGER *) val) = d->xcelqrx ?
11320 (SQL_CU_DML_STATEMENTS | SQL_CU_INDEX_DEFINITION |
11321 SQL_CU_TABLE_DEFINITION) : 0;
11323 *((SQLUINTEGER *) val) = 0;
11325 *valLen =
sizeof (SQLUINTEGER);
11327 case SQL_SCROLL_CONCURRENCY:
11328 *((SQLUINTEGER *) val) = SQL_SCCO_LOCK;
11329 *valLen =
sizeof (SQLUINTEGER);
11331 case SQL_SCROLL_OPTIONS:
11332 *((SQLUINTEGER *) val) = SQL_SO_STATIC | SQL_SO_FORWARD_ONLY;
11333 *valLen =
sizeof (SQLUINTEGER);
11335 case SQL_TABLE_TERM:
11336 strmak(val,
"TABLE", valMax, valLen);
11338 case SQL_TXN_CAPABLE:
11339 *((SQLSMALLINT *) val) = SQL_TC_ALL;
11340 *valLen =
sizeof (SQLSMALLINT);
11342 case SQL_CONVERT_FUNCTIONS:
11343 *((SQLUINTEGER *) val) = 0;
11344 *valLen =
sizeof (SQLUINTEGER);
11346 case SQL_SYSTEM_FUNCTIONS:
11347 case SQL_NUMERIC_FUNCTIONS:
11348 case SQL_STRING_FUNCTIONS:
11349 case SQL_TIMEDATE_FUNCTIONS:
11350 *((SQLUINTEGER *) val) = 0;
11351 *valLen =
sizeof (SQLUINTEGER);
11353 case SQL_CONVERT_BIGINT:
11354 case SQL_CONVERT_BIT:
11355 case SQL_CONVERT_CHAR:
11356 case SQL_CONVERT_DATE:
11357 case SQL_CONVERT_DECIMAL:
11358 case SQL_CONVERT_DOUBLE:
11359 case SQL_CONVERT_FLOAT:
11360 case SQL_CONVERT_INTEGER:
11361 case SQL_CONVERT_LONGVARCHAR:
11362 case SQL_CONVERT_NUMERIC:
11363 case SQL_CONVERT_REAL:
11364 case SQL_CONVERT_SMALLINT:
11365 case SQL_CONVERT_TIME:
11366 case SQL_CONVERT_TIMESTAMP:
11367 case SQL_CONVERT_TINYINT:
11368 case SQL_CONVERT_VARCHAR:
11369 *((SQLUINTEGER *) val) =
11370 SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL |
11371 SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT | SQL_CVT_REAL |
11372 SQL_CVT_DOUBLE | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR |
11373 SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_BIGINT |
11374 SQL_CVT_DATE | SQL_CVT_TIME | SQL_CVT_TIMESTAMP;
11375 *valLen =
sizeof (SQLUINTEGER);
11377 case SQL_CONVERT_BINARY:
11378 case SQL_CONVERT_VARBINARY:
11379 case SQL_CONVERT_LONGVARBINARY:
11380 *((SQLUINTEGER *) val) = 0;
11381 *valLen =
sizeof (SQLUINTEGER);
11383 case SQL_POSITIONED_STATEMENTS:
11384 *((SQLUINTEGER *) val) = 0;
11385 *valLen =
sizeof (SQLUINTEGER);
11387 case SQL_LOCK_TYPES:
11388 *((SQLUINTEGER *) val) = SQL_LCK_NO_CHANGE;
11389 *valLen =
sizeof (SQLUINTEGER);
11391 case SQL_BOOKMARK_PERSISTENCE:
11392 *((SQLUINTEGER *) val) = SQL_BP_SCROLL;
11393 *valLen =
sizeof (SQLUINTEGER);
11396 *((SQLUINTEGER *) val) = SQL_U_UNION | SQL_U_UNION_ALL;
11397 *valLen =
sizeof (SQLUINTEGER);
11399 case SQL_OWNER_USAGE:
11400 case SQL_SUBQUERIES:
11401 case SQL_TIMEDATE_ADD_INTERVALS:
11402 case SQL_TIMEDATE_DIFF_INTERVALS:
11403 *((SQLUINTEGER *) val) = 0;
11404 *valLen =
sizeof (SQLUINTEGER);
11406 case SQL_QUOTED_IDENTIFIER_CASE:
11407 *((SQLUSMALLINT *) val) = SQL_IC_SENSITIVE;
11408 *valLen =
sizeof (SQLUSMALLINT);
11410 case SQL_POS_OPERATIONS:
11411 *((SQLUINTEGER *) val) = SQL_POS_POSITION | SQL_POS_UPDATE |
11412 SQL_POS_DELETE | SQL_POS_ADD | SQL_POS_REFRESH;
11413 *valLen =
sizeof (SQLUINTEGER);
11415 case SQL_ALTER_TABLE:
11416 *((SQLUINTEGER *) val) = 0;
11417 *valLen =
sizeof (SQLUINTEGER);
11419 case SQL_CORRELATION_NAME:
11420 *((SQLSMALLINT *) val) = SQL_CN_DIFFERENT;
11421 *valLen =
sizeof (SQLSMALLINT);
11423 case SQL_NON_NULLABLE_COLUMNS:
11424 *((SQLSMALLINT *) val) = SQL_NNC_NON_NULL;
11425 *valLen =
sizeof (SQLSMALLINT);
11427 case SQL_NULL_COLLATION:
11428 *((SQLSMALLINT *) val) = SQL_NC_START;
11429 *valLen =
sizeof (SQLSMALLINT);
11431 case SQL_MAX_COLUMNS_IN_GROUP_BY:
11432 case SQL_MAX_COLUMNS_IN_ORDER_BY:
11433 case SQL_MAX_COLUMNS_IN_SELECT:
11434 case SQL_MAX_COLUMNS_IN_TABLE:
11435 case SQL_MAX_ROW_SIZE:
11436 case SQL_MAX_TABLES_IN_SELECT:
11437 *((SQLSMALLINT *) val) = 0;
11438 *valLen =
sizeof (SQLSMALLINT);
11440 case SQL_MAX_BINARY_LITERAL_LEN:
11441 case SQL_MAX_CHAR_LITERAL_LEN:
11442 *((SQLUINTEGER *) val) = 0;
11443 *valLen =
sizeof (SQLUINTEGER);
11445 case SQL_MAX_COLUMNS_IN_INDEX:
11446 *((SQLSMALLINT *) val) = 0;
11447 *valLen =
sizeof (SQLSMALLINT);
11449 case SQL_MAX_INDEX_SIZE:
11450 *((SQLUINTEGER *) val) = 0;
11451 *valLen =
sizeof (SQLUINTEGER);
11453 #ifdef SQL_MAX_IDENTIFIER_LENGTH
11454 case SQL_MAX_IDENTIFIER_LENGTH:
11455 *((SQLUINTEGER *) val) = 255;
11456 *valLen =
sizeof (SQLUINTEGER);
11459 case SQL_MAX_STATEMENT_LEN:
11460 *((SQLUINTEGER *) val) = 16384;
11461 *valLen =
sizeof (SQLUINTEGER);
11463 case SQL_QUALIFIER_LOCATION:
11464 *((SQLSMALLINT *) val) = SQL_QL_START;
11465 *valLen =
sizeof (SQLSMALLINT);
11467 case SQL_GETDATA_EXTENSIONS:
11468 *((SQLUINTEGER *) val) =
11469 SQL_GD_ANY_COLUMN | SQL_GD_ANY_ORDER | SQL_GD_BOUND;
11470 *valLen =
sizeof (SQLUINTEGER);
11472 case SQL_STATIC_SENSITIVITY:
11473 *((SQLUINTEGER *) val) = 0;
11474 *valLen =
sizeof (SQLUINTEGER);
11476 case SQL_FILE_USAGE:
11477 #if defined(_WIN32) || defined(_WIN64)
11478 *((SQLSMALLINT *) val) =
11479 d->xcelqrx ? SQL_FILE_CATALOG : SQL_FILE_NOT_SUPPORTED;
11481 *((SQLSMALLINT *) val) = SQL_FILE_NOT_SUPPORTED;
11483 *valLen =
sizeof (SQLSMALLINT);
11486 *((SQLSMALLINT *) val) = SQL_GB_GROUP_BY_EQUALS_SELECT;
11487 *valLen =
sizeof (SQLSMALLINT);
11490 strmak(val,
"CREATE,SELECT,DROP,DELETE,UPDATE,INSERT,"
11491 "INTO,VALUES,TABLE,INDEX,FROM,SET,WHERE,AND,CURRENT,OF",
11494 case SQL_SPECIAL_CHARACTERS:
11495 #ifdef SQL_COLLATION_SEQ
11496 case SQL_COLLATION_SEQ:
11498 strmak(val,
"", valMax, valLen);
11500 case SQL_BATCH_SUPPORT:
11501 case SQL_BATCH_ROW_COUNT:
11502 case SQL_PARAM_ARRAY_ROW_COUNTS:
11503 *((SQLUINTEGER *) val) = 0;
11504 *valLen =
sizeof (SQLUINTEGER);
11506 case SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1:
11507 *((SQLUINTEGER *) val) = SQL_CA1_NEXT | SQL_CA1_BOOKMARK;
11508 *valLen =
sizeof (SQLUINTEGER);
11510 case SQL_STATIC_CURSOR_ATTRIBUTES1:
11511 *((SQLUINTEGER *) val) = SQL_CA1_NEXT | SQL_CA1_ABSOLUTE |
11512 SQL_CA1_RELATIVE | SQL_CA1_BOOKMARK | SQL_CA1_POS_POSITION |
11513 SQL_CA1_POS_DELETE | SQL_CA1_POS_UPDATE | SQL_CA1_POS_REFRESH |
11514 SQL_CA1_LOCK_NO_CHANGE | SQL_CA1_BULK_ADD |
11515 SQL_CA1_BULK_UPDATE_BY_BOOKMARK | SQL_CA1_BULK_DELETE_BY_BOOKMARK;
11516 *valLen =
sizeof (SQLUINTEGER);
11518 case SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2:
11519 case SQL_STATIC_CURSOR_ATTRIBUTES2:
11520 *((SQLUINTEGER *) val) = SQL_CA2_READ_ONLY_CONCURRENCY |
11521 SQL_CA2_LOCK_CONCURRENCY;
11522 *valLen =
sizeof (SQLUINTEGER);
11524 case SQL_KEYSET_CURSOR_ATTRIBUTES1:
11525 case SQL_KEYSET_CURSOR_ATTRIBUTES2:
11526 case SQL_DYNAMIC_CURSOR_ATTRIBUTES1:
11527 case SQL_DYNAMIC_CURSOR_ATTRIBUTES2:
11528 *((SQLUINTEGER *) val) = 0;
11529 *valLen =
sizeof (SQLUINTEGER);
11531 case SQL_ODBC_INTERFACE_CONFORMANCE:
11532 *((SQLUINTEGER *) val) = SQL_OIC_CORE;
11533 *valLen =
sizeof (SQLUINTEGER);
11536 setstatd(d, -1,
"unsupported info option %d",
11537 (*d->
ov3) ?
"HYC00" :
"S1C00", type);
11540 return SQL_SUCCESS;
11543 #if (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC)) || !defined(WINTERFACE)
11555 SQLGetInfo(SQLHDBC
dbc, SQLUSMALLINT type, SQLPOINTER val, SQLSMALLINT valMax,
11556 SQLSMALLINT *valLen)
11580 SQLSMALLINT *valLen)
11583 SQLSMALLINT len = 0;
11588 if (ret == SQL_SUCCESS) {
11589 SQLWCHAR *v = NULL;
11592 case SQL_USER_NAME:
11593 case SQL_DRIVER_ODBC_VER:
11594 case SQL_DATA_SOURCE_NAME:
11595 case SQL_DRIVER_NAME:
11596 case SQL_DRIVER_VER:
11598 case SQL_SERVER_NAME:
11599 case SQL_DATABASE_NAME:
11600 case SQL_SEARCH_PATTERN_ESCAPE:
11601 case SQL_DBMS_NAME:
11603 case SQL_NEED_LONG_DATA_LEN:
11604 case SQL_ROW_UPDATES:
11605 case SQL_ACCESSIBLE_PROCEDURES:
11606 case SQL_PROCEDURES:
11607 case SQL_EXPRESSIONS_IN_ORDERBY:
11608 case SQL_ODBC_SQL_OPT_IEF:
11609 case SQL_LIKE_ESCAPE_CLAUSE:
11610 case SQL_ORDER_BY_COLUMNS_IN_SELECT:
11611 case SQL_OUTER_JOINS:
11612 case SQL_COLUMN_ALIAS:
11613 case SQL_ACCESSIBLE_TABLES:
11614 case SQL_MULT_RESULT_SETS:
11615 case SQL_MULTIPLE_ACTIVE_TXN:
11616 case SQL_MAX_ROW_SIZE_INCLUDES_LONG:
11617 case SQL_DATA_SOURCE_READ_ONLY:
11618 #ifdef SQL_DESCRIBE_PARAMETER
11619 case SQL_DESCRIBE_PARAMETER:
11621 case SQL_IDENTIFIER_QUOTE_CHAR:
11622 case SQL_OWNER_TERM:
11623 case SQL_PROCEDURE_TERM:
11624 case SQL_QUALIFIER_NAME_SEPARATOR:
11625 case SQL_QUALIFIER_TERM:
11626 case SQL_TABLE_TERM:
11628 case SQL_SPECIAL_CHARACTERS:
11629 #ifdef SQL_CATALOG_NAME
11630 case SQL_CATALOG_NAME:
11632 #ifdef SQL_COLLATION_SEQ
11633 case SQL_COLLATION_SEQ:
11639 int vmax = valMax /
sizeof (SQLWCHAR);
11649 len *=
sizeof (SQLWCHAR);
11656 if (valMax >=
sizeof (SQLWCHAR)) {
11657 *((SQLWCHAR *)val) = 0;
11661 len *=
sizeof (SQLWCHAR);
11683 SQLUSMALLINT *flags)
11686 SQLUSMALLINT exists[100];
11688 if (
dbc == SQL_NULL_HDBC) {
11689 return SQL_INVALID_HANDLE;
11692 exists[i] = SQL_FALSE;
11694 exists[SQL_API_SQLALLOCCONNECT] = SQL_TRUE;
11695 exists[SQL_API_SQLFETCH] = SQL_TRUE;
11696 exists[SQL_API_SQLALLOCENV] = SQL_TRUE;
11697 exists[SQL_API_SQLFREECONNECT] = SQL_TRUE;
11698 exists[SQL_API_SQLALLOCSTMT] = SQL_TRUE;
11699 exists[SQL_API_SQLFREEENV] = SQL_TRUE;
11700 exists[SQL_API_SQLBINDCOL] = SQL_TRUE;
11701 exists[SQL_API_SQLFREESTMT] = SQL_TRUE;
11702 exists[SQL_API_SQLCANCEL] = SQL_TRUE;
11703 exists[SQL_API_SQLGETCURSORNAME] = SQL_TRUE;
11704 exists[SQL_API_SQLCOLATTRIBUTES] = SQL_TRUE;
11705 exists[SQL_API_SQLNUMRESULTCOLS] = SQL_TRUE;
11706 exists[SQL_API_SQLCONNECT] = SQL_TRUE;
11707 exists[SQL_API_SQLPREPARE] = SQL_TRUE;
11708 exists[SQL_API_SQLDESCRIBECOL] = SQL_TRUE;
11709 exists[SQL_API_SQLROWCOUNT] = SQL_TRUE;
11710 exists[SQL_API_SQLDISCONNECT] = SQL_TRUE;
11711 exists[SQL_API_SQLSETCURSORNAME] = SQL_FALSE;
11712 exists[SQL_API_SQLERROR] = SQL_TRUE;
11713 exists[SQL_API_SQLSETPARAM] = SQL_TRUE;
11714 exists[SQL_API_SQLEXECDIRECT] = SQL_TRUE;
11715 exists[SQL_API_SQLTRANSACT] = SQL_TRUE;
11716 exists[SQL_API_SQLBULKOPERATIONS] = SQL_TRUE;
11717 exists[SQL_API_SQLEXECUTE] = SQL_TRUE;
11718 exists[SQL_API_SQLBINDPARAMETER] = SQL_TRUE;
11719 exists[SQL_API_SQLGETTYPEINFO] = SQL_TRUE;
11720 exists[SQL_API_SQLCOLUMNS] = SQL_TRUE;
11721 exists[SQL_API_SQLPARAMDATA] = SQL_TRUE;
11722 exists[SQL_API_SQLDRIVERCONNECT] = SQL_TRUE;
11723 exists[SQL_API_SQLPUTDATA] = SQL_TRUE;
11724 exists[SQL_API_SQLGETCONNECTOPTION] = SQL_TRUE;
11725 exists[SQL_API_SQLSETCONNECTOPTION] = SQL_TRUE;
11726 exists[SQL_API_SQLGETDATA] = SQL_TRUE;
11727 exists[SQL_API_SQLSETSTMTOPTION] = SQL_TRUE;
11728 exists[SQL_API_SQLGETFUNCTIONS] = SQL_TRUE;
11729 exists[SQL_API_SQLSPECIALCOLUMNS] = SQL_TRUE;
11730 exists[SQL_API_SQLGETINFO] = SQL_TRUE;
11731 exists[SQL_API_SQLSTATISTICS] = SQL_TRUE;
11732 exists[SQL_API_SQLGETSTMTOPTION] = SQL_TRUE;
11733 exists[SQL_API_SQLTABLES] = SQL_TRUE;
11734 exists[SQL_API_SQLBROWSECONNECT] = SQL_FALSE;
11735 exists[SQL_API_SQLNUMPARAMS] = SQL_TRUE;
11736 exists[SQL_API_SQLCOLUMNPRIVILEGES] = SQL_FALSE;
11737 exists[SQL_API_SQLPARAMOPTIONS] = SQL_FALSE;
11738 exists[SQL_API_SQLDATASOURCES] = SQL_TRUE;
11739 exists[SQL_API_SQLPRIMARYKEYS] = SQL_TRUE;
11740 exists[SQL_API_SQLDESCRIBEPARAM] = SQL_TRUE;
11741 exists[SQL_API_SQLPROCEDURECOLUMNS] = SQL_TRUE;
11742 exists[SQL_API_SQLDRIVERS] = SQL_FALSE;
11743 exists[SQL_API_SQLPROCEDURES] = SQL_TRUE;
11744 exists[SQL_API_SQLEXTENDEDFETCH] = SQL_TRUE;
11745 exists[SQL_API_SQLSETPOS] = SQL_TRUE;
11746 exists[SQL_API_SQLFOREIGNKEYS] = SQL_TRUE;
11747 exists[SQL_API_SQLSETSCROLLOPTIONS] = SQL_TRUE;
11748 exists[SQL_API_SQLMORERESULTS] = SQL_TRUE;
11749 exists[SQL_API_SQLTABLEPRIVILEGES] = SQL_TRUE;
11750 exists[SQL_API_SQLNATIVESQL] = SQL_TRUE;
11751 if (func == SQL_API_ALL_FUNCTIONS) {
11752 memcpy(flags, exists,
sizeof (exists));
11753 }
else if (func == SQL_API_ODBC3_ALL_FUNCTIONS) {
11755 #define SET_EXISTS(x) \
11756 flags[(x) >> 4] |= (1 << ((x) & 0xF))
11757 #define CLR_EXISTS(x) \
11758 flags[(x) >> 4] &= ~(1 << ((x) & 0xF))
11761 sizeof (SQLUSMALLINT) * SQL_API_ODBC3_ALL_FUNCTIONS_SIZE);
11764 flags[i >> 4] |= (1 << (i & 0xF));
11777 #if !defined(HAVE_UNIXODBC) || !(HAVE_UNIXODBC)
11790 *flags = exists[func];
11793 case SQL_API_SQLALLOCHANDLE:
11794 case SQL_API_SQLFREEHANDLE:
11795 case SQL_API_SQLGETSTMTATTR:
11796 case SQL_API_SQLSETSTMTATTR:
11797 case SQL_API_SQLGETCONNECTATTR:
11798 case SQL_API_SQLSETCONNECTATTR:
11799 case SQL_API_SQLGETENVATTR:
11800 case SQL_API_SQLSETENVATTR:
11801 case SQL_API_SQLCLOSECURSOR:
11802 case SQL_API_SQLBINDPARAM:
11803 #if !defined(HAVE_UNIXODBC) || !(HAVE_UNIXODBC)
11809 case SQL_API_SQLGETDIAGREC:
11811 case SQL_API_SQLGETDIAGFIELD:
11812 case SQL_API_SQLFETCHSCROLL:
11813 case SQL_API_SQLENDTRAN:
11817 *flags = SQL_FALSE;
11821 return SQL_SUCCESS;
11836 return SQL_INVALID_HANDLE;
11840 *env = SQL_NULL_HENV;
11846 #if defined(_WIN32) || defined(_WIN64)
11847 InitializeCriticalSection(&e->cs);
11849 #if defined(ENABLE_NVFS) && (ENABLE_NVFS)
11854 *env = (SQLHENV) e;
11855 return SQL_SUCCESS;
11881 if (env == SQL_NULL_HENV) {
11882 return SQL_INVALID_HANDLE;
11886 return SQL_SUCCESS;
11888 #if defined(_WIN32) || defined(_WIN64)
11889 EnterCriticalSection(&e->cs);
11892 #if defined(_WIN32) || defined(_WIN64)
11893 LeaveCriticalSection(&e->cs);
11898 #if defined(_WIN32) || defined(_WIN64)
11899 LeaveCriticalSection(&e->cs);
11900 DeleteCriticalSection(&e->cs);
11903 return SQL_SUCCESS;
11930 const char *verstr;
11931 int maj = 0,
min = 0, lev = 0;
11938 *
dbc = SQL_NULL_HDBC;
11941 memset(d, 0,
sizeof (
DBC));
11942 d->
curtype = SQL_CURSOR_STATIC;
11944 verstr = sqlite3_libversion();
11945 sscanf(verstr,
"%d.%d.%d", &maj, &
min, &lev);
11948 #if defined(_WIN32) || defined(_WIN64)
11950 EnterCriticalSection(&e->cs);
11970 #if defined(_WIN32) || defined(_WIN64)
11971 InitializeCriticalSection(&d->cs);
11974 LeaveCriticalSection(&e->cs);
11980 *
dbc = (SQLHDBC) d;
11982 return SQL_SUCCESS;
12009 SQLRETURN ret = SQL_ERROR;
12011 if (
dbc == SQL_NULL_HDBC) {
12012 return SQL_INVALID_HANDLE;
12016 return SQL_INVALID_HANDLE;
12020 #if defined(_WIN32) || defined(_WIN64)
12021 EnterCriticalSection(&e->cs);
12028 setstatd(d, -1,
"not disconnected", (*d->
ov3) ?
"HY000" :
"S1000");
12060 #if defined(_WIN32) || defined(_WIN64)
12062 LeaveCriticalSection(&d->cs);
12063 DeleteCriticalSection(&d->cs);
12068 #if defined(_WIN32) || defined(_WIN64)
12070 LeaveCriticalSection(&e->cs);
12100 SQLINTEGER bufmax, SQLINTEGER *buflen)
12105 if (
dbc == SQL_NULL_HDBC) {
12106 return SQL_INVALID_HANDLE;
12110 val = (SQLPOINTER) &dummy;
12116 case SQL_ATTR_CONNECTION_DEAD:
12117 *((SQLINTEGER *) val) = d->
sqlite ? SQL_CD_FALSE : SQL_CD_TRUE;
12118 *buflen =
sizeof (SQLINTEGER);
12120 case SQL_ATTR_ACCESS_MODE:
12121 *((SQLINTEGER *) val) = SQL_MODE_READ_WRITE;
12122 *buflen =
sizeof (SQLINTEGER);
12124 case SQL_ATTR_AUTOCOMMIT:
12125 *((SQLINTEGER *) val) =
12126 d->
autocommit ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF;
12127 *buflen =
sizeof (SQLINTEGER);
12129 case SQL_ATTR_LOGIN_TIMEOUT:
12130 *((SQLINTEGER *) val) = 100;
12131 *buflen =
sizeof (SQLINTEGER);
12133 case SQL_ATTR_ODBC_CURSORS:
12134 *((SQLINTEGER *) val) = SQL_CUR_USE_DRIVER;
12135 *buflen =
sizeof (SQLINTEGER);
12137 case SQL_ATTR_PACKET_SIZE:
12138 *((SQLINTEGER *) val) = 16384;
12139 *buflen =
sizeof (SQLINTEGER);
12141 case SQL_ATTR_TXN_ISOLATION:
12142 *((SQLINTEGER *) val) = SQL_TXN_SERIALIZABLE;
12143 *buflen =
sizeof (SQLINTEGER);
12145 case SQL_ATTR_TRACEFILE:
12146 case SQL_ATTR_TRANSLATE_LIB:
12147 *((SQLCHAR *) val) = 0;
12150 case SQL_ATTR_CURRENT_CATALOG:
12151 #if defined(_WIN32) || defined(_WIN64)
12153 if ((bufmax > 4) && (val != (SQLPOINTER) &dummy)) {
12154 strcpy((
char *) val,
"main");
12160 *((SQLCHAR *) val) = 0;
12163 case SQL_ATTR_TRACE:
12164 case SQL_ATTR_QUIET_MODE:
12165 case SQL_ATTR_TRANSLATE_OPTION:
12166 case SQL_ATTR_KEYSET_SIZE:
12167 case SQL_ATTR_QUERY_TIMEOUT:
12168 *((SQLINTEGER *) val) = 0;
12169 *buflen =
sizeof (SQLINTEGER);
12171 case SQL_ATTR_PARAM_BIND_TYPE:
12172 *((
SQLULEN *) val) = SQL_PARAM_BIND_BY_COLUMN;
12173 *buflen =
sizeof (SQLUINTEGER);
12175 case SQL_ATTR_ROW_BIND_TYPE:
12176 *((
SQLULEN *) val) = SQL_BIND_BY_COLUMN;
12179 case SQL_ATTR_USE_BOOKMARKS:
12180 *((SQLINTEGER *) val) = SQL_UB_OFF;
12181 *buflen =
sizeof (SQLINTEGER);
12183 case SQL_ATTR_ASYNC_ENABLE:
12184 *((SQLINTEGER *) val) = SQL_ASYNC_ENABLE_OFF;
12185 *buflen =
sizeof (SQLINTEGER);
12187 case SQL_ATTR_NOSCAN:
12188 *((SQLINTEGER *) val) = SQL_NOSCAN_ON;
12189 *buflen =
sizeof (SQLINTEGER);
12191 case SQL_ATTR_CONCURRENCY:
12192 *((SQLINTEGER *) val) = SQL_CONCUR_LOCK;
12193 *buflen =
sizeof (SQLINTEGER);
12195 #ifdef SQL_ATTR_CURSOR_SENSITIVITY
12196 case SQL_ATTR_CURSOR_SENSITIVITY:
12197 *((SQLINTEGER *) val) = SQL_UNSPECIFIED;
12198 *buflen =
sizeof (SQLINTEGER);
12201 case SQL_ATTR_SIMULATE_CURSOR:
12202 *((SQLINTEGER *) val) = SQL_SC_NON_UNIQUE;
12203 *buflen =
sizeof (SQLINTEGER);
12205 case SQL_ATTR_MAX_ROWS:
12206 *((SQLINTEGER *) val) = 0;
12207 *buflen =
sizeof (SQLINTEGER);
12208 case SQL_ATTR_MAX_LENGTH:
12209 *((SQLINTEGER *) val) = 1000000000;
12210 *buflen =
sizeof (SQLINTEGER);
12212 case SQL_ATTR_CURSOR_TYPE:
12213 *((SQLINTEGER *) val) = d->
curtype;
12214 *buflen =
sizeof (SQLINTEGER);
12216 case SQL_ATTR_RETRIEVE_DATA:
12217 *((SQLINTEGER *) val) = SQL_RD_ON;
12218 *buflen =
sizeof (SQLINTEGER);
12220 #ifdef SQL_ATTR_METADATA_ID
12221 case SQL_ATTR_METADATA_ID:
12222 *((
SQLULEN *) val) = SQL_FALSE;
12223 return SQL_SUCCESS;
12226 *((SQLINTEGER *) val) = 0;
12227 *buflen =
sizeof (SQLINTEGER);
12228 setstatd(d, -1,
"unsupported connect attribute %d",
12229 (*d->
ov3) ?
"HYC00" :
"S1C00", (
int) attr);
12232 return SQL_SUCCESS;
12247 SQLGetConnectAttr(SQLHDBC
dbc, SQLINTEGER attr, SQLPOINTER val,
12248 SQLINTEGER bufmax, SQLINTEGER *buflen)
12272 SQLINTEGER bufmax, SQLINTEGER *buflen)
12275 SQLINTEGER len = 0;
12279 if (ret == SQL_SUCCESS) {
12280 SQLWCHAR *v = NULL;
12283 case SQL_ATTR_TRACEFILE:
12284 case SQL_ATTR_CURRENT_CATALOG:
12285 case SQL_ATTR_TRANSLATE_LIB:
12290 int vmax = bufmax /
sizeof (SQLWCHAR);
12300 len *=
sizeof (SQLWCHAR);
12307 if (bufmax >=
sizeof (SQLWCHAR)) {
12308 *((SQLWCHAR *)val) = 0;
12312 len *=
sizeof (SQLWCHAR);
12340 if (
dbc == SQL_NULL_HDBC) {
12341 return SQL_INVALID_HANDLE;
12345 case SQL_AUTOCOMMIT:
12346 d->
autocommit = val == (SQLPOINTER) SQL_AUTOCOMMIT_ON;
12348 return endtran(d, SQL_COMMIT, 1);
12353 return SQL_SUCCESS;
12354 #ifdef SQL_ATTR_METADATA_ID
12355 case SQL_ATTR_METADATA_ID:
12356 if (val == (SQLPOINTER) SQL_FALSE) {
12362 setstatd(d, -1,
"option value changed",
"01S02");
12363 return SQL_SUCCESS_WITH_INFO;
12365 return SQL_SUCCESS;
12379 SQLSetConnectAttr(SQLHDBC
dbc, SQLINTEGER attr, SQLPOINTER val,
12428 if (
dbc == SQL_NULL_HDBC) {
12429 return SQL_INVALID_HANDLE;
12433 param = (SQLPOINTER) &dummy;
12436 case SQL_ACCESS_MODE:
12437 *((SQLINTEGER *) param) = SQL_MODE_READ_WRITE;
12439 case SQL_AUTOCOMMIT:
12440 *((SQLINTEGER *) param) =
12441 d->
autocommit ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF;
12443 case SQL_LOGIN_TIMEOUT:
12444 *((SQLINTEGER *) param) = 100;
12446 case SQL_ODBC_CURSORS:
12447 *((SQLINTEGER *) param) = SQL_CUR_USE_DRIVER;
12449 case SQL_PACKET_SIZE:
12450 *((SQLINTEGER *) param) = 16384;
12452 case SQL_TXN_ISOLATION:
12453 *((SQLINTEGER *) param) = SQL_TXN_SERIALIZABLE;
12455 case SQL_OPT_TRACE:
12456 case SQL_OPT_TRACEFILE:
12457 case SQL_QUIET_MODE:
12458 case SQL_TRANSLATE_DLL:
12459 case SQL_TRANSLATE_OPTION:
12460 case SQL_KEYSET_SIZE:
12461 case SQL_QUERY_TIMEOUT:
12462 case SQL_BIND_TYPE:
12463 case SQL_CURRENT_QUALIFIER:
12464 *((SQLINTEGER *) param) = 0;
12466 case SQL_USE_BOOKMARKS:
12467 *((SQLINTEGER *) param) = SQL_UB_OFF;
12469 case SQL_ASYNC_ENABLE:
12470 *((SQLINTEGER *) param) = SQL_ASYNC_ENABLE_OFF;
12473 *((SQLINTEGER *) param) = SQL_NOSCAN_ON;
12475 case SQL_CONCURRENCY:
12476 *((SQLINTEGER *) param) = SQL_CONCUR_LOCK;
12478 case SQL_SIMULATE_CURSOR:
12479 *((SQLINTEGER *) param) = SQL_SC_NON_UNIQUE;
12482 *((SQLINTEGER *) param) = 0;
12484 case SQL_ROWSET_SIZE:
12485 case SQL_MAX_LENGTH:
12486 *((SQLINTEGER *) param) = 1000000000;
12488 case SQL_CURSOR_TYPE:
12489 *((SQLINTEGER *) param) = d->
curtype;
12491 case SQL_RETRIEVE_DATA:
12492 *((SQLINTEGER *) param) = SQL_RD_ON;
12495 *((SQLINTEGER *) param) = 0;
12496 setstatd(d, -1,
"unsupported connect option %d",
12497 (*d->
ov3) ?
"HYC00" :
"S1C00", opt);
12500 return SQL_SUCCESS;
12513 SQLGetConnectOption(SQLHDBC
dbc, SQLUSMALLINT opt, SQLPOINTER param)
12540 if (SQL_SUCCEEDED(ret)) {
12542 case SQL_OPT_TRACEFILE:
12543 case SQL_CURRENT_QUALIFIER:
12544 case SQL_TRANSLATE_DLL:
12546 *(SQLWCHAR *) param = 0;
12569 if (
dbc == SQL_NULL_HDBC) {
12570 return SQL_INVALID_HANDLE;
12574 case SQL_AUTOCOMMIT:
12577 return endtran(d, SQL_COMMIT, 1);
12583 setstatd(d, -1,
"option value changed",
"01S02");
12584 return SQL_SUCCESS_WITH_INFO;
12586 return SQL_SUCCESS;
12599 SQLSetConnectOption(SQLHDBC
dbc, SQLUSMALLINT opt,
SQLULEN param)
12631 #if defined(WITHOUT_DRIVERMGR) || (!defined(_WIN32) && !defined(_WIN64))
12646 char *str = dsn, *start;
12647 int len = strlen(attr);
12650 while (*str && *str ==
';') {
12654 if ((str = strchr(str,
'=')) == NULL) {
12657 if (str - start == len && strncasecmp(start, attr, len) == 0) {
12659 while (*str && *str !=
';') {
12662 len =
min(outLen - 1, str - start);
12663 strncpy(out, start, len);
12667 while (*str && *str !=
';') {
12688 int pwdLen,
int isu)
12693 char buf[SQL_MAX_MESSAGE_LENGTH * 6], dbname[SQL_MAX_MESSAGE_LENGTH];
12694 char busy[SQL_MAX_MESSAGE_LENGTH / 4], tracef[SQL_MAX_MESSAGE_LENGTH];
12695 char loadext[SQL_MAX_MESSAGE_LENGTH];
12696 char sflag[32], spflag[32], ntflag[32], nwflag[32], biflag[32];
12697 char snflag[32], lnflag[32], ncflag[32], fkflag[32], jmode[32];
12699 #if defined(_WIN32) || defined(_WIN64)
12703 if (
dbc == SQL_NULL_HDBC) {
12704 return SQL_INVALID_HANDLE;
12708 return SQL_INVALID_HANDLE;
12710 if (d->
sqlite != NULL) {
12711 setstatd(d, -1,
"connection already established",
"08002");
12715 if (dsnLen == SQL_NTS) {
12716 len =
sizeof (buf) - 1;
12718 len =
min(
sizeof (buf) - 1, dsnLen);
12721 strncpy(buf, (
char *) dsn, len);
12724 if (buf[0] ==
'\0') {
12725 setstatd(d, -1,
"invalid DSN", (*d->
ov3) ?
"HY090" :
"S1090");
12728 #if defined(_WIN32) || defined(_WIN64)
12734 char *cdsn = utf_to_wmb(buf, len);
12737 setstatd(d, -1,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
12746 #ifdef WITHOUT_DRIVERMGR
12747 getdsnattr(buf,
"database", dbname,
sizeof (dbname));
12748 if (dbname[0] ==
'\0') {
12749 strncpy(dbname, buf,
sizeof (dbname));
12750 dbname[
sizeof (dbname) - 1] =
'\0';
12752 getdsnattr(buf,
"timeout", busy,
sizeof (busy));
12754 getdsnattr(buf,
"stepapi", sflag,
sizeof (sflag));
12756 getdsnattr(buf,
"syncpragma", spflag,
sizeof (spflag));
12758 getdsnattr(buf,
"notxn", ntflag,
sizeof (ntflag));
12760 getdsnattr(buf,
"nowchar", nwflag,
sizeof (nwflag));
12762 getdsnattr(buf,
"shortnames", snflag,
sizeof (snflag));
12764 getdsnattr(buf,
"longnames", lnflag,
sizeof (lnflag));
12766 getdsnattr(buf,
"nocreat", ncflag,
sizeof (ncflag));
12768 getdsnattr(buf,
"fksupport", fkflag,
sizeof (fkflag));
12770 getdsnattr(buf,
"loadext", loadext,
sizeof (loadext));
12772 getdsnattr(buf,
"journalmode", jmode,
sizeof (jmode));
12774 getdsnattr(buf,
"jdconv", jdflag,
sizeof (jdflag));
12775 #if defined(_WIN32) || defined(_WIN64)
12777 getdsnattr(buf,
"oemcp", oemcp,
sizeof (oemcp));
12780 getdsnattr(buf,
"bigint", biflag,
sizeof (biflag));
12782 SQLGetPrivateProfileString(buf,
"timeout",
"100000",
12784 SQLGetPrivateProfileString(buf,
"database",
"",
12785 dbname,
sizeof (dbname),
ODBC_INI);
12786 #if defined(_WIN32) || defined(_WIN64)
12790 SQLGetPrivateProfileString(buf,
"stepapi",
"",
12792 SQLGetPrivateProfileString(buf,
"syncpragma",
"NORMAL",
12793 spflag,
sizeof (spflag),
ODBC_INI);
12794 SQLGetPrivateProfileString(buf,
"notxn",
"",
12795 ntflag,
sizeof (ntflag),
ODBC_INI);
12796 SQLGetPrivateProfileString(buf,
"nowchar",
"",
12797 nwflag,
sizeof (nwflag),
ODBC_INI);
12798 SQLGetPrivateProfileString(buf,
"shortnames",
"",
12799 snflag,
sizeof (snflag),
ODBC_INI);
12800 SQLGetPrivateProfileString(buf,
"longnames",
"",
12801 lnflag,
sizeof (lnflag),
ODBC_INI);
12802 SQLGetPrivateProfileString(buf,
"nocreat",
"",
12803 ncflag,
sizeof (ncflag),
ODBC_INI);
12804 SQLGetPrivateProfileString(buf,
"fksupport",
"",
12805 fkflag,
sizeof (fkflag),
ODBC_INI);
12806 SQLGetPrivateProfileString(buf,
"loadext",
"",
12807 loadext,
sizeof (loadext),
ODBC_INI);
12808 SQLGetPrivateProfileString(buf,
"journalmode",
"",
12810 SQLGetPrivateProfileString(buf,
"jdconv",
"",
12811 jdflag,
sizeof (jdflag),
ODBC_INI);
12812 #if defined(_WIN32) || defined(_WIN64)
12813 SQLGetPrivateProfileString(buf,
"oemcp",
"1",
12816 SQLGetPrivateProfileString(buf,
"bigint",
"",
12817 biflag,
sizeof (biflag),
ODBC_INI);
12820 #ifdef WITHOUT_DRIVERMGR
12821 getdsnattr(buf,
"tracefile", tracef,
sizeof (tracef));
12823 SQLGetPrivateProfileString(buf,
"tracefile",
"",
12824 tracef,
sizeof (tracef),
ODBC_INI);
12826 if (tracef[0] !=
'\0') {
12827 d->
trace = fopen(tracef,
"a");
12835 #if defined(_WIN32) || defined(_WIN64)
12844 d->
pwdLen = (pwdLen == SQL_NTS) ? strlen(d->
pwd) : pwdLen;
12846 ret =
dbopen(d, dbname, isu, (
char *) dsn, sflag, spflag, ntflag,
12848 if (ret == SQL_SUCCESS) {
12868 SQLConnect(SQLHDBC
dbc, SQLCHAR *dsn, SQLSMALLINT dsnLen,
12869 SQLCHAR *uid, SQLSMALLINT uidLen,
12870 SQLCHAR *pwd, SQLSMALLINT pwdLen)
12875 ret =
drvconnect(
dbc, dsn, dsnLen, (
char *) pwd, pwdLen, 0);
12896 SQLWCHAR *uid, SQLSMALLINT uidLen,
12897 SQLWCHAR *pwd, SQLSMALLINT pwdLen)
12909 setstatd(d, -1,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
12919 setstatd(d, -1,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
12924 ret =
drvconnect(
dbc, (SQLCHAR *) dsna, SQL_NTS, pwda, SQL_NTS, 1);
12945 if (
dbc == SQL_NULL_HDBC) {
12946 return SQL_INVALID_HANDLE;
12950 return SQL_INVALID_HANDLE;
12953 setstatd(d, -1,
"incomplete transaction",
"25000");
12961 fprintf(d->
trace,
"-- sqlite3_close: '%s'\n",
12965 rc = sqlite3_close(d->
sqlite);
12966 if (rc == SQLITE_BUSY) {
12967 setstatd(d, -1,
"unfinished statements",
"25000");
12974 return SQL_SUCCESS;
12994 #if defined(WITHOUT_DRIVERMGR) || (!defined(_WIN32) && !defined(_WIN64))
13011 SQLCHAR *connIn, SQLSMALLINT connInLen,
13012 SQLCHAR *connOut, SQLSMALLINT connOutMax,
13013 SQLSMALLINT *connOutLen, SQLUSMALLINT drvcompl)
13018 char buf[SQL_MAX_MESSAGE_LENGTH * 8], dbname[SQL_MAX_MESSAGE_LENGTH];
13019 char dsn[SQL_MAX_MESSAGE_LENGTH], busy[SQL_MAX_MESSAGE_LENGTH / 4];
13020 char tracef[SQL_MAX_MESSAGE_LENGTH], loadext[SQL_MAX_MESSAGE_LENGTH];
13021 char pwd[SQL_MAX_MESSAGE_LENGTH];
13022 char sflag[32], spflag[32], ntflag[32], snflag[32], lnflag[32];
13023 char ncflag[32], nwflag[32], fkflag[32], jmode[32], biflag[32];
13026 if (
dbc == SQL_NULL_HDBC) {
13027 return SQL_INVALID_HANDLE;
13029 if (drvcompl != SQL_DRIVER_COMPLETE &&
13030 drvcompl != SQL_DRIVER_COMPLETE_REQUIRED &&
13031 drvcompl != SQL_DRIVER_PROMPT &&
13032 drvcompl != SQL_DRIVER_NOPROMPT) {
13033 return SQL_NO_DATA;
13037 setstatd(d, -1,
"connection already established",
"08002");
13041 if (connInLen == SQL_NTS) {
13042 len =
sizeof (buf) - 1;
13044 len =
min(connInLen,
sizeof (buf) - 1);
13046 if (connIn != NULL) {
13047 strncpy(buf, (
char *) connIn, len);
13051 setstatd(d, -1,
"invalid connect attributes",
13052 (*d->
ov3) ?
"HY090" :
"S1090");
13059 if (!dsn[0] && !strchr(buf,
';') && !strchr(buf,
'=')) {
13060 strncpy(dsn, buf,
sizeof (dsn) - 1);
13061 dsn[
sizeof (dsn) - 1] =
'\0';
13065 getdsnattr(buf,
"timeout", busy,
sizeof (busy));
13066 #ifndef WITHOUT_DRIVERMGR
13067 if (dsn[0] && !busy[0]) {
13068 SQLGetPrivateProfileString(dsn,
"timeout",
"100000",
13073 getdsnattr(buf,
"database", dbname,
sizeof (dbname));
13074 #ifndef WITHOUT_DRIVERMGR
13075 if (dsn[0] && !dbname[0]) {
13076 SQLGetPrivateProfileString(dsn,
"database",
"",
13077 dbname,
sizeof (dbname),
ODBC_INI);
13081 getdsnattr(buf,
"stepapi", sflag,
sizeof (sflag));
13082 #ifndef WITHOUT_DRIVERMGR
13083 if (dsn[0] && !sflag[0]) {
13084 SQLGetPrivateProfileString(dsn,
"stepapi",
"",
13089 getdsnattr(buf,
"syncpragma", spflag,
sizeof (spflag));
13090 #ifndef WITHOUT_DRIVERMGR
13091 if (dsn[0] && !spflag[0]) {
13092 SQLGetPrivateProfileString(dsn,
"syncpragma",
"NORMAL",
13093 spflag,
sizeof (spflag),
ODBC_INI);
13097 getdsnattr(buf,
"notxn", ntflag,
sizeof (ntflag));
13098 #ifndef WITHOUT_DRIVERMGR
13099 if (dsn[0] && !ntflag[0]) {
13100 SQLGetPrivateProfileString(dsn,
"notxn",
"",
13101 ntflag,
sizeof (ntflag),
ODBC_INI);
13105 getdsnattr(buf,
"shortnames", snflag,
sizeof (snflag));
13106 #ifndef WITHOUT_DRIVERMGR
13107 if (dsn[0] && !snflag[0]) {
13108 SQLGetPrivateProfileString(dsn,
"shortnames",
"",
13109 snflag,
sizeof (snflag),
ODBC_INI);
13113 getdsnattr(buf,
"longnames", lnflag,
sizeof (lnflag));
13114 #ifndef WITHOUT_DRIVERMGR
13115 if (dsn[0] && !lnflag[0]) {
13116 SQLGetPrivateProfileString(dsn,
"longnames",
"",
13117 lnflag,
sizeof (lnflag),
ODBC_INI);
13121 getdsnattr(buf,
"nocreat", ncflag,
sizeof (ncflag));
13122 #ifndef WITHOUT_DRIVERMGR
13123 if (dsn[0] && !ncflag[0]) {
13124 SQLGetPrivateProfileString(dsn,
"nocreat",
"",
13125 ncflag,
sizeof (ncflag),
ODBC_INI);
13129 getdsnattr(buf,
"nowchar", nwflag,
sizeof (nwflag));
13130 #ifndef WITHOUT_DRIVERMGR
13131 if (dsn[0] && !nwflag[0]) {
13132 SQLGetPrivateProfileString(dsn,
"nowchar",
"",
13133 nwflag,
sizeof (nwflag),
ODBC_INI);
13137 getdsnattr(buf,
"fksupport", fkflag,
sizeof (fkflag));
13138 #ifndef WITHOUT_DRIVERMGR
13139 if (dsn[0] && !fkflag[0]) {
13140 SQLGetPrivateProfileString(dsn,
"fksupport",
"",
13141 fkflag,
sizeof (fkflag),
ODBC_INI);
13145 getdsnattr(buf,
"loadext", loadext,
sizeof (loadext));
13146 #ifndef WITHOUT_DRIVERMGR
13147 if (dsn[0] && !loadext[0]) {
13148 SQLGetPrivateProfileString(dsn,
"loadext",
"",
13149 loadext,
sizeof (loadext),
ODBC_INI);
13153 getdsnattr(buf,
"journalmode", jmode,
sizeof (jmode));
13154 #ifndef WITHOUT_DRIVERMGR
13155 if (dsn[0] && !jmode[0]) {
13156 SQLGetPrivateProfileString(dsn,
"journalmode",
"",
13161 getdsnattr(buf,
"bigint", biflag,
sizeof (biflag));
13162 #ifndef WITHOUT_DRIVERMGR
13163 if (dsn[0] && !biflag[0]) {
13164 SQLGetPrivateProfileString(dsn,
"bigint",
"",
13165 biflag,
sizeof (biflag),
ODBC_INI);
13169 getdsnattr(buf,
"jdconv", jdflag,
sizeof (jdflag));
13170 #ifndef WITHOUT_DRIVERMGR
13171 if (dsn[0] && !jdflag[0]) {
13172 SQLGetPrivateProfileString(dsn,
"jdconv",
"",
13173 jdflag,
sizeof (jdflag),
ODBC_INI);
13178 #ifndef WITHOUT_DRIVERMGR
13179 if (dsn[0] && !pwd[0]) {
13180 SQLGetPrivateProfileString(dsn,
"pwd",
"",
13185 if (!dbname[0] && !dsn[0]) {
13186 strcpy(dsn,
"SQLite");
13187 strncpy(dbname, buf,
sizeof (dbname));
13188 dbname[
sizeof (dbname) - 1] =
'\0';
13191 getdsnattr(buf,
"tracefile", tracef,
sizeof (tracef));
13192 #ifndef WITHOUT_DRIVERMGR
13193 if (dsn[0] && !tracef[0]) {
13194 SQLGetPrivateProfileString(dsn,
"tracefile",
"",
13195 tracef,
sizeof (tracef),
ODBC_INI);
13198 if (connOut || connOutLen) {
13202 count = snprintf(buf,
sizeof (buf),
13203 "DSN=%s;Database=%s;StepAPI=%s;Timeout=%s;"
13204 "SyncPragma=%s;NoTXN=%s;ShortNames=%s;LongNames=%s;"
13205 "NoCreat=%s;NoWCHAR=%s;FKSupport=%s;Tracefile=%s;"
13206 "JournalMode=%s;LoadExt=%s;BigInt=%s;JDConv=%s;"
13208 dsn, dbname, sflag, busy, spflag, ntflag,
13209 snflag, lnflag, ncflag, nwflag, fkflag, tracef,
13210 jmode, loadext, biflag, jdflag, pwd);
13212 buf[
sizeof (buf) - 1] =
'\0';
13214 len =
min(connOutMax - 1, strlen(buf));
13216 strncpy((
char *) connOut, buf, len);
13217 connOut[len] =
'\0';
13223 if (tracef[0] !=
'\0') {
13224 d->
trace = fopen(tracef,
"a");
13234 d->
pwdLen = strlen(pwd);
13236 ret =
dbopen(d, dbname, 0, dsn, sflag, spflag, ntflag, jmode, busy);
13237 memset(pwd, 0,
sizeof (pwd));
13238 if (ret == SQL_SUCCESS) {
13257 if (
stmt == SQL_NULL_HSTMT) {
13258 return SQL_INVALID_HANDLE;
13293 return SQL_SUCCESS;
13309 if (
dbc == SQL_NULL_HDBC) {
13310 return SQL_INVALID_HANDLE;
13314 return SQL_INVALID_HANDLE;
13318 *
stmt = SQL_NULL_HSTMT;
13321 *
stmt = (SQLHSTMT) s;
13322 memset(s, 0,
sizeof (
STMT));
13325 s->
bkmrk = SQL_UB_OFF;
13346 sprintf((
char *) s->
cursorname,
"CUR_%I64X", (SQLUBIGINT) *
stmt);
13361 return SQL_SUCCESS;
13393 SQLRETURN ret = SQL_SUCCESS;
13396 if (
stmt == SQL_NULL_HSTMT) {
13397 return SQL_INVALID_HANDLE;
13403 case SQL_RESET_PARAMS:
13418 setstat(s, -1,
"unsupported option", (*s->
ov3) ?
"HYC00" :
"S1C00");
13448 if (
stmt != SQL_NULL_HSTMT) {
13450 #if defined(_WIN32) || defined(_WIN64)
13452 if (d->
magic ==
DBC_MAGIC && d->owner != GetCurrentThreadId() &&
13455 sqlite3_interrupt(d->
sqlite);
13456 return SQL_SUCCESS;
13461 sqlite3_interrupt(d->
sqlite);
13483 if (
stmt == SQL_NULL_HSTMT) {
13484 return SQL_INVALID_HANDLE;
13487 if (lenp && !cursor) {
13489 return SQL_SUCCESS;
13493 strncpy((
char *) cursor, (
char *) s->
cursorname, buflen - 1);
13494 cursor[buflen - 1] =
'\0';
13500 return SQL_SUCCESS;
13514 SQLGetCursorName(SQLHSTMT
stmt, SQLCHAR *cursor, SQLSMALLINT buflen,
13518 #if defined(_WIN32) || defined(_WIN64)
13519 SQLSMALLINT len = 0;
13523 #if defined(_WIN32) || defined(_WIN64)
13529 if (ret == SQL_SUCCESS) {
13533 c = utf_to_wmb((
char *) cursor, len);
13541 strncpy((
char *) cursor, c, buflen - 1);
13542 cursor[buflen - 1] = 0;
13547 *lenp =
min(len, buflen - 1);
13575 SQLSMALLINT len = 0;
13579 if (ret == SQL_SUCCESS) {
13580 SQLWCHAR *c = NULL;
13592 cursor[buflen - 1] = 0;
13597 *lenp =
min(len, buflen - 1);
13619 if (
stmt == SQL_NULL_HSTMT) {
13620 return SQL_INVALID_HANDLE;
13624 !((cursor[0] >=
'A' && cursor[0] <=
'Z') ||
13625 (cursor[0] >=
'a' && cursor[0] <=
'z'))) {
13626 setstat(s, -1,
"invalid cursor name", (*s->
ov3) ?
"HYC00" :
"S1C00");
13629 if (len == SQL_NTS) {
13634 strncpy((
char *) s->
cursorname, (
char *) cursor, len);
13636 return SQL_SUCCESS;
13649 SQLSetCursorName(SQLHSTMT
stmt, SQLCHAR *cursor, SQLSMALLINT len)
13651 #if defined(_WIN32) || defined(_WIN64)
13657 #if defined(_WIN32) || defined(_WIN64)
13663 c = wmb_to_utf_c((
char *) cursor, len);
13673 #if defined(_WIN32) || defined(_WIN64)
13741 case SQL_HANDLE_ENV:
13743 if (ret == SQL_SUCCESS) {
13744 ENV *e = (
ENV *) *output;
13751 case SQL_HANDLE_DBC:
13753 case SQL_HANDLE_STMT:
13755 ret =
drvallocstmt((SQLHDBC) input, (SQLHSTMT *) output);
13773 case SQL_HANDLE_ENV:
13775 case SQL_HANDLE_DBC:
13777 case SQL_HANDLE_STMT:
13794 for (i = 0; i < s->
dcols; i++) {
13885 for (i = s->
nbindcols; i < ncols; i++) {
13886 bindcols[i].
type = SQL_UNKNOWN_TYPE;
13887 bindcols[i].
max = 0;
13888 bindcols[i].
lenp = NULL;
13889 bindcols[i].
valp = NULL;
13890 bindcols[i].
index = i;
13891 bindcols[i].
offs = 0;
13896 }
else if (ncols > 0) {
13904 return SQL_SUCCESS;
13922 SQLPOINTER val, SQLINTEGER len,
SQLLEN *lenp,
int partial)
13924 char **data, valdummy[16];
13926 SQLINTEGER *ilenp = NULL;
13929 SQLRETURN sret = SQL_NO_DATA;
13935 if (((SQLINTEGER *) lenp) + 1 == (SQLINTEGER *) val) {
13936 ilenp = (SQLINTEGER *) lenp;
13939 if (col >= s->
ncols) {
13940 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009" :
"S1002");
13944 return SQL_SUCCESS;
13947 *lenp = SQL_NULL_DATA;
13951 *lenp = SQL_NULL_DATA;
13956 #if (defined(_WIN32) || defined(_WIN64)) && defined(WINTERFACE)
13958 if (type == SQL_C_WCHAR && otype == SQL_C_DEFAULT) {
13965 val = (SQLPOINTER) valdummy;
13967 if (*data == NULL) {
13968 *lenp = SQL_NULL_DATA;
13970 case SQL_C_UTINYINT:
13971 case SQL_C_TINYINT:
13972 case SQL_C_STINYINT:
13976 *((SQLCHAR *) val) = 0;
13981 *((SQLSMALLINT *) val) = 0;
13986 *((SQLINTEGER *) val) = 0;
13989 case SQL_C_SBIGINT:
13990 case SQL_C_UBIGINT:
13991 *((SQLBIGINT *) val) = 0;
13995 *((
float *) val) = 0;
13998 *((
double *) val) = 0;
14003 *((SQLCHAR *) val) =
'\0';
14006 #ifdef WCHARSUPPORT
14009 *((SQLWCHAR *) val) =
'\0';
14013 #ifdef SQL_C_TYPE_DATE
14014 case SQL_C_TYPE_DATE:
14017 memset((DATE_STRUCT *) val, 0,
sizeof (DATE_STRUCT));
14019 #ifdef SQL_C_TYPE_TIME
14020 case SQL_C_TYPE_TIME:
14023 memset((TIME_STRUCT *) val, 0,
sizeof (TIME_STRUCT));
14025 #ifdef SQL_C_TYPE_TIMESTAMP
14026 case SQL_C_TYPE_TIMESTAMP:
14028 case SQL_C_TIMESTAMP:
14029 memset((TIMESTAMP_STRUCT *) val, 0,
sizeof (TIMESTAMP_STRUCT));
14036 #if defined(_WIN32) || defined(_WIN64)
14043 case SQL_C_UTINYINT:
14044 case SQL_C_TINYINT:
14045 case SQL_C_STINYINT:
14046 *((SQLCHAR *) val) = strtol(*data, &endp, 0);
14047 if (endp && endp == *data) {
14048 *lenp = SQL_NULL_DATA;
14050 *lenp =
sizeof (SQLCHAR);
14055 *((SQLCHAR *) val) =
getbool(*data);
14056 *lenp =
sizeof (SQLCHAR);
14062 *((SQLSMALLINT *) val) = strtol(*data, &endp, 0);
14063 if (endp && endp == *data) {
14064 *lenp = SQL_NULL_DATA;
14066 *lenp =
sizeof (SQLSMALLINT);
14072 *((SQLINTEGER *) val) = strtol(*data, &endp, 0);
14073 if (endp && endp == *data) {
14074 *lenp = SQL_NULL_DATA;
14076 *lenp =
sizeof (SQLINTEGER);
14080 case SQL_C_UBIGINT:
14081 #if defined(_WIN32) || defined(_WIN64)
14082 if (sscanf(*data,
"%I64u%c", (SQLUBIGINT *) val, &endc) != 1) {
14083 *lenp = SQL_NULL_DATA;
14085 *lenp =
sizeof (SQLUBIGINT);
14089 *((SQLUBIGINT *) val) = strtoul(*data, &endp, 0);
14091 *((SQLUBIGINT *) val) = strtoull(*data, &endp, 0);
14093 if (endp && endp == *data) {
14094 *lenp = SQL_NULL_DATA;
14096 *lenp =
sizeof (SQLUBIGINT);
14100 case SQL_C_SBIGINT:
14101 #if defined(_WIN32) || defined(_WIN64)
14102 if (sscanf(*data,
"%I64d%c", (SQLBIGINT *) val, &endc) != 1) {
14103 *lenp = SQL_NULL_DATA;
14105 *lenp =
sizeof (SQLBIGINT);
14109 *((SQLBIGINT *) val) = strtol(*data, &endp, 0);
14111 *((SQLBIGINT *) val) = strtoll(*data, &endp, 0);
14113 if (endp && endp == *data) {
14114 *lenp = SQL_NULL_DATA;
14116 *lenp =
sizeof (SQLBIGINT);
14122 *((
float *) val) =
ln_strtod(*data, &endp);
14123 if (endp && endp == *data) {
14124 *lenp = SQL_NULL_DATA;
14126 *lenp =
sizeof (float);
14130 *((
double *) val) =
ln_strtod(*data, &endp);
14131 if (endp && endp == *data) {
14132 *lenp = SQL_NULL_DATA;
14134 *lenp =
sizeof (double);
14137 case SQL_C_BINARY: {
14138 int dlen, offs = 0;
14162 if (!(dp[0] ==
'x' || dp[0] ==
'X') || dp[1] !=
'\'' ||
14163 dp[dlen - 1] !=
'\'') {
14174 memset(bin, 0, dlen);
14176 for (i = 0; i < dlen; i++) {
14180 if (!*dp || !(x = strchr(
xdigits, *dp))) {
14184 bin[i] = (v >= 16) ? ((v - 6) << 4) : (v << 4);
14186 if (!*dp || !(x = strchr(
xdigits, *dp))) {
14190 setstat(s, -1,
"conversion error",
14191 (*s->
ov3) ?
"HY000" :
"S1000");
14195 bin[i] |= (v >= 16) ? (v - 6) : v;
14200 if (partial && len && s->
bindcols) {
14205 sret = SQL_SUCCESS;
14209 sret = SQL_NO_DATA;
14216 memcpy(val, bin + offs,
min(len, dlen));
14221 *lenp =
min(len, dlen);
14222 if (*lenp == len && *lenp != dlen) {
14223 *lenp = SQL_NO_TOTAL;
14226 if (partial && len && s->
bindcols) {
14227 if (*lenp == SQL_NO_TOTAL) {
14230 setstat(s, -1,
"data right truncated",
"01004");
14234 sret = SQL_SUCCESS_WITH_INFO;
14239 if (*lenp == SQL_NO_TOTAL) {
14241 setstat(s, -1,
"data right truncated",
"01004");
14242 sret = SQL_SUCCESS_WITH_INFO;
14248 #ifdef WCHARSUPPORT
14252 int doz, zlen = len - 1;
14253 int dlen = strlen(*data);
14255 #ifdef WCHARSUPPORT
14256 SQLWCHAR *ucdata = NULL;
14257 SQLCHAR *cdata = (SQLCHAR *) *data;
14260 #if (defined(_WIN32) || defined(_WIN64)) && defined(WINTERFACE)
14263 (s->
cols == statSpec2P || s->
cols == statSpec3P) &&
14264 type == SQL_C_WCHAR) {
14265 if (len > 0 && len <=
sizeof (SQLWCHAR)) {
14266 ((
char *) val)[0] = data[0][0];
14267 memset((
char *) val + 1, 0, len - 1);
14269 sret = SQL_SUCCESS;
14275 #ifdef WCHARSUPPORT
14281 doz =
sizeof (SQLWCHAR);
14287 if (type == SQL_C_WCHAR) {
14292 dlen =
uc_strlen(ucdata) *
sizeof (SQLWCHAR);
14294 #if defined(_WIN32) || defined(_WIN64)
14295 else if (*s->
oemcp && type == SQL_C_CHAR) {
14296 ucdata = (SQLWCHAR *) utf_to_wmb((
char *) cdata, dlen);
14300 cdata = (SQLCHAR *) ucdata;
14301 dlen = strlen((
char *) cdata);
14305 doz = (type == SQL_C_CHAR) ? 1 : 0;
14307 if (partial && len && s->
bindcols) {
14309 #ifdef WCHARSUPPORT
14314 #ifdef WCHARSUPPORT
14315 if (type == SQL_C_WCHAR) {
14316 ((SQLWCHAR *) val)[0] = 0;
14318 ((
char *) val)[0] =
'\0';
14321 ((
char *) val)[0] =
'\0';
14326 sret = SQL_SUCCESS;
14330 sret = SQL_NO_DATA;
14336 if (val && !valnull && len) {
14337 #ifdef WCHARSUPPORT
14338 if (type == SQL_C_WCHAR) {
14339 uc_strncpy(val, ucdata + offs /
sizeof (SQLWCHAR),
14340 (len - doz) /
sizeof (SQLWCHAR));
14342 strncpy(val, (
char *) cdata + offs, len - doz);
14345 strncpy(val, *data + offs, len - doz);
14348 if (valnull || len < 1) {
14351 *lenp =
min(len - doz, dlen);
14352 if (*lenp == len - doz && *lenp != dlen) {
14353 *lenp = SQL_NO_TOTAL;
14354 }
else if (*lenp < zlen) {
14358 if (len && !valnull && doz) {
14359 #ifdef WCHARSUPPORT
14360 if (type == SQL_C_WCHAR) {
14361 ((SQLWCHAR *) val)[zlen /
sizeof (SQLWCHAR)] = 0;
14363 ((
char *) val)[zlen] =
'\0';
14366 ((
char *) val)[zlen] =
'\0';
14369 #ifdef WCHARSUPPORT
14372 if (partial && len && s->
bindcols) {
14373 if (*lenp == SQL_NO_TOTAL) {
14376 setstat(s, -1,
"data right truncated",
"01004");
14380 sret = SQL_SUCCESS_WITH_INFO;
14385 if (*lenp == SQL_NO_TOTAL) {
14387 setstat(s, -1,
"data right truncated",
"01004");
14388 sret = SQL_SUCCESS_WITH_INFO;
14393 #ifdef SQL_C_TYPE_DATE
14394 case SQL_C_TYPE_DATE:
14398 *lenp = SQL_NULL_DATA;
14400 *lenp =
sizeof (DATE_STRUCT);
14403 #ifdef SQL_C_TYPE_TIME
14404 case SQL_C_TYPE_TIME:
14408 *lenp = SQL_NULL_DATA;
14410 *lenp =
sizeof (TIME_STRUCT);
14413 #ifdef SQL_C_TYPE_TIMESTAMP
14414 case SQL_C_TYPE_TIMESTAMP:
14416 case SQL_C_TIMESTAMP:
14418 (TIMESTAMP_STRUCT *) val) < 0) {
14419 *lenp = SQL_NULL_DATA;
14421 *lenp =
sizeof (TIMESTAMP_STRUCT);
14425 ((TIMESTAMP_STRUCT *) val)->fraction = 0;
14428 ((TIMESTAMP_STRUCT *) val)->fraction /= 100000000;
14429 ((TIMESTAMP_STRUCT *) val)->fraction *= 100000000;
14432 ((TIMESTAMP_STRUCT *) val)->fraction /= 10000000;
14433 ((TIMESTAMP_STRUCT *) val)->fraction *= 10000000;
14441 sret = SQL_SUCCESS;
14467 if (
stmt == SQL_NULL_HSTMT) {
14468 return SQL_INVALID_HANDLE;
14472 if (col == 0 && s->
bkmrk == SQL_UB_ON &&
14473 type == SQL_C_BOOKMARK) {
14482 return SQL_SUCCESS;
14483 }
else if (col == 0 && s->
bkmrk == SQL_UB_VARIABLE &&
14484 type == SQL_C_VARBOOKMARK &&
14485 max >= sizeof (sqlite_int64)) {
14494 return SQL_SUCCESS;
14496 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009" :
"S1002");
14503 if (type == SQL_C_DEFAULT) {
14511 sz =
sizeof (SQLINTEGER);
14513 case SQL_C_TINYINT:
14514 case SQL_C_UTINYINT:
14515 case SQL_C_STINYINT:
14516 sz =
sizeof (SQLCHAR);
14521 sz =
sizeof (SQLSMALLINT);
14524 sz =
sizeof (SQLFLOAT);
14527 sz =
sizeof (SQLDOUBLE);
14529 case SQL_C_TIMESTAMP:
14530 sz =
sizeof (SQL_TIMESTAMP_STRUCT);
14533 sz =
sizeof (SQL_TIME_STRUCT);
14536 sz =
sizeof (SQL_DATE_STRUCT);
14540 #ifdef WCHARSUPPORT
14544 #ifdef SQL_C_TYPE_DATE
14545 case SQL_C_TYPE_DATE:
14546 sz =
sizeof (SQL_DATE_STRUCT);
14549 #ifdef SQL_C_TYPE_TIME
14550 case SQL_C_TYPE_TIME:
14551 sz =
sizeof (SQL_TIME_STRUCT);
14554 #ifdef SQL_C_TYPE_TIMESTAMP
14555 case SQL_C_TYPE_TIMESTAMP:
14556 sz =
sizeof (SQL_TIMESTAMP_STRUCT);
14561 sz =
sizeof (SQLCHAR);
14567 case SQL_C_SBIGINT:
14568 case SQL_C_UBIGINT:
14569 sz =
sizeof (SQLBIGINT);
14577 setstat(s, -1,
"invalid type %d",
"HY003", type);
14588 if (sz == 0 &&
max < 0) {
14589 setstat(s, -1,
"invalid length",
"HY090");
14601 return SQL_SUCCESS;
14632 {
"SYSTEM",
"COLUMN",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
14633 {
"SYSTEM",
"COLUMN",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
14634 {
"SYSTEM",
"COLUMN",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
14635 {
"SYSTEM",
"COLUMN",
"TABLE_TYPE",
SCOL_VARCHAR, 50 },
14640 {
"SYSTEM",
"COLUMN",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
14641 {
"SYSTEM",
"COLUMN",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
14642 {
"SYSTEM",
"COLUMN",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
14643 {
"SYSTEM",
"COLUMN",
"TABLE_TYPE",
SCOL_VARCHAR, 50 },
14663 SQLCHAR *cat, SQLSMALLINT catLen,
14664 SQLCHAR *schema, SQLSMALLINT schemaLen,
14665 SQLCHAR *table, SQLSMALLINT tableLen,
14666 SQLCHAR *type, SQLSMALLINT typeLen)
14671 int ncols, asize, rc, size, npatt;
14672 char *errp = NULL, *sql, tname[512];
14673 char *where =
"(type = 'table' or type = 'view')";
14677 if (ret != SQL_SUCCESS) {
14682 if (type && (typeLen > 0 || typeLen == SQL_NTS) && type[0] ==
'%') {
14683 int size = 3 * asize;
14690 memset(s->
rows, 0, sizeof (
char *) * size);
14700 #ifdef MEMORY_DEBUG
14707 return SQL_SUCCESS;
14709 if (cat && (catLen > 0 || catLen == SQL_NTS) && cat[0] ==
'%') {
14713 if (schema && (schemaLen > 0 || schemaLen == SQL_NTS) &&
14714 schema[0] ==
'%') {
14715 if ((!cat || catLen == 0 || !cat[0]) &&
14716 (!table || tableLen == 0 || !table[0])) {
14721 if (type && (typeLen > 0 || typeLen == SQL_NTS) && type[0] !=
'\0') {
14723 int with_view = 0, with_table = 0;
14725 if (typeLen == SQL_NTS) {
14726 strncpy(tmp, (
char *) type,
sizeof (tmp));
14727 tmp[
sizeof (tmp) - 1] =
'\0';
14729 int len =
min(
sizeof (tmp) - 1, typeLen);
14731 strncpy(tmp, (
char *) type, len);
14742 if (t[0] ==
'\'') {
14745 if (strncmp(t,
"table", 5) == 0) {
14747 }
else if (strncmp(t,
"view", 4) == 0) {
14750 t = strchr(t,
',');
14755 if (with_view && with_table) {
14757 }
else if (with_view && !with_table) {
14758 where =
"type = 'view'";
14759 }
else if (!with_view && with_table) {
14760 where =
"type = 'table'";
14762 return SQL_SUCCESS;
14770 if (tableLen == SQL_NTS) {
14771 size =
sizeof (tname) - 1;
14773 size =
min(
sizeof (tname) - 1, tableLen);
14775 strncpy(tname, (
char *) table, size);
14777 tname[size] =
'\0';
14779 #if defined(_WIN32) || defined(_WIN64)
14781 sql = sqlite3_mprintf(
"select %s as 'TABLE_CAT', "
14782 "%s as 'TABLE_SCHEM', "
14783 "tbl_name as 'TABLE_NAME', "
14784 "upper(type) as 'TABLE_TYPE', "
14785 "NULL as 'REMARKS' "
14786 "from sqlite_master where %s "
14787 "and tbl_name like %Q",
14788 d->xcelqrx ?
"'main'" :
"NULL",
14789 d->xcelqrx ?
"''" :
"NULL",
14792 sql = sqlite3_mprintf(
"select %s as 'TABLE_CAT', "
14793 "%s as 'TABLE_SCHEM', "
14794 "tbl_name as 'TABLE_NAME', "
14795 "upper(type) as 'TABLE_TYPE', "
14796 "NULL as 'REMARKS' "
14797 "from sqlite_master where %s "
14798 "and lower(tbl_name) = lower(%Q)",
14799 d->xcelqrx ?
"'main'" :
"NULL",
14800 d->xcelqrx ?
"''" :
"NULL",
14805 sql = sqlite3_mprintf(
"select NULL as 'TABLE_QUALIFIER', "
14806 "NULL as 'TABLE_OWNER', "
14807 "tbl_name as 'TABLE_NAME', "
14808 "upper(type) as 'TABLE_TYPE', "
14809 "NULL as 'REMARKS' "
14810 "from sqlite_master where %s "
14811 "and tbl_name like %Q",
14814 sql = sqlite3_mprintf(
"select NULL as 'TABLE_QUALIFIER', "
14815 "NULL as 'TABLE_OWNER', "
14816 "tbl_name as 'TABLE_NAME', "
14817 "upper(type) as 'TABLE_TYPE', "
14818 "NULL as 'REMARKS' "
14819 "from sqlite_master where %s "
14820 "and lower(tbl_name) = lower(%Q)",
14828 if (ret != SQL_SUCCESS) {
14833 rc = sqlite3_get_table(d->
sqlite, sql, &s->
rows, &s->
nrows, &ncols, &errp);
14835 if (rc == SQLITE_OK) {
14836 if (ncols != s->
ncols) {
14840 s->
rowfree = sqlite3_free_table;
14848 sqlite3_free(errp);
14852 return SQL_SUCCESS;
14871 SQLTables(SQLHSTMT
stmt,
14872 SQLCHAR *cat, SQLSMALLINT catLen,
14873 SQLCHAR *schema, SQLSMALLINT schemaLen,
14874 SQLCHAR *table, SQLSMALLINT tableLen,
14875 SQLCHAR *type, SQLSMALLINT typeLen)
14877 #if defined(_WIN32) || defined(_WIN64)
14878 char *c = NULL, *s = NULL, *t = NULL, *y = NULL;
14883 #if defined(_WIN32) || defined(_WIN64)
14886 table, tableLen, type, typeLen);
14890 c = wmb_to_utf_c((
char *) cat, catLen);
14897 s = wmb_to_utf_c((
char *) schema, schemaLen);
14904 t = wmb_to_utf_c((
char *) table, tableLen);
14911 y = wmb_to_utf_c((
char *) type, typeLen);
14917 ret =
drvtables(
stmt, (SQLCHAR *) c, SQL_NTS, (SQLCHAR *) s, SQL_NTS,
14918 (SQLCHAR *) t, SQL_NTS, (SQLCHAR *) y, SQL_NTS);
14921 table, tableLen, type, typeLen);
14923 #if defined(_WIN32) || defined(_WIN64)
14954 SQLWCHAR *cat, SQLSMALLINT catLen,
14955 SQLWCHAR *schema, SQLSMALLINT schemaLen,
14956 SQLWCHAR *table, SQLSMALLINT tableLen,
14957 SQLWCHAR *type, SQLSMALLINT typeLen)
14959 char *c = NULL, *s = NULL, *t = NULL, *y = NULL;
14991 ret =
drvtables(
stmt, (SQLCHAR *) c, SQL_NTS, (SQLCHAR *) s, SQL_NTS,
14992 (SQLCHAR *) t, SQL_NTS, (SQLCHAR *) y, SQL_NTS);
15008 {
"SYSTEM",
"COLUMN",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
15009 {
"SYSTEM",
"COLUMN",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
15010 {
"SYSTEM",
"COLUMN",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
15011 {
"SYSTEM",
"COLUMN",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
15012 {
"SYSTEM",
"COLUMN",
"DATA_TYPE", SQL_SMALLINT, 50 },
15013 {
"SYSTEM",
"COLUMN",
"TYPE_NAME",
SCOL_VARCHAR, 50 },
15014 {
"SYSTEM",
"COLUMN",
"PRECISION", SQL_INTEGER, 50 },
15015 {
"SYSTEM",
"COLUMN",
"LENGTH", SQL_INTEGER, 50 },
15016 {
"SYSTEM",
"COLUMN",
"SCALE", SQL_SMALLINT, 50 },
15017 {
"SYSTEM",
"COLUMN",
"RADIX", SQL_SMALLINT, 50 },
15018 {
"SYSTEM",
"COLUMN",
"NULLABLE", SQL_SMALLINT, 50 },
15020 {
"SYSTEM",
"COLUMN",
"COLUMN_DEF",
SCOL_VARCHAR, 50 },
15021 {
"SYSTEM",
"COLUMN",
"SQL_DATA_TYPE", SQL_SMALLINT, 50 },
15022 {
"SYSTEM",
"COLUMN",
"SQL_DATETIME_SUB", SQL_SMALLINT, 50 },
15023 {
"SYSTEM",
"COLUMN",
"CHAR_OCTET_LENGTH", SQL_SMALLINT, 50 },
15024 {
"SYSTEM",
"COLUMN",
"ORDINAL_POSITION", SQL_SMALLINT, 50 },
15025 {
"SYSTEM",
"COLUMN",
"IS_NULLABLE",
SCOL_VARCHAR, 50 }
15029 {
"SYSTEM",
"COLUMN",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
15030 {
"SYSTEM",
"COLUMN",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
15031 {
"SYSTEM",
"COLUMN",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
15032 {
"SYSTEM",
"COLUMN",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
15033 {
"SYSTEM",
"COLUMN",
"DATA_TYPE", SQL_SMALLINT, 50 },
15034 {
"SYSTEM",
"COLUMN",
"TYPE_NAME",
SCOL_VARCHAR, 50 },
15035 {
"SYSTEM",
"COLUMN",
"COLUMN_SIZE", SQL_INTEGER, 50 },
15036 {
"SYSTEM",
"COLUMN",
"BUFFER_LENGTH", SQL_INTEGER, 50 },
15037 {
"SYSTEM",
"COLUMN",
"DECIMAL_DIGITS", SQL_SMALLINT, 50 },
15038 {
"SYSTEM",
"COLUMN",
"NUM_PREC_RADIX", SQL_SMALLINT, 50 },
15039 {
"SYSTEM",
"COLUMN",
"NULLABLE", SQL_SMALLINT, 50 },
15041 {
"SYSTEM",
"COLUMN",
"COLUMN_DEF",
SCOL_VARCHAR, 50 },
15042 {
"SYSTEM",
"COLUMN",
"SQL_DATA_TYPE", SQL_SMALLINT, 50 },
15043 {
"SYSTEM",
"COLUMN",
"SQL_DATETIME_SUB", SQL_SMALLINT, 50 },
15044 {
"SYSTEM",
"COLUMN",
"CHAR_OCTET_LENGTH", SQL_SMALLINT, 50 },
15045 {
"SYSTEM",
"COLUMN",
"ORDINAL_POSITION", SQL_SMALLINT, 50 },
15046 {
"SYSTEM",
"COLUMN",
"IS_NULLABLE",
SCOL_VARCHAR, 50 }
15065 SQLCHAR *cat, SQLSMALLINT catLen,
15066 SQLCHAR *schema, SQLSMALLINT schemaLen,
15067 SQLCHAR *table, SQLSMALLINT tableLen,
15068 SQLCHAR *col, SQLSMALLINT colLen)
15073 int ret, nrows, ncols, asize, i, k, roffs, namec;
15074 int tnrows, tncols, npatt;
15076 char *errp = NULL, *sql, tname[512], cname[512], **rowp, **trows;
15080 if (sret != SQL_SUCCESS) {
15089 if (tableLen == SQL_NTS) {
15090 size =
sizeof (tname) - 1;
15092 size =
min(
sizeof (tname) - 1, tableLen);
15094 strncpy(tname, (
char *) table, size);
15096 tname[size] =
'\0';
15100 if (colLen == SQL_NTS) {
15101 size =
sizeof (cname) - 1;
15103 size =
min(
sizeof (cname) - 1, colLen);
15105 strncpy(cname, (
char *) col, size);
15107 cname[size] =
'\0';
15108 if (!strcmp(cname,
"%")) {
15112 sql = sqlite3_mprintf(
"select tbl_name from sqlite_master where "
15113 "(type = 'table' or type = 'view') "
15114 "and tbl_name like %Q", tname);
15116 sql = sqlite3_mprintf(
"select tbl_name from sqlite_master where "
15117 "(type = 'table' or type = 'view') "
15118 "and lower(tbl_name) = lower(%Q)", tname);
15124 if (sret != SQL_SUCCESS) {
15129 ret = sqlite3_get_table(d->
sqlite, sql, &trows, &tnrows, &tncols, &errp);
15131 if (ret != SQLITE_OK) {
15132 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
15133 errp ? errp :
"unknown error", ret);
15135 sqlite3_free(errp);
15141 sqlite3_free(errp);
15145 if (tncols * tnrows <= 0) {
15146 sqlite3_free_table(trows);
15147 return SQL_SUCCESS;
15150 for (i = 1; i <= tnrows; i++) {
15151 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", trows[i]);
15153 sqlite3_free_table(trows);
15157 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
15159 if (ret != SQLITE_OK) {
15160 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
15161 errp ? errp :
"unknown error", ret);
15163 sqlite3_free(errp);
15166 sqlite3_free_table(trows);
15170 sqlite3_free(errp);
15173 if (ncols * nrows > 0) {
15175 for (k = 0; k < ncols; k++) {
15176 if (strcmp(rowp[k],
"name") == 0) {
15183 for (k = 1; k <= nrows; k++) {
15184 if (
namematch(rowp[k * ncols + namec], cname, 1)) {
15193 sqlite3_free_table(rowp);
15197 sqlite3_free_table(trows);
15198 return SQL_SUCCESS;
15201 size = (size + 1) * asize;
15205 sqlite3_free_table(trows);
15208 s->
rows[0] = (
char *) size;
15210 memset(s->
rows, 0, sizeof (
char *) * size);
15213 for (i = 1; i <= tnrows; i++) {
15214 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", trows[i]);
15216 sqlite3_free_table(trows);
15220 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
15222 if (ret != SQLITE_OK) {
15223 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
15224 errp ? errp :
"unknown error", ret);
15226 sqlite3_free(errp);
15229 sqlite3_free_table(trows);
15233 sqlite3_free(errp);
15236 if (ncols * nrows > 0) {
15237 int m, mr, nr = nrows;
15240 for (k = 0; k < ncols; k++) {
15241 if (strcmp(rowp[k],
"name") == 0) {
15249 for (k = 1; k <= nrows; k++) {
15250 if (
namematch(rowp[k * ncols + namec], cname, 1)) {
15256 for (k = 0; k < nr; k++) {
15257 m = asize * (roffs + k);
15258 #if defined(_WIN32) || defined(_WIN64)
15259 s->
rows[m + 0] =
xstrdup(d->xcelqrx ?
"main" :
"");
15270 for (k = 0; nr && k < ncols; k++) {
15271 if (strcmp(rowp[k],
"cid") == 0) {
15272 for (mr = 0, m = 1; m <= nrows; m++) {
15277 !
namematch(rowp[m * ncols + namec], cname, 1)) {
15280 ir = asize * (roffs + mr);
15281 sscanf(rowp[m * ncols + k],
"%d", &coln);
15282 sprintf(buf,
"%d", coln + 1);
15286 }
else if (k == namec) {
15287 for (mr = 0, m = 1; m <= nrows; m++) {
15291 !
namematch(rowp[m * ncols + namec], cname, 1)) {
15294 ir = asize * (roffs + mr);
15298 }
else if (strcmp(rowp[k],
"notnull") == 0) {
15299 for (mr = 0, m = 1; m <= nrows; m++) {
15303 !
namematch(rowp[m * ncols + namec], cname, 1)) {
15306 ir = asize * (roffs + mr);
15307 if (*rowp[m * ncols + k] !=
'0') {
15313 xstrdup((*rowp[m * ncols + k] !=
'0') ?
15317 }
else if (strcmp(rowp[k],
"dflt_value") == 0) {
15318 for (mr = 0, m = 1; m <= nrows; m++) {
15319 char *dflt =
unquote(rowp[m * ncols + k]);
15323 !
namematch(rowp[m * ncols + namec], cname, 1)) {
15326 ir = asize * (roffs + mr);
15327 s->
rows[ir + 12] =
xstrdup(dflt ? dflt :
"NULL");
15330 }
else if (strcmp(rowp[k],
"type") == 0) {
15331 for (mr = 0, m = 1; m <= nrows; m++) {
15332 char *
typename = rowp[m * ncols + k];
15333 int sqltype, mm, dd, ir;
15337 !
namematch(rowp[m * ncols + namec], cname, 1)) {
15340 ir = asize * (roffs + mr);
15344 getmd(
typename, sqltype, &mm, &dd);
15345 #ifdef SQL_LONGVARCHAR
15346 if (sqltype == SQL_VARCHAR && mm > 255) {
15347 sqltype = SQL_LONGVARCHAR;
15351 #ifdef SQL_WLONGVARCHAR
15352 if (sqltype == SQL_WVARCHAR && mm > 255) {
15353 sqltype = SQL_WLONGVARCHAR;
15357 if (sqltype == SQL_VARBINARY && mm > 255) {
15358 sqltype = SQL_LONGVARBINARY;
15360 sprintf(buf,
"%d", sqltype);
15363 sprintf(buf,
"%d", mm);
15365 sprintf(buf,
"%d", dd);
15373 sqlite3_free_table(rowp);
15375 sqlite3_free_table(trows);
15376 return SQL_SUCCESS;
15395 SQLColumns(SQLHSTMT
stmt,
15396 SQLCHAR *cat, SQLSMALLINT catLen,
15397 SQLCHAR *schema, SQLSMALLINT schemaLen,
15398 SQLCHAR *table, SQLSMALLINT tableLen,
15399 SQLCHAR *col, SQLSMALLINT colLen)
15401 #if defined(_WIN32) || defined(_WIN64)
15402 char *c = NULL, *s = NULL, *t = NULL, *k = NULL;
15407 #if defined(_WIN32) || defined(_WIN64)
15410 table, tableLen, col, colLen);
15414 c = wmb_to_utf_c((
char *) cat, catLen);
15421 s = wmb_to_utf_c((
char *) schema, schemaLen);
15428 t = wmb_to_utf_c((
char *) table, tableLen);
15435 k = wmb_to_utf_c((
char *) col, colLen);
15441 ret =
drvcolumns(
stmt, (SQLCHAR *) c, SQL_NTS, (SQLCHAR *) s, SQL_NTS,
15442 (SQLCHAR *) t, SQL_NTS, (SQLCHAR *) k, SQL_NTS);
15445 table, tableLen, col, colLen);
15447 #if defined(_WIN32) || defined(_WIN64)
15478 SQLWCHAR *cat, SQLSMALLINT catLen,
15479 SQLWCHAR *schema, SQLSMALLINT schemaLen,
15480 SQLWCHAR *table, SQLSMALLINT tableLen,
15481 SQLWCHAR *col, SQLSMALLINT colLen)
15483 char *c = NULL, *s = NULL, *t = NULL, *k = NULL;
15515 ret =
drvcolumns(
stmt, (SQLCHAR *) c, SQL_NTS, (SQLCHAR *) s, SQL_NTS,
15516 (SQLCHAR *) t, SQL_NTS, (SQLCHAR *) k, SQL_NTS);
15534 {
"SYSTEM",
"TYPE",
"DATA_TYPE", SQL_SMALLINT, 2 },
15535 {
"SYSTEM",
"TYPE",
"PRECISION", SQL_INTEGER, 9 },
15536 {
"SYSTEM",
"TYPE",
"LITERAL_PREFIX",
SCOL_VARCHAR, 50 },
15537 {
"SYSTEM",
"TYPE",
"LITERAL_SUFFIX",
SCOL_VARCHAR, 50 },
15538 {
"SYSTEM",
"TYPE",
"CREATE_PARAMS",
SCOL_VARCHAR, 50 },
15539 {
"SYSTEM",
"TYPE",
"NULLABLE", SQL_SMALLINT, 2 },
15540 {
"SYSTEM",
"TYPE",
"CASE_SENSITIVE", SQL_SMALLINT, 2 },
15541 {
"SYSTEM",
"TYPE",
"SEARCHABLE", SQL_SMALLINT, 2 },
15542 {
"SYSTEM",
"TYPE",
"UNSIGNED_ATTRIBUTE", SQL_SMALLINT, 2 },
15543 {
"SYSTEM",
"TYPE",
"MONEY", SQL_SMALLINT, 2 },
15544 {
"SYSTEM",
"TYPE",
"AUTO_INCREMENT", SQL_SMALLINT, 2 },
15545 {
"SYSTEM",
"TYPE",
"LOCAL_TYPE_NAME",
SCOL_VARCHAR, 50 },
15546 {
"SYSTEM",
"TYPE",
"MINIMUM_SCALE", SQL_SMALLINT, 2 },
15547 {
"SYSTEM",
"TYPE",
"MAXIMUM_SCALE", SQL_SMALLINT, 2 }
15552 {
"SYSTEM",
"TYPE",
"DATA_TYPE", SQL_SMALLINT, 2 },
15553 {
"SYSTEM",
"TYPE",
"COLUMN_SIZE", SQL_INTEGER, 9 },
15554 {
"SYSTEM",
"TYPE",
"LITERAL_PREFIX",
SCOL_VARCHAR, 50 },
15555 {
"SYSTEM",
"TYPE",
"LITERAL_SUFFIX",
SCOL_VARCHAR, 50 },
15556 {
"SYSTEM",
"TYPE",
"CREATE_PARAMS",
SCOL_VARCHAR, 50 },
15557 {
"SYSTEM",
"TYPE",
"NULLABLE", SQL_SMALLINT, 2 },
15558 {
"SYSTEM",
"TYPE",
"CASE_SENSITIVE", SQL_SMALLINT, 2 },
15559 {
"SYSTEM",
"TYPE",
"SEARCHABLE", SQL_SMALLINT, 2 },
15560 {
"SYSTEM",
"TYPE",
"UNSIGNED_ATTRIBUTE", SQL_SMALLINT, 2 },
15561 {
"SYSTEM",
"TYPE",
"FIXED_PREC_SCALE", SQL_SMALLINT, 2 },
15562 {
"SYSTEM",
"TYPE",
"AUTO_UNIQUE_VALUE", SQL_SMALLINT, 2 },
15563 {
"SYSTEM",
"TYPE",
"LOCAL_TYPE_NAME",
SCOL_VARCHAR, 50 },
15564 {
"SYSTEM",
"TYPE",
"MINIMUM_SCALE", SQL_SMALLINT, 2 },
15565 {
"SYSTEM",
"TYPE",
"MAXIMUM_SCALE", SQL_SMALLINT, 2 },
15566 {
"SYSTEM",
"TYPE",
"SQL_DATA_TYPE", SQL_SMALLINT, 2 },
15567 {
"SYSTEM",
"TYPE",
"SQL_DATETIME_SUB", SQL_SMALLINT, 2 },
15568 {
"SYSTEM",
"TYPE",
"NUM_PREC_RADIX", SQL_INTEGER, 4 },
15569 {
"SYSTEM",
"TYPE",
"INTERVAL_PRECISION", SQL_SMALLINT, 2 }
15585 int offs = row * asize;
15586 char *tcode, *crpar = NULL, *sign =
stringify(SQL_FALSE);
15587 char *quote[2] = { NULL, NULL };
15588 static char tcodes[32 * 32];
15593 tcode = tcodes + tind * 32;
15594 sprintf(tcode,
"%d", type);
15595 s->
rows[offs + 0] =
typename;
15596 s->
rows[offs + 1] = tcode;
15598 s->
rows[offs + 15] = tcode;
15599 s->
rows[offs + 16] =
"0";
15603 #ifdef SQL_LONGVARCHAR
15604 case SQL_LONGVARCHAR:
15606 case SQL_WLONGVARCHAR:
15609 quote[0] = quote[1] =
"'";
15611 s->
rows[offs + 2] =
"65536";
15617 s->
rows[offs + 2] =
"1";
15626 s->
rows[offs + 2] =
"255";
15628 quote[0] = quote[1] =
"'";
15632 s->
rows[offs + 2] =
"3";
15635 s->
rows[offs + 2] =
"5";
15638 s->
rows[offs + 2] =
"9";
15642 s->
rows[offs + 2] =
"19";
15646 s->
rows[offs + 2] =
"7";
15649 s->
rows[offs + 2] =
"15";
15651 #ifdef SQL_TYPE_DATE
15652 case SQL_TYPE_DATE:
15655 s->
rows[offs + 2] =
"10";
15656 quote[0] = quote[1] =
"'";
15659 #ifdef SQL_TYPE_TIME
15660 case SQL_TYPE_TIME:
15663 s->
rows[offs + 2] =
"8";
15664 quote[0] = quote[1] =
"'";
15667 #ifdef SQL_TYPE_TIMESTAMP
15668 case SQL_TYPE_TIMESTAMP:
15670 case SQL_TIMESTAMP:
15671 s->
rows[offs + 2] =
"32";
15672 quote[0] = quote[1] =
"'";
15675 case SQL_VARBINARY:
15678 s->
rows[offs + 2] =
"255";
15680 case SQL_LONGVARBINARY:
15683 s->
rows[offs + 2] =
"65536";
15686 s->
rows[offs + 3] = quote[0];
15687 s->
rows[offs + 4] = quote[1];
15688 s->
rows[offs + 5] = crpar;
15692 s->
rows[offs + 9] = sign;
15695 s->
rows[offs + 12] =
typename;
15699 s->
rows[offs + 13] =
"0";
15700 s->
rows[offs + 14] =
"0";
15702 #ifdef SQL_TYPE_TIMESTAMP
15703 case SQL_TYPE_TIMESTAMP:
15705 case SQL_TIMESTAMP:
15706 s->
rows[offs + 13] =
"0";
15707 s->
rows[offs + 14] =
"3";
15710 s->
rows[offs + 13] = NULL;
15711 s->
rows[offs + 14] = NULL;
15727 char **pa = (
char **) a;
15728 char **pb = (
char **) b;
15731 na = strtol(pa[1], NULL, 0);
15732 nb = strtol(pb[1], NULL, 0);
15752 if (ret != SQL_SUCCESS) {
15756 #ifdef SQL_LONGVARCHAR
15757 s->
nrows = (sqltype == SQL_ALL_TYPES) ? 13 : 1;
15759 s->
nrows = (sqltype == SQL_ALL_TYPES) ? 12 : 1;
15761 if (sqltype == SQL_ALL_TYPES) {
15764 #ifdef SQL_WLONGVARCHAR
15769 if (sqltype == SQL_ALL_TYPES) {
15783 #ifdef MEMORY_DEBUG
15788 memset(s->
rows, 0, sizeof (
char *) * (s->
nrows + 1) * asize);
15789 if (sqltype == SQL_ALL_TYPES) {
15792 mktypeinfo(s, cc++, asize,
"varchar", SQL_VARCHAR, 0);
15793 mktypeinfo(s, cc++, asize,
"tinyint", SQL_TINYINT, 0);
15794 mktypeinfo(s, cc++, asize,
"smallint", SQL_SMALLINT, 0);
15795 mktypeinfo(s, cc++, asize,
"integer", SQL_INTEGER, 0);
15796 mktypeinfo(s, cc++, asize,
"float", SQL_FLOAT, 0);
15797 mktypeinfo(s, cc++, asize,
"double", SQL_DOUBLE, 0);
15798 #ifdef SQL_TYPE_DATE
15800 (*s->
ov3) ? SQL_TYPE_DATE : SQL_DATE, 0);
15802 mktypeinfo(s, cc++, asize,
"date", SQL_DATE, 0);
15804 #ifdef SQL_TYPE_TIME
15806 (*s->
ov3) ? SQL_TYPE_TIME : SQL_TIME, 0);
15808 mktypeinfo(s, cc++, asize,
"time", SQL_TIME, 0);
15810 #ifdef SQL_TYPE_TIMESTAMP
15812 (*s->
ov3) ? SQL_TYPE_TIMESTAMP : SQL_TIMESTAMP, 0);
15814 mktypeinfo(s, cc++, asize,
"timestamp", SQL_TIMESTAMP, 0);
15816 mktypeinfo(s, cc++, asize,
"char", SQL_CHAR, 0);
15817 mktypeinfo(s, cc++, asize,
"numeric", SQL_DOUBLE, 0);
15818 #ifdef SQL_LONGVARCHAR
15819 mktypeinfo(s, cc++, asize,
"text", SQL_LONGVARCHAR, 0);
15820 mktypeinfo(s, cc++, asize,
"longvarchar", SQL_LONGVARCHAR, 0);
15822 mktypeinfo(s, cc++, asize,
"text", SQL_VARCHAR, 0);
15824 mktypeinfo(s, cc++, asize,
"varbinary", SQL_VARBINARY, 0);
15825 mktypeinfo(s, cc++, asize,
"longvarbinary", SQL_LONGVARBINARY, 0);
15827 mktypeinfo(s, cc++, asize,
"bit", SQL_BIT, 0);
15830 mktypeinfo(s, cc++, asize,
"bigint", SQL_BIGINT, 0);
15833 mktypeinfo(s, cc++, asize,
"wvarchar", SQL_WVARCHAR, 0);
15834 mktypeinfo(s, cc++, asize,
"wchar", SQL_WCHAR, 0);
15835 #ifdef SQL_WLONGVARCHAR
15836 mktypeinfo(s, cc++, asize,
"wtext", SQL_WLONGVARCHAR, 0);
15837 mktypeinfo(s, cc++, asize,
"longwvarchar", SQL_WLONGVARCHAR, 0);
15840 qsort(s->
rows + asize, s->
nrows, sizeof (
char *) * asize,
15845 mktypeinfo(s, 1, asize,
"char", SQL_CHAR, 10);
15848 mktypeinfo(s, 1, asize,
"varchar", SQL_VARCHAR, 1);
15851 mktypeinfo(s, 1, asize,
"tinyint", SQL_TINYINT, 2);
15854 mktypeinfo(s, 1, asize,
"smallint", SQL_SMALLINT, 3);
15857 mktypeinfo(s, 1, asize,
"integer", SQL_INTEGER, 4);
15860 mktypeinfo(s, 1, asize,
"float", SQL_FLOAT, 5);
15863 mktypeinfo(s, 1, asize,
"double", SQL_DOUBLE, 6);
15865 #ifdef SQL_TYPE_DATE
15866 case SQL_TYPE_DATE:
15867 mktypeinfo(s, 1, asize,
"date", SQL_TYPE_DATE, 25);
15871 mktypeinfo(s, 1, asize,
"date", SQL_DATE, 7);
15873 #ifdef SQL_TYPE_TIME
15874 case SQL_TYPE_TIME:
15875 mktypeinfo(s, 1, asize,
"time", SQL_TYPE_TIME, 26);
15879 mktypeinfo(s, 1, asize,
"time", SQL_TIME, 8);
15881 #ifdef SQL_TYPE_TIMESTAMP
15882 case SQL_TYPE_TIMESTAMP:
15883 mktypeinfo(s, 1, asize,
"timestamp", SQL_TYPE_TIMESTAMP, 27);
15886 case SQL_TIMESTAMP:
15887 mktypeinfo(s, 1, asize,
"timestamp", SQL_TIMESTAMP, 9);
15889 #ifdef SQL_LONGVARCHAR
15890 case SQL_LONGVARCHAR:
15891 mktypeinfo(s, 1, asize,
"longvarchar", SQL_LONGVARCHAR, 12);
15894 case SQL_VARBINARY:
15895 mktypeinfo(s, 1, asize,
"varbinary", SQL_VARBINARY, 30);
15897 case SQL_LONGVARBINARY:
15898 mktypeinfo(s, 1, asize,
"longvarbinary", SQL_LONGVARBINARY, 31);
15902 mktypeinfo(s, 1, asize,
"bit", SQL_BIT, 29);
15907 mktypeinfo(s, 1, asize,
"bigint", SQL_BIGINT, 28);
15913 mktypeinfo(s, 1, asize,
"wchar", SQL_WCHAR, 18);
15916 #ifdef SQL_WVARCHAR
15918 mktypeinfo(s, 1, asize,
"wvarchar", SQL_WVARCHAR, 19);
15921 #ifdef SQL_WLONGVARCHAR
15922 case SQL_WLONGVARCHAR:
15923 mktypeinfo(s, 1, asize,
"longwvarchar", SQL_WLONGVARCHAR, 20);
15931 return SQL_SUCCESS;
15943 SQLGetTypeInfo(SQLHSTMT
stmt, SQLSMALLINT sqltype)
15979 {
"SYSTEM",
"STATISTICS",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
15980 {
"SYSTEM",
"STATISTICS",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
15981 {
"SYSTEM",
"STATISTICS",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
15982 {
"SYSTEM",
"STATISTICS",
"NON_UNIQUE", SQL_SMALLINT, 50 },
15983 {
"SYSTEM",
"STATISTICS",
"INDEX_QUALIFIER",
SCOL_VARCHAR, 255 },
15984 {
"SYSTEM",
"STATISTICS",
"INDEX_NAME",
SCOL_VARCHAR, 255 },
15985 {
"SYSTEM",
"STATISTICS",
"TYPE", SQL_SMALLINT, 50 },
15986 {
"SYSTEM",
"STATISTICS",
"SEQ_IN_INDEX", SQL_SMALLINT, 50 },
15987 {
"SYSTEM",
"STATISTICS",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
15988 {
"SYSTEM",
"STATISTICS",
"COLLATION",
SCOL_CHAR, 1 },
15989 {
"SYSTEM",
"STATISTICS",
"CARDINALITY", SQL_INTEGER, 50 },
15990 {
"SYSTEM",
"STATISTICS",
"PAGES", SQL_INTEGER, 50 },
15991 {
"SYSTEM",
"STATISTICS",
"FILTER_CONDITION",
SCOL_VARCHAR, 255 }
15995 {
"SYSTEM",
"STATISTICS",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
15996 {
"SYSTEM",
"STATISTICS",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
15997 {
"SYSTEM",
"STATISTICS",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
15998 {
"SYSTEM",
"STATISTICS",
"NON_UNIQUE", SQL_SMALLINT, 50 },
15999 {
"SYSTEM",
"STATISTICS",
"INDEX_QUALIFIER",
SCOL_VARCHAR, 255 },
16000 {
"SYSTEM",
"STATISTICS",
"INDEX_NAME",
SCOL_VARCHAR, 255 },
16001 {
"SYSTEM",
"STATISTICS",
"TYPE", SQL_SMALLINT, 50 },
16002 {
"SYSTEM",
"STATISTICS",
"ORDINAL_POSITION", SQL_SMALLINT, 50 },
16003 {
"SYSTEM",
"STATISTICS",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
16004 {
"SYSTEM",
"STATISTICS",
"ASC_OR_DESC",
SCOL_CHAR, 1 },
16005 {
"SYSTEM",
"STATISTICS",
"CARDINALITY", SQL_INTEGER, 50 },
16006 {
"SYSTEM",
"STATISTICS",
"PAGES", SQL_INTEGER, 50 },
16007 {
"SYSTEM",
"STATISTICS",
"FILTER_CONDITION",
SCOL_VARCHAR, 255 }
16026 SQLCHAR *schema, SQLSMALLINT schemaLen,
16027 SQLCHAR *table, SQLSMALLINT tableLen,
16028 SQLUSMALLINT itype, SQLUSMALLINT resv)
16033 int i, asize, ret, nrows, ncols, offs, namec, uniquec, addipk = 0;
16035 char **rowp, *errp = NULL, *sql, tname[512];
16039 if (sret != SQL_SUCCESS) {
16044 if (!table || table[0] ==
'\0' || table[0] ==
'%') {
16045 setstat(s, -1,
"need table name", (*s->
ov3) ?
"HY000" :
"S1000");
16048 if (tableLen == SQL_NTS) {
16049 size =
sizeof (tname) - 1;
16051 size =
min(
sizeof (tname) - 1, tableLen);
16053 strncpy(tname, (
char *) table, size);
16054 tname[size] =
'\0';
16057 if (sret != SQL_SUCCESS) {
16063 if (itype == SQL_INDEX_UNIQUE || itype == SQL_INDEX_ALL) {
16065 ret = SQLITE_ERROR;
16066 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", tname);
16069 ret = sqlite3_get_table(d->
sqlite, sql, &rowp,
16070 &nrows, &ncols, NULL);
16073 if (ret == SQLITE_OK) {
16074 int colid, typec, npk = 0, npkint = 0;
16076 namec =
findcol(rowp, ncols,
"name");
16077 uniquec =
findcol(rowp, ncols,
"pk");
16078 typec =
findcol(rowp, ncols,
"type");
16079 colid =
findcol(rowp, ncols,
"cid");
16080 if (namec < 0 || uniquec < 0 || typec < 0 || colid < 0) {
16083 for (i = 1; i <= nrows; i++) {
16084 if (*rowp[i * ncols + uniquec] !=
'0') {
16086 if (strlen(rowp[i * ncols + typec]) == 7 &&
16087 strncasecmp(rowp[i * ncols + typec],
"integer", 7)
16093 if (npkint == 1 && npk == npkint) {
16098 sqlite3_free_table(rowp);
16100 sql = sqlite3_mprintf(
"PRAGMA index_list(%Q)", tname);
16105 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
16107 if (ret != SQLITE_OK) {
16108 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
16109 errp ? errp :
"unknown error", ret);
16111 sqlite3_free(errp);
16117 sqlite3_free(errp);
16121 namec =
findcol(rowp, ncols,
"name");
16122 uniquec =
findcol(rowp, ncols,
"unique");
16123 if (namec < 0 || uniquec < 0) {
16126 for (i = 1; i <= nrows; i++) {
16127 int nnrows, nncols;
16131 isuniq = *rowp[i * ncols + uniquec] !=
'0';
16132 if (isuniq || itype == SQL_INDEX_ALL) {
16133 ret = SQLITE_ERROR;
16134 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
16135 rowp[i * ncols + namec]);
16138 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
16139 &nnrows, &nncols, NULL);
16142 if (ret == SQLITE_OK) {
16144 sqlite3_free_table(rowpp);
16153 sqlite3_free_table(rowp);
16154 return SQL_SUCCESS;
16157 size = (size + 1) * asize;
16163 s->
rows[0] = (
char *) size;
16165 memset(s->
rows, 0, sizeof (
char *) * size);
16170 int nrows2, ncols2;
16172 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", tname);
16175 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
16176 &nrows2, &ncols2, NULL);
16179 if (ret == SQLITE_OK) {
16180 int colid, typec, roffs, namecc, uniquecc;
16182 namecc =
findcol(rowpp, ncols2,
"name");
16183 uniquecc =
findcol(rowpp, ncols2,
"pk");
16184 typec =
findcol(rowpp, ncols2,
"type");
16185 colid =
findcol(rowpp, ncols2,
"cid");
16186 if (namecc < 0 || uniquecc < 0 || typec < 0 || colid < 0) {
16191 for (i = 1; i <= nrows2; i++) {
16192 if (*rowpp[i * ncols2 + uniquecc] !=
'0' &&
16193 strlen(rowpp[i * ncols2 + typec]) == 7 &&
16194 strncasecmp(rowpp[i * ncols2 + typec],
"integer", 7)
16205 #if defined(_WIN32) || defined(_WIN64)
16206 s->
rows[roffs + 0] =
xstrdup(d->xcelqrx ?
"main" :
"");
16214 s->
rows[roffs + 5] =
xstrdup(
"sqlite_autoindex_0");
16217 s->
rows[roffs + 8] =
xstrdup(rowpp[i * ncols2 + namecc]);
16221 sqlite3_free_table(rowpp);
16223 for (i = 1; i <= nrows; i++) {
16224 int nnrows, nncols;
16227 if (*rowp[i * ncols + uniquec] !=
'0' || itype == SQL_INDEX_ALL) {
16230 ret = SQLITE_ERROR;
16231 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
16232 rowp[i * ncols + namec]);
16235 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
16236 &nnrows, &nncols, NULL);
16239 if (ret != SQLITE_OK) {
16242 for (k = 0; nnrows && k < nncols; k++) {
16243 if (strcmp(rowpp[k],
"name") == 0) {
16246 for (m = 1; m <= nnrows; m++) {
16247 int roffs = (offs + addipk + m) * s->
ncols;
16250 isuniq = *rowp[i * ncols + uniquec] !=
'0';
16259 s->
rows[roffs + 5] =
xstrdup(rowp[i * ncols + namec]);
16260 s->
rows[roffs + 6] =
16262 s->
rows[roffs + 8] =
xstrdup(rowpp[m * nncols + k]);
16265 }
else if (strcmp(rowpp[k],
"seqno") == 0) {
16268 for (m = 1; m <= nnrows; m++) {
16269 int roffs = (offs + addipk + m) * s->
ncols;
16273 sscanf(rowpp[m * nncols + k],
"%d", &pos);
16274 sprintf(buf,
"%d", pos + 1);
16280 sqlite3_free_table(rowpp);
16283 sqlite3_free_table(rowp);
16284 return SQL_SUCCESS;
16303 SQLStatistics(SQLHSTMT
stmt, SQLCHAR *cat, SQLSMALLINT catLen,
16304 SQLCHAR *schema, SQLSMALLINT schemaLen,
16305 SQLCHAR *table, SQLSMALLINT tableLen,
16306 SQLUSMALLINT itype, SQLUSMALLINT resv)
16308 #if defined(_WIN32) || defined(_WIN64)
16309 char *c = NULL, *s = NULL, *t = NULL;
16314 #if defined(_WIN32) || defined(_WIN64)
16317 table, tableLen, itype, resv);
16321 c = wmb_to_utf_c((
char *) cat, catLen);
16328 s = wmb_to_utf_c((
char *) schema, schemaLen);
16335 t = wmb_to_utf_c((
char *) table, tableLen);
16342 (SQLCHAR *) t, SQL_NTS, itype, resv);
16345 table, tableLen, itype, resv);
16347 #if defined(_WIN32) || defined(_WIN64)
16377 SQLWCHAR *schema, SQLSMALLINT schemaLen,
16378 SQLWCHAR *table, SQLSMALLINT tableLen,
16379 SQLUSMALLINT itype, SQLUSMALLINT resv)
16381 char *c = NULL, *s = NULL, *t = NULL;
16407 (SQLCHAR *) t, SQL_NTS, itype, resv);
16433 SQLRETURN ret = SQL_ERROR;
16436 if (
stmt == SQL_NULL_HSTMT) {
16437 return SQL_INVALID_HANDLE;
16440 if (col == 0 && s->
bkmrk != SQL_UB_OFF) {
16441 if (s->
bkmrk == SQL_UB_ON && type == SQL_C_BOOKMARK) {
16442 *((SQLINTEGER *) val) = s->
rowp;
16444 *lenp =
sizeof (SQLINTEGER);
16448 }
else if (s->
bkmrk == SQL_UB_VARIABLE && type == SQL_C_VARBOOKMARK) {
16450 char **data, *endp = 0;
16455 *((sqlite_int64 *) val) = strtol(*data, &endp, 0);
16457 *((sqlite_int64 *) val) = strtoll(*data, &endp, 0);
16460 *((sqlite_int64 *) val) = s->
rowp;
16463 *lenp =
sizeof (sqlite_int64);
16469 if (col < 1 || col > s->
ncols) {
16470 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009" :
"S1002");
16474 ret =
getrowdata(s, col, type, val, len, lenp, 1);
16490 int ret, i, withinfo = 0;
16494 int bsize =
sizeof (SQLINTEGER);
16499 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
16507 val = (SQLPOINTER) ((
char *) val + *s->
bind_offs);
16510 char **data, *endp = 0;
16515 *(sqlite_int64 *) val = strtol(*data, &endp, 0);
16517 *(sqlite_int64 *) val = strtoll(*data, &endp, 0);
16520 *(sqlite_int64 *) val = s->
rowp;
16522 bsize =
sizeof (sqlite_int64);
16526 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
16527 val = (SQLINTEGER *)
16533 val = (SQLINTEGER *) ((
char *) val + *s->
bind_offs);
16540 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
16560 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
16563 dp = (SQLPOINTER) ((
char *) b->
valp + b->
max * rsi);
16566 dp = (SQLPOINTER) ((
char *) dp + *s->
bind_offs);
16570 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
16573 lp = b->
lenp + rsi;
16581 if (!SQL_SUCCEEDED(ret)) {
16585 if (ret != SQL_SUCCESS) {
16587 #ifdef SQL_ROW_SUCCESS_WITH_INFO
16593 if (SQL_SUCCEEDED(ret)) {
16594 ret = withinfo ? SQL_SUCCESS_WITH_INFO : SQL_SUCCESS;
16611 int i, withinfo = 0;
16614 if (
stmt == SQL_NULL_HSTMT) {
16615 return SQL_INVALID_HANDLE;
16638 setstat(s, -1,
"no result set available",
"24000");
16643 if (s->
curtype == SQL_CURSOR_FORWARD_ONLY && orient != SQL_FETCH_NEXT) {
16644 setstat(s, -1,
"wrong fetch direction",
"01000");
16651 if (((
DBC *) (s->
dbc))->cur_s3stmt == s && s->
s3stmt) {
16655 ret = (i == 0) ? SQL_NO_DATA : SQL_SUCCESS;
16659 if (ret != SQL_SUCCESS) {
16663 if (s->
nrows < 1) {
16667 if (!SQL_SUCCEEDED(ret)) {
16669 }
else if (ret == SQL_SUCCESS_WITH_INFO) {
16673 }
else if (s->
rows) {
16675 case SQL_FETCH_NEXT:
16676 if (s->
nrows < 1) {
16677 return SQL_NO_DATA;
16684 return SQL_NO_DATA;
16687 case SQL_FETCH_PRIOR:
16690 return SQL_NO_DATA;
16693 if (s->
rowp < -1) {
16695 return SQL_NO_DATA;
16698 case SQL_FETCH_FIRST:
16699 if (s->
nrows < 1) {
16700 return SQL_NO_DATA;
16704 case SQL_FETCH_LAST:
16705 if (s->
nrows < 1) {
16706 return SQL_NO_DATA;
16709 if (--s->
rowp < -1) {
16713 case SQL_FETCH_ABSOLUTE:
16716 return SQL_NO_DATA;
16717 }
else if (offset < 0) {
16718 if (0 - offset <= s->nrows) {
16723 return SQL_NO_DATA;
16724 }
else if (offset > s->
nrows) {
16726 return SQL_NO_DATA;
16728 s->
rowp = offset - 1 - 1;
16730 case SQL_FETCH_RELATIVE:
16735 return SQL_NO_DATA;
16739 if (s->
rowp < -1) {
16741 return SQL_NO_DATA;
16745 case SQL_FETCH_BOOKMARK:
16747 if (offset < 0 || offset >= s->
nrows) {
16748 return SQL_NO_DATA;
16750 s->
rowp = offset - 1;
16756 if (s->
bkmrk == SQL_UB_VARIABLE) {
16758 sqlite_int64 bkmrk, rowid;
16760 bkmrk = *(sqlite_int64 *) s->
bkmrkptr;
16761 for (rowp = 0; rowp < s->
nrows; rowp++) {
16762 char **data, *endp = 0;
16767 rowid = strtol(*data, &endp, 0);
16769 rowid = strtoll(*data, &endp, 0);
16771 if (rowid == bkmrk) {
16776 rowp = *(sqlite_int64 *) s->
bkmrkptr;
16781 if (rowp + offset < 0 || rowp + offset >= s->
nrows) {
16782 return SQL_NO_DATA;
16784 s->
rowp = rowp + offset - 1;
16800 if (!SQL_SUCCEEDED(ret)) {
16802 }
else if (ret == SQL_SUCCESS_WITH_INFO) {
16809 if (SQL_SUCCEEDED(ret)) {
16810 return SQL_NO_DATA;
16814 if (SQL_SUCCEEDED(ret)) {
16815 ret = withinfo ? SQL_SUCCESS_WITH_INFO : SQL_SUCCESS;
16882 SQLINTEGER *bkmrkptr;
16885 if (
stmt == SQL_NULL_HSTMT) {
16886 return SQL_INVALID_HANDLE;
16921 if (
stmt == SQL_NULL_HSTMT) {
16922 return SQL_INVALID_HANDLE;
16929 return SQL_SUCCESS;
16945 if (
stmt == SQL_NULL_HSTMT) {
16946 return SQL_INVALID_HANDLE;
16953 return SQL_SUCCESS;
16972 SQLSMALLINT nameMax, SQLSMALLINT *nameLen,
16973 SQLSMALLINT *type,
SQLULEN *size,
16974 SQLSMALLINT *digits, SQLSMALLINT *nullable)
16980 if (
stmt == SQL_NULL_HSTMT) {
16981 return SQL_INVALID_HANDLE;
16985 setstat(s, -1,
"no columns", (*s->
ov3) ?
"07009" :
"S1002");
16988 if (col < 1 || col > s->
ncols) {
16989 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009" :
"S1002");
16992 c = s->
cols + col - 1;
16993 if (name && nameMax > 0) {
16994 strncpy((
char *) name, c->
column, nameMax);
16995 name[nameMax - 1] =
'\0';
17000 *nameLen = strlen((
char *) name);
17002 *nameLen = strlen(c->
column);
17014 *type = SQL_VARCHAR;
17016 #ifdef SQL_LONGVARCHAR
17017 case SQL_WLONGVARCHAR:
17018 *type = SQL_LONGVARCHAR;
17034 return SQL_SUCCESS;
17053 SQLDescribeCol(SQLHSTMT
stmt, SQLUSMALLINT col, SQLCHAR *name,
17054 SQLSMALLINT nameMax, SQLSMALLINT *nameLen,
17055 SQLSMALLINT *type,
SQLULEN *size,
17056 SQLSMALLINT *digits, SQLSMALLINT *nullable)
17058 #if defined(_WIN32) || defined(_WIN64)
17059 SQLSMALLINT len = 0;
17064 #if defined(_WIN32) || defined(_WIN64)
17067 type, size, digits, nullable);
17071 &len, type, size, digits, nullable);
17072 if (ret == SQL_SUCCESS) {
17077 n = (SQLCHAR *) utf_to_wmb((
char *) name, len);
17079 strncpy((
char *) name, (
char *) n, nameMax);
17081 len =
min(nameMax, strlen((
char *) n));
17099 len = strlen(c->
column);
17110 type, size, digits, nullable);
17134 SQLSMALLINT nameMax, SQLSMALLINT *nameLen,
17135 SQLSMALLINT *type,
SQLULEN *size,
17136 SQLSMALLINT *digits, SQLSMALLINT *nullable)
17139 SQLSMALLINT len = 0;
17143 (SQLSMALLINT) (nameMax *
sizeof (SQLWCHAR)),
17144 &len, type, size, digits, nullable);
17145 if (ret == SQL_SUCCESS) {
17148 SQLWCHAR *n = NULL;
17172 len = strlen(c->
column);
17198 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17204 char *valc = (
char *) val;
17206 if (
stmt == SQL_NULL_HSTMT) {
17207 return SQL_INVALID_HANDLE;
17216 if (
id == SQL_COLUMN_COUNT) {
17220 *valLen =
sizeof (int);
17221 return SQL_SUCCESS;
17223 if (
id == SQL_COLUMN_TYPE && col == 0) {
17225 *val2 = SQL_INTEGER;
17227 *valLen =
sizeof (int);
17228 return SQL_SUCCESS;
17230 #ifdef SQL_DESC_OCTET_LENGTH
17231 if (
id == SQL_DESC_OCTET_LENGTH && col == 0) {
17235 *valLen =
sizeof (int);
17236 return SQL_SUCCESS;
17239 if (col < 1 || col > s->
ncols) {
17240 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009":
"S1002");
17243 c = s->
cols + col - 1;
17246 case SQL_COLUMN_LABEL:
17248 if (valc && valMax > 0) {
17249 strncpy(valc, c->
label, valMax);
17250 valc[valMax - 1] =
'\0';
17252 *valLen = strlen(c->
label);
17256 case SQL_COLUMN_NAME:
17257 case SQL_DESC_NAME:
17258 if (valc && valMax > 0) {
17259 strncpy(valc, c->
column, valMax);
17260 valc[valMax - 1] =
'\0';
17262 *valLen = strlen(c->
column);
17264 if (*valLen >= valMax) {
17265 setstat(s, -1,
"data right truncated",
"01004");
17266 return SQL_SUCCESS_WITH_INFO;
17268 return SQL_SUCCESS;
17269 #ifdef SQL_DESC_BASE_COLUMN_NAME
17270 case SQL_DESC_BASE_COLUMN_NAME:
17271 if (strchr(c->
column,
'(') || strchr(c->
column,
')')) {
17272 if (valc && valMax > 0) {
17276 }
else if (valc && valMax > 0) {
17277 strncpy(valc, c->
column, valMax);
17278 valc[valMax - 1] =
'\0';
17279 *valLen = strlen(c->
column);
17283 case SQL_COLUMN_TYPE:
17284 case SQL_DESC_TYPE:
17287 int type = c->
type;
17295 type = SQL_VARCHAR;
17297 #ifdef SQL_LONGVARCHAR
17298 case SQL_WLONGVARCHAR:
17299 type = SQL_LONGVARCHAR;
17313 *valLen =
sizeof (int);
17314 return SQL_SUCCESS;
17315 case SQL_COLUMN_DISPLAY_SIZE:
17319 *valLen =
sizeof (int);
17320 return SQL_SUCCESS;
17321 case SQL_COLUMN_UNSIGNED:
17323 *val2 = c->
nosign ? SQL_TRUE : SQL_FALSE;
17325 *valLen =
sizeof (int);
17326 return SQL_SUCCESS;
17327 case SQL_COLUMN_SCALE:
17328 case SQL_DESC_SCALE:
17332 *valLen =
sizeof (int);
17333 return SQL_SUCCESS;
17334 case SQL_COLUMN_PRECISION:
17335 case SQL_DESC_PRECISION:
17355 #ifdef SQL_TYPE_TIMESTAMP
17356 case SQL_TYPE_TIMESTAMP:
17358 case SQL_TIMESTAMP:
17366 *valLen =
sizeof (int);
17367 return SQL_SUCCESS;
17368 case SQL_COLUMN_MONEY:
17372 *valLen =
sizeof (int);
17373 return SQL_SUCCESS;
17374 case SQL_COLUMN_AUTO_INCREMENT:
17378 *valLen =
sizeof (int);
17379 return SQL_SUCCESS;
17380 case SQL_COLUMN_LENGTH:
17381 case SQL_DESC_LENGTH:
17385 *valLen =
sizeof (int);
17386 return SQL_SUCCESS;
17387 case SQL_COLUMN_NULLABLE:
17388 case SQL_DESC_NULLABLE:
17392 *valLen =
sizeof (int);
17393 return SQL_SUCCESS;
17394 case SQL_COLUMN_SEARCHABLE:
17396 *val2 = SQL_SEARCHABLE;
17398 *valLen =
sizeof (int);
17399 return SQL_SUCCESS;
17400 case SQL_COLUMN_CASE_SENSITIVE:
17404 *valLen =
sizeof (int);
17405 return SQL_SUCCESS;
17406 case SQL_COLUMN_UPDATABLE:
17410 *valLen =
sizeof (int);
17411 return SQL_SUCCESS;
17412 case SQL_DESC_COUNT:
17416 *valLen =
sizeof (int);
17417 return SQL_SUCCESS;
17418 case SQL_COLUMN_TYPE_NAME: {
17422 if (c->
type == SQL_WCHAR ||
17423 c->
type == SQL_WVARCHAR ||
17424 c->
type == SQL_WLONGVARCHAR) {
17426 if (strcasecmp(tn,
"varchar") == 0) {
17432 if (valc && valMax > 0) {
17433 strncpy(valc, tn, valMax);
17434 valc[valMax - 1] =
'\0';
17435 p = strchr(valc,
'(');
17438 while (p > valc &&
ISSPACE(p[-1])) {
17443 *valLen = strlen(valc);
17445 *valLen = strlen(tn);
17446 p = strchr(tn,
'(');
17449 while (p > tn &&
ISSPACE(p[-1])) {
17457 case SQL_COLUMN_OWNER_NAME:
17458 case SQL_COLUMN_QUALIFIER_NAME: {
17461 if (valc && valMax > 0) {
17462 strncpy(valc, z, valMax);
17463 valc[valMax - 1] =
'\0';
17465 *valLen = strlen(z);
17468 case SQL_COLUMN_TABLE_NAME:
17469 #if (SQL_COLUMN_TABLE_NAME != SQL_DESC_TABLE_NAME)
17470 case SQL_DESC_TABLE_NAME:
17472 #ifdef SQL_DESC_BASE_TABLE_NAME
17473 case SQL_DESC_BASE_TABLE_NAME:
17475 if (valc && valMax > 0) {
17476 strncpy(valc, c->
table, valMax);
17477 valc[valMax - 1] =
'\0';
17479 *valLen = strlen(c->
table);
17481 #ifdef SQL_DESC_NUM_PREC_RADIX
17482 case SQL_DESC_NUM_PREC_RADIX:
17488 #ifdef SQL_LONGVARCHAR
17489 case SQL_WLONGVARCHAR:
17494 #ifdef SQL_LONGVARCHAR
17495 case SQL_LONGVARCHAR:
17498 case SQL_VARBINARY:
17499 case SQL_LONGVARBINARY:
17506 *valLen =
sizeof (int);
17507 return SQL_SUCCESS;
17510 setstat(s, -1,
"unsupported column attributes %d",
"HY091",
id);
17528 SQLColAttributes(SQLHSTMT
stmt, SQLUSMALLINT col, SQLUSMALLINT
id,
17529 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17532 #if defined(_WIN32) || defined(_WIN64)
17533 SQLSMALLINT len = 0;
17538 #if defined(_WIN32) || defined(_WIN64)
17544 if (SQL_SUCCEEDED(ret)) {
17548 case SQL_COLUMN_LABEL:
17549 case SQL_COLUMN_NAME:
17550 case SQL_DESC_NAME:
17551 case SQL_COLUMN_TYPE_NAME:
17552 case SQL_COLUMN_OWNER_NAME:
17553 case SQL_COLUMN_QUALIFIER_NAME:
17554 case SQL_COLUMN_TABLE_NAME:
17555 #if (SQL_COLUMN_TABLE_NAME != SQL_DESC_TABLE_NAME)
17556 case SQL_DESC_TABLE_NAME:
17558 #ifdef SQL_DESC_BASE_COLUMN_NAME
17559 case SQL_DESC_BASE_COLUMN_NAME:
17561 #ifdef SQL_DESC_BASE_TABLE_NAME
17562 case SQL_DESC_BASE_TABLE_NAME:
17564 if (val && valMax > 0) {
17567 v = utf_to_wmb((
char *) val, SQL_NTS);
17569 strncpy(val, v, vmax);
17570 len =
min(vmax, strlen(v));
17575 v[vmax - 1] =
'\0';
17611 SQLColAttributesW(SQLHSTMT
stmt, SQLUSMALLINT col, SQLUSMALLINT
id,
17612 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17616 SQLSMALLINT len = 0;
17620 if (SQL_SUCCEEDED(ret)) {
17621 SQLWCHAR *v = NULL;
17624 case SQL_COLUMN_LABEL:
17625 case SQL_COLUMN_NAME:
17626 case SQL_DESC_NAME:
17627 case SQL_COLUMN_TYPE_NAME:
17628 case SQL_COLUMN_OWNER_NAME:
17629 case SQL_COLUMN_QUALIFIER_NAME:
17630 case SQL_COLUMN_TABLE_NAME:
17631 #if (SQL_COLUMN_TABLE_NAME != SQL_DESC_TABLE_NAME)
17632 case SQL_DESC_TABLE_NAME:
17634 #ifdef SQL_DESC_BASE_COLUMN_NAME
17635 case SQL_DESC_BASE_COLUMN_NAME:
17637 #ifdef SQL_DESC_BASE_TABLE_NAME
17638 case SQL_DESC_BASE_TABLE_NAME:
17640 if (val && valMax > 0) {
17641 int vmax = valMax /
sizeof (SQLWCHAR);
17648 len *=
sizeof (SQLWCHAR);
17651 v = (SQLWCHAR *) val;
17652 v[vmax - 1] =
'\0';
17682 drvcolattribute(SQLHSTMT
stmt, SQLUSMALLINT col, SQLUSMALLINT
id,
17683 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17689 char *valc = (
char *) val;
17692 if (
stmt == SQL_NULL_HSTMT) {
17693 return SQL_INVALID_HANDLE;
17699 if (col < 1 || col > s->
ncols) {
17700 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009" :
"S1002");
17706 c = s->
cols + col - 1;
17708 case SQL_DESC_COUNT:
17711 case SQL_DESC_CATALOG_NAME:
17712 if (valc && valMax > 0) {
17713 strncpy(valc, c->
db, valMax);
17714 valc[valMax - 1] =
'\0';
17716 *valLen = strlen(c->
db);
17718 if (*valLen >= valMax) {
17719 setstat(s, -1,
"data right truncated",
"01004");
17720 return SQL_SUCCESS_WITH_INFO;
17723 case SQL_COLUMN_LENGTH:
17724 case SQL_DESC_LENGTH:
17727 case SQL_COLUMN_LABEL:
17729 if (valc && valMax > 0) {
17730 strncpy(valc, c->
label, valMax);
17731 valc[valMax - 1] =
'\0';
17733 *valLen = strlen(c->
label);
17737 case SQL_COLUMN_NAME:
17738 case SQL_DESC_NAME:
17739 if (valc && valMax > 0) {
17740 strncpy(valc, c->
column, valMax);
17741 valc[valMax - 1] =
'\0';
17743 *valLen = strlen(c->
column);
17745 case SQL_DESC_SCHEMA_NAME: {
17748 if (valc && valMax > 0) {
17749 strncpy(valc, z, valMax);
17750 valc[valMax - 1] =
'\0';
17752 *valLen = strlen(z);
17755 #ifdef SQL_DESC_BASE_COLUMN_NAME
17756 case SQL_DESC_BASE_COLUMN_NAME:
17757 if (strchr(c->
column,
'(') || strchr(c->
column,
')')) {
17760 }
else if (valc && valMax > 0) {
17761 strncpy(valc, c->
column, valMax);
17762 valc[valMax - 1] =
'\0';
17763 *valLen = strlen(c->
column);
17767 case SQL_DESC_TYPE_NAME: {
17771 if (c->
type == SQL_WCHAR ||
17772 c->
type == SQL_WVARCHAR ||
17773 c->
type == SQL_WLONGVARCHAR) {
17775 if (strcasecmp(tn,
"varchar") == 0) {
17781 if (valc && valMax > 0) {
17782 strncpy(valc, tn, valMax);
17783 valc[valMax - 1] =
'\0';
17784 p = strchr(valc,
'(');
17787 while (p > valc &&
ISSPACE(p[-1])) {
17792 *valLen = strlen(valc);
17794 *valLen = strlen(tn);
17795 p = strchr(tn,
'(');
17798 while (p > tn &&
ISSPACE(p[-1])) {
17806 case SQL_DESC_OCTET_LENGTH:
17809 if (c->
type == SQL_WCHAR ||
17810 c->
type == SQL_WVARCHAR ||
17811 c->
type == SQL_WLONGVARCHAR) {
17813 v *=
sizeof (SQLWCHAR);
17818 #if (SQL_COLUMN_TABLE_NAME != SQL_DESC_TABLE_NAME)
17819 case SQL_COLUMN_TABLE_NAME:
17821 #ifdef SQL_DESC_BASE_TABLE_NAME
17822 case SQL_DESC_BASE_TABLE_NAME:
17824 case SQL_DESC_TABLE_NAME:
17825 if (valc && valMax > 0) {
17826 strncpy(valc, c->
table, valMax);
17827 valc[valMax - 1] =
'\0';
17829 *valLen = strlen(c->
table);
17831 case SQL_DESC_TYPE:
17842 #ifdef SQL_LONGVARCHAR
17843 case SQL_WLONGVARCHAR:
17844 v = SQL_LONGVARCHAR;
17851 case SQL_DESC_CONCISE_TYPE:
17868 case SQL_TIMESTAMP:
17869 v = SQL_C_TIMESTAMP;
17877 #ifdef SQL_C_TYPE_TIMESTAMP
17878 case SQL_TYPE_TIMESTAMP:
17879 v = SQL_C_TYPE_TIMESTAMP;
17882 #ifdef SQL_C_TYPE_TIME
17883 case SQL_TYPE_TIME:
17884 v = SQL_C_TYPE_TIME;
17887 #ifdef SQL_C_TYPE_DATE
17888 case SQL_TYPE_DATE:
17889 v = SQL_C_TYPE_DATE;
17904 v = (s->
nowchar[0] || s->
nowchar[1]) ? SQL_C_CHAR : SQL_C_WCHAR;
17911 case SQL_DESC_UPDATABLE:
17914 case SQL_COLUMN_DISPLAY_SIZE:
17917 case SQL_COLUMN_UNSIGNED:
17918 v = c->
nosign ? SQL_TRUE : SQL_FALSE;
17920 case SQL_COLUMN_SEARCHABLE:
17921 v = SQL_SEARCHABLE;
17923 case SQL_COLUMN_SCALE:
17924 case SQL_DESC_SCALE:
17927 case SQL_COLUMN_PRECISION:
17928 case SQL_DESC_PRECISION:
17947 #ifdef SQL_TYPE_TIMESTAMP
17948 case SQL_TYPE_TIMESTAMP:
17950 case SQL_TIMESTAMP:
17958 case SQL_COLUMN_MONEY:
17961 case SQL_COLUMN_AUTO_INCREMENT:
17964 case SQL_DESC_NULLABLE:
17967 #ifdef SQL_DESC_NUM_PREC_RADIX
17968 case SQL_DESC_NUM_PREC_RADIX:
17973 #ifdef SQL_LONGVARCHAR
17974 case SQL_WLONGVARCHAR:
17979 #ifdef SQL_LONGVARCHAR
17980 case SQL_LONGVARCHAR:
17983 case SQL_VARBINARY:
17984 case SQL_LONGVARBINARY:
17993 setstat(s, -1,
"unsupported column attribute %d",
"HY091",
id);
17999 return SQL_SUCCESS;
18016 SQLColAttribute(SQLHSTMT
stmt, SQLUSMALLINT col, SQLUSMALLINT
id,
18017 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
18020 #if defined(_WIN32) || defined(_WIN64)
18021 SQLSMALLINT len = 0;
18026 #if defined(_WIN32) || defined(_WIN64)
18028 ret = drvcolattribute(
stmt, col,
id, val, valMax, valLen,
18029 (SQLPOINTER) val2);
18032 ret = drvcolattribute(
stmt, col,
id, val, valMax, &len,
18033 (SQLPOINTER) val2);
18034 if (SQL_SUCCEEDED(ret)) {
18038 case SQL_DESC_SCHEMA_NAME:
18039 case SQL_DESC_CATALOG_NAME:
18040 case SQL_COLUMN_LABEL:
18041 case SQL_DESC_NAME:
18042 case SQL_DESC_TABLE_NAME:
18043 #ifdef SQL_DESC_BASE_TABLE_NAME
18044 case SQL_DESC_BASE_TABLE_NAME:
18046 #ifdef SQL_DESC_BASE_COLUMN_NAME
18047 case SQL_DESC_BASE_COLUMN_NAME:
18049 case SQL_DESC_TYPE_NAME:
18050 if (val && valMax > 0) {
18053 v = utf_to_wmb((
char *) val, SQL_NTS);
18055 strncpy(val, v, vmax);
18056 len =
min(vmax, strlen(v));
18061 v[vmax - 1] =
'\0';
18076 ret = drvcolattribute(
stmt, col,
id, val, valMax, valLen,
18077 (SQLPOINTER) val2);
18098 SQLColAttributeW(SQLHSTMT
stmt, SQLUSMALLINT col, SQLUSMALLINT
id,
18099 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
18103 SQLSMALLINT len = 0;
18106 ret = drvcolattribute(
stmt, col,
id, val, valMax, &len,
18107 (SQLPOINTER) val2);
18108 if (SQL_SUCCEEDED(ret)) {
18109 SQLWCHAR *v = NULL;
18112 case SQL_DESC_SCHEMA_NAME:
18113 case SQL_DESC_CATALOG_NAME:
18114 case SQL_COLUMN_LABEL:
18115 case SQL_DESC_NAME:
18116 case SQL_DESC_TABLE_NAME:
18117 #ifdef SQL_DESC_BASE_TABLE_NAME
18118 case SQL_DESC_BASE_TABLE_NAME:
18120 #ifdef SQL_DESC_BASE_COLUMN_NAME
18121 case SQL_DESC_BASE_COLUMN_NAME:
18123 case SQL_DESC_TYPE_NAME:
18124 if (val && valMax > 0) {
18125 int vmax = valMax /
sizeof (SQLWCHAR);
18132 len *=
sizeof (SQLWCHAR);
18135 v = (SQLWCHAR *) val;
18136 v[vmax - 1] =
'\0';
18167 drverror(SQLHENV env, SQLHDBC
dbc, SQLHSTMT
stmt,
18168 SQLCHAR *sqlState, SQLINTEGER *nativeErr,
18169 SQLCHAR *errmsg, SQLSMALLINT errmax, SQLSMALLINT *errlen)
18173 SQLSMALLINT dummy2;
18175 if (env == SQL_NULL_HENV &&
18176 dbc == SQL_NULL_HDBC &&
18177 stmt == SQL_NULL_HSTMT) {
18178 return SQL_INVALID_HANDLE;
18181 sqlState[0] =
'\0';
18186 nativeErr = &dummy1;
18205 if (s->
logmsg[0] ==
'\0') {
18210 strcpy((
char *) sqlState, s->
sqlstate);
18211 if (errmax == SQL_NTS) {
18212 strcpy((
char *) errmsg,
"[SQLite]");
18213 strcat((
char *) errmsg, (
char *) s->
logmsg);
18214 *errlen = strlen((
char *) errmsg);
18216 strncpy((
char *) errmsg,
"[SQLite]", errmax);
18217 if (errmax - 8 > 0) {
18218 strncpy((
char *) errmsg + 8, (
char *) s->
logmsg, errmax - 8);
18220 *errlen =
min(strlen((
char *) s->
logmsg) + 8, errmax);
18224 return SQL_SUCCESS;
18235 strcpy((
char *) sqlState, d->
sqlstate);
18236 if (errmax == SQL_NTS) {
18237 strcpy((
char *) errmsg,
"[SQLite]");
18238 strcat((
char *) errmsg, (
char *) d->
logmsg);
18239 *errlen = strlen((
char *) errmsg);
18241 strncpy((
char *) errmsg,
"[SQLite]", errmax);
18242 if (errmax - 8 > 0) {
18243 strncpy((
char *) errmsg + 8, (
char *) d->
logmsg, errmax - 8);
18245 *errlen =
min(strlen((
char *) d->
logmsg) + 8, errmax);
18249 return SQL_SUCCESS;
18252 sqlState[0] =
'\0';
18256 return SQL_NO_DATA;
18274 SQLError(SQLHENV env, SQLHDBC
dbc, SQLHSTMT
stmt,
18275 SQLCHAR *sqlState, SQLINTEGER *nativeErr,
18276 SQLCHAR *errmsg, SQLSMALLINT errmax, SQLSMALLINT *errlen)
18278 return drverror(env,
dbc,
stmt, sqlState, nativeErr,
18279 errmsg, errmax, errlen);
18298 SQLErrorW(SQLHENV env, SQLHDBC
dbc, SQLHSTMT
stmt,
18299 SQLWCHAR *sqlState, SQLINTEGER *nativeErr,
18300 SQLWCHAR *errmsg, SQLSMALLINT errmax, SQLSMALLINT *errlen)
18303 SQLSMALLINT len = 0;
18306 ret = drverror(env,
dbc,
stmt, (SQLCHAR *) state, nativeErr,
18307 (SQLCHAR *) errmsg, errmax, &len);
18308 if (ret == SQL_SUCCESS) {
18311 6 *
sizeof (SQLWCHAR));
18315 SQLWCHAR *e = NULL;
18343 }
else if (ret == SQL_NO_DATA) {
18367 SQLMoreResults(SQLHSTMT
stmt)
18370 if (
stmt == SQL_NULL_HSTMT) {
18371 return SQL_INVALID_HANDLE;
18374 return SQL_NO_DATA;
18388 int ncols = *ncolsp, guessed_types = 0;
18389 SQLRETURN ret = SQL_SUCCESS;
18397 const char *colname, *
typename;
18398 #
if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME)
18401 #if defined(HAVE_SQLITE3COLUMNDATABASENAME) && (HAVE_SQLITE3COLUMNDATABASENAME)
18405 for (i = size = 0; i < ncols; i++) {
18406 colname = sqlite3_column_name(s3stmt, i);
18407 size += 3 + 3 * strlen(colname);
18409 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME)
18410 tblname = (
char *) size;
18411 for (i = 0; i < ncols; i++) {
18412 p = (
char *) sqlite3_column_table_name(s3stmt, i);
18413 size += 2 + (p ? strlen(p) : 0);
18416 #if defined(HAVE_SQLITE3COLUMNDATABASENAME) && (HAVE_SQLITE3COLUMNDATABASENAME)
18417 dbname = (
char *) size;
18418 for (i = 0; i < ncols; i++) {
18419 p = (
char *) sqlite3_column_database_name(s3stmt, i);
18420 size += 2 + (p ? strlen(p) : 0);
18423 dyncols =
xmalloc(ncols *
sizeof (
COL) + size);
18429 p = (
char *) (dyncols + ncols);
18430 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME)
18433 #if defined(HAVE_SQLITE3COLUMNDATABASENAME) && (HAVE_SQLITE3COLUMNDATABASENAME)
18436 for (i = 0; i < ncols; i++) {
18439 colname = sqlite3_column_name(s3stmt, i);
18441 fprintf(d->
trace,
"-- column %d name: '%s'\n",
18445 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME)
18446 q = (
char *) sqlite3_column_table_name(s3stmt, i);
18447 strcpy(tblname, q ? q :
"");
18449 fprintf(d->
trace,
"-- table %d name: '%s'\n",
18453 dyncols[i].
table = tblname;
18454 tblname += strlen(tblname) + 1;
18456 #if defined(HAVE_SQLITE3COLUMNDATABASENAME) && (HAVE_SQLITE3COLUMNDATABASENAME)
18457 q = (
char *) sqlite3_column_database_name(s3stmt, i);
18458 strcpy(dbname, q ? q :
"");
18460 fprintf(d->
trace,
"-- database %d name: '%s'\n",
18464 dyncols[i].
db = dbname;
18465 dbname += strlen(dbname) + 1;
18467 dyncols[i].
db = ((
DBC *) (s->
dbc))->dbname;
18470 strcpy(p, colname);
18471 dyncols[i].
label = p;
18472 p += strlen(p) + 1;
18473 q = strchr(colname,
'.');
18475 char *q2 = strchr(q + 1,
'.');
18483 #if !defined(HAVE_SQLITE3COLUMNTABLENAME) || !(HAVE_SQLITE3COLUMNTABLENAME)
18484 dyncols[i].
table = p;
18486 strncpy(p, colname, q - colname);
18487 p[q - colname] =
'\0';
18488 p += strlen(p) + 1;
18491 p += strlen(p) + 1;
18493 #if !defined(HAVE_SQLITE3COLUMNTABLENAME) || !(HAVE_SQLITE3COLUMNTABLENAME)
18494 dyncols[i].
table =
"";
18496 strcpy(p, colname);
18498 p += strlen(p) + 1;
18503 #ifdef SQL_LONGVARCHAR
18504 dyncols[i].
type = SQL_LONGVARCHAR;
18505 dyncols[i].
size = 65535;
18507 dyncols[i].
type = SQL_VARCHAR;
18508 dyncols[i].
size = 255;
18510 dyncols[i].
index = i;
18511 dyncols[i].
scale = 0;
18512 dyncols[i].
prec = 0;
18514 dyncols[i].
autoinc = SQL_FALSE;
18515 dyncols[i].
notnull = SQL_NULLABLE;
18516 dyncols[i].
ispk = -1;
18518 #ifdef FULL_METADATA
18519 s3stmt_addmeta(s3stmt, i, d, &dyncols[i]);
18542 drvprepare(SQLHSTMT
stmt, SQLCHAR *query, SQLINTEGER queryLen)
18549 if (
stmt == SQL_NULL_HSTMT) {
18550 return SQL_INVALID_HANDLE;
18553 if (s->
dbc == SQL_NULL_HDBC) {
18564 if (sret != SQL_SUCCESS) {
18573 setstat(s, -1,
"%s", (*s->
ov3) ?
"HY000" :
"S1000", errp);
18581 int ret, ncols, nretry = 0;
18583 sqlite3_stmt *s3stmt = NULL;
18585 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
18592 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
18593 ret = sqlite3_prepare_v2(d->
sqlite, (
char *) s->
query, -1,
18596 ret = sqlite3_prepare(d->
sqlite, (
char *) s->
query, -1,
18599 if (ret != SQLITE_OK) {
18601 sqlite3_finalize(s3stmt);
18605 }
while (ret == SQLITE_SCHEMA && (++nretry) < 2);
18607 if (ret != SQLITE_OK) {
18610 sqlite3_finalize(s3stmt);
18612 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
18613 sqlite3_errmsg(d->
sqlite), ret);
18616 if (sqlite3_bind_parameter_count(s3stmt) != s->
nparams) {
18618 sqlite3_finalize(s3stmt);
18619 setstat(s, SQLITE_ERROR,
"parameter marker count incorrect",
18620 (*s->
ov3) ?
"HY000" :
"S1000");
18623 ncols = sqlite3_column_count(s3stmt);
18631 return SQL_SUCCESS;
18647 int rc, i, ncols = 0, nrows = 0, busy_count;
18650 if (
stmt == SQL_NULL_HSTMT) {
18651 return SQL_INVALID_HANDLE;
18654 if (s->
dbc == SQL_NULL_HDBC) {
18663 setstat(s, -1,
"no query prepared", (*s->
ov3) ?
"HY000" :
"S1000");
18668 setstat(s, -1,
"unbound parameters in query",
18669 (*s->
ov3) ?
"HY000" :
"S1000");
18672 for (i = 0; i < s->
nparams; i++) {
18681 if (lenp && *lenp < 0 && *lenp > SQL_LEN_DATA_AT_EXEC_OFFSET &&
18682 *lenp != SQL_NTS && *lenp != SQL_NULL_DATA &&
18683 *lenp != SQL_DATA_AT_EXEC) {
18684 setstat(s, -1,
"invalid length reference",
"HY009");
18687 if (lenp && (*lenp <= SQL_LEN_DATA_AT_EXEC_OFFSET ||
18688 *lenp == SQL_DATA_AT_EXEC)) {
18696 if (ret != SQL_SUCCESS) {
18705 for (i = 0; i < s->
nparams; i++) {
18712 if (p->
need <= 0 &&
18713 p->
lenp && (*p->
lenp <= SQL_LEN_DATA_AT_EXEC_OFFSET ||
18714 *p->
lenp == SQL_DATA_AT_EXEC)) {
18722 for (i = 0; i < s->
nparams; i++) {
18724 if (ret != SQL_SUCCESS) {
18731 s->
curtype == SQL_CURSOR_FORWARD_ONLY &&
18735 if (ret == SQL_SUCCESS) {
18742 if (rc == SQLITE_BUSY) {
18745 sqlite3_free(errp);
18748 for (i = 0; i < s->
nparams; i++) {
18755 if (!p->
lenp || (*p->
lenp > SQL_LEN_DATA_AT_EXEC_OFFSET &&
18756 *p->
lenp != SQL_DATA_AT_EXEC)) {
18765 if (rc != SQLITE_OK) {
18766 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
18767 errp ? errp :
"unknown error", rc);
18769 sqlite3_free(errp);
18776 sqlite3_free(errp);
18785 nrows += sqlite3_changes(d->sqlite);
18789 if (s->
ncols != ncols) {
18793 setstat(s, -1,
"broken result set %d/%d",
18794 (*s->
ov3) ?
"HY000" :
"S1000", s->
ncols, ncols);
18806 for (i = 0; i < s->
nparams; i++) {
18817 }
else if (p->
lenp0 && p->
inc > 0) {
18820 if (!p->
lenp || (*p->
lenp > SQL_LEN_DATA_AT_EXEC_OFFSET &&
18821 *p->
lenp != SQL_DATA_AT_EXEC)) {
18830 }
else if (p->
lenp && (*p->
lenp <= SQL_LEN_DATA_AT_EXEC_OFFSET ||
18831 *p->
lenp == SQL_DATA_AT_EXEC)) {
18840 if (ret != SQL_NEED_DATA) {
18841 for (i = 0; i < s->
nparams; i++) {
18848 if (!p->
lenp || (*p->
lenp > SQL_LEN_DATA_AT_EXEC_OFFSET &&
18849 *p->
lenp != SQL_DATA_AT_EXEC)) {
18866 ret == SQL_SUCCESS && nrows == 0) {
18882 SQLPrepare(SQLHSTMT
stmt, SQLCHAR *query, SQLINTEGER queryLen)
18885 #if defined(_WIN32) || defined(_WIN64)
18890 #if defined(_WIN32) || defined(_WIN64)
18892 ret = drvprepare(
stmt, query, queryLen);
18895 q = wmb_to_utf_c((
char *) query, queryLen);
18900 query = (SQLCHAR *) q;
18901 queryLen = SQL_NTS;
18903 ret = drvprepare(
stmt, query, queryLen);
18904 #if defined(_WIN32) || defined(_WIN64)
18924 SQLPrepareW(SQLHSTMT
stmt, SQLWCHAR *query, SQLINTEGER queryLen)
18934 ret = drvprepare(
stmt, (SQLCHAR *) q, SQL_NTS);
18949 SQLExecute(SQLHSTMT
stmt)
18969 SQLExecDirect(SQLHSTMT
stmt, SQLCHAR *query, SQLINTEGER queryLen)
18972 #if defined(_WIN32) || defined(_WIN64)
18977 #if defined(_WIN32) || defined(_WIN64)
18979 ret = drvprepare(
stmt, query, queryLen);
18980 if (ret == SQL_SUCCESS) {
18985 q = wmb_to_utf_c((
char *) query, queryLen);
18990 query = (SQLCHAR *) q;
18991 queryLen = SQL_NTS;
18993 ret = drvprepare(
stmt, query, queryLen);
18994 if (ret == SQL_SUCCESS) {
18997 #if defined(_WIN32) || defined(_WIN64)
19017 SQLExecDirectW(SQLHSTMT
stmt, SQLWCHAR *query, SQLINTEGER queryLen)
19027 ret = drvprepare(
stmt, (SQLCHAR *) q, SQL_NTS);
19029 if (ret == SQL_SUCCESS) {
19039 #if defined(_WIN32) || defined(_WIN64)
19040 #ifndef WITHOUT_DRIVERMGR
19046 #include <windowsx.h>
19047 #include <winuser.h>
19049 #define MAXPATHLEN (259+1)
19050 #define MAXKEYLEN (15+1)
19051 #define MAXDESC (255+1)
19052 #define MAXDSNAME (255+1)
19053 #define MAXTONAME (32+1)
19054 #define MAXDBNAME MAXPATHLEN
19060 #define KEY_DBNAME 2
19062 #define KEY_DRIVER 4
19063 #define KEY_STEPAPI 5
19064 #define KEY_SYNCP 6
19065 #define KEY_NOTXN 7
19066 #define KEY_SHORTNAM 8
19067 #define KEY_LONGNAM 9
19068 #define KEY_NOCREAT 10
19069 #define KEY_NOWCHAR 11
19070 #define KEY_LOADEXT 12
19071 #define KEY_JMODE 13
19072 #define KEY_FKSUPPORT 14
19073 #define KEY_OEMCP 15
19074 #define KEY_BIGINT 16
19075 #define KEY_PASSWD 17
19076 #define KEY_JDCONV 18
19077 #define NUMOFKEYS 19
19081 char attr[MAXPATHLEN*4];
19087 ATTR attr[NUMOFKEYS];
19088 char DSN[MAXDSNAME];
19097 {
"DSN", KEY_DSN },
19098 {
"DESC", KEY_DESC },
19099 {
"Description", KEY_DESC},
19100 {
"Database", KEY_DBNAME },
19101 {
"Timeout", KEY_BUSY },
19102 {
"Driver", KEY_DRIVER },
19103 {
"StepAPI", KEY_STEPAPI },
19104 {
"SyncPragma", KEY_SYNCP },
19105 {
"NoTXN", KEY_NOTXN },
19106 {
"ShortNames", KEY_SHORTNAM },
19107 {
"LongNames", KEY_LONGNAM },
19108 {
"NoCreat", KEY_NOCREAT },
19109 {
"NoWCHAR", KEY_NOWCHAR },
19110 {
"LoadExt", KEY_LOADEXT },
19111 {
"JournalMode", KEY_JMODE },
19112 {
"FKSupport", KEY_FKSUPPORT },
19113 {
"OEMCP", KEY_OEMCP },
19114 {
"BigInt", KEY_BIGINT },
19115 {
"PWD", KEY_PASSWD },
19116 {
"JDConv", KEY_JDCONV },
19127 ParseAttributes(LPCSTR attribs, SETUPDLG *setupdlg)
19129 char *str = (
char *) attribs, *start, key[MAXKEYLEN];
19134 if ((str = strchr(str,
'=')) == NULL) {
19138 nkey = str - start;
19139 if (nkey <
sizeof (key)) {
19142 memcpy(key, start, nkey);
19144 for (i = 0; attrLookup[i].key; i++) {
19145 if (strcasecmp(attrLookup[i].key, key) == 0) {
19146 elem = attrLookup[i].ikey;
19152 while (*str && *str !=
';') {
19156 int end =
min(str - start,
sizeof (setupdlg->attr[elem].attr) - 1);
19158 setupdlg->attr[elem].supplied = TRUE;
19159 memcpy(setupdlg->attr[elem].attr, start, end);
19160 setupdlg->attr[elem].attr[end] =
'\0';
19174 SetDSNAttributes(HWND parent, SETUPDLG *setupdlg)
19176 char *dsn = setupdlg->attr[KEY_DSN].attr;
19178 if (setupdlg->newDSN && strlen(dsn) == 0) {
19181 if (!SQLWriteDSNToIni(dsn, setupdlg->driver)) {
19183 char buf[MAXPATHLEN], msg[MAXPATHLEN];
19185 LoadString(hModule, IDS_BADDSN, buf,
sizeof (buf));
19186 wsprintf(msg, buf, dsn);
19187 LoadString(hModule, IDS_MSGTITLE, buf,
sizeof (buf));
19188 MessageBox(parent, msg, buf,
19189 MB_ICONEXCLAMATION | MB_OK | MB_TASKMODAL |
19194 if (parent || setupdlg->attr[KEY_DESC].supplied) {
19195 SQLWritePrivateProfileString(dsn,
"Description",
19196 setupdlg->attr[KEY_DESC].attr,
19199 if (parent || setupdlg->attr[KEY_DBNAME].supplied) {
19200 SQLWritePrivateProfileString(dsn,
"Database",
19201 setupdlg->attr[KEY_DBNAME].attr,
19204 if (parent || setupdlg->attr[KEY_BUSY].supplied) {
19205 SQLWritePrivateProfileString(dsn,
"Timeout",
19206 setupdlg->attr[KEY_BUSY].attr,
19209 if (parent || setupdlg->attr[KEY_STEPAPI].supplied) {
19210 SQLWritePrivateProfileString(dsn,
"StepAPI",
19211 setupdlg->attr[KEY_STEPAPI].attr,
19214 if (parent || setupdlg->attr[KEY_SYNCP].supplied) {
19215 SQLWritePrivateProfileString(dsn,
"SyncPragma",
19216 setupdlg->attr[KEY_SYNCP].attr,
19219 if (parent || setupdlg->attr[KEY_NOTXN].supplied) {
19220 SQLWritePrivateProfileString(dsn,
"NoTXN",
19221 setupdlg->attr[KEY_NOTXN].attr,
19224 if (parent || setupdlg->attr[KEY_SHORTNAM].supplied) {
19225 SQLWritePrivateProfileString(dsn,
"ShortNames",
19226 setupdlg->attr[KEY_SHORTNAM].attr,
19229 if (parent || setupdlg->attr[KEY_LONGNAM].supplied) {
19230 SQLWritePrivateProfileString(dsn,
"LongNames",
19231 setupdlg->attr[KEY_LONGNAM].attr,
19234 if (parent || setupdlg->attr[KEY_NOCREAT].supplied) {
19235 SQLWritePrivateProfileString(dsn,
"NoCreat",
19236 setupdlg->attr[KEY_NOCREAT].attr,
19239 if (parent || setupdlg->attr[KEY_NOWCHAR].supplied) {
19240 SQLWritePrivateProfileString(dsn,
"NoWCHAR",
19241 setupdlg->attr[KEY_NOWCHAR].attr,
19244 if (parent || setupdlg->attr[KEY_FKSUPPORT].supplied) {
19245 SQLWritePrivateProfileString(dsn,
"FKSupport",
19246 setupdlg->attr[KEY_FKSUPPORT].attr,
19249 if (parent || setupdlg->attr[KEY_OEMCP].supplied) {
19250 SQLWritePrivateProfileString(dsn,
"OEMCP",
19251 setupdlg->attr[KEY_OEMCP].attr,
19254 if (parent || setupdlg->attr[KEY_LOADEXT].supplied) {
19255 SQLWritePrivateProfileString(dsn,
"LoadExt",
19256 setupdlg->attr[KEY_LOADEXT].attr,
19259 if (parent || setupdlg->attr[KEY_BIGINT].supplied) {
19260 SQLWritePrivateProfileString(dsn,
"BigInt",
19261 setupdlg->attr[KEY_BIGINT].attr,
19264 if (parent || setupdlg->attr[KEY_JDCONV].supplied) {
19265 SQLWritePrivateProfileString(dsn,
"JDConv",
19266 setupdlg->attr[KEY_JDCONV].attr,
19269 if (parent || setupdlg->attr[KEY_PASSWD].supplied) {
19270 SQLWritePrivateProfileString(dsn,
"PWD",
19271 setupdlg->attr[KEY_PASSWD].attr,
19274 if (setupdlg->attr[KEY_DSN].supplied &&
19275 strcasecmp(setupdlg->DSN, setupdlg->attr[KEY_DSN].attr)) {
19276 SQLRemoveDSNFromIni(setupdlg->DSN);
19287 GetAttributes(SETUPDLG *setupdlg)
19289 char *dsn = setupdlg->attr[KEY_DSN].attr;
19291 if (!setupdlg->attr[KEY_DESC].supplied) {
19292 SQLGetPrivateProfileString(dsn,
"Description",
"",
19293 setupdlg->attr[KEY_DESC].attr,
19294 sizeof (setupdlg->attr[KEY_DESC].attr),
19297 if (!setupdlg->attr[KEY_DBNAME].supplied) {
19298 SQLGetPrivateProfileString(dsn,
"Database",
"",
19299 setupdlg->attr[KEY_DBNAME].attr,
19300 sizeof (setupdlg->attr[KEY_DBNAME].attr),
19303 if (!setupdlg->attr[KEY_BUSY].supplied) {
19304 SQLGetPrivateProfileString(dsn,
"Timeout",
"100000",
19305 setupdlg->attr[KEY_BUSY].attr,
19306 sizeof (setupdlg->attr[KEY_BUSY].attr),
19309 if (!setupdlg->attr[KEY_STEPAPI].supplied) {
19310 SQLGetPrivateProfileString(dsn,
"StepAPI",
"0",
19311 setupdlg->attr[KEY_STEPAPI].attr,
19312 sizeof (setupdlg->attr[KEY_STEPAPI].attr),
19315 if (!setupdlg->attr[KEY_SYNCP].supplied) {
19316 SQLGetPrivateProfileString(dsn,
"SyncPragma",
"NORMAL",
19317 setupdlg->attr[KEY_SYNCP].attr,
19318 sizeof (setupdlg->attr[KEY_SYNCP].attr),
19321 if (!setupdlg->attr[KEY_NOTXN].supplied) {
19322 SQLGetPrivateProfileString(dsn,
"NoTXN",
"",
19323 setupdlg->attr[KEY_NOTXN].attr,
19324 sizeof (setupdlg->attr[KEY_NOTXN].attr),
19327 if (!setupdlg->attr[KEY_SHORTNAM].supplied) {
19328 SQLGetPrivateProfileString(dsn,
"ShortNames",
"",
19329 setupdlg->attr[KEY_SHORTNAM].attr,
19330 sizeof (setupdlg->attr[KEY_SHORTNAM].attr),
19333 if (!setupdlg->attr[KEY_LONGNAM].supplied) {
19334 SQLGetPrivateProfileString(dsn,
"LongNames",
"",
19335 setupdlg->attr[KEY_LONGNAM].attr,
19336 sizeof (setupdlg->attr[KEY_LONGNAM].attr),
19339 if (!setupdlg->attr[KEY_NOCREAT].supplied) {
19340 SQLGetPrivateProfileString(dsn,
"NoCreat",
"",
19341 setupdlg->attr[KEY_NOCREAT].attr,
19342 sizeof (setupdlg->attr[KEY_NOCREAT].attr),
19345 if (!setupdlg->attr[KEY_NOWCHAR].supplied) {
19346 SQLGetPrivateProfileString(dsn,
"NoWCHAR",
"",
19347 setupdlg->attr[KEY_NOWCHAR].attr,
19348 sizeof (setupdlg->attr[KEY_NOWCHAR].attr),
19351 if (!setupdlg->attr[KEY_FKSUPPORT].supplied) {
19352 SQLGetPrivateProfileString(dsn,
"FKSupport",
"",
19353 setupdlg->attr[KEY_FKSUPPORT].attr,
19354 sizeof (setupdlg->attr[KEY_FKSUPPORT].attr),
19357 if (!setupdlg->attr[KEY_OEMCP].supplied) {
19358 SQLGetPrivateProfileString(dsn,
"OEMCP",
"",
19359 setupdlg->attr[KEY_OEMCP].attr,
19360 sizeof (setupdlg->attr[KEY_OEMCP].attr),
19363 if (!setupdlg->attr[KEY_LOADEXT].supplied) {
19364 SQLGetPrivateProfileString(dsn,
"LoadExt",
"",
19365 setupdlg->attr[KEY_LOADEXT].attr,
19366 sizeof (setupdlg->attr[KEY_LOADEXT].attr),
19369 if (!setupdlg->attr[KEY_JMODE].supplied) {
19370 SQLGetPrivateProfileString(dsn,
"JournalMode",
"",
19371 setupdlg->attr[KEY_JMODE].attr,
19372 sizeof (setupdlg->attr[KEY_JMODE].attr),
19375 if (!setupdlg->attr[KEY_BIGINT].supplied) {
19376 SQLGetPrivateProfileString(dsn,
"BigInt",
"",
19377 setupdlg->attr[KEY_BIGINT].attr,
19378 sizeof (setupdlg->attr[KEY_BIGINT].attr),
19381 if (!setupdlg->attr[KEY_PASSWD].supplied) {
19382 SQLGetPrivateProfileString(dsn,
"PWD",
"",
19383 setupdlg->attr[KEY_PASSWD].attr,
19384 sizeof (setupdlg->attr[KEY_PASSWD].attr),
19387 if (!setupdlg->attr[KEY_JDCONV].supplied) {
19388 SQLGetPrivateProfileString(dsn,
"JDConv",
"",
19389 setupdlg->attr[KEY_JDCONV].attr,
19390 sizeof (setupdlg->attr[KEY_JDCONV].attr),
19401 GetDBFile(HWND hdlg)
19404 SETUPDLG *setupdlg = (SETUPDLG *) GetWindowLongPtr(hdlg, DWLP_USER);
19406 SETUPDLG *setupdlg = (SETUPDLG *) GetWindowLong(hdlg, DWL_USER);
19410 memset(&ofn, 0,
sizeof (ofn));
19411 ofn.lStructSize =
sizeof (ofn);
19412 ofn.hwndOwner = hdlg;
19414 ofn.hInstance = (HINSTANCE) GetWindowLongPtr(hdlg, GWLP_HINSTANCE);
19416 ofn.hInstance = (HINSTANCE) GetWindowLong(hdlg, GWL_HINSTANCE);
19418 ofn.lpstrFile = (LPTSTR) setupdlg->attr[KEY_DBNAME].attr;
19419 ofn.nMaxFile = MAXPATHLEN;
19420 ofn.Flags = OFN_HIDEREADONLY | OFN_PATHMUSTEXIST |
19421 OFN_NOCHANGEDIR | OFN_EXPLORER | OFN_FILEMUSTEXIST;
19422 if (GetOpenFileName(&ofn)) {
19423 SetDlgItemText(hdlg, IDC_DBNAME, setupdlg->attr[KEY_DBNAME].attr);
19424 setupdlg->attr[KEY_DBNAME].supplied = TRUE;
19437 static BOOL CALLBACK
19438 ConfigDlgProc(HWND hdlg, WORD wmsg, WPARAM wparam, LPARAM lparam)
19440 SETUPDLG *setupdlg = NULL;
19444 case WM_INITDIALOG:
19446 SetWindowLongPtr(hdlg, DWLP_USER, lparam);
19448 SetWindowLong(hdlg, DWL_USER, lparam);
19450 setupdlg = (SETUPDLG *) lparam;
19451 GetAttributes(setupdlg);
19452 SetDlgItemText(hdlg, IDC_DSNAME, setupdlg->attr[KEY_DSN].attr);
19453 SetDlgItemText(hdlg, IDC_DESC, setupdlg->attr[KEY_DESC].attr);
19454 SetDlgItemText(hdlg, IDC_DBNAME, setupdlg->attr[KEY_DBNAME].attr);
19455 SetDlgItemText(hdlg, IDC_TONAME, setupdlg->attr[KEY_BUSY].attr);
19456 SetDlgItemText(hdlg, IDC_LOADEXT, setupdlg->attr[KEY_LOADEXT].attr);
19457 SendDlgItemMessage(hdlg, IDC_DSNAME, EM_LIMITTEXT,
19458 (WPARAM) (MAXDSNAME - 1), (LPARAM) 0);
19459 SendDlgItemMessage(hdlg, IDC_DESC, EM_LIMITTEXT,
19460 (WPARAM) (MAXDESC - 1), (LPARAM) 0);
19461 SendDlgItemMessage(hdlg, IDC_DBNAME, EM_LIMITTEXT,
19462 (WPARAM) (MAXDBNAME - 1), (LPARAM) 0);
19463 SendDlgItemMessage(hdlg, IDC_TONAME, EM_LIMITTEXT,
19464 (WPARAM) (MAXTONAME - 1), (LPARAM) 0);
19465 SendDlgItemMessage(hdlg, IDC_LOADEXT, EM_LIMITTEXT,
19466 (WPARAM) (MAXPATHLEN*4 - 1), (LPARAM) 0);
19467 CheckDlgButton(hdlg, IDC_STEPAPI,
19468 getbool(setupdlg->attr[KEY_STEPAPI].attr) ?
19469 BST_CHECKED : BST_UNCHECKED);
19470 CheckDlgButton(hdlg, IDC_NOTXN,
19471 getbool(setupdlg->attr[KEY_NOTXN].attr) ?
19472 BST_CHECKED : BST_UNCHECKED);
19473 CheckDlgButton(hdlg, IDC_SHORTNAM,
19474 getbool(setupdlg->attr[KEY_SHORTNAM].attr) ?
19475 BST_CHECKED : BST_UNCHECKED);
19476 CheckDlgButton(hdlg, IDC_LONGNAM,
19477 getbool(setupdlg->attr[KEY_LONGNAM].attr) ?
19478 BST_CHECKED : BST_UNCHECKED);
19479 CheckDlgButton(hdlg, IDC_NOCREAT,
19480 getbool(setupdlg->attr[KEY_NOCREAT].attr) ?
19481 BST_CHECKED : BST_UNCHECKED);
19482 CheckDlgButton(hdlg, IDC_NOWCHAR,
19483 getbool(setupdlg->attr[KEY_NOWCHAR].attr) ?
19484 BST_CHECKED : BST_UNCHECKED);
19485 CheckDlgButton(hdlg, IDC_FKSUPPORT,
19486 getbool(setupdlg->attr[KEY_FKSUPPORT].attr) ?
19487 BST_CHECKED : BST_UNCHECKED);
19488 CheckDlgButton(hdlg, IDC_OEMCP,
19489 getbool(setupdlg->attr[KEY_OEMCP].attr) ?
19490 BST_CHECKED : BST_UNCHECKED);
19491 CheckDlgButton(hdlg, IDC_BIGINT,
19492 getbool(setupdlg->attr[KEY_BIGINT].attr) ?
19493 BST_CHECKED : BST_UNCHECKED);
19494 CheckDlgButton(hdlg, IDC_JDCONV,
19495 getbool(setupdlg->attr[KEY_JDCONV].attr) ?
19496 BST_CHECKED : BST_UNCHECKED);
19497 SendDlgItemMessage(hdlg, IDC_SYNCP,
19498 CB_LIMITTEXT, (WPARAM) 10, (LPARAM) 0);
19499 SendDlgItemMessage(hdlg, IDC_SYNCP,
19500 CB_ADDSTRING, 0, (LPARAM)
"NORMAL");
19501 SendDlgItemMessage(hdlg, IDC_SYNCP,
19502 CB_ADDSTRING, 0, (LPARAM)
"OFF");
19503 SendDlgItemMessage(hdlg, IDC_SYNCP,
19504 CB_ADDSTRING, 0, (LPARAM)
"FULL");
19505 SendDlgItemMessage(hdlg, IDC_SYNCP,
19506 CB_SELECTSTRING, (WPARAM) -1,
19507 (LPARAM) setupdlg->attr[KEY_SYNCP].attr);
19508 if (setupdlg->defDSN) {
19509 EnableWindow(GetDlgItem(hdlg, IDC_DSNAME), FALSE);
19510 EnableWindow(GetDlgItem(hdlg, IDC_DSNAMETEXT), FALSE);
19514 switch (GET_WM_COMMAND_ID(wparam, lparam)) {
19516 if (GET_WM_COMMAND_CMD(wparam, lparam) == EN_CHANGE) {
19517 char item[MAXDSNAME];
19519 EnableWindow(GetDlgItem(hdlg, IDOK),
19520 GetDlgItemText(hdlg, IDC_DSNAME,
19521 item,
sizeof (item)));
19530 setupdlg = (SETUPDLG *) GetWindowLongPtr(hdlg, DWLP_USER);
19532 setupdlg = (SETUPDLG *) GetWindowLong(hdlg, DWL_USER);
19534 if (!setupdlg->defDSN) {
19535 GetDlgItemText(hdlg, IDC_DSNAME,
19536 setupdlg->attr[KEY_DSN].attr,
19537 sizeof (setupdlg->attr[KEY_DSN].attr));
19539 GetDlgItemText(hdlg, IDC_DESC,
19540 setupdlg->attr[KEY_DESC].attr,
19541 sizeof (setupdlg->attr[KEY_DESC].attr));
19542 GetDlgItemText(hdlg, IDC_DBNAME,
19543 setupdlg->attr[KEY_DBNAME].attr,
19544 sizeof (setupdlg->attr[KEY_DBNAME].attr));
19545 GetDlgItemText(hdlg, IDC_TONAME,
19546 setupdlg->attr[KEY_BUSY].attr,
19547 sizeof (setupdlg->attr[KEY_BUSY].attr));
19548 GetDlgItemText(hdlg, IDC_LOADEXT,
19549 setupdlg->attr[KEY_LOADEXT].attr,
19550 sizeof (setupdlg->attr[KEY_LOADEXT].attr));
19551 index = SendDlgItemMessage(hdlg, IDC_SYNCP,
19552 CB_GETCURSEL, (WPARAM) 0, (LPARAM) 0);
19553 if (index != (WORD) CB_ERR) {
19554 SendDlgItemMessage(hdlg, IDC_SYNCP,
19555 CB_GETLBTEXT, index,
19556 (LPARAM) setupdlg->attr[KEY_SYNCP].attr);
19558 strcpy(setupdlg->attr[KEY_STEPAPI].attr,
19559 (IsDlgButtonChecked(hdlg, IDC_STEPAPI) == BST_CHECKED) ?
19561 strcpy(setupdlg->attr[KEY_NOTXN].attr,
19562 (IsDlgButtonChecked(hdlg, IDC_NOTXN) == BST_CHECKED) ?
19564 strcpy(setupdlg->attr[KEY_SHORTNAM].attr,
19565 (IsDlgButtonChecked(hdlg, IDC_SHORTNAM) == BST_CHECKED) ?
19567 strcpy(setupdlg->attr[KEY_LONGNAM].attr,
19568 (IsDlgButtonChecked(hdlg, IDC_LONGNAM) == BST_CHECKED) ?
19570 strcpy(setupdlg->attr[KEY_NOCREAT].attr,
19571 (IsDlgButtonChecked(hdlg, IDC_NOCREAT) == BST_CHECKED) ?
19573 strcpy(setupdlg->attr[KEY_NOWCHAR].attr,
19574 (IsDlgButtonChecked(hdlg, IDC_NOWCHAR) == BST_CHECKED) ?
19576 strcpy(setupdlg->attr[KEY_FKSUPPORT].attr,
19577 (IsDlgButtonChecked(hdlg, IDC_FKSUPPORT) == BST_CHECKED) ?
19579 strcpy(setupdlg->attr[KEY_OEMCP].attr,
19580 (IsDlgButtonChecked(hdlg, IDC_OEMCP) == BST_CHECKED) ?
19582 strcpy(setupdlg->attr[KEY_BIGINT].attr,
19583 (IsDlgButtonChecked(hdlg, IDC_BIGINT) == BST_CHECKED) ?
19585 strcpy(setupdlg->attr[KEY_JDCONV].attr,
19586 (IsDlgButtonChecked(hdlg, IDC_JDCONV) == BST_CHECKED) ?
19588 SetDSNAttributes(hdlg, setupdlg);
19591 EndDialog(hdlg, wparam);
19609 ConfigDSN(HWND hwnd, WORD request, LPCSTR driver, LPCSTR attribs)
19612 SETUPDLG *setupdlg;
19614 setupdlg = (SETUPDLG *)
xmalloc(
sizeof (SETUPDLG));
19615 if (setupdlg == NULL) {
19618 memset(setupdlg, 0,
sizeof (SETUPDLG));
19620 ParseAttributes(attribs, setupdlg);
19622 if (setupdlg->attr[KEY_DSN].supplied) {
19623 strcpy(setupdlg->DSN, setupdlg->attr[KEY_DSN].attr);
19625 setupdlg->DSN[0] =
'\0';
19627 if (request == ODBC_REMOVE_DSN) {
19628 if (!setupdlg->attr[KEY_DSN].supplied) {
19631 success = SQLRemoveDSNFromIni(setupdlg->attr[KEY_DSN].attr);
19634 setupdlg->parent = hwnd;
19635 setupdlg->driver = driver;
19636 setupdlg->newDSN = request == ODBC_ADD_DSN;
19637 setupdlg->defDSN = strcasecmp(setupdlg->attr[KEY_DSN].attr,
19640 success = DialogBoxParam(hModule, MAKEINTRESOURCE(CONFIGDSN),
19641 hwnd, (DLGPROC) ConfigDlgProc,
19642 (LPARAM) setupdlg) == IDOK;
19643 }
else if (setupdlg->attr[KEY_DSN].supplied) {
19644 success = SetDSNAttributes(hwnd, setupdlg);
19662 static BOOL CALLBACK
19663 DriverConnectProc(HWND hdlg, WORD wmsg, WPARAM wparam, LPARAM lparam)
19665 SETUPDLG *setupdlg;
19669 case WM_INITDIALOG:
19671 SetWindowLongPtr(hdlg, DWLP_USER, lparam);
19673 SetWindowLong(hdlg, DWL_USER, lparam);
19675 setupdlg = (SETUPDLG *) lparam;
19676 SetDlgItemText(hdlg, IDC_DSNAME, setupdlg->attr[KEY_DSN].attr);
19677 SetDlgItemText(hdlg, IDC_DESC, setupdlg->attr[KEY_DESC].attr);
19678 SetDlgItemText(hdlg, IDC_DBNAME, setupdlg->attr[KEY_DBNAME].attr);
19679 SetDlgItemText(hdlg, IDC_TONAME, setupdlg->attr[KEY_BUSY].attr);
19680 SetDlgItemText(hdlg, IDC_LOADEXT, setupdlg->attr[KEY_LOADEXT].attr);
19681 SendDlgItemMessage(hdlg, IDC_DSNAME, EM_LIMITTEXT,
19682 (WPARAM) (MAXDSNAME - 1), (LPARAM) 0);
19683 SendDlgItemMessage(hdlg, IDC_DESC, EM_LIMITTEXT,
19684 (WPARAM) (MAXDESC - 1), (LPARAM) 0);
19685 SendDlgItemMessage(hdlg, IDC_DBNAME, EM_LIMITTEXT,
19686 (WPARAM) (MAXDBNAME - 1), (LPARAM) 0);
19687 SendDlgItemMessage(hdlg, IDC_TONAME, EM_LIMITTEXT,
19688 (WPARAM) (MAXTONAME - 1), (LPARAM) 0);
19689 SendDlgItemMessage(hdlg, IDC_LOADEXT, EM_LIMITTEXT,
19690 (WPARAM) (MAXPATHLEN*4 - 1), (LPARAM) 0);
19691 CheckDlgButton(hdlg, IDC_STEPAPI,
19692 getbool(setupdlg->attr[KEY_STEPAPI].attr) ?
19693 BST_CHECKED : BST_UNCHECKED);
19694 CheckDlgButton(hdlg, IDC_NOTXN,
19695 getbool(setupdlg->attr[KEY_NOTXN].attr) ?
19696 BST_CHECKED : BST_UNCHECKED);
19697 CheckDlgButton(hdlg, IDC_SHORTNAM,
19698 getbool(setupdlg->attr[KEY_SHORTNAM].attr) ?
19699 BST_CHECKED : BST_UNCHECKED);
19700 CheckDlgButton(hdlg, IDC_LONGNAM,
19701 getbool(setupdlg->attr[KEY_LONGNAM].attr) ?
19702 BST_CHECKED : BST_UNCHECKED);
19703 CheckDlgButton(hdlg, IDC_NOCREAT,
19704 getbool(setupdlg->attr[KEY_NOCREAT].attr) ?
19705 BST_CHECKED : BST_UNCHECKED);
19706 CheckDlgButton(hdlg, IDC_NOWCHAR,
19707 getbool(setupdlg->attr[KEY_NOWCHAR].attr) ?
19708 BST_CHECKED : BST_UNCHECKED);
19709 CheckDlgButton(hdlg, IDC_FKSUPPORT,
19710 getbool(setupdlg->attr[KEY_FKSUPPORT].attr) ?
19711 BST_CHECKED : BST_UNCHECKED);
19712 CheckDlgButton(hdlg, IDC_OEMCP,
19713 getbool(setupdlg->attr[KEY_OEMCP].attr) ?
19714 BST_CHECKED : BST_UNCHECKED);
19715 CheckDlgButton(hdlg, IDC_BIGINT,
19716 getbool(setupdlg->attr[KEY_BIGINT].attr) ?
19717 BST_CHECKED : BST_UNCHECKED);
19718 CheckDlgButton(hdlg, IDC_JDCONV,
19719 getbool(setupdlg->attr[KEY_JDCONV].attr) ?
19720 BST_CHECKED : BST_UNCHECKED);
19721 SendDlgItemMessage(hdlg, IDC_SYNCP,
19722 CB_LIMITTEXT, (WPARAM) 10, (LPARAM) 0);
19723 SendDlgItemMessage(hdlg, IDC_SYNCP,
19724 CB_ADDSTRING, 0, (LPARAM)
"NORMAL");
19725 SendDlgItemMessage(hdlg, IDC_SYNCP,
19726 CB_ADDSTRING, 0, (LPARAM)
"OFF");
19727 SendDlgItemMessage(hdlg, IDC_SYNCP,
19728 CB_ADDSTRING, 0, (LPARAM)
"FULL");
19729 SendDlgItemMessage(hdlg, IDC_SYNCP,
19730 CB_SELECTSTRING, (WORD) -1,
19731 (LPARAM) setupdlg->attr[KEY_SYNCP].attr);
19732 if (setupdlg->defDSN) {
19733 EnableWindow(GetDlgItem(hdlg, IDC_DSNAME), FALSE);
19734 EnableWindow(GetDlgItem(hdlg, IDC_DSNAMETEXT), FALSE);
19738 switch (GET_WM_COMMAND_ID(wparam, lparam)) {
19744 setupdlg = (SETUPDLG *) GetWindowLongPtr(hdlg, DWLP_USER);
19746 setupdlg = (SETUPDLG *) GetWindowLong(hdlg, DWL_USER);
19748 GetDlgItemText(hdlg, IDC_DSNAME,
19749 setupdlg->attr[KEY_DSN].attr,
19750 sizeof (setupdlg->attr[KEY_DSN].attr));
19751 GetDlgItemText(hdlg, IDC_DBNAME,
19752 setupdlg->attr[KEY_DBNAME].attr,
19753 sizeof (setupdlg->attr[KEY_DBNAME].attr));
19754 GetDlgItemText(hdlg, IDC_TONAME,
19755 setupdlg->attr[KEY_BUSY].attr,
19756 sizeof (setupdlg->attr[KEY_BUSY].attr));
19757 GetDlgItemText(hdlg, IDC_LOADEXT,
19758 setupdlg->attr[KEY_LOADEXT].attr,
19759 sizeof (setupdlg->attr[KEY_LOADEXT].attr));
19760 index = SendDlgItemMessage(hdlg, IDC_SYNCP,
19761 CB_GETCURSEL, (WPARAM) 0, (LPARAM) 0);
19762 if (index != (WORD) CB_ERR) {
19763 SendDlgItemMessage(hdlg, IDC_SYNCP,
19764 CB_GETLBTEXT, index,
19765 (LPARAM) setupdlg->attr[KEY_SYNCP].attr);
19767 strcpy(setupdlg->attr[KEY_STEPAPI].attr,
19768 (IsDlgButtonChecked(hdlg, IDC_STEPAPI) == BST_CHECKED) ?
19770 strcpy(setupdlg->attr[KEY_NOTXN].attr,
19771 (IsDlgButtonChecked(hdlg, IDC_NOTXN) == BST_CHECKED) ?
19773 strcpy(setupdlg->attr[KEY_SHORTNAM].attr,
19774 (IsDlgButtonChecked(hdlg, IDC_SHORTNAM) == BST_CHECKED) ?
19776 strcpy(setupdlg->attr[KEY_LONGNAM].attr,
19777 (IsDlgButtonChecked(hdlg, IDC_LONGNAM) == BST_CHECKED) ?
19779 strcpy(setupdlg->attr[KEY_NOCREAT].attr,
19780 (IsDlgButtonChecked(hdlg, IDC_NOCREAT) == BST_CHECKED) ?
19782 strcpy(setupdlg->attr[KEY_NOWCHAR].attr,
19783 (IsDlgButtonChecked(hdlg, IDC_NOWCHAR) == BST_CHECKED) ?
19785 strcpy(setupdlg->attr[KEY_FKSUPPORT].attr,
19786 (IsDlgButtonChecked(hdlg, IDC_FKSUPPORT) == BST_CHECKED) ?
19788 strcpy(setupdlg->attr[KEY_OEMCP].attr,
19789 (IsDlgButtonChecked(hdlg, IDC_OEMCP) == BST_CHECKED) ?
19791 strcpy(setupdlg->attr[KEY_BIGINT].attr,
19792 (IsDlgButtonChecked(hdlg, IDC_BIGINT) == BST_CHECKED) ?
19794 strcpy(setupdlg->attr[KEY_JDCONV].attr,
19795 (IsDlgButtonChecked(hdlg, IDC_JDCONV) == BST_CHECKED) ?
19799 EndDialog(hdlg, GET_WM_COMMAND_ID(wparam, lparam) == IDOK);
19821 SQLCHAR *connIn, SQLSMALLINT connInLen,
19822 SQLCHAR *connOut, SQLSMALLINT connOutMax,
19823 SQLSMALLINT *connOutLen, SQLUSMALLINT drvcompl)
19825 BOOL maybeprompt, prompt = FALSE, defaultdsn = FALSE;
19827 SETUPDLG *setupdlg;
19829 char *dsn = NULL, *driver = NULL, *dbname = NULL;
19831 if (
dbc == SQL_NULL_HDBC) {
19832 return SQL_INVALID_HANDLE;
19836 setstatd(d, -1,
"connection already established",
"08002");
19839 setupdlg = (SETUPDLG *)
xmalloc(
sizeof (SETUPDLG));
19840 if (setupdlg == NULL) {
19843 memset(setupdlg, 0,
sizeof (SETUPDLG));
19844 maybeprompt = drvcompl == SQL_DRIVER_COMPLETE ||
19845 drvcompl == SQL_DRIVER_COMPLETE_REQUIRED;
19846 if (connIn == NULL || !connInLen ||
19847 (connInLen == SQL_NTS && !connIn[0])) {
19850 ParseAttributes((LPCSTR) connIn, setupdlg);
19851 if (!setupdlg->attr[KEY_DSN].attr[0] &&
19852 drvcompl == SQL_DRIVER_COMPLETE_REQUIRED) {
19853 strcpy(setupdlg->attr[KEY_DSN].attr,
"DEFAULT");
19856 GetAttributes(setupdlg);
19857 if (drvcompl == SQL_DRIVER_PROMPT ||
19859 !setupdlg->attr[KEY_DBNAME].attr[0])) {
19867 setupdlg->defDSN = setupdlg->attr[KEY_DRIVER].attr[0] !=
'\0';
19868 dlgret = DialogBoxParam(hModule, MAKEINTRESOURCE(DRIVERCONNECT),
19869 hwnd, (DLGPROC) DriverConnectProc,
19870 (LPARAM) setupdlg);
19872 if (!dlgret || dlgret == -1) {
19874 return SQL_NO_DATA;
19877 dsn = setupdlg->attr[KEY_DSN].attr;
19878 driver = setupdlg->attr[KEY_DRIVER].attr;
19879 dbname = setupdlg->attr[KEY_DBNAME].attr;
19880 if (connOut || connOutLen) {
19881 char buf[SQL_MAX_MESSAGE_LENGTH * 8];
19883 char dsn_0 = (dsn && !defaultdsn) ? dsn[0] :
'\0';
19884 char drv_0 = driver ? driver[0] :
'\0';
19887 count = snprintf(buf,
sizeof (buf),
19888 "%s%s%s%s%s%sDatabase=%s;StepAPI=%s;"
19889 "SyncPragma=%s;NoTXN=%s;Timeout=%s;"
19890 "ShortNames=%s;LongNames=%s;"
19891 "NoCreat=%s;NoWCHAR=%s;"
19892 "FKSupport=%s;JournalMode=%s;OEMCP=%s;LoadExt=%s;"
19893 "BigInt=%s;JDConv=%s;PWD=%s",
19894 dsn_0 ?
"DSN=" :
"",
19897 drv_0 ?
"Driver=" :
"",
19898 drv_0 ? driver :
"",
19900 dbname ? dbname :
"",
19901 setupdlg->attr[KEY_STEPAPI].attr,
19902 setupdlg->attr[KEY_SYNCP].attr,
19903 setupdlg->attr[KEY_NOTXN].attr,
19904 setupdlg->attr[KEY_BUSY].attr,
19905 setupdlg->attr[KEY_SHORTNAM].attr,
19906 setupdlg->attr[KEY_LONGNAM].attr,
19907 setupdlg->attr[KEY_NOCREAT].attr,
19908 setupdlg->attr[KEY_NOWCHAR].attr,
19909 setupdlg->attr[KEY_FKSUPPORT].attr,
19910 setupdlg->attr[KEY_JMODE].attr,
19911 setupdlg->attr[KEY_OEMCP].attr,
19912 setupdlg->attr[KEY_LOADEXT].attr,
19913 setupdlg->attr[KEY_BIGINT].attr,
19914 setupdlg->attr[KEY_JDCONV].attr,
19915 setupdlg->attr[KEY_PASSWD].attr);
19917 buf[
sizeof (buf) - 1] =
'\0';
19919 len =
min(connOutMax - 1, strlen(buf));
19921 strncpy((
char *) connOut, buf, len);
19922 connOut[len] =
'\0';
19929 char tracef[SQL_MAX_MESSAGE_LENGTH];
19932 SQLGetPrivateProfileString(setupdlg->attr[KEY_DSN].attr,
19933 "tracefile",
"", tracef,
19935 if (tracef[0] !=
'\0') {
19936 d->
trace = fopen(tracef,
"a");
19947 d->
pwdLen = strlen(setupdlg->attr[KEY_PASSWD].attr);
19948 d->
pwd = (d->
pwdLen > 0) ? setupdlg->attr[KEY_PASSWD].attr : NULL;
19949 ret =
dbopen(d, dbname ? dbname :
"", 0,
19951 setupdlg->attr[KEY_STEPAPI].attr,
19952 setupdlg->attr[KEY_SYNCP].attr,
19953 setupdlg->attr[KEY_NOTXN].attr,
19954 setupdlg->attr[KEY_JMODE].attr,
19955 setupdlg->attr[KEY_BUSY].attr);
19956 if (ret != SQL_SUCCESS) {
19957 if (maybeprompt && !prompt) {
19962 memset(setupdlg->attr[KEY_PASSWD].attr, 0,
19963 sizeof (setupdlg->attr[KEY_PASSWD].attr));
19964 if (ret == SQL_SUCCESS) {
19965 dbloadext(d, setupdlg->attr[KEY_LOADEXT].attr);
19989 SQLDriverConnect(SQLHDBC
dbc, SQLHWND hwnd,
19990 SQLCHAR *connIn, SQLSMALLINT connInLen,
19991 SQLCHAR *connOut, SQLSMALLINT connOutMax,
19992 SQLSMALLINT *connOutLen, SQLUSMALLINT drvcompl)
19998 connOut, connOutMax, connOutLen, drvcompl);
20019 SQLDriverConnectW(SQLHDBC
dbc, SQLHWND hwnd,
20020 SQLWCHAR *connIn, SQLSMALLINT connInLen,
20021 SQLWCHAR *connOut, SQLSMALLINT connOutMax,
20022 SQLSMALLINT *connOutLen, SQLUSMALLINT drvcompl)
20026 SQLSMALLINT len = 0;
20030 #if defined(_WIN32) || defined(_WIN64)
20031 if (connInLen == SQL_NTS) {
20034 ci = uc_to_wmb(connIn, connInLen);
20041 setstatd(d, -1,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
20047 (SQLCHAR *) connOut, connOutMax, &len, drvcompl);
20050 if (ret == SQL_SUCCESS) {
20051 SQLWCHAR *co = NULL;
20055 #if defined(_WIN32) || defined(_WIN64)
20056 co = wmb_to_uc((
char *) connOut, len);
20061 uc_strncpy(connOut, co, connOutMax /
sizeof (SQLWCHAR));
20062 len =
min(connOutMax /
sizeof (SQLWCHAR),
uc_strlen(co));
20083 #if defined(_WIN32) || defined(_WIN64)
20094 LibMain(HANDLE hinst, DWORD reason, LPVOID reserved)
20099 case DLL_PROCESS_ATTACH:
20107 #ifdef SQLITE_DYNLOAD
20110 #ifdef SQLITE_HAS_CODEC
20111 sqlite3_activate_see(SQLITE_ACTIVATION_KEY);
20114 #if defined(ENABLE_NVFS) && (ENABLE_NVFS)
20118 case DLL_THREAD_ATTACH:
20120 case DLL_PROCESS_DETACH:
20122 #ifdef SQLITE_DYNLOAD
20127 case DLL_THREAD_DETACH:
20144 DllMain(HANDLE hinst, DWORD reason, LPVOID reserved)
20146 return LibMain(hinst, reason, reserved);
20149 #ifndef WITHOUT_INSTALLER
20158 InUnError(
char *name)
20163 WORD errlen, errmax =
sizeof (errmsg) - 1;
20169 sqlret = SQLInstallerError(err, &code, errmsg, errmax, &errlen);
20170 if (SQL_SUCCEEDED(sqlret)) {
20171 MessageBox(NULL, errmsg, name,
20172 MB_ICONSTOP | MB_OK | MB_TASKMODAL | MB_SETFOREGROUND);
20176 }
while (sqlret != SQL_NO_DATA);
20187 InUn(
int remove,
char *cmdline)
20189 #ifdef SQLITE_HAS_CODEC
20190 static char *drivername =
"SQLite3 ODBC Driver (SEE)";
20191 static char *dsname =
"SQLite3 SEE Datasource";
20193 static char *drivername =
"SQLite3 ODBC Driver";
20194 static char *dsname =
"SQLite3 Datasource";
20197 char dllbuf[301], path[301], driver[300], attr[300], inst[400];
20198 WORD pathmax =
sizeof (path) - 1, pathlen;
20199 DWORD usecnt, mincnt;
20203 GetModuleFileName(hModule, dllbuf,
sizeof (dllbuf));
20204 p = strrchr(dllbuf,
'\\');
20205 dllname = p ? (p + 1) : dllbuf;
20206 quiet = cmdline && strstr(cmdline,
"quiet");
20207 if (SQLInstallDriverManager(path, pathmax, &pathlen)) {
20208 sprintf(driver,
"%s;Driver=%s;Setup=%s;",
20209 drivername, dllname, dllname);
20219 SQLInstallDriverEx(driver, NULL, path, pathmax, NULL,
20220 ODBC_INSTALL_INQUIRY, &usecnt);
20221 pathlen = strlen(path);
20222 while (pathlen > 0 && path[pathlen - 1] ==
'\\') {
20224 path[pathlen] =
'\0';
20226 sprintf(driver,
"%s;Driver=%s\\%s;Setup=%s\\%s;",
20227 drivername, path, dllname, path, dllname);
20235 sprintf(inst,
"%s\\%s", path, dllname);
20236 if (!remove && usecnt > 0) {
20238 if (GetFileAttributesA(dllbuf) != INVALID_FILE_ATTRIBUTES &&
20239 CopyFile(dllbuf, inst, 0)) {
20243 sprintf(buf,
"%s replaced.", drivername);
20244 MessageBox(NULL, buf,
"Info",
20245 MB_ICONINFORMATION | MB_OK | MB_TASKMODAL |
20251 mincnt = remove ? 1 : 0;
20252 while (usecnt != mincnt) {
20253 if (!SQLRemoveDriver(driver, TRUE, &usecnt)) {
20258 if (usecnt && !SQLRemoveDriver(driver, TRUE, &usecnt)) {
20259 InUnError(
"SQLRemoveDriver");
20267 sprintf(buf,
"%s uninstalled.", drivername);
20268 MessageBox(NULL, buf,
"Info",
20269 MB_ICONINFORMATION |MB_OK | MB_TASKMODAL |
20273 sprintf(attr,
"DSN=%s;Database=;", dsname);
20281 SQLConfigDataSource(NULL, ODBC_REMOVE_SYS_DSN, drivername, attr);
20284 if (GetFileAttributesA(dllbuf) == INVALID_FILE_ATTRIBUTES) {
20287 if (strcasecmp(dllbuf, inst) != 0 && !CopyFile(dllbuf, inst, 0)) {
20290 sprintf(buf,
"Copy %s to %s failed.", dllbuf, inst);
20291 MessageBox(NULL, buf,
"CopyFile",
20292 MB_ICONSTOP |MB_OK | MB_TASKMODAL | MB_SETFOREGROUND);
20295 if (!SQLInstallDriverEx(driver, path, path, pathmax, &pathlen,
20296 ODBC_INSTALL_COMPLETE, &usecnt)) {
20297 InUnError(
"SQLInstallDriverEx");
20300 sprintf(attr,
"DSN=%s;Database=;", dsname);
20308 SQLConfigDataSource(NULL, ODBC_REMOVE_SYS_DSN, drivername, attr);
20309 if (!SQLConfigDataSource(NULL, ODBC_ADD_SYS_DSN, drivername, attr)) {
20310 InUnError(
"SQLConfigDataSource");
20316 sprintf(buf,
"%s installed.", drivername);
20317 MessageBox(NULL, buf,
"Info",
20318 MB_ICONINFORMATION | MB_OK | MB_TASKMODAL |
20322 InUnError(
"SQLInstallDriverManager");
20337 install(HWND hwnd, HINSTANCE hinst, LPSTR lpszCmdLine,
int nCmdShow)
20339 InUn(0, lpszCmdLine);
20351 uninstall(HWND hwnd, HINSTANCE hinst, LPSTR lpszCmdLine,
int nCmdShow)
20353 InUn(1, lpszCmdLine);
20358 #ifndef WITHOUT_SHELL
20369 setargv(
int *argcp,
char ***argvp,
char *cmdline,
char *argv0)
20371 char *p, *arg, *argspace, **argv;
20372 int argc, size, inquote, copy, slashes;
20374 size = 2 + (argv0 ? 1 : 0);
20375 for (p = cmdline; *p !=
'\0'; p++) {
20386 argspace = malloc(size *
sizeof (
char *) + strlen(cmdline) + 1);
20387 argv = (
char **) argspace;
20388 argspace += size *
sizeof (
char *);
20392 argv[argc++] = argv0;
20395 for (; argc < size; argc++) {
20396 argv[argc] = arg = argspace;
20407 while (*p ==
'\\') {
20412 if ((slashes & 1) == 0) {
20414 if (inquote && p[1] ==
'"') {
20418 inquote = !inquote;
20428 if (*p ==
'\0' || (!inquote &&
ISSPACE(*p))) {
20438 argspace = arg + 1;
20454 shell(HWND hwnd, HINSTANCE hinst, LPSTR lpszCmdLine,
int nCmdShow)
20456 int argc, needcon = 0;
20458 extern int sqlite3_main(
int,
char **);
20459 static const char *name =
"SQLite3 Shell";
20460 DWORD ftype0, ftype1, ftype2;
20462 ftype0 = GetFileType(GetStdHandle(STD_INPUT_HANDLE));
20463 ftype1 = GetFileType(GetStdHandle(STD_OUTPUT_HANDLE));
20464 ftype2 = GetFileType(GetStdHandle(STD_ERROR_HANDLE));
20465 if (ftype0 != FILE_TYPE_DISK && ftype0 != FILE_TYPE_CHAR &&
20466 ftype0 != FILE_TYPE_PIPE) {
20469 ftype0 = FILE_TYPE_UNKNOWN;
20471 if (ftype1 != FILE_TYPE_DISK && ftype1 != FILE_TYPE_CHAR &&
20472 ftype1 != FILE_TYPE_PIPE) {
20475 ftype1 = FILE_TYPE_UNKNOWN;
20477 if (ftype2 != FILE_TYPE_DISK && ftype2 != FILE_TYPE_CHAR &&
20478 ftype2 != FILE_TYPE_PIPE) {
20481 ftype2 = FILE_TYPE_UNKNOWN;
20485 SetConsoleTitle(name);
20487 if (ftype0 == FILE_TYPE_UNKNOWN) {
20488 freopen(
"CONIN$",
"r", stdin);
20490 if (ftype1 == FILE_TYPE_UNKNOWN) {
20491 freopen(
"CONOUT$",
"w", stdout);
20493 if (ftype2 == FILE_TYPE_UNKNOWN) {
20494 freopen(
"CONOUT$",
"w", stderr);
20496 setargv(&argc, &argv, lpszCmdLine, (
char *) name);
20497 #if defined(ENABLE_NVFS) && (ENABLE_NVFS)
20500 sqlite3_main(argc, argv);
20507 #if defined(HAVE_ODBCINSTEXT_H) && (HAVE_ODBCINSTEXT_H)
20514 #include <odbcinstext.h>
20517 ODBCINSTGetProperties(HODBCINSTPROPERTY prop)
20519 static const char *instYN[] = {
"No",
"Yes", NULL };
20520 static const char *syncPragma[] = {
"NORMAL",
"OFF",
"FULL", NULL };
20521 static const char *jmPragma[] = {
20522 "DELETE",
"PERSIST",
"OFF",
"TRUNCATE",
"MEMORY",
"WAL", NULL
20525 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20526 prop = prop->pNext;
20527 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20528 prop->nPromptType = ODBCINST_PROMPTTYPE_FILENAME;
20529 strncpy(prop->szName,
"Database", INI_MAX_PROPERTY_NAME);
20530 strncpy(prop->szValue,
"", INI_MAX_PROPERTY_VALUE);
20531 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20532 prop = prop->pNext;
20533 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20534 prop->nPromptType = ODBCINST_PROMPTTYPE_TEXTEDIT;
20535 strncpy(prop->szName,
"Timeout", INI_MAX_PROPERTY_NAME);
20536 strncpy(prop->szValue,
"100000", INI_MAX_PROPERTY_VALUE);
20537 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20538 prop = prop->pNext;
20539 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20540 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20541 prop->aPromptData = malloc(
sizeof (instYN));
20542 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20543 strncpy(prop->szName,
"StepAPI", INI_MAX_PROPERTY_NAME);
20544 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20545 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20546 prop = prop->pNext;
20547 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20548 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20549 prop->aPromptData = malloc(
sizeof (instYN));
20550 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20551 strncpy(prop->szName,
"ShortNames", INI_MAX_PROPERTY_NAME);
20552 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20553 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20554 prop = prop->pNext;
20555 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20556 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20557 prop->aPromptData = malloc(
sizeof (instYN));
20558 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20559 strncpy(prop->szName,
"LongNames", INI_MAX_PROPERTY_NAME);
20560 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20561 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20562 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20563 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20564 prop->aPromptData = malloc(
sizeof (instYN));
20565 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20566 strncpy(prop->szName,
"NoCreat", INI_MAX_PROPERTY_NAME);
20567 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20569 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20570 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20571 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20572 prop->aPromptData = malloc(
sizeof (instYN));
20573 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20574 strncpy(prop->szName,
"NoWCHAR", INI_MAX_PROPERTY_NAME);
20575 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20577 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20578 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20579 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20580 prop->aPromptData = malloc(
sizeof (instYN));
20581 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20582 strncpy(prop->szName,
"FKSupport", INI_MAX_PROPERTY_NAME);
20583 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20584 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20585 prop = prop->pNext;
20586 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20587 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20588 prop->aPromptData = malloc(
sizeof (syncPragma));
20589 memcpy(prop->aPromptData, syncPragma, sizeof (syncPragma));
20590 strncpy(prop->szName,
"SyncPragma", INI_MAX_PROPERTY_NAME);
20591 strncpy(prop->szValue,
"NORMAL", INI_MAX_PROPERTY_VALUE);
20592 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20593 prop = prop->pNext;
20594 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20595 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20596 prop->aPromptData = malloc(
sizeof (jmPragma));
20597 memcpy(prop->aPromptData, jmPragma, sizeof (jmPragma));
20598 strncpy(prop->szName,
"JournalMode", INI_MAX_PROPERTY_NAME);
20599 strncpy(prop->szValue,
"DELETE", INI_MAX_PROPERTY_VALUE);
20600 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20601 prop = prop->pNext;
20602 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20603 prop->nPromptType = ODBCINST_PROMPTTYPE_TEXTEDIT;
20604 strncpy(prop->szName,
"LoadExt", INI_MAX_PROPERTY_NAME);
20605 strncpy(prop->szValue,
"", INI_MAX_PROPERTY_VALUE);
20606 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20607 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20608 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20609 prop->aPromptData = malloc(
sizeof (instYN));
20610 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20611 strncpy(prop->szName,
"BigInt", INI_MAX_PROPERTY_NAME);
20612 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20618 #ifdef SQLITE_DYNLOAD
20632 return SQLITE_ERROR;
20641 static sqlite_int64
20659 static const char *
20668 return SQLITE_NULL;
20671 #define DLS_ENT(name, func) \
20672 { "sqlite3_" #name, offsetof(struct dl_sqlite3_funcs, name), \
20675 #define DLS_ENT3(name, off, func) \
20676 { "sqlite3_" #name, offsetof(struct dl_sqlite3_funcs, off), \
20679 #define DLS_END { NULL, 0, NULL }
20685 } dls_nametab[] = {
20686 DLS_ENT(activate_see, dls_void),
20687 DLS_ENT(bind_blob, dls_error),
20688 DLS_ENT(bind_double, dls_error),
20689 DLS_ENT(bind_int, dls_error),
20690 DLS_ENT(bind_int64, dls_error),
20691 DLS_ENT(bind_null, dls_error),
20692 DLS_ENT(bind_parameter_count, dls_0),
20693 DLS_ENT(bind_text, dls_error),
20695 DLS_ENT(changes, dls_0),
20696 DLS_ENT(close, dls_error),
20697 DLS_ENT(column_blob, dls_null),
20698 DLS_ENT(column_bytes, dls_0),
20699 DLS_ENT(column_count, dls_0),
20700 DLS_ENT(column_database_name, dls_empty),
20701 DLS_ENT(column_decltype, dls_empty),
20702 DLS_ENT(column_double, dls_00),
20703 DLS_ENT(column_name, dls_empty),
20704 DLS_ENT(column_origin_name, dls_null),
20705 DLS_ENT(column_table_name, dls_null),
20706 DLS_ENT(column_text, dls_null),
20707 DLS_ENT(column_type, dls_snull),
20708 DLS_ENT(create_function, dls_error),
20709 DLS_ENT(enable_load_extension, dls_error),
20710 DLS_ENT(errcode, dls_error),
20711 DLS_ENT(errmsg, dls_empty),
20712 DLS_ENT(exec, dls_error),
20713 DLS_ENT(finalize, dls_error),
20714 DLS_ENT(free, free),
20715 DLS_ENT(free_table, dls_void),
20716 DLS_ENT(get_table, dls_error),
20717 DLS_ENT(interrupt, dls_void),
20718 DLS_ENT(key, dls_error),
20719 DLS_ENT(last_insert_rowid, dls_0LL),
20720 DLS_ENT(libversion, dls_empty),
20721 DLS_ENT(load_extension, dls_error),
20722 DLS_ENT(malloc, malloc),
20723 DLS_ENT(mprintf, dls_null),
20724 DLS_ENT(open, dls_error),
20725 DLS_ENT(open16, dls_error),
20726 DLS_ENT(open_v2, dls_error),
20727 DLS_ENT(prepare, dls_error),
20728 DLS_ENT(prepare_v2, dls_error),
20729 DLS_ENT(profile, dls_null),
20730 DLS_ENT(realloc, realloc),
20731 DLS_ENT(rekey, dls_error),
20732 DLS_ENT(reset, dls_error),
20733 DLS_ENT(result_blob, dls_void),
20734 DLS_ENT(result_error, dls_void),
20735 DLS_ENT(result_int, dls_void),
20736 DLS_ENT(result_null, dls_void),
20737 DLS_ENT(step, dls_error),
20738 #if defined(_WIN32) || defined(_WIN64)
20739 DLS_ENT3(strnicmp, xstrnicmp, _strnicmp),
20741 DLS_ENT3(strnicmp, xstrnicmp, strncasecmp),
20743 DLS_ENT(table_column_metadata, dls_error),
20744 DLS_ENT(trace, dls_null),
20745 DLS_ENT(user_data, dls_null),
20746 DLS_ENT(value_blob, dls_null),
20747 DLS_ENT(value_bytes, dls_0),
20748 DLS_ENT(value_text, dls_empty),
20749 DLS_ENT(value_type, dls_snull),
20753 #if defined(_WIN32) || defined(_WIN64)
20755 static HMODULE sqlite3_dll = 0;
20761 static const char *dll_names[] = {
20762 "System.Data.SQLite.dll",
20768 while (dll_names[i]) {
20769 sqlite3_dll = LoadLibrary(dll_names[i]);
20776 while (dls_nametab[i].name) {
20777 void *func = 0, **loc;
20780 func = (
void *) GetProcAddress(sqlite3_dll, dls_nametab[i].name);
20783 func = dls_nametab[i].func;
20785 loc = (
void **) ((
char *) &dls_funcs + dls_nametab[i].offset);
20789 if (!sqlite3_dll) {
20790 char buf[MAXPATHLEN], msg[MAXPATHLEN];
20792 LoadString(hModule, IDS_DRVTITLE, buf,
sizeof (buf));
20793 LoadString(hModule, IDS_DLLERR, msg,
sizeof (msg));
20794 MessageBox(NULL, msg, buf,
20795 MB_ICONEXCLAMATION | MB_OK | MB_TASKMODAL |
20804 FreeLibrary(sqlite3_dll);
20813 static void *libsqlite3_so = 0;
20820 libsqlite3_so = dlopen(
"libsqlite3.so.0", RTLD_NOW | RTLD_GLOBAL);
20822 while (dls_nametab[i].name) {
20823 void *func = 0, **loc;
20825 if (libsqlite3_so) {
20826 func = dlsym(libsqlite3_so, dls_nametab[i].name);
20829 func = dls_nametab[i].func;
20831 loc = (
void **) ((
char *) &dls_funcs + dls_nametab[i].offset);
20835 if (!libsqlite3_so) {
20836 const char errmsg[] =
"SQLite3 shared library not found.\n";
20838 write(2, errmsg,
sizeof (errmsg) - 1);
20845 if (libsqlite3_so) {
20846 dlclose(libsqlite3_so);