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)
32static void dls_init(
void);
33static void dls_fini(
void);
39static 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)
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))
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
279static const char *
xdigits =
"0123456789ABCDEFabcdef";
284xmalloc_(
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];
307xrealloc_(
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];
344xfree_(
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);
376xstrdup_(
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
422static 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)
433static int strcasecmp_(
const char *a,
const char *b)
434 __attribute__((__unused__));
437static 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)
538extern void nvfs_init(
void);
539extern const char *nvfs_makevfs(
const char *);
569 ((c) && strchr(digit_chars, (c)) != NULL)
578 ((c) && strchr(space_chars, (c)) != NULL)
599static SQLRETURN
getrowdata(
STMT *s, SQLUSMALLINT col, SQLSMALLINT otype,
600 SQLPOINTER val, SQLINTEGER len,
SQLLEN *lenp,
603#if (defined(_WIN32) || defined(_WIN64)) && defined(WINTERFACE)
605static 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)
1065wmb_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);
1107wmb_to_utf_c(
char *str,
int len)
1109 if (len == SQL_NTS) {
1112 return wmb_to_utf(str, len);
1125utf_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);
1167wmb_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);
1198uc_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);
1279drvgpps(
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;
1407 if (nalloc < t->nalloc) {
1413 t->
rc = SQLITE_NOMEM;
1422 for (i = 0; i < ncol; i++) {
1423 p = (
char *) sqlite3_column_name(t->
stmt, i);
1425 char *q =
xmalloc(strlen(p) + 1);
1442 }
else if (t->
ncol != ncol) {
1443 t->
errmsg = sqlite3_mprintf(
"drvgettable() called with two or"
1444 " more incompatible queries");
1445 t->
rc = SQLITE_ERROR;
1449 if (rc == SQLITE_ROW) {
1450 for (i = 0; i < ncol; i++) {
1451 int coltype = sqlite3_column_type(t->
stmt, i);
1454 if (coltype == SQLITE_BLOB) {
1455 int k, nbytes = sqlite3_column_bytes(t->
stmt, i);
1457 unsigned const char *bp;
1459 bp = sqlite3_column_blob(t->
stmt, i);
1467 for (k = 0; k < nbytes; k++) {
1468 *qp++ =
xdigits[(bp[k] >> 4)];
1469 *qp++ =
xdigits[(bp[k] & 0xF)];
1474 }
else if (coltype == SQLITE_FLOAT) {
1475 struct lconv *lc = 0;
1476 double val = sqlite3_column_double(t->
stmt, i);
1484 snprintf(buffer,
sizeof (buffer),
"%.15g", val);
1486 if (lc && lc->decimal_point && lc->decimal_point[0] &&
1487 lc->decimal_point[0] !=
'.') {
1488 p = strchr(buffer, lc->decimal_point[0]);
1498 }
else if (coltype != SQLITE_NULL) {
1499 p =
xstrdup((
char *) sqlite3_column_text(t->
stmt, i));
1513 int *ncolp,
char **errp,
int nparam,
BINDPARM *p)
1516 int rc = SQLITE_OK, keep = sql == NULL;
1518 const char *sqlleft = 0;
1519 int nretry = 0, haveerr = 0;
1522 return SQLITE_ERROR;
1536 tres.
rc = SQLITE_OK;
1541 return SQLITE_NOMEM;
1546 if (tres.
stmt == NULL) {
1547 return SQLITE_NOMEM;
1551 while (sql && *sql && (rc == SQLITE_OK ||
1552 (rc == SQLITE_SCHEMA && (++nretry) < 2))) {
1556#if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
1558 rc = sqlite3_prepare_v2(d->
sqlite, sql, -1, &tres.
stmt, &sqlleft);
1561 rc = sqlite3_prepare(d->
sqlite, sql, -1, &tres.
stmt, &sqlleft);
1563 if (rc != SQLITE_OK) {
1566 sqlite3_finalize(tres.
stmt);
1577 if (sqlite3_bind_parameter_count(tres.
stmt) != nparam) {
1580 sqlite3_mprintf(
"%s",
"parameter marker count incorrect");
1587 ncol = sqlite3_column_count(tres.
stmt);
1593 rc = sqlite3_step(tres.
stmt);
1594 if (rc == SQLITE_ROW || rc == SQLITE_DONE) {
1600 if (rc != SQLITE_ROW) {
1603 rc = sqlite3_reset(tres.
stmt);
1607 rc = sqlite3_finalize(tres.
stmt);
1610 if (rc != SQLITE_SCHEMA) {
1613 while (sql &&
ISSPACE(*sql)) {
1617 if (rc == SQLITE_DONE) {
1629 sqlite3_reset(tres.
stmt);
1634 sqlite3_finalize(tres.
stmt);
1639 }
else if (rc != SQLITE_OK && rc == sqlite3_errcode(d->
sqlite) && errp) {
1640 *errp = sqlite3_mprintf(
"%s", sqlite3_errmsg(d->
sqlite));
1647 if (rc == SQLITE_ABORT) {
1652 sqlite3_free(*errp);
1656 sqlite3_free(tres.
errmsg);
1661 sqlite3_free(tres.
errmsg);
1662 if (rc != SQLITE_OK) {
1684#if defined(__GNUC__) && (__GNUC__ >= 2)
1685static void setstatd(
DBC *,
int,
char *,
char *, ...)
1686 __attribute__((format (printf, 3, 5)));
1703 count = vsnprintf((
char *) d->
logmsg, sizeof (d->
logmsg), msg, ap);
1724#if defined(__GNUC__) && (__GNUC__ >= 2)
1725static void setstat(
STMT *,
int,
char *,
char *, ...)
1726 __attribute__((format (printf, 3, 5)));
1743 count = vsnprintf((
char *) s->
logmsg, sizeof (s->
logmsg), msg, ap);
1767 if (
dbc == SQL_NULL_HDBC) {
1768 return SQL_INVALID_HANDLE;
1771 setstatd(d, -1,
"not supported",
"IM001");
1786 if (
stmt == SQL_NULL_HSTMT) {
1787 return SQL_INVALID_HANDLE;
1790 setstat(s, -1,
"not supported",
"IM001");
1802 if (x && ((
char **) x)[0]) {
1803 xfree(((
char **) x)[0]);
1804 ((
char **) x)[0] = NULL;
1817 setstat(s, -1,
"out of memory", (*s->
ov3) ?
"HY000" :
"S1000");
1830 setstat(s, -1,
"not connected", (*s->
ov3) ?
"HY000" :
"S1000");
1841#if defined(HAVE_LOCALECONV) || defined(_WIN32) || defined(_WIN64)
1846 struct lconv *lc = 0;
1847 char buf[128], *p, *end;
1851 if (lc && lc->decimal_point && lc->decimal_point[0] &&
1852 lc->decimal_point[0] !=
'.') {
1853 strncpy(buf, data,
sizeof (buf) - 1);
1854 buf[
sizeof (buf) - 1] =
'\0';
1855 p = strchr(buf,
'.');
1857 *p = lc->decimal_point[0];
1863 value = strtod(p, &end);
1864 end = (
char *) data + (end - p);
1873#define ln_strtod(A,B) strtod(A,B)
1886 int len = strlen(str);
1891 if ((str[0] ==
'\'' && str[end] ==
'\'') ||
1892 (str[0] ==
'"' && str[end] ==
'"') ||
1893 (str[0] ==
'[' && str[end] ==
']')) {
1894 memmove(str, str + 1, end - 1);
1895 str[end - 1] =
'\0';
1916 while ((q = strchr(p,
'_')) != NULL) {
1917 if (q == str || q[-1] !=
'\\') {
1923 while ((q = strchr(p,
'%')) != NULL) {
1924 if (q == str || q[-1] !=
'\\') {
1930 while ((q = strchr(p,
'\\')) != NULL) {
1931 if (q[1] ==
'\\' || q[1] ==
'_' || q[1] ==
'%') {
1932 memmove(q, q + 1, strlen(q));
1960 if (*str ==
'\0' && cp !=
'%') {
1964 while (*pat ==
'%') {
1972 if (cp !=
'_' && cp !=
'\\') {
1996 if (esc && cp ==
'\\' &&
1997 (pat[1] ==
'\\' || pat[1] ==
'%' || pat[1] ==
'_')) {
2026#if !defined(_WIN32) && !defined(_WIN64)
2028#ifdef HAVE_NANOSLEEP
2041#if defined(_WIN32) || defined(_WIN64)
2042 d->
t0 = GetTickCount();
2044 gettimeofday(&tv, NULL);
2045 d->
t0 = tv.tv_sec * 1000 + tv.tv_usec / 1000;
2048#if defined(_WIN32) || defined(_WIN64)
2049 t1 = GetTickCount();
2051 gettimeofday(&tv, NULL);
2052 t1 = tv.tv_sec * 1000 + tv.tv_usec / 1000;
2057#if defined(_WIN32) || defined(_WIN64)
2060#ifdef HAVE_NANOSLEEP
2062 ts.tv_nsec = 10000000;
2064 ret = nanosleep(&ts, &ts);
2065 if (ret < 0 && errno != EINTR) {
2075 select(0, NULL, NULL, NULL, &tv);
2098 int count = 0, step = 0,
max, rc = SQLITE_ERROR;
2100#if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME)
2108 while (step <
max) {
2110 rc = sqlite3_exec(x,
"PRAGMA empty_result_callbacks = on;",
2112 if (rc == SQLITE_OK) {
2114 "PRAGMA foreign_keys = on;" :
2115 "PRAGMA foreign_keys = off;",
2118 }
else if (step < 2) {
2120 "PRAGMA full_column_names = off;" :
2121 "PRAGMA full_column_names = on;",
2123 }
else if (step < 3) {
2125 "PRAGMA short_column_names = on;" :
2126 "PRAGMA short_column_names = off;",
2129 if (rc != SQLITE_OK) {
2130 if (rc != SQLITE_BUSY ||
2162 for (i = 1; i <= size; i++) {
2179mapsqltype(
const char *
typename,
int *nosign,
int ov3,
int nowchar,
2183 int testsign = 0, result;
2186 result = nowchar ? SQL_VARCHAR : SQL_WVARCHAR;
2188 result = SQL_VARCHAR;
2193 q = p =
xmalloc(strlen(
typename) + 1);
2197 strcpy(p,
typename);
2202 if (strncmp(p,
"inter", 5) == 0) {
2203 }
else if (strncmp(p,
"int", 3) == 0 ||
2204 strncmp(p,
"mediumint", 9) == 0) {
2206 result = SQL_INTEGER;
2207 }
else if (strncmp(p,
"numeric", 7) == 0) {
2208 result = SQL_DOUBLE;
2209 }
else if (strncmp(p,
"tinyint", 7) == 0) {
2211 result = SQL_TINYINT;
2212 }
else if (strncmp(p,
"smallint", 8) == 0) {
2214 result = SQL_SMALLINT;
2215 }
else if (strncmp(p,
"float", 5) == 0) {
2216 result = SQL_DOUBLE;
2217 }
else if (strncmp(p,
"double", 6) == 0 ||
2218 strncmp(p,
"real", 4) == 0) {
2219 result = SQL_DOUBLE;
2220 }
else if (strncmp(p,
"timestamp", 9) == 0) {
2221#ifdef SQL_TYPE_TIMESTAMP
2222 result = ov3 ? SQL_TYPE_TIMESTAMP : SQL_TIMESTAMP;
2224 result = SQL_TIMESTAMP;
2226 }
else if (strncmp(p,
"datetime", 8) == 0) {
2227#ifdef SQL_TYPE_TIMESTAMP
2228 result = ov3 ? SQL_TYPE_TIMESTAMP : SQL_TIMESTAMP;
2230 result = SQL_TIMESTAMP;
2232 }
else if (strncmp(p,
"time", 4) == 0) {
2234 result = ov3 ? SQL_TYPE_TIME : SQL_TIME;
2238 }
else if (strncmp(p,
"date", 4) == 0) {
2240 result = ov3 ? SQL_TYPE_DATE : SQL_DATE;
2244#ifdef SQL_LONGVARCHAR
2245 }
else if (strncmp(p,
"text", 4) == 0 ||
2246 strncmp(p,
"memo", 4) == 0 ||
2247 strncmp(p,
"longvarchar", 11) == 0) {
2249 result = nowchar ? SQL_LONGVARCHAR : SQL_WLONGVARCHAR;
2251 result = SQL_LONGVARCHAR;
2254 }
else if (strncmp(p,
"wtext", 5) == 0 ||
2255 strncmp(p,
"wvarchar", 8) == 0 ||
2256 strncmp(p,
"longwvarchar", 12) == 0) {
2257 result = SQL_WLONGVARCHAR;
2261 }
else if (strncmp(p,
"bool", 4) == 0 ||
2262 strncmp(p,
"bit", 3) == 0) {
2266 }
else if (strncmp(p,
"bigint", 6) == 0) {
2268 result = SQL_BIGINT;
2270 }
else if (strncmp(p,
"blob", 4) == 0) {
2271 result = SQL_BINARY;
2272 }
else if (strncmp(p,
"varbinary", 9) == 0) {
2273 result = SQL_VARBINARY;
2274 }
else if (strncmp(p,
"longvarbinary", 13) == 0) {
2275 result = SQL_LONGVARBINARY;
2279 *nosign = strstr(p,
"unsigned") != NULL;
2285 if (dobigint && result == SQL_INTEGER) {
2286 result = SQL_BIGINT;
2303getmd(
const char *
typename,
int sqltype,
int *mp,
int *dp)
2308 case SQL_INTEGER: m = 10; d = 9;
break;
2309 case SQL_TINYINT: m = 4; d = 3;
break;
2310 case SQL_SMALLINT: m = 6; d = 5;
break;
2311 case SQL_FLOAT: m = 25; d = 24;
break;
2312 case SQL_DOUBLE: m = 54; d = 53;
break;
2313 case SQL_VARCHAR: m = 255; d = 0;
break;
2316 case SQL_WVARCHAR: m = 255; d = 0;
break;
2322 case SQL_DATE: m = 10; d = 0;
break;
2326 case SQL_TIME: m = 8; d = 0;
break;
2327#ifdef SQL_TYPE_TIMESTAMP
2328 case SQL_TYPE_TIMESTAMP:
2330 case SQL_TIMESTAMP: m = 32; d = 3;
break;
2331#ifdef SQL_LONGVARCHAR
2332 case SQL_LONGVARCHAR : m = 65536; d = 0;
break;
2335#ifdef SQL_WLONGVARCHAR
2336 case SQL_WLONGVARCHAR: m = 65536; d = 0;
break;
2340 case SQL_VARBINARY: m = 255; d = 0;
break;
2341 case SQL_LONGVARBINARY: m = 65536; d = 0;
break;
2343 case SQL_BIGINT: m = 20; d = 19;
break;
2346 case SQL_BIT: m = 1; d = 1;
break;
2349 if (m &&
typename) {
2353 if (sscanf(
typename,
"%*[^(](%d,%d %1[)]", &mm, &dd, clbr) == 3) {
2356 }
else if (sscanf(
typename,
"%*[^(](%d %1[)]", &mm, clbr) == 2) {
2357 if (sqltype == SQL_TIMESTAMP) {
2360#ifdef SQL_TYPE_TIMESTAMP
2361 else if (sqltype == SQL_TYPE_TIMESTAMP) {
2390 if (type == SQL_C_DEFAULT) {
2393 type = (nosign > 0) ? SQL_C_ULONG : SQL_C_LONG;
2396 type = (nosign > 0) ? SQL_C_UTINYINT : SQL_C_TINYINT;
2399 type = (nosign > 0) ? SQL_C_USHORT : SQL_C_SHORT;
2405 type = SQL_C_DOUBLE;
2408 type = SQL_C_TIMESTAMP;
2416#ifdef SQL_C_TYPE_TIMESTAMP
2417 case SQL_TYPE_TIMESTAMP:
2418 type = SQL_C_TYPE_TIMESTAMP;
2421#ifdef SQL_C_TYPE_TIME
2423 type = SQL_C_TYPE_TIME;
2426#ifdef SQL_C_TYPE_DATE
2428 type = SQL_C_TYPE_DATE;
2434#ifdef SQL_WLONGVARCHAR
2435 case SQL_WLONGVARCHAR:
2437 type = nowchar ? SQL_C_CHAR : SQL_C_WCHAR;
2442 case SQL_LONGVARBINARY:
2443 type = SQL_C_BINARY;
2457 type = nowchar ? SQL_C_CHAR : SQL_C_WCHAR;
2478 while (*sql &&
ISSPACE(*sql)) {
2481 if (*sql && *sql !=
';') {
2483 static const struct {
2505 if (size >= ddlstr[i].len &&
2506 strncasecmp(sql, ddlstr[i].str, ddlstr[i].len) == 0) {
2527fixupsql(
char *sql,
int sqlLen,
int cte,
int *nparam,
int *isselect,
2530 char *q = sql, *qz = NULL, *p, *inq = NULL, *out;
2531 int np = 0, isddl = -1, size;
2536 if (sqlLen != SQL_NTS) {
2541 memcpy(q, sql, sqlLen);
2545 size = strlen(sql) * 4;
2547 size +=
sizeof (
char *) - 1;
2548 size &= ~(
sizeof (
char *) - 1);
2581 if (!inq && q[1] ==
'-') {
2607 }
while (*qq &&
ISSPACE(*qq));
2608 if (*qq && *qq !=
';') {
2611 *errmsg =
"only one SQL statement allowed";
2626 int ojfn = 0, brc = 0;
2627 char *inq2 = NULL, *end = q + 1, *start;
2629 while (*end &&
ISSPACE(*end)) {
2632 if (*end !=
'd' && *end !=
'D' &&
2633 *end !=
't' && *end !=
'T') {
2638 if (inq2 && *end == *inq2) {
2640 }
else if (inq2 == NULL && *end ==
'{') {
2641 char *nerr = 0, *nsql;
2643 nsql =
fixupsql(end, SQL_NTS, cte, 0, 0, &nerr);
2644 if (nsql && !nerr) {
2650 }
else if (inq2 == NULL && *end ==
'}') {
2654 }
else if (inq2 == NULL && (*end ==
'\'' || *end ==
'"')) {
2656 }
else if (inq2 == NULL && *end ==
'?') {
2662 char *end2 = end - 1;
2665 while (start < end) {
2671 while (start < end) {
2678 while (start < end2 && *start !=
'\'') {
2681 while (end2 > start && *end2 !=
'\'') {
2684 if (*start ==
'\'' && *end2 ==
'\'') {
2685 while (start <= end2) {
2719 if (!incom && p[1] ==
'-') {
2729 if (incom > 0 && p[-1] ==
'*') {
2733 }
else if (!incom && p[1] ==
'*') {
2745 (strncasecmp(p,
"select", 6) == 0 ||
2746 strncasecmp(p,
"pragma", 6) == 0)) {
2748 }
else if (cte && size >= 4 && strncasecmp(p,
"with", 4) == 0) {
2750 }
else if (size >= 7 && strncasecmp(p,
"explain", 7) == 0) {
2768 char *q = sql, *inq = NULL;
2792 if (!inq && q[1] ==
'-') {
2802 if (!inq &&
ISSPACE(*q) && q[1]) {
2803 if (strncasecmp(q + 1,
"ilike", 5) == 0) {
2804 if ((q[2] !=
'\0') && (q[3] !=
'\0') &&
2805 (q[4] !=
'\0') && (q[5] !=
'\0') &&
2806 ((q[6] ==
'\0') ||
ISSPACE(q[6]))) {
2808 memmove(q, q + 1, strlen(q));
2833 for (i = 0; i < ncols; i++) {
2834 if (strcmp(cols[i], name) == 0) {
2862#ifndef FULL_METADATA
2863 int pk, nn, t, r, nrows, ncols;
2864 char **rowp, *flagp, flags[128];
2875 for (i = 1; table[0] && i < s->
dcols; i++) {
2880 if (i >= s->
dcols) {
2881 for (i = 0; i < s->
dcols; i++) {
2885 }
else if (s->
dcols == 1) {
2889 for (i = 0; i < s->
dcols; i++) {
2895#ifdef SQL_LONGVARCHAR
2902#ifdef SQL_WLONGVARCHAR
2914#ifndef FULL_METADATA
2917 if (flagp == NULL) {
2923 memset(flagp, 0,
sizeof (flags[0]) * s->
dcols);
2924 for (i = 0; i < s->
dcols; i++) {
2928 for (i = 0; i < s->
dcols; i++) {
2929 int ret, lastpk = -1, autoinccount = 0;
2938 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", s->
dyncols[i].
table);
2943 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, NULL);
2945 if (ret != SQLITE_OK) {
2948 k =
findcol(rowp, ncols,
"name");
2949 t =
findcol(rowp, ncols,
"type");
2950 pk =
findcol(rowp, ncols,
"pk");
2951 nn =
findcol(rowp, ncols,
"notnull");
2952 if (k < 0 || t < 0) {
2955 for (r = 1; r <= nrows; r++) {
2958 for (m = i; m < s->
dcols; m++) {
2962 char *dotp = strchr(colname,
'.');
2969 strcmp(colname, rowp[r * ncols + k]) == 0 &&
2971 char *
typename = rowp[r * ncols + t];
2982#ifdef SQL_LONGVARCHAR
2989#ifdef SQL_WLONGVARCHAR
3000 if (pk >= 0 && strcmp(rowp[r * ncols + pk],
"1") == 0) {
3002 if (++autoinccount > 1) {
3009 if (strlen(
typename) == 7 &&
3010 strncasecmp(
typename,
"integer", 7) == 0) {
3017 if (nn >= 0 && rowp[r * ncols + nn][0] !=
'0') {
3024 sqlite3_free_table(rowp);
3026 for (i = k = 0; i < s->
dcols; i++) {
3027 if (flagp[i] == 0) {
3032 }
else if (flagp[i] != k) {
3040 for (i = 0; i < s->
dcols; i++) {
3047 if (flagp != flags) {
3051 for (i = 1, k = 0; i < s->
dcols; i++) {
3059 for (i = 0; i < s->
dcols; i++) {
3081 int z, a, b, c, d, e, x1;
3084 ijd = jd * 86400000.0 + 0.5;
3085 z = (int) ((ijd + 43200000) / 86400000);
3086 a = (int) ((z - 1867216.25) / 36524.25);
3087 a = z + 1 + a - (a / 4);
3089 c = (int) ((b - 122.1) / 365.25);
3090 d = (36525 * c) / 100;
3091 e = (int) ((b - d) / 30.6001);
3092 x1 = (int) (30.6001 * e);
3093 ds->day = b - d - x1;
3094 ds->month = (e < 14) ? (e - 1) : (e - 13);
3095 ds->year = (ds->month > 2) ? (c - 4716) : (c - 4715);
3113 ijd = jd * 86400000.0 + 0.5;
3114 s = (int)((ijd + 43200000) % 86400000);
3117 *fp = (s % 1000) * 1000000;
3121 ts->hour = s / 3600;
3122 s -= ts->hour * 3600;
3123 ts->minute = s / 60;
3124 ds += s - ts->minute *60;
3125 ts->second = (int) ds;
3138 static const int mdays[] = {
3139 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
3146 mday = mdays[(month - 1) % 12];
3147 if (mday == 28 && year % 4 == 0 &&
3148 (!(year % 100 == 0) || year % 400 == 0)) {
3174 char *p, *q, sepc =
'\0';
3176 ds->year = ds->month = ds->day = 0;
3178 p = strchr(str,
'.');
3202 strncpy(buf, p + 0, 4); buf[4] =
'\0';
3203 ds->year = strtol(buf, NULL, 10);
3204 strncpy(buf, p + 4, 2); buf[2] =
'\0';
3205 ds->month = strtol(buf, NULL, 10);
3206 strncpy(buf, p + 6, 2); buf[2] =
'\0';
3207 ds->day = strtol(buf, NULL, 10);
3215 n = strtol(p, &q, 10);
3227 if (*q ==
'-' || *q ==
'/' || *q ==
'\0' || i == 2) {
3229 case 0: ds->year = n;
break;
3230 case 1: ds->month = n;
break;
3231 case 2: ds->day = n;
break;
3248 ds->month < 1 || ds->month > 12 ||
3249 ds->day < 1 || ds->day >
getmdays(ds->year, ds->month)) {
3260 if (ds->month >= 1 && ds->month <= 12 &&
3261 (ds->day >= 1 || ds->day <=
getmdays(ds->year, ds->month))) {
3287 int i, err = 0, ampm = -1;
3291 ts->hour = ts->minute = ts->second = 0;
3293 p = strchr(str,
'.');
3317 strncpy(buf, p + 0, 2); buf[2] =
'\0';
3318 ts->hour = strtol(buf, NULL, 10);
3319 strncpy(buf, p + 2, 2); buf[2] =
'\0';
3320 ts->minute = strtol(buf, NULL, 10);
3321 strncpy(buf, p + 4, 2); buf[2] =
'\0';
3322 ts->second = strtol(buf, NULL, 10);
3330 n = strtol(p, &q, 10);
3339 if (*q ==
':' || *q ==
'\0' || i == 2) {
3341 case 0: ts->hour = n;
break;
3342 case 1: ts->minute = n;
break;
3343 case 2: ts->second = n;
break;
3359 if ((p[0] ==
'p' || p[0] ==
'P') &&
3360 (p[1] ==
'm' || p[1] ==
'M')) {
3362 }
else if ((p[0] ==
'a' || p[0] ==
'A') &&
3363 (p[1] ==
'm' || p[1] ==
'M')) {
3369 if (ts->hour < 12) {
3372 }
else if (ampm == 0) {
3373 if (ts->hour == 12) {
3380 if (err || ts->hour > 23 || ts->minute > 59 || ts->second > 59) {
3408 int i, m, n, err = 0, ampm = -1;
3410 char *p, *q, in =
'\0', sepc =
'\0';
3412 tss->year = tss->month = tss->day = 0;
3413 tss->hour = tss->minute = tss->second = 0;
3416 p = strchr(str,
'.');
3418 q = strchr(str,
'-');
3423 q = strchr(str,
'/');
3425 q = strchr(str,
':');
3438 tss->year = ds.year;
3439 tss->month = ds.month;
3441 tss->hour = ts.hour;
3442 tss->minute = ts.minute;
3443 tss->second = ts.second;
3463 strncpy(buf, p + 0, 4); buf[4] =
'\0';
3464 tss->year = strtol(buf, NULL, 10);
3465 strncpy(buf, p + 4, 2); buf[2] =
'\0';
3466 tss->month = strtol(buf, NULL, 10);
3467 strncpy(buf, p + 6, 2); buf[2] =
'\0';
3468 tss->day = strtol(buf, NULL, 10);
3469 strncpy(buf, p + 8, 2); buf[2] =
'\0';
3470 tss->hour = strtol(buf, NULL, 10);
3471 strncpy(buf, p + 10, 2); buf[2] =
'\0';
3472 tss->minute = strtol(buf, NULL, 10);
3473 strncpy(buf, p + 12, 2); buf[2] =
'\0';
3474 tss->second = strtol(buf, NULL, 10);
3477 strncpy(buf, p + 14, m);
3483 tss->fraction = strtol(buf, NULL, 10);
3489 while ((m & 7) != 7) {
3491 n = strtol(p, &q, 10);
3531 case 0: tss->year = n;
break;
3532 case 1: tss->month = n;
break;
3533 case 2: tss->day = n;
break;
3548 case 0: tss->hour = n;
break;
3549 case 1: tss->minute = n;
break;
3550 case 2: tss->second = n;
break;
3563 (void) strtol(q + 1, &e, 10);
3564 if (e && *e ==
'-') {
3580 if (p[0] ==
'+' || p[0] ==
'-') {
3596 if ((q[0] ==
'a' || q[0] ==
'A') &&
3597 (q[1] ==
'm' || q[1] ==
'M')) {
3600 }
else if ((q[0] ==
'p' || q[0] ==
'P') &&
3601 (q[1] ==
'm' || q[1] ==
'M')) {
3610 if ((m & 7) > 1 && (m & 8)) {
3616 if (*q !=
'+' && *q !=
'-') {
3619 sign = (*q ==
'+') ? -1 : 1;
3621 n = strtol(p, &q, 10);
3622 if (!q || *q++ !=
':' || !
ISDIGIT(*q)) {
3627 nn = strtol(p, &q, 10);
3628 tss->minute += nn * sign;
3629 if ((SQLSMALLINT) tss->minute < 0) {
3632 }
else if (tss->minute >= 60) {
3636 tss->hour += n * sign;
3637 if ((SQLSMALLINT) tss->hour < 0) {
3640 }
else if (tss->hour >= 24) {
3644 if ((
short) tss->day < 1 || tss->day >= 28) {
3645 int mday, pday, pmon;
3647 mday =
getmdays(tss->year, tss->month);
3648 pmon = tss->month - 1;
3653 if ((SQLSMALLINT) tss->day < 1) {
3656 }
else if (tss->day > mday) {
3660 if ((SQLSMALLINT) tss->month < 1) {
3663 }
else if (tss->month > 12) {
3672 (tss->month < 1 || tss->month > 12 ||
3673 tss->day < 1 || tss->day >
getmdays(tss->year, tss->month))) {
3687 if (!err && (m & 1) == 0) {
3692 tss->year = t.wYear;
3693 tss->month = t.wMonth;
3699 gettimeofday(&tv, NULL);
3700 tm = *localtime(&tv.tv_sec);
3701 tss->year = tm.tm_year + 1900;
3702 tss->month = tm.tm_mon + 1;
3703 tss->day = tm.tm_mday;
3707 if (tss->fraction < 0) {
3712 tss->month < 1 || tss->month > 12 ||
3713 tss->day < 1 || tss->day >
getmdays(tss->year, tss->month) ||
3714 tss->hour > 23 || tss->minute > 59 || tss->second > 59) {
3719 if (tss->hour < 12) {
3722 }
else if (ampm == 0) {
3723 if (tss->hour == 12) {
3728 return ((m & 7) < 1) ? -1 : 0;
3741 return string[0] && strchr(
"Yy123456789Tt",
string[0]) != NULL;
3757 DBC *d = (
DBC *) sqlite3_user_data(ctx);
3762 if (sqlite3_value_type(args[0]) != SQLITE_NULL) {
3763 filename = (
char *) sqlite3_value_text(args[0]);
3768 char *wname = utf_to_wmb(filename, -1);
3771 FILE *f = fopen(filename,
"r");
3778 f = fopen(wname,
"rb");
3780 sqlite3_result_error(ctx,
"out of memory", -1);
3786 if (fseek(f, 0, SEEK_END) == 0) {
3788 if (fseek(f, 0, SEEK_SET) == 0) {
3789 p = sqlite3_malloc(n);
3791 nn = fread(p, 1, n, f);
3793 sqlite3_result_error(ctx,
"read error", -1);
3796 sqlite3_result_blob(ctx, p, n, sqlite3_free);
3799 sqlite3_result_error(ctx,
"out of memory", -1);
3802 sqlite3_result_error(ctx,
"seek error", -1);
3805 sqlite3_result_error(ctx,
"seek error", -1);
3809 sqlite3_result_error(ctx,
"cannot open file", -1);
3812 sqlite3_result_error(ctx,
"no filename given", -1);
3827 DBC *d = (
DBC *) sqlite3_user_data(ctx);
3834 p = (
char *) sqlite3_value_blob(args[0]);
3835 n = sqlite3_value_bytes(args[0]);
3838 if (sqlite3_value_type(args[1]) != SQLITE_NULL) {
3839 filename = (
char *) sqlite3_value_text(args[1]);
3845 char *wname = utf_to_wmb(filename, -1);
3848 FILE *f = fopen(filename,
"w");
3854 f = fopen(wname,
"wb");
3856 sqlite3_result_error(ctx,
"out of memory", -1);
3862 nn = fwrite(p, 1, n, f);
3865 sqlite3_result_error(ctx,
"write error", -1);
3867 sqlite3_result_int(ctx, nn);
3870 sqlite3_result_error(ctx,
"cannot open file", -1);
3873 sqlite3_result_error(ctx,
"no filename given", -1);
3876 sqlite3_result_null(ctx);
3888#if defined(HAVE_SQLITE3PROFILE) && (HAVE_SQLITE3PROFILE)
3889dbtrace(
void *arg,
const char *msg, sqlite_uint64 et)
3891dbtrace(
void *arg,
const char *msg)
3896 if (msg && d->
trace) {
3897 int len = strlen(msg);
3898#if defined(HAVE_SQLITE3PROFILE) && (HAVE_SQLITE3PROFILE)
3905 if (msg[len - 1] !=
';') {
3908 fprintf(d->
trace,
"%s%s", msg, end);
3909#if defined(HAVE_SQLITE3PROFILE) && (HAVE_SQLITE3PROFILE)
3910 s = et / 1000000000LL;
3911 f = et % 1000000000LL;
3912 fprintf(d->
trace,
"-- took %lu.%09lu seconds\n", s, f);
3929 if (fn && d->
trace) {
3931 fprintf(d->
trace,
"-- %s: %s\n", fn, sql);
3933 fprintf(d->
trace,
"-- %s\n", fn);
3949 if (rc != SQLITE_OK && d->
trace) {
3950 fprintf(d->
trace,
"-- SQLITE ERROR CODE %d", rc);
3951 fprintf(d->
trace, err ?
": %s\n" :
"\n", err);
3972 char *spflag,
char *ntflag,
char *jmode,
char *busy)
3975 int rc, tmp, busyto = 100000;
3976#if defined(HAVE_SQLITE3VFS) && (HAVE_SQLITE3VFS)
3977 int flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
3979 const char *vfs_name = NULL;
3984 fprintf(d->
trace,
"-- sqlite3_close (deferred): '%s'\n",
3988#if defined(HAVE_SQLITE3CLOSEV2) && (HAVE_SQLITE3CLOSEV2)
3989 sqlite3_close_v2(d->
sqlite);
3991 sqlite3_close(d->
sqlite);
3995#if defined(HAVE_SQLITE3VFS) && (HAVE_SQLITE3VFS)
3997 flags &= ~ SQLITE_OPEN_CREATE;
3999#if defined(_WIN32) || defined(_WIN64)
4001 char expname[SQL_MAX_MESSAGE_LENGTH * 2];
4004 rc = ExpandEnvironmentStrings(name, expname,
sizeof (expname));
4005 if (rc <=
sizeof (expname)) {
4006 uname = wmb_to_utf(expname, rc - 1);
4008 uname = wmb_to_utf(name, -1);
4012 setstatd(d, rc,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
4017#if defined(ENABLE_NVFS) && (ENABLE_NVFS)
4018 vfs_name = nvfs_makevfs(uname);
4020#ifdef SQLITE_OPEN_URI
4021 flags |= SQLITE_OPEN_URI;
4023 rc = sqlite3_open_v2(uname, &d->
sqlite, flags, vfs_name);
4024#if defined(WINTERFACE) || defined(_WIN32) || defined(_WIN64)
4025 if (uname != name) {
4030#if defined(_WIN32) || defined(_WIN64)
4035 cname = utf_to_wmb(name, -1);
4037 if (GetFileAttributesA(cname ? cname : name) ==
4038 INVALID_FILE_ATTRIBUTES) {
4040 rc = SQLITE_CANTOPEN;
4041 setstatd(d, rc,
"cannot open database",
4042 (*d->
ov3) ?
"HY000" :
"S1000");
4048 if (d->
nocreat && access(name, 004) < 0) {
4049 rc = SQLITE_CANTOPEN;
4050 setstatd(d, rc,
"cannot open database", (*d->
ov3) ?
"HY000" :
"S1000");
4054#if defined(_WIN32) || defined(_WIN64)
4056 WCHAR *wname = wmb_to_uc(name, -1);
4060 setstatd(d, rc,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
4063 rc = sqlite3_open16(wname, &d->
sqlite);
4067 rc = sqlite3_open(name, &d->
sqlite);
4069 if (rc != SQLITE_OK) {
4071 setstatd(d, rc,
"connect failed", (*d->
ov3) ?
"HY000" :
"S1000");
4073 sqlite3_close(d->
sqlite);
4078#if defined(SQLITE_DYNLOAD) || defined(SQLITE_HAS_CODEC)
4086#if defined(HAVE_SQLITE3PROFILE) && (HAVE_SQLITE3PROFILE)
4095 SQL_CURSOR_FORWARD_ONLY : SQL_CURSOR_STATIC;
4096 tmp = strtol(busy, &endp, 0);
4097 if (endp && *endp ==
'\0' && endp != busy) {
4100 if (busyto < 1 || busyto > 1000000) {
4110 fprintf(d->
trace,
"-- sqlite3_close: '%s'\n",
4114 sqlite3_close(d->
sqlite);
4118 if (!spflag || spflag[0] ==
'\0') {
4121 if (spflag[0] !=
'\0') {
4124 sprintf(syncp,
"PRAGMA synchronous = %8.8s;", spflag);
4125 sqlite3_exec(d->
sqlite, syncp, NULL, NULL, NULL);
4127 if (jmode[0] !=
'\0') {
4130 sprintf(jourp,
"PRAGMA journal_mode = %16.16s;", jmode);
4131 sqlite3_exec(d->
sqlite, jourp, NULL, NULL, NULL);
4134 fprintf(d->
trace,
"-- sqlite3_open: '%s'\n", d->
dbname);
4137#if defined(_WIN32) || defined(_WIN64)
4139 char pname[MAX_PATH];
4140 HANDLE h = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
4141 FALSE, GetCurrentProcessId());
4145 HMODULE m = NULL, l = LoadLibrary(
"psapi.dll");
4147 typedef BOOL (WINAPI *epmfunc)(HANDLE, HMODULE *, DWORD, LPDWORD);
4148 typedef BOOL (WINAPI *gmbfunc)(HANDLE, HMODULE, LPSTR, DWORD);
4153 epm = (epmfunc) GetProcAddress(l,
"EnumProcessModules");
4154 gmb = (gmbfunc) GetProcAddress(l,
"GetModuleBaseNameA");
4155 if (epm && gmb && epm(h, &m,
sizeof (m), &need)) {
4156 gmb(h, m, pname,
sizeof (pname));
4162 d->xcelqrx = strncasecmp(pname,
"EXCEL", 5) == 0 ||
4163 strncasecmp(pname,
"MSQRY", 5) == 0;
4164 if (d->
trace && d->xcelqrx) {
4166 fprintf(d->
trace,
"-- enabled EXCEL quirks\n");
4171 sqlite3_create_function(d->
sqlite,
"blob_import", 1, SQLITE_UTF8,
4173 sqlite3_create_function(d->
sqlite,
"blob_export", 2, SQLITE_UTF8,
4187#if defined(HAVE_SQLITE3LOADEXTENSION) && (HAVE_SQLITE3LOADEXTENSION)
4189 char path[SQL_MAX_MESSAGE_LENGTH];
4195 sqlite3_enable_load_extension(d->
sqlite, 1);
4196#if defined(_WIN32) || defined(_WIN64)
4197 GetModuleFileName(hModule, path,
sizeof (path));
4198 p = strrchr(path,
'\\');
4199 plen = p ? ((p + 1) - path) : 0;
4202 p = strchr(exts,
',');
4204 strncpy(path + plen, exts, p - exts);
4205 path[plen + (p - exts)] =
'\0';
4207 strcpy(path + plen, exts);
4210 char *errmsg = NULL;
4212#if defined(_WIN32) || defined(_WIN64)
4218 ((q[1] ==
':' && (q[2] ==
'\\' || q[2] ==
'/')) ||
4219 q[0] ==
'\\' || q[0] ==
'/' || q[0] ==
'.'))) {
4223 for (i = 0; q[i] !=
'\0'; i++) {
4228 rc = sqlite3_load_extension(d->
sqlite, q, 0, &errmsg);
4230 rc = sqlite3_load_extension(d->
sqlite, path, 0, &errmsg);
4232 if (rc != SQLITE_OK) {
4233#if defined(_WIN32) || defined(_WIN64)
4234 char buf[512], msg[512];
4236 LoadString(hModule, IDS_EXTERR, buf,
sizeof (buf));
4237 wsprintf(msg, buf, q, errmsg ?
4238 errmsg :
"no error info available");
4239 LoadString(hModule, IDS_EXTTITLE, buf,
sizeof (buf));
4240 MessageBox(NULL, msg, buf,
4241 MB_ICONEXCLAMATION | MB_OK | MB_TASKMODAL |
4244 fprintf(stderr,
"extension '%s' did not load%s%s\n",
4245 path, errmsg ?
": " :
"", errmsg ? errmsg :
"");
4266 char as[SQL_MAX_MESSAGE_LENGTH];
4272 p = strchr(attas,
',');
4274 strncpy(as, attas, p - attas);
4275 as[p - attas] =
'\0';
4282 sql = sqlite3_mprintf(
"ATTACH %Q AS %s", d->
dbname, as);
4284 sqlite3_exec(d->
sqlite, sql, NULL, NULL, NULL);
4306 char *
typename = (
char *) sqlite3_column_decltype(s3stmt, col);
4311 int coltype = sqlite3_column_type(s3stmt, col);
4313 if (guessed_types) {
4317 sprintf(guess,
" (guessed from %d)", coltype);
4320 case SQLITE_INTEGER:
typename =
"integer";
break;
4321 case SQLITE_FLOAT:
typename =
"double";
break;
4323 case SQLITE_TEXT:
typename =
"varchar";
break;
4324 case SQLITE_BLOB:
typename =
"blob";
break;
4326 case SQLITE_NULL:
typename =
"null";
break;
4331 fprintf(d->
trace,
"-- column %d type%s: '%s'\n", col + 1,
4349s3stmt_addmeta(sqlite3_stmt *s3stmt,
int col,
DBC *d,
COL *ci)
4351 int nn = 0, pk = 0, ai = 0;
4352 const char *dn = NULL, *tn = NULL, *cn = NULL, *dummy[4];
4354 dn = sqlite3_column_database_name(s3stmt, col);
4355 tn = sqlite3_column_table_name(s3stmt, col);
4356 cn = sqlite3_column_origin_name(s3stmt, col);
4357 dummy[0] = dummy[1] = 0;
4359 sqlite3_table_column_metadata(d->
sqlite, dn, tn, cn,
4363 ci->
autoinc = ai ? SQL_TRUE: SQL_FALSE;
4364 ci->
notnull = nn ? SQL_NO_NULLS : SQL_NULLABLE;
4365 ci->
ispk = pk ? 1 : 0;
4367 fprintf(d->
trace,
"-- column %d %s\n",
4368 col + 1, nn ?
"notnull" :
"nullable");
4370 fprintf(d->
trace,
"-- column %d autoincrement\n", col + 1);
4375 if (ci->
ispk && tn) {
4377 dummy[2] = dummy[3] = 0;
4379 sqlite3_table_column_metadata(d->
sqlite, dn, tn,
"rowid",
4380 dummy + 2, dummy + 3,
4382 if (pk && dummy[0] && dummy[0] == dummy[2]) {
4401 const char *errp = NULL;
4405 setstat(s, -1,
"stale statement", (*s->
ov3) ?
"HY000" :
"S1000");
4408 rc = sqlite3_step(s->
s3stmt);
4409 if (rc == SQLITE_ROW || rc == SQLITE_DONE) {
4411 ncols = sqlite3_column_count(s->
s3stmt);
4416 const char *colname, *
typename;
4417#if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME)
4420#if defined(HAVE_SQLITE3COLUMNDATABASENAME) && (HAVE_SQLITE3COLUMNDATABASENAME)
4424 for (i = size = 0; i < ncols; i++) {
4425 colname = sqlite3_column_name(s->
s3stmt, i);
4426 size += 3 + 3 * strlen(colname);
4428#if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME)
4429 tblname = (
char *) size;
4430 for (i = 0; i < ncols; i++) {
4431 p = (
char *) sqlite3_column_table_name(s->
s3stmt, i);
4432 size += 2 + (p ? strlen(p) : 0);
4435#if defined(HAVE_SQLITE3COLUMNDATABASENAME) && (HAVE_SQLITE3COLUMNDATABASENAME)
4436 dbname = (
char *) size;
4437 for (i = 0; i < ncols; i++) {
4438 p = (
char *) sqlite3_column_database_name(s->
s3stmt, i);
4439 size += 2 + (p ? strlen(p) : 0);
4442 dyncols =
xmalloc(ncols *
sizeof (
COL) + size);
4447 sqlite3_finalize(s->
s3stmt);
4452 p = (
char *) (dyncols + ncols);
4453#if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME)
4456#if defined(HAVE_SQLITE3COLUMNDATABASENAME) && (HAVE_SQLITE3COLUMNDATABASENAME)
4459 for (i = 0; i < ncols; i++) {
4462 colname = sqlite3_column_name(s->
s3stmt, i);
4464 fprintf(d->
trace,
"-- column %d name: '%s'\n",
4468#if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME)
4469 q = (
char *) sqlite3_column_table_name(s->
s3stmt, i);
4470 strcpy(tblname, q ? q :
"");
4472 fprintf(d->
trace,
"-- table %d name: '%s'\n",
4476 dyncols[i].
table = tblname;
4477 tblname += strlen(tblname) + 1;
4479#if defined(HAVE_SQLITE3COLUMNDATABASENAME) && (HAVE_SQLITE3COLUMNDATABASENAME)
4480 q = (
char *) sqlite3_column_database_name(s->
s3stmt, i);
4481 strcpy(dbname, q ? q :
"");
4483 fprintf(d->
trace,
"-- database %d name: '%s'\n",
4487 dyncols[i].
db = dbname;
4488 dbname += strlen(dbname) + 1;
4490 dyncols[i].
db = ((
DBC *) (s->
dbc))->dbname;
4494 dyncols[i].
label = p;
4496 q = strchr(colname,
'.');
4498 char *q2 = strchr(q + 1,
'.');
4506#if !defined(HAVE_SQLITE3COLUMNTABLENAME) || !(HAVE_SQLITE3COLUMNTABLENAME)
4507 dyncols[i].
table = p;
4509 strncpy(p, colname, q - colname);
4510 p[q - colname] =
'\0';
4516#if !defined(HAVE_SQLITE3COLUMNTABLENAME) || !(HAVE_SQLITE3COLUMNTABLENAME)
4517 dyncols[i].
table =
"";
4526#ifdef SQL_LONGVARCHAR
4527 dyncols[i].
type = SQL_LONGVARCHAR;
4528 dyncols[i].
size = 65535;
4530 dyncols[i].
type = SQL_VARCHAR;
4531 dyncols[i].
size = 255;
4533 dyncols[i].
index = i;
4534 dyncols[i].
scale = 0;
4535 dyncols[i].
prec = 0;
4537 dyncols[i].
autoinc = SQL_FALSE;
4538 dyncols[i].
notnull = SQL_NULLABLE;
4539 dyncols[i].
ispk = -1;
4542 s3stmt_addmeta(s->
s3stmt, i, d, &dyncols[i]);
4556 if (rc == SQLITE_DONE) {
4560 sqlite3_finalize(s->
s3stmt);
4565 rowd =
xmalloc((1 + 2 * ncols) *
sizeof (
char *));
4567 const unsigned char *value;
4569 rowd[0] = (
char *) ((
PTRDIFF_T) (ncols * 2));
4571 for (i = 0; i < ncols; i++) {
4572 int coltype = sqlite3_column_type(s->
s3stmt, i);
4574 rowd[i] = rowd[i + ncols] = NULL;
4575 if (coltype == SQLITE_BLOB) {
4576 int k, nbytes = sqlite3_column_bytes(s->
s3stmt, i);
4578 unsigned const char *bp;
4580 bp = sqlite3_column_blob(s->
s3stmt, i);
4583 rowd[i + ncols] = qp;
4586 for (k = 0; k < nbytes; k++) {
4587 *qp++ =
xdigits[(bp[k] >> 4)];
4588 *qp++ =
xdigits[(bp[k] & 0xF)];
4594 }
else if (coltype == SQLITE_FLOAT) {
4595 struct lconv *lc = 0;
4596 double d = sqlite3_column_double(s->
s3stmt, i);
4597 char *p, buffer[128];
4604 snprintf(buffer,
sizeof (buffer),
"%.15g", d);
4606 if (lc && lc->decimal_point && lc->decimal_point[0] &&
4607 lc->decimal_point[0] !=
'.') {
4608 p = strchr(buffer, lc->decimal_point[0]);
4613 rowd[i + ncols] =
xstrdup(buffer);
4615 }
else if (coltype != SQLITE_NULL) {
4616 value = sqlite3_column_text(s->
s3stmt, i);
4617 rowd[i + ncols] =
xstrdup((
char *) value);
4620 for (i = 0; i < ncols; i++) {
4621 int coltype = sqlite3_column_type(s->
s3stmt, i);
4624 if (coltype == SQLITE_BLOB) {
4625 value = sqlite3_column_blob(s->
s3stmt, i);
4626 }
else if (coltype != SQLITE_NULL) {
4627 value = sqlite3_column_text(s->
s3stmt, i);
4629 if (value && !rowd[i + ncols]) {
4641 if (rc == SQLITE_DONE) {
4643 sqlite3_finalize(s->
s3stmt);
4652 rc = sqlite3_reset(s->
s3stmt);
4654 errp = sqlite3_errmsg(d->
sqlite);
4658 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
4659 errp ? errp :
"unknown error", rc);
4682 sqlite3_reset(s->
s3stmt);
4723 sqlite3_finalize(s->
s3stmt);
4740 sqlite3_stmt *s3stmt = NULL;
4745#if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
4752#if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
4753 rc = sqlite3_prepare_v2(d->
sqlite, (
char *) s->
query, -1,
4756 rc = sqlite3_prepare(d->
sqlite, (
char *) s->
query, -1,
4759 if (rc != SQLITE_OK) {
4761 sqlite3_finalize(s3stmt);
4765 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
4767 if (rc != SQLITE_OK) {
4770 sqlite3_finalize(s3stmt);
4772 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
4773 sqlite3_errmsg(d->
sqlite), rc);
4776 if (sqlite3_bind_parameter_count(s3stmt) != s->
nparams) {
4778 sqlite3_finalize(s3stmt);
4779 setstat(s, SQLITE_ERROR,
"parameter marker count incorrect",
4780 (*s->
ov3) ?
"HY000" :
"S1000");
4799SQLDataSources(SQLHENV env, SQLUSMALLINT dir, SQLCHAR *srvname,
4800 SQLSMALLINT buflen1, SQLSMALLINT *lenp1,
4801 SQLCHAR *desc, SQLSMALLINT buflen2, SQLSMALLINT *lenp2)
4803 if (env == SQL_NULL_HENV) {
4804 return SQL_INVALID_HANDLE;
4817 SQLSMALLINT buflen1, SQLSMALLINT *lenp1,
4818 SQLWCHAR *desc, SQLSMALLINT buflen2, SQLSMALLINT *lenp2)
4820 if (env == SQL_NULL_HENV) {
4821 return SQL_INVALID_HANDLE;
4833SQLDrivers(SQLHENV env, SQLUSMALLINT dir, SQLCHAR *drvdesc,
4834 SQLSMALLINT descmax, SQLSMALLINT *desclenp,
4835 SQLCHAR *drvattr, SQLSMALLINT attrmax, SQLSMALLINT *attrlenp)
4837 if (env == SQL_NULL_HENV) {
4838 return SQL_INVALID_HANDLE;
4851 SQLSMALLINT descmax, SQLSMALLINT *desclenp,
4852 SQLWCHAR *drvattr, SQLSMALLINT attrmax, SQLSMALLINT *attrlenp)
4854 if (env == SQL_NULL_HENV) {
4855 return SQL_INVALID_HANDLE;
4867SQLBrowseConnect(SQLHDBC
dbc, SQLCHAR *connin, SQLSMALLINT conninLen,
4868 SQLCHAR *connout, SQLSMALLINT connoutMax,
4869 SQLSMALLINT *connoutLen)
4887 SQLWCHAR *connout, SQLSMALLINT connoutMax,
4888 SQLSMALLINT *connoutLen)
4911 int i, dlen, done = 0;
4914 if (
stmt == SQL_NULL_HSTMT) {
4915 return SQL_INVALID_HANDLE;
4920 setstat(s, -1,
"sequence error",
"HY010");
4923 for (i = (s->
pdcount < 0) ? 0 : s->
pdcount; i < s->nparams; i++) {
4928 if (len == SQL_NULL_DATA) {
4931 p->
len = SQL_NULL_DATA;
4933 }
else if (type != SQL_C_CHAR
4935 && type != SQL_C_WCHAR
4937 && type != SQL_C_BINARY) {
4942 case SQL_C_UTINYINT:
4943 case SQL_C_STINYINT:
4947 size =
sizeof (SQLCHAR);
4952 size =
sizeof (SQLSMALLINT);
4957 size =
sizeof (SQLINTEGER);
4962 size =
sizeof (SQLBIGINT);
4966 size =
sizeof (float);
4969 size =
sizeof (double);
4971#ifdef SQL_C_TYPE_DATE
4972 case SQL_C_TYPE_DATE:
4975 size =
sizeof (DATE_STRUCT);
4977#ifdef SQL_C_TYPE_DATE
4978 case SQL_C_TYPE_TIME:
4981 size =
sizeof (TIME_STRUCT);
4983#ifdef SQL_C_TYPE_DATE
4984 case SQL_C_TYPE_TIMESTAMP:
4986 case SQL_C_TIMESTAMP:
4987 size =
sizeof (TIMESTAMP_STRUCT);
4996 memcpy(p->
param, data, size);
4999 }
else if (len == SQL_NTS && (
5002 || type == SQL_C_WCHAR
5008 if (type == SQL_C_WCHAR) {
5015#if defined(_WIN32) || defined(_WIN64)
5017 dp = wmb_to_utf(data, strlen (data));
5033 strcpy(p->
param, dp);
5039 }
else if (len < 0) {
5040 setstat(s, -1,
"invalid length",
"HY090");
5045 setstat(s, -1,
"no memory for parameter",
"HY013");
5048 memcpy((
char *) p->
param + p->
offs, data, dlen);
5052 if (type == SQL_C_WCHAR) {
5074 *((
char *) p->
param + p->
len) =
'\0';
5076 p->
need = (type == SQL_C_CHAR || type == SQL_C_WCHAR)
5079 *((
char *) p->
param + p->
len) =
'\0';
5080 p->
need = (type == SQL_C_CHAR) ? -1 : 0;
5082#if defined(_WIN32) || defined(_WIN64)
5083 if (type == SQL_C_CHAR && *s->
oemcp &&
5084 !(p->
stype == SQL_BINARY ||
5085 p->
stype == SQL_VARBINARY ||
5086 p->
stype == SQL_LONGVARBINARY)) {
5087 char *dp = wmb_to_utf(p->
param, p->
len);
5096 p->
len = strlen(dp);
5098 if (p->
type == SQL_C_WCHAR &&
5099 (p->
stype == SQL_VARCHAR ||
5100 p->
stype == SQL_LONGVARCHAR) &&
5101 p->
len == p->
coldef * sizeof (SQLWCHAR)) {
5170 int type, len = 0, needalloc = 0;
5178#if (defined(_WIN32) || defined(_WIN64)) && defined(WINTERFACE)
5180 if (type == SQL_C_WCHAR && p->
type == SQL_C_DEFAULT) {
5193 if (type == SQL_C_CHAR &&
5194 (p->
stype == SQL_BINARY ||
5195 p->
stype == SQL_VARBINARY ||
5196 p->
stype == SQL_LONGVARBINARY)) {
5197 type = SQL_C_BINARY;
5205 }
else if (*p->
lenp == SQL_DATA_AT_EXEC) {
5209 if (len <= SQL_LEN_DATA_AT_EXEC_OFFSET) {
5210 len = SQL_LEN_DATA_AT_EXEC(len);
5214 setstat(s, -1,
"invalid length",
"HY009");
5230 if (type == SQL_C_WCHAR) {
5231 if (!p->
lenp || *p->
lenp == SQL_NTS) {
5233 }
else if (*p->
lenp >= 0) {
5238 if (type == SQL_C_CHAR) {
5239 if (!p->
lenp || *p->
lenp == SQL_NTS) {
5241#if defined(_WIN32) || defined(_WIN64)
5244 }
else if (*p->
lenp >= 0) {
5254 if (type == SQL_C_WCHAR) {
5270 if (type == SQL_C_CHAR) {
5275#if defined(_WIN32) || defined(_WIN64)
5287#if defined(_WIN32) || defined(_WIN64)
5289 p->
len = strlen(dp);
5308 case SQL_C_UTINYINT:
5310 case SQL_C_STINYINT:
5311 p->
s3type = SQLITE_INTEGER;
5312 p->
s3size =
sizeof (int);
5316 p->
s3type = SQLITE_INTEGER;
5317 p->
s3size =
sizeof (int);
5322 p->
s3type = SQLITE_INTEGER;
5323 p->
s3size =
sizeof (int);
5327 p->
s3type = SQLITE_INTEGER;
5328 p->
s3size =
sizeof (int);
5333 p->
s3type = SQLITE_INTEGER;
5334 p->
s3size =
sizeof (int);
5339 p->
s3type = SQLITE_INTEGER;
5340 p->
s3size =
sizeof (int);
5346 p->
s3type = SQLITE_INTEGER;
5347 p->
s3size =
sizeof (sqlite_int64);
5351 p->
s3type = SQLITE_INTEGER;
5352 p->
s3size =
sizeof (sqlite_int64);
5357 p->
s3type = SQLITE_FLOAT;
5358 p->
s3size =
sizeof (double);
5362 p->
s3type = SQLITE_FLOAT;
5363 p->
s3size =
sizeof (double);
5366#ifdef SQL_C_TYPE_DATE
5367 case SQL_C_TYPE_DATE:
5371 int a, b, x1, x2, y, m, d;
5373 p->
s3type = SQLITE_FLOAT;
5374 p->
s3size =
sizeof (double);
5375 y = ((DATE_STRUCT *) p->
param)->year;
5376 m = ((DATE_STRUCT *) p->
param)->month;
5377 d = ((DATE_STRUCT *) p->
param)->day;
5383 b = 2 - a + (a / 4);
5384 x1 = 36525 * (y + 4716) / 100;
5385 x2 = 306001 * (m + 1) / 10000;
5386 p->
s3dval = x1 + x2 + d + b - 1524.5;
5389 sprintf(p->
strbuf,
"%04d-%02d-%02d",
5390 ((DATE_STRUCT *) p->
param)->year,
5391 ((DATE_STRUCT *) p->
param)->month,
5392 ((DATE_STRUCT *) p->
param)->day);
5397#ifdef SQL_C_TYPE_TIME
5398 case SQL_C_TYPE_TIME:
5402 p->
s3type = SQLITE_FLOAT;
5403 p->
s3size =
sizeof (double);
5405 (((TIME_STRUCT *) p->
param)->hour * 3600000.0 +
5406 ((TIME_STRUCT *) p->
param)->minute * 60000.0 +
5407 ((TIME_STRUCT *) p->
param)->second * 1000.0) / 86400000.0;
5410 sprintf(p->
strbuf,
"%02d:%02d:%02d",
5411 ((TIME_STRUCT *) p->
param)->hour,
5412 ((TIME_STRUCT *) p->
param)->minute,
5413 ((TIME_STRUCT *) p->
param)->second);
5418#ifdef SQL_C_TYPE_TIMESTAMP
5419 case SQL_C_TYPE_TIMESTAMP:
5421 case SQL_C_TIMESTAMP:
5423 int a, b, x1, x2, y, m, d;
5425 p->
s3type = SQLITE_FLOAT;
5426 p->
s3size =
sizeof (double);
5427 y = ((TIMESTAMP_STRUCT *) p->
param)->year;
5428 m = ((TIMESTAMP_STRUCT *) p->
param)->month;
5429 d = ((TIMESTAMP_STRUCT *) p->
param)->day;
5435 b = 2 - a + (a / 4);
5436 x1 = 36525 * (y + 4716) / 100;
5437 x2 = 306001 * (m + 1) / 10000;
5438 p->
s3dval = x1 + x2 + d + b - 1524.5 +
5439 (((TIMESTAMP_STRUCT *) p->
param)->hour * 3600000.0 +
5440 ((TIMESTAMP_STRUCT *) p->
param)->minute * 60000.0 +
5441 ((TIMESTAMP_STRUCT *) p->
param)->second * 1000.0 +
5442 ((TIMESTAMP_STRUCT *) p->
param)->fraction / 1.0E6)
5446 len = (int) ((TIMESTAMP_STRUCT *) p->
param)->fraction;
5453 sprintf(p->
strbuf,
"%04d-%02d-%02d %02d:%02d:00.000",
5454 ((TIMESTAMP_STRUCT *) p->
param)->year,
5455 ((TIMESTAMP_STRUCT *) p->
param)->month,
5456 ((TIMESTAMP_STRUCT *) p->
param)->day,
5457 ((TIMESTAMP_STRUCT *) p->
param)->hour,
5458 ((TIMESTAMP_STRUCT *) p->
param)->minute);
5460 sprintf(p->
strbuf,
"%04d-%02d-%02d %02d:%02d:%02d.000",
5461 ((TIMESTAMP_STRUCT *) p->
param)->year,
5462 ((TIMESTAMP_STRUCT *) p->
param)->month,
5463 ((TIMESTAMP_STRUCT *) p->
param)->day,
5464 ((TIMESTAMP_STRUCT *) p->
param)->hour,
5465 ((TIMESTAMP_STRUCT *) p->
param)->minute,
5466 ((TIMESTAMP_STRUCT *) p->
param)->second);
5468 sprintf(p->
strbuf,
"%04d-%02d-%02d %02d:%02d:%02d.%03d",
5469 ((TIMESTAMP_STRUCT *) p->
param)->year,
5470 ((TIMESTAMP_STRUCT *) p->
param)->month,
5471 ((TIMESTAMP_STRUCT *) p->
param)->day,
5472 ((TIMESTAMP_STRUCT *) p->
param)->hour,
5473 ((TIMESTAMP_STRUCT *) p->
param)->minute,
5474 ((TIMESTAMP_STRUCT *) p->
param)->second,
5483 setstat(s, -1,
"unsupported parameter type",
5484 (*s->
ov3) ?
"07009" :
"S1093");
5507 SQLSMALLINT buftype, SQLSMALLINT ptype, SQLUINTEGER coldef,
5509 SQLPOINTER data, SQLINTEGER buflen,
SQLLEN *len)
5514 if (
stmt == SQL_NULL_HSTMT) {
5515 return SQL_INVALID_HANDLE;
5519 setstat(s, -1,
"invalid parameter", (*s->
ov3) ?
"07009" :
"S1093");
5522 if (!data && !len) {
5523 setstat(s, -1,
"invalid buffer",
"HY003");
5543 int npar =
max(10, pnum + 1);
5553 case SQL_C_STINYINT:
5554 case SQL_C_UTINYINT:
5559 buflen =
sizeof (SQLCHAR);
5564 buflen =
sizeof (SQLSMALLINT);
5569 buflen =
sizeof (SQLINTEGER);
5572 buflen =
sizeof (float);
5575 buflen =
sizeof (double);
5577 case SQL_C_TIMESTAMP:
5578#ifdef SQL_C_TYPE_TIMESTAMP
5579 case SQL_C_TYPE_TIMESTAMP:
5581 buflen =
sizeof (TIMESTAMP_STRUCT);
5584#ifdef SQL_C_TYPE_TIME
5585 case SQL_C_TYPE_TIME:
5587 buflen =
sizeof (TIME_STRUCT);
5590#ifdef SQL_C_TYPE_DATE
5591 case SQL_C_TYPE_DATE:
5593 buflen =
sizeof (DATE_STRUCT);
5597 buflen =
sizeof (SQLBIGINT);
5602 buflen =
sizeof (SQLBIGINT);
5607 buflen =
sizeof (SQLBIGINT);
5646 SQLSMALLINT buftype, SQLSMALLINT ptype,
SQLULEN coldef,
5654 scale, data, buflen, len);
5675 SQLSMALLINT ptype,
SQLULEN lenprec,
5676 SQLSMALLINT scale, SQLPOINTER val,
5683 lenprec, scale, val, 0, lenp);
5703 if (
stmt == SQL_NULL_HSTMT) {
5704 return SQL_INVALID_HANDLE;
5726 if (*p->
lenp == SQL_DATA_AT_EXEC) {
5729 p->
len = SQL_LEN_DATA_AT_EXEC(*p->
lenp);
5731 if (p->
len < 0 && p->
len != SQL_NTS &&
5732 p->
len != SQL_NULL_DATA) {
5733 setstat(s, -1,
"invalid length",
"HY009");
5746 return SQL_NEED_DATA;
5766 if (
stmt == SQL_NULL_HSTMT) {
5767 return SQL_INVALID_HANDLE;
5776 for (i = 0; i < s->
pdcount; i++) {
5781 p->
need = (type == SQL_C_CHAR || type == SQL_C_WCHAR) ? -1 : 0;
5787 *pind = (SQLPOINTER) p->
param0;
5812 SQLULEN *size, SQLSMALLINT *decdigits, SQLSMALLINT *nullable)
5815 SQLRETURN ret = SQL_ERROR;
5818 if (
stmt == SQL_NULL_HSTMT) {
5819 return SQL_INVALID_HANDLE;
5824 setstat(s, -1,
"invalid parameter index",
5825 (*s->
ov3) ?
"HY000" :
"S1000");
5829#ifdef SQL_LONGVARCHAR
5831 *dtype = s->
nowchar[0] ? SQL_LONGVARCHAR : SQL_WLONGVARCHAR;
5833 *dtype = SQL_LONGVARCHAR;
5837 *dtype = s->
nowchar[0] ? SQL_VARCHAR : SQL_WVARCHAR;
5839 *dtype = SQL_VARCHAR;
5844#ifdef SQL_LONGVARCHAR
5854 *nullable = SQL_NULLABLE;
5877 SQLSMALLINT sqltype,
SQLULEN coldef,
5878 SQLSMALLINT scale, SQLPOINTER val,
SQLLEN *nval)
5884 type, sqltype, coldef, scale, val,
5885 SQL_SETPARAM_VALUE_MAX, nval);
5911SQLGetDescField(SQLHDESC handle, SQLSMALLINT recno,
5912 SQLSMALLINT fieldid, SQLPOINTER value,
5913 SQLINTEGER buflen, SQLINTEGER *strlen)
5926 SQLSMALLINT fieldid, SQLPOINTER value,
5927 SQLINTEGER buflen, SQLINTEGER *strlen)
5939SQLSetDescField(SQLHDESC handle, SQLSMALLINT recno,
5940 SQLSMALLINT fieldid, SQLPOINTER value,
5954 SQLSMALLINT fieldid, SQLPOINTER value,
5967SQLGetDescRec(SQLHDESC handle, SQLSMALLINT recno,
5968 SQLCHAR *name, SQLSMALLINT buflen,
5969 SQLSMALLINT *strlen, SQLSMALLINT *type,
5970 SQLSMALLINT *subtype,
SQLLEN *len,
5971 SQLSMALLINT *prec, SQLSMALLINT *scale,
5972 SQLSMALLINT *nullable)
5985 SQLWCHAR *name, SQLSMALLINT buflen,
5986 SQLSMALLINT *strlen, SQLSMALLINT *type,
5987 SQLSMALLINT *subtype,
SQLLEN *len,
5988 SQLSMALLINT *prec, SQLSMALLINT *scale,
5989 SQLSMALLINT *nullable)
6001 SQLSMALLINT type, SQLSMALLINT subtype,
6002 SQLLEN len, SQLSMALLINT prec,
6003 SQLSMALLINT scale, SQLPOINTER data,
6022 int ncols3,
int *nret)
6027 if (
stmt == SQL_NULL_HSTMT) {
6028 return SQL_INVALID_HANDLE;
6031 if (s->
dbc == SQL_NULL_HDBC) {
6041 if (colspec3 && *s->
ov3) {
6064 {
"SYSTEM",
"TABLEPRIV",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
6065 {
"SYSTEM",
"TABLEPRIV",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
6066 {
"SYSTEM",
"TABLEPRIV",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
6067 {
"SYSTEM",
"TABLEPRIV",
"GRANTOR",
SCOL_VARCHAR, 50 },
6068 {
"SYSTEM",
"TABLEPRIV",
"GRANTEE",
SCOL_VARCHAR, 50 },
6069 {
"SYSTEM",
"TABLEPRIV",
"PRIVILEGE",
SCOL_VARCHAR, 50 },
6070 {
"SYSTEM",
"TABLEPRIV",
"IS_GRANTABLE",
SCOL_VARCHAR, 50 }
6074 {
"SYSTEM",
"TABLEPRIV",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
6075 {
"SYSTEM",
"TABLEPRIV",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
6076 {
"SYSTEM",
"TABLEPRIV",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
6077 {
"SYSTEM",
"TABLEPRIV",
"GRANTOR",
SCOL_VARCHAR, 50 },
6078 {
"SYSTEM",
"TABLEPRIV",
"GRANTEE",
SCOL_VARCHAR, 50 },
6079 {
"SYSTEM",
"TABLEPRIV",
"PRIVILEGE",
SCOL_VARCHAR, 50 },
6080 {
"SYSTEM",
"TABLEPRIV",
"IS_GRANTABLE",
SCOL_VARCHAR, 50 }
6097 SQLCHAR *cat, SQLSMALLINT catLen,
6098 SQLCHAR *schema, SQLSMALLINT schemaLen,
6099 SQLCHAR *table, SQLSMALLINT tableLen)
6104 int ncols, rc, size, npatt;
6105 char *errp = NULL, *sql, tname[512];
6109 if (ret != SQL_SUCCESS) {
6114 if (cat && (catLen > 0 || catLen == SQL_NTS) && cat[0] ==
'%') {
6118 if (schema && (schemaLen > 0 || schemaLen == SQL_NTS) &&
6120 if ((!cat || catLen == 0 || !cat[0]) &&
6121 (!table || tableLen == 0 || !table[0])) {
6131 if (tableLen == SQL_NTS) {
6132 size =
sizeof (tname) - 1;
6134 size =
min(
sizeof (tname) - 1, tableLen);
6136 strncpy(tname, (
char *) table, size);
6140#if defined(_WIN32) || defined(_WIN64)
6142 sql = sqlite3_mprintf(
"select %s as 'TABLE_QUALIFIER', "
6143 "%s as 'TABLE_OWNER', "
6144 "tbl_name as 'TABLE_NAME', "
6147 "'SELECT' AS 'PRIVILEGE', "
6148 "NULL as 'IS_GRANTABLE' "
6149 "from sqlite_master where "
6150 "(type = 'table' or type = 'view') "
6151 "and tbl_name like %Q "
6153 "select %s as 'TABLE_QUALIFIER', "
6154 "%s as 'TABLE_OWNER', "
6155 "tbl_name as 'TABLE_NAME', "
6158 "'UPDATE' AS 'PRIVILEGE', "
6159 "NULL as 'IS_GRANTABLE' "
6160 "from sqlite_master where "
6161 "(type = 'table' or type = 'view') "
6162 "and tbl_name like %Q "
6164 "select %s as 'TABLE_QUALIFIER', "
6165 "%s as 'TABLE_OWNER', "
6166 "tbl_name as 'TABLE_NAME', "
6169 "'DELETE' AS 'PRIVILEGE', "
6170 "NULL as 'IS_GRANTABLE' "
6171 "from sqlite_master where "
6172 "(type = 'table' or type = 'view') "
6173 "and tbl_name like %Q "
6175 "select %s as 'TABLE_QUALIFIER', "
6176 "%s as 'TABLE_OWNER', "
6177 "tbl_name as 'TABLE_NAME', "
6180 "'INSERT' AS 'PRIVILEGE', "
6181 "NULL as 'IS_GRANTABLE' "
6182 "from sqlite_master where "
6183 "(type = 'table' or type = 'view') "
6184 "and tbl_name like %Q "
6186 "select %s as 'TABLE_QUALIFIER', "
6187 "%s as 'TABLE_OWNER', "
6188 "tbl_name as 'TABLE_NAME', "
6191 "'REFERENCES' AS 'PRIVILEGE', "
6192 "NULL as 'IS_GRANTABLE' "
6193 "from sqlite_master where "
6194 "(type = 'table' or type = 'view') "
6195 "and tbl_name like %Q",
6196 d->xcelqrx ?
"'main'" :
"NULL",
6197 d->xcelqrx ?
"''" :
"NULL",
6199 d->xcelqrx ?
"'main'" :
"NULL",
6200 d->xcelqrx ?
"''" :
"NULL",
6202 d->xcelqrx ?
"'main'" :
"NULL",
6203 d->xcelqrx ?
"''" :
"NULL",
6205 d->xcelqrx ?
"'main'" :
"NULL",
6206 d->xcelqrx ?
"''" :
"NULL",
6208 d->xcelqrx ?
"'main'" :
"NULL",
6209 d->xcelqrx ?
"''" :
"NULL",
6212 sql = sqlite3_mprintf(
"select %s as 'TABLE_QUALIFIER', "
6213 "%s as 'TABLE_OWNER', "
6214 "tbl_name as 'TABLE_NAME', "
6217 "'SELECT' AS 'PRIVILEGE', "
6218 "NULL as 'IS_GRANTABLE' "
6219 "from sqlite_master where "
6220 "(type = 'table' or type = 'view') "
6221 "and lower(tbl_name) = lower(%Q) "
6223 "select %s as 'TABLE_QUALIFIER', "
6224 "%s as 'TABLE_OWNER', "
6225 "tbl_name as 'TABLE_NAME', "
6228 "'UPDATE' AS 'PRIVILEGE', "
6229 "NULL as 'IS_GRANTABLE' "
6230 "from sqlite_master where "
6231 "(type = 'table' or type = 'view') "
6232 "and lower(tbl_name) = lower(%Q) "
6234 "select %s as 'TABLE_QUALIFIER', "
6235 "%s as 'TABLE_OWNER', "
6236 "tbl_name as 'TABLE_NAME', "
6239 "'DELETE' AS 'PRIVILEGE', "
6240 "NULL as 'IS_GRANTABLE' "
6241 "from sqlite_master where "
6242 "(type = 'table' or type = 'view') "
6243 "and lower(tbl_name) = lower(%Q) "
6245 "select %s as 'TABLE_QUALIFIER', "
6246 "%s as 'TABLE_OWNER', "
6247 "tbl_name as 'TABLE_NAME', "
6250 "'INSERT' AS 'PRIVILEGE', "
6251 "NULL as 'IS_GRANTABLE' "
6252 "from sqlite_master where "
6253 "(type = 'table' or type = 'view') "
6254 "and lower(tbl_name) = lower(%Q) "
6256 "select %s as 'TABLE_QUALIFIER', "
6257 "%s as 'TABLE_OWNER', "
6258 "tbl_name as 'TABLE_NAME', "
6261 "'REFERENCES' AS 'PRIVILEGE', "
6262 "NULL as 'IS_GRANTABLE' "
6263 "from sqlite_master where "
6264 "(type = 'table' or type = 'view') "
6265 "and lower(tbl_name) = lower(%Q)",
6266 d->xcelqrx ?
"'main'" :
"NULL",
6267 d->xcelqrx ?
"''" :
"NULL",
6269 d->xcelqrx ?
"'main'" :
"NULL",
6270 d->xcelqrx ?
"''" :
"NULL",
6272 d->xcelqrx ?
"'main'" :
"NULL",
6273 d->xcelqrx ?
"''" :
"NULL",
6275 d->xcelqrx ?
"'main'" :
"NULL",
6276 d->xcelqrx ?
"''" :
"NULL",
6278 d->xcelqrx ?
"'main'" :
"NULL",
6279 d->xcelqrx ?
"''" :
"NULL",
6284 sql = sqlite3_mprintf(
"select NULL as 'TABLE_QUALIFIER', "
6285 "NULL as 'TABLE_OWNER', "
6286 "tbl_name as 'TABLE_NAME', "
6289 "'SELECT' AS 'PRIVILEGE', "
6290 "NULL as 'IS_GRANTABLE' "
6291 "from sqlite_master where "
6292 "(type = 'table' or type = 'view') "
6293 "and tbl_name like %Q "
6295 "select NULL as 'TABLE_QUALIFIER', "
6296 "NULL as 'TABLE_OWNER', "
6297 "tbl_name as 'TABLE_NAME', "
6300 "'UPDATE' AS 'PRIVILEGE', "
6301 "NULL as 'IS_GRANTABLE' "
6302 "from sqlite_master where "
6303 "(type = 'table' or type = 'view') "
6304 "and tbl_name like %Q "
6306 "select NULL as 'TABLE_QUALIFIER', "
6307 "NULL as 'TABLE_OWNER', "
6308 "tbl_name as 'TABLE_NAME', "
6311 "'DELETE' AS 'PRIVILEGE', "
6312 "NULL as 'IS_GRANTABLE' "
6313 "from sqlite_master where "
6314 "(type = 'table' or type = 'view') "
6315 "and tbl_name like %Q "
6317 "select NULL as 'TABLE_QUALIFIER', "
6318 "NULL as 'TABLE_OWNER', "
6319 "tbl_name as 'TABLE_NAME', "
6322 "'INSERT' AS 'PRIVILEGE', "
6323 "NULL as 'IS_GRANTABLE' "
6324 "from sqlite_master where "
6325 "(type = 'table' or type = 'view') "
6326 "and tbl_name like %Q "
6328 "select NULL as 'TABLE_QUALIFIER', "
6329 "NULL as 'TABLE_OWNER', "
6330 "tbl_name as 'TABLE_NAME', "
6333 "'REFERENCES' AS 'PRIVILEGE', "
6334 "NULL as 'IS_GRANTABLE' "
6335 "from sqlite_master where "
6336 "(type = 'table' or type = 'view') "
6337 "and tbl_name like %Q",
6338 tname, tname, tname, tname, tname);
6340 sql = sqlite3_mprintf(
"select NULL as 'TABLE_QUALIFIER', "
6341 "NULL as 'TABLE_OWNER', "
6342 "tbl_name as 'TABLE_NAME', "
6345 "'SELECT' AS 'PRIVILEGE', "
6346 "NULL as 'IS_GRANTABLE' "
6347 "from sqlite_master where "
6348 "(type = 'table' or type = 'view') "
6349 "and lower(tbl_name) = lower(%Q) "
6351 "select NULL as 'TABLE_QUALIFIER', "
6352 "NULL as 'TABLE_OWNER', "
6353 "tbl_name as 'TABLE_NAME', "
6356 "'UPDATE' AS 'PRIVILEGE', "
6357 "NULL as 'IS_GRANTABLE' "
6358 "from sqlite_master where "
6359 "(type = 'table' or type = 'view') "
6360 "and lower(tbl_name) = lower(%Q) "
6362 "select NULL as 'TABLE_QUALIFIER', "
6363 "NULL as 'TABLE_OWNER', "
6364 "tbl_name as 'TABLE_NAME', "
6367 "'DELETE' AS 'PRIVILEGE', "
6368 "NULL as 'IS_GRANTABLE' "
6369 "from sqlite_master where "
6370 "(type = 'table' or type = 'view') "
6371 "and lower(tbl_name) = lower(%Q) "
6373 "select NULL as 'TABLE_QUALIFIER', "
6374 "NULL as 'TABLE_OWNER', "
6375 "tbl_name as 'TABLE_NAME', "
6378 "'INSERT' AS 'PRIVILEGE', "
6379 "NULL as 'IS_GRANTABLE' "
6380 "from sqlite_master where "
6381 "(type = 'table' or type = 'view') "
6382 "and lower(tbl_name) = lower(%Q) "
6384 "select NULL as 'TABLE_QUALIFIER', "
6385 "NULL as 'TABLE_OWNER', "
6386 "tbl_name as 'TABLE_NAME', "
6389 "'REFERENCES' AS 'PRIVILEGE', "
6390 "NULL as 'IS_GRANTABLE' "
6391 "from sqlite_master where "
6392 "(type = 'table' or type = 'view') "
6393 "and lower(tbl_name) = lower(%Q)",
6394 tname, tname, tname, tname, tname);
6401 if (ret != SQL_SUCCESS) {
6406 rc = sqlite3_get_table(d->
sqlite, sql, &s->
rows, &s->
nrows, &ncols, &errp);
6408 if (rc == SQLITE_OK) {
6409 if (ncols != s->
ncols) {
6413 s->
rowfree = sqlite3_free_table;
6429#if !defined(WINTERFACE) || (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC))
6443SQLTablePrivileges(SQLHSTMT
stmt,
6444 SQLCHAR *catalog, SQLSMALLINT catalogLen,
6445 SQLCHAR *schema, SQLSMALLINT schemaLen,
6446 SQLCHAR *table, SQLSMALLINT tableLen)
6448#if defined(_WIN32) || defined(_WIN64)
6449 char *c = NULL, *s = NULL, *t = NULL;
6454#if defined(_WIN32) || defined(_WIN64)
6461 c = wmb_to_utf_c((
char *) catalog, catalogLen);
6468 s = wmb_to_utf_c((
char *) schema, schemaLen);
6475 t = wmb_to_utf_c((
char *) table, tableLen);
6482 (SQLCHAR *) s, SQL_NTS,
6483 (SQLCHAR *) t, SQL_NTS);
6488#if defined(_WIN32) || defined(_WIN64)
6501#if !defined(HAVE_UNIXODBC) || !(HAVE_UNIXODBC)
6517 SQLWCHAR *catalog, SQLSMALLINT catalogLen,
6518 SQLWCHAR *schema, SQLSMALLINT schemaLen,
6519 SQLWCHAR *table, SQLSMALLINT tableLen)
6521 char *c = NULL, *s = NULL, *t = NULL;
6547 (SQLCHAR *) s, SQL_NTS,
6548 (SQLCHAR *) t, SQL_NTS);
6564 {
"SYSTEM",
"COLPRIV",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
6565 {
"SYSTEM",
"COLPRIV",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
6566 {
"SYSTEM",
"COLPRIV",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
6567 {
"SYSTEM",
"COLPRIV",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6574 {
"SYSTEM",
"COLPRIV",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
6575 {
"SYSTEM",
"COLPRIV",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
6576 {
"SYSTEM",
"COLPRIV",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
6577 {
"SYSTEM",
"COLPRIV",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6583#if !defined(WINTERFACE) || (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC))
6599SQLColumnPrivileges(SQLHSTMT
stmt,
6600 SQLCHAR *catalog, SQLSMALLINT catalogLen,
6601 SQLCHAR *schema, SQLSMALLINT schemaLen,
6602 SQLCHAR *table, SQLSMALLINT tableLen,
6603 SQLCHAR *column, SQLSMALLINT columnLen)
6615#if !defined(HAVE_UNIXODBC) || !(HAVE_UNIXODBC)
6633 SQLWCHAR *catalog, SQLSMALLINT catalogLen,
6634 SQLWCHAR *schema, SQLSMALLINT schemaLen,
6635 SQLWCHAR *table, SQLSMALLINT tableLen,
6636 SQLWCHAR *column, SQLSMALLINT columnLen)
6654 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
6655 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
6656 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
6657 {
"SYSTEM",
"PRIMARYKEY",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6658 {
"SYSTEM",
"PRIMARYKEY",
"KEY_SEQ", SQL_SMALLINT, 50 },
6659 {
"SYSTEM",
"PRIMARYKEY",
"PK_NAME",
SCOL_VARCHAR, 50 }
6663 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
6664 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
6665 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
6666 {
"SYSTEM",
"PRIMARYKEY",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6667 {
"SYSTEM",
"PRIMARYKEY",
"KEY_SEQ", SQL_SMALLINT, 50 },
6668 {
"SYSTEM",
"PRIMARYKEY",
"PK_NAME",
SCOL_VARCHAR, 50 }
6685 SQLCHAR *cat, SQLSMALLINT catLen,
6686 SQLCHAR *schema, SQLSMALLINT schemaLen,
6687 SQLCHAR *table, SQLSMALLINT tableLen)
6692 int i, asize, ret, nrows, ncols, nrows2 = 0, ncols2 = 0;
6693 int namec = -1, uniquec = -1, namec2 = -1, uniquec2 = -1, offs, seq = 1;
6695 char **rowp = NULL, **rowp2 = NULL, *errp = NULL, *sql, tname[512];
6699 if (sret != SQL_SUCCESS) {
6704 if (!table || table[0] ==
'\0' || table[0] ==
'%') {
6705 setstat(s, -1,
"need table name", (*s->
ov3) ?
"HY000" :
"S1000");
6708 if (tableLen == SQL_NTS) {
6709 size =
sizeof (tname) - 1;
6711 size =
min(
sizeof (tname) - 1, tableLen);
6713 strncpy(tname, (
char *) table, size);
6716 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", tname);
6721 if (sret != SQL_SUCCESS) {
6726 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
6728 if (ret != SQLITE_OK) {
6729 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
6730 errp ? errp :
"unknown error", ret);
6742 if (ncols * nrows > 0) {
6745 namec =
findcol(rowp, ncols,
"name");
6746 uniquec =
findcol(rowp, ncols,
"pk");
6747 typec =
findcol(rowp, ncols,
"type");
6748 if (namec >= 0 && uniquec >= 0 && typec >= 0) {
6749 for (i = 1; i <= nrows; i++) {
6750 if (*rowp[i * ncols + uniquec] !=
'0') {
6757 sql = sqlite3_mprintf(
"PRAGMA index_list(%Q)", tname);
6759 sqlite3_free_table(rowp);
6763 ret = sqlite3_get_table(d->
sqlite, sql, &rowp2, &nrows2, &ncols2,
6766 if (ret != SQLITE_OK) {
6767 sqlite3_free_table(rowp);
6768 sqlite3_free_table(rowp2);
6769 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
6770 errp ? errp :
"unknown error", ret);
6782 if (ncols2 * nrows2 > 0) {
6783 namec2 =
findcol(rowp2, ncols2,
"name");
6784 uniquec2 =
findcol(rowp2, ncols2,
"unique");
6785 if (namec2 >= 0 && uniquec2 >= 0) {
6786 for (i = 1; i <= nrows2; i++) {
6787 int nnrows, nncols, nlen = 0;
6790 if (rowp2[i * ncols2 + namec2]) {
6791 nlen = strlen(rowp2[i * ncols2 + namec2]);
6794 strncmp(rowp2[i * ncols2 + namec2],
6795 "sqlite_autoindex_", 17)) {
6798 if (*rowp2[i * ncols2 + uniquec2] !=
'0') {
6800 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
6801 rowp2[i * ncols2 + namec2]);
6804 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
6805 &nnrows, &nncols, NULL);
6808 if (ret == SQLITE_OK) {
6810 sqlite3_free_table(rowpp);
6817 sqlite3_free_table(rowp);
6818 sqlite3_free_table(rowp2);
6822 size = (size + 1) * asize;
6826 sqlite3_free_table(rowp);
6827 sqlite3_free_table(rowp2);
6830 s->
rows[0] = (
char *) size;
6832 memset(s->
rows, 0, sizeof (
char *) * size);
6836 for (i = 1; i <= nrows; i++) {
6837 if (*rowp[i * ncols + uniquec] !=
'0') {
6840#if defined(_WIN32) || defined(_WIN64)
6841 s->
rows[offs + 0] =
xstrdup(d->xcelqrx ?
"main" :
"");
6848 s->
rows[offs + 3] =
xstrdup(rowp[i * ncols + namec]);
6849 sprintf(buf,
"%d", seq++);
6856 for (i = 1; i <= nrows2; i++) {
6857 int nnrows, nncols, nlen = 0;
6860 if (rowp2[i * ncols2 + namec2]) {
6861 nlen = strlen(rowp2[i * ncols2 + namec2]);
6864 strncmp(rowp2[i * ncols2 + namec2],
"sqlite_autoindex_", 17)) {
6867 if (*rowp2[i * ncols2 + uniquec2] !=
'0') {
6871 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
6872 rowp2[i * ncols2 + namec2]);
6875 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
6876 &nnrows, &nncols, NULL);
6879 if (ret != SQLITE_OK) {
6882 for (k = 0; nnrows && k < nncols; k++) {
6883 if (strcmp(rowpp[k],
"name") == 0) {
6886 for (m = 1; m <= nnrows; m++) {
6887 int roffs = offs + (m - 1) * s->
ncols;
6889#if defined(_WIN32) || defined(_WIN64)
6890 s->
rows[roffs + 0] =
6891 xstrdup(d->xcelqrx ?
"main" :
"");
6898 s->
rows[roffs + 3] =
6899 xstrdup(rowpp[m * nncols + k]);
6900 s->
rows[roffs + 5] =
6901 xstrdup(rowp2[i * ncols2 + namec2]);
6903 }
else if (strcmp(rowpp[k],
"seqno") == 0) {
6906 for (m = 1; m <= nnrows; m++) {
6907 int roffs = offs + (m - 1) * s->
ncols;
6911 sscanf(rowpp[m * nncols + k],
"%d", &pos);
6912 sprintf(buf,
"%d", pos + 1);
6917 offs += nnrows * s->
ncols;
6918 sqlite3_free_table(rowpp);
6922 sqlite3_free_table(rowp);
6923 sqlite3_free_table(rowp2);
6941SQLPrimaryKeys(SQLHSTMT
stmt,
6942 SQLCHAR *cat, SQLSMALLINT catLen,
6943 SQLCHAR *schema, SQLSMALLINT schemaLen,
6944 SQLCHAR *table, SQLSMALLINT tableLen)
6946#if defined(_WIN32) || defined(_WIN64)
6947 char *c = NULL, *s = NULL, *t = NULL;
6952#if defined(_WIN32) || defined(_WIN64)
6959 c = wmb_to_utf_c((
char *) cat, catLen);
6966 s = wmb_to_utf_c((
char *) schema, schemaLen);
6973 t = wmb_to_utf_c((
char *) table, tableLen);
6980 (SQLCHAR *) s, SQL_NTS, (SQLCHAR *) t, SQL_NTS);
6985#if defined(_WIN32) || defined(_WIN64)
7013 SQLWCHAR *cat, SQLSMALLINT catLen,
7014 SQLWCHAR *schema, SQLSMALLINT schemaLen,
7015 SQLWCHAR *table, SQLSMALLINT tableLen)
7017 char *c = NULL, *s = NULL, *t = NULL;
7043 (SQLCHAR *) s, SQL_NTS, (SQLCHAR *) t, SQL_NTS);
7058 {
"SYSTEM",
"COLUMN",
"SCOPE", SQL_SMALLINT, 1 },
7059 {
"SYSTEM",
"COLUMN",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
7060 {
"SYSTEM",
"COLUMN",
"DATA_TYPE", SQL_SMALLINT, 50 },
7062 {
"SYSTEM",
"COLUMN",
"PRECISION", SQL_INTEGER, 50 },
7063 {
"SYSTEM",
"COLUMN",
"LENGTH", SQL_INTEGER, 50 },
7064 {
"SYSTEM",
"COLUMN",
"DECIMAL_DIGITS", SQL_INTEGER, 50 },
7065 {
"SYSTEM",
"COLUMN",
"PSEUDO_COLUMN", SQL_SMALLINT, 1 },
7066 {
"SYSTEM",
"COLUMN",
"NULLABLE", SQL_SMALLINT, 1 }
7070 {
"SYSTEM",
"COLUMN",
"SCOPE", SQL_SMALLINT, 1 },
7071 {
"SYSTEM",
"COLUMN",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
7072 {
"SYSTEM",
"COLUMN",
"DATA_TYPE", SQL_SMALLINT, 50 },
7074 {
"SYSTEM",
"COLUMN",
"COLUMN_SIZE", SQL_INTEGER, 50 },
7075 {
"SYSTEM",
"COLUMN",
"BUFFER_LENGTH", SQL_INTEGER, 50 },
7076 {
"SYSTEM",
"COLUMN",
"DECIMAL_DIGITS", SQL_INTEGER, 50 },
7077 {
"SYSTEM",
"COLUMN",
"PSEUDO_COLUMN", SQL_SMALLINT, 1 },
7078 {
"SYSTEM",
"COLUMN",
"NULLABLE", SQL_SMALLINT, 1 }
7098 SQLCHAR *cat, SQLSMALLINT catLen,
7099 SQLCHAR *schema, SQLSMALLINT schemaLen,
7100 SQLCHAR *table, SQLSMALLINT tableLen,
7101 SQLUSMALLINT scope, SQLUSMALLINT nullable)
7106 int i, asize, ret, nrows, ncols, nnnrows, nnncols, offs;
7108 int namec = -1, uniquec = -1, namecc = -1, typecc = -1;
7109 int notnullcc = -1, mkrowid = 0;
7110 char *errp = NULL, *sql, tname[512];
7111 char **rowp = NULL, **rowppp = NULL;
7115 if (sret != SQL_SUCCESS) {
7120 if (!table || table[0] ==
'\0' || table[0] ==
'%') {
7121 setstat(s, -1,
"need table name", (*s->
ov3) ?
"HY000" :
"S1000");
7124 if (tableLen == SQL_NTS) {
7125 size =
sizeof (tname) - 1;
7127 size =
min(
sizeof (tname) - 1, tableLen);
7129 strncpy(tname, (
char *) table, size);
7132 if (
id != SQL_BEST_ROWID) {
7135 sql = sqlite3_mprintf(
"PRAGMA index_list(%Q)", tname);
7140 if (sret != SQL_SUCCESS) {
7145 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
7147 if (ret != SQLITE_OK) {
7149 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
7150 errp ? errp :
"unknown error", ret);
7162 if (ncols * nrows <= 0) {
7163 goto nodata_but_rowid;
7165 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", tname);
7170 ret = sqlite3_get_table(d->
sqlite, sql, &rowppp, &nnnrows, &nnncols,
7173 if (ret != SQLITE_OK) {
7174 sqlite3_free_table(rowp);
7181 namec =
findcol(rowp, ncols,
"name");
7182 uniquec =
findcol(rowp, ncols,
"unique");
7183 if (namec < 0 || uniquec < 0) {
7184 goto nodata_but_rowid;
7186 namecc =
findcol(rowppp, nnncols,
"name");
7187 typecc =
findcol(rowppp, nnncols,
"type");
7188 notnullcc =
findcol(rowppp, nnncols,
"notnull");
7189 for (i = 1; i <= nrows; i++) {
7191 char **rowpp = NULL;
7193 if (*rowp[i * ncols + uniquec] !=
'0') {
7195 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
7196 rowp[i * ncols + namec]);
7199 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
7200 &nnrows, &nncols, NULL);
7203 if (ret == SQLITE_OK) {
7205 sqlite3_free_table(rowpp);
7215 size = (size + 1) * asize;
7219 sqlite3_free_table(rowp);
7220 sqlite3_free_table(rowppp);
7223 s->
rows[0] = (
char *) size;
7225 memset(s->
rows, 0, sizeof (
char *) * size);
7232 for (i = 1; i <= nrows; i++) {
7234 char **rowpp = NULL;
7236 if (*rowp[i * ncols + uniquec] !=
'0') {
7240 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
7241 rowp[i * ncols + namec]);
7244 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
7245 &nnrows, &nncols, NULL);
7248 if (ret != SQLITE_OK) {
7251 for (k = 0; nnrows && k < nncols; k++) {
7252 if (strcmp(rowpp[k],
"name") == 0) {
7255 for (m = 1; m <= nnrows; m++) {
7256 int roffs = (offs + m) * s->
ncols;
7258 s->
rows[roffs + 0] =
7260 s->
rows[roffs + 1] =
xstrdup(rowpp[m * nncols + k]);
7262 s->
rows[roffs + 7] =
7264 if (namecc >= 0 && typecc >= 0) {
7267 for (ii = 1; ii <= nnnrows; ii++) {
7268 if (strcmp(rowppp[ii * nnncols + namecc],
7269 rowpp[m * nncols + k]) == 0) {
7270 char *typen = rowppp[ii * nnncols + typecc];
7271 int sqltype, mm, dd, isnullable = 0;
7278 getmd(typen, sqltype, &mm, &dd);
7279#ifdef SQL_LONGVARCHAR
7280 if (sqltype == SQL_VARCHAR && mm > 255) {
7281 sqltype = SQL_LONGVARCHAR;
7285#ifdef SQL_WLONGVARCHAR
7286 if (sqltype == SQL_WVARCHAR && mm > 255) {
7287 sqltype = SQL_WLONGVARCHAR;
7291 if (sqltype == SQL_VARBINARY && mm > 255) {
7292 sqltype = SQL_LONGVARBINARY;
7294 sprintf(buf,
"%d", sqltype);
7296 sprintf(buf,
"%d", mm);
7298 sprintf(buf,
"%d", dd);
7300 if (notnullcc >= 0) {
7302 rowppp[ii * nnncols + notnullcc];
7304 isnullable = inp[0] !=
'0';
7306 sprintf(buf,
"%d", isnullable);
7315 sqlite3_free_table(rowpp);
7318 if (nullable == SQL_NO_NULLS) {
7319 for (i = 1; i < s->
nrows; i++) {
7320 if (s->
rows[i * s->
ncols + 8][0] ==
'0') {
7323 for (m = 0; m < s->
ncols; m++) {
7326 size = s->
ncols *
sizeof (
char *) * (s->
nrows - i1);
7332 s->
ncols * sizeof (
char *));
7340 sqlite3_free_table(rowp);
7341 sqlite3_free_table(rowppp);
7342 if (s->
nrows == 0) {
7374SQLSpecialColumns(SQLHSTMT
stmt, SQLUSMALLINT
id,
7375 SQLCHAR *cat, SQLSMALLINT catLen,
7376 SQLCHAR *schema, SQLSMALLINT schemaLen,
7377 SQLCHAR *table, SQLSMALLINT tableLen,
7378 SQLUSMALLINT scope, SQLUSMALLINT nullable)
7380#if defined(_WIN32) || defined(_WIN64)
7381 char *c = NULL, *s = NULL, *t = NULL;
7386#if defined(_WIN32) || defined(_WIN64)
7389 table, tableLen, scope, nullable);
7393 c = wmb_to_utf_c((
char *) cat, catLen);
7400 s = wmb_to_utf_c((
char *) schema, schemaLen);
7407 t = wmb_to_utf_c((
char *) table, tableLen);
7414 (SQLCHAR *) s, SQL_NTS, (SQLCHAR *) t, SQL_NTS,
7418 table, tableLen, scope, nullable);
7420#if defined(_WIN32) || defined(_WIN64)
7451 SQLWCHAR *cat, SQLSMALLINT catLen,
7452 SQLWCHAR *schema, SQLSMALLINT schemaLen,
7453 SQLWCHAR *table, SQLSMALLINT tableLen,
7454 SQLUSMALLINT scope, SQLUSMALLINT nullable)
7456 char *c = NULL, *s = NULL, *t = NULL;
7482 (SQLCHAR *) s, SQL_NTS, (SQLCHAR *) t, SQL_NTS,
7498 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
7499 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_OWNER",
SCOL_VARCHAR, 50 },
7500 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_NAME",
SCOL_VARCHAR, 255 },
7501 {
"SYSTEM",
"FOREIGNKEY",
"PKCOLUMN_NAME",
SCOL_VARCHAR, 255 },
7502 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
7503 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_OWNER",
SCOL_VARCHAR, 50 },
7504 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_NAME",
SCOL_VARCHAR, 255 },
7505 {
"SYSTEM",
"FOREIGNKEY",
"FKCOLUMN_NAME",
SCOL_VARCHAR, 255 },
7506 {
"SYSTEM",
"FOREIGNKEY",
"KEY_SEQ", SQL_SMALLINT, 5 },
7507 {
"SYSTEM",
"FOREIGNKEY",
"UPDATE_RULE", SQL_SMALLINT, 5 },
7508 {
"SYSTEM",
"FOREIGNKEY",
"DELETE_RULE", SQL_SMALLINT, 5 },
7509 {
"SYSTEM",
"FOREIGNKEY",
"FK_NAME",
SCOL_VARCHAR, 255 },
7510 {
"SYSTEM",
"FOREIGNKEY",
"PK_NAME",
SCOL_VARCHAR, 255 },
7511 {
"SYSTEM",
"FOREIGNKEY",
"DEFERRABILITY", SQL_SMALLINT, 5 }
7515 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_CAT",
SCOL_VARCHAR, 50 },
7516 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_SCHEM",
SCOL_VARCHAR, 50 },
7517 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_NAME",
SCOL_VARCHAR, 255 },
7518 {
"SYSTEM",
"FOREIGNKEY",
"PKCOLUMN_NAME",
SCOL_VARCHAR, 255 },
7519 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_CAT",
SCOL_VARCHAR, 50 },
7520 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_SCHEM",
SCOL_VARCHAR, 50 },
7521 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_NAME",
SCOL_VARCHAR, 255 },
7522 {
"SYSTEM",
"FOREIGNKEY",
"FKCOLUMN_NAME",
SCOL_VARCHAR, 255 },
7523 {
"SYSTEM",
"FOREIGNKEY",
"KEY_SEQ", SQL_SMALLINT, 5 },
7524 {
"SYSTEM",
"FOREIGNKEY",
"UPDATE_RULE", SQL_SMALLINT, 5 },
7525 {
"SYSTEM",
"FOREIGNKEY",
"DELETE_RULE", SQL_SMALLINT, 5 },
7526 {
"SYSTEM",
"FOREIGNKEY",
"FK_NAME",
SCOL_VARCHAR, 255 },
7527 {
"SYSTEM",
"FOREIGNKEY",
"PK_NAME",
SCOL_VARCHAR, 255 },
7528 {
"SYSTEM",
"FOREIGNKEY",
"DEFERRABILITY", SQL_SMALLINT, 5 }
7551 SQLCHAR *PKcatalog, SQLSMALLINT PKcatalogLen,
7552 SQLCHAR *PKschema, SQLSMALLINT PKschemaLen,
7553 SQLCHAR *PKtable, SQLSMALLINT PKtableLen,
7554 SQLCHAR *FKcatalog, SQLSMALLINT FKcatalogLen,
7555 SQLCHAR *FKschema, SQLSMALLINT FKschemaLen,
7556 SQLCHAR *FKtable, SQLSMALLINT FKtableLen)
7561 int i, asize, ret, nrows, ncols, offs, namec, seqc, fromc, toc;
7564 char **rowp, *errp = NULL, *sql, pname[512], fname[512];
7568 if (sret != SQL_SUCCESS) {
7573 if (sret != SQL_SUCCESS) {
7577 if ((!PKtable || PKtable[0] ==
'\0' || PKtable[0] ==
'%') &&
7578 (!FKtable || FKtable[0] ==
'\0' || FKtable[0] ==
'%')) {
7579 setstat(s, -1,
"need table name", (*s->
ov3) ?
"HY000" :
"S1000");
7584 if (PKtableLen == SQL_NTS) {
7585 size =
sizeof (pname) - 1;
7587 size =
min(
sizeof (pname) - 1, PKtableLen);
7589 strncpy(pname, (
char *) PKtable, size);
7595 if (FKtableLen == SQL_NTS) {
7596 size =
sizeof (fname) - 1;
7598 size =
min(
sizeof (fname) - 1, FKtableLen);
7600 strncpy(fname, (
char *) FKtable, size);
7603 if (fname[0] !=
'\0') {
7607 sql = sqlite3_mprintf(
"PRAGMA foreign_key_list(%Q)", fname);
7610 ret = sqlite3_get_table(d->
sqlite, sql, &rowp,
7611 &nrows, &ncols, &errp);
7614 if (ret != SQLITE_OK) {
7615 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
7616 errp ? errp :
"unknown error", ret);
7627 if (ncols * nrows <= 0) {
7629 sqlite3_free_table(rowp);
7633 namec =
findcol(rowp, ncols,
"table");
7634 seqc =
findcol(rowp, ncols,
"seq");
7635 fromc =
findcol(rowp, ncols,
"from");
7636 toc =
findcol(rowp, ncols,
"to");
7637 onu =
findcol(rowp, ncols,
"on_update");
7638 ond =
findcol(rowp, ncols,
"on_delete");
7639 if (namec < 0 || seqc < 0 || fromc < 0 || toc < 0) {
7642 plen = strlen(pname);
7643 for (i = 1; i <= nrows; i++) {
7644 char *ptab =
unquote(rowp[i * ncols + namec]);
7647 int len = strlen(ptab);
7649 if (plen != len || strncasecmp(pname, ptab, plen) != 0) {
7659 size = (size + 1) * asize;
7665 s->
rows[0] = (
char *) size;
7667 memset(s->
rows, 0, sizeof (
char *) * size);
7670 for (i = 1; i <= nrows; i++) {
7671 int pos = 0, roffs = (offs + 1) * s->
ncols;
7672 char *ptab = rowp[i * ncols + namec];
7676 int len = strlen(ptab);
7678 if (plen != len || strncasecmp(pname, ptab, plen) != 0) {
7682#if defined(_WIN32) || defined(_WIN64)
7683 s->
rows[roffs + 0] =
xstrdup(d->xcelqrx ?
"main" :
"");
7690 s->
rows[roffs + 3] =
xstrdup(rowp[i * ncols + toc]);
7694 s->
rows[roffs + 7] =
xstrdup(rowp[i * ncols + fromc]);
7695 sscanf(rowp[i * ncols + seqc],
"%d", &pos);
7696 sprintf(buf,
"%d", pos + 1);
7701 if (strcmp(rowp[i * ncols + onu],
"SET NULL") == 0) {
7703 }
else if (strcmp(rowp[i * ncols + onu],
"SET DEFAULT") == 0) {
7705 }
else if (strcmp(rowp[i * ncols + onu],
"CASCADE") == 0) {
7707 }
else if (strcmp(rowp[i * ncols + onu],
"RESTRICT") == 0) {
7716 if (strcmp(rowp[i * ncols + ond],
"SET NULL") == 0) {
7718 }
else if (strcmp(rowp[i * ncols + ond],
"SET DEFAULT") == 0) {
7720 }
else if (strcmp(rowp[i * ncols + ond],
"CASCADE") == 0) {
7722 }
else if (strcmp(rowp[i * ncols + ond],
"RESTRICT") == 0) {
7728 s->
rows[roffs + 11] = NULL;
7729 s->
rows[roffs + 12] = NULL;
7733 sqlite3_free_table(rowp);
7735 int nnrows, nncols, plen = strlen(pname);
7738 sql =
"select name from sqlite_master where type='table'";
7740 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
7741 if (ret != SQLITE_OK) {
7742 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
7743 errp ? errp :
"unknown error", ret);
7754 if (ncols * nrows <= 0) {
7758 for (i = 1; i <= nrows; i++) {
7766 sql = sqlite3_mprintf(
"PRAGMA foreign_key_list(%Q)", rowp[i]);
7769 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
7770 &nnrows, &nncols, NULL);
7773 if (ret != SQLITE_OK || nncols * nnrows <= 0) {
7774 sqlite3_free_table(rowpp);
7777 namec =
findcol(rowpp, nncols,
"table");
7778 seqc =
findcol(rowpp, nncols,
"seq");
7779 fromc =
findcol(rowpp, nncols,
"from");
7780 toc =
findcol(rowpp, nncols,
"to");
7781 if (namec < 0 || seqc < 0 || fromc < 0 || toc < 0) {
7782 sqlite3_free_table(rowpp);
7785 for (k = 1; k <= nnrows; k++) {
7786 char *ptab =
unquote(rowpp[k * nncols + namec]);
7789 int len = strlen(ptab);
7791 if (len != plen || strncasecmp(pname, ptab, plen) != 0) {
7797 sqlite3_free_table(rowpp);
7803 size = (size + 1) * asize;
7809 s->
rows[0] = (
char *) size;
7811 memset(s->
rows, 0, sizeof (
char *) * size);
7814 for (i = 1; i <= nrows; i++) {
7822 sql = sqlite3_mprintf(
"PRAGMA foreign_key_list(%Q)", rowp[i]);
7825 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
7826 &nnrows, &nncols, NULL);
7829 if (ret != SQLITE_OK || nncols * nnrows <= 0) {
7830 sqlite3_free_table(rowpp);
7833 namec =
findcol(rowpp, nncols,
"table");
7834 seqc =
findcol(rowpp, nncols,
"seq");
7835 fromc =
findcol(rowpp, nncols,
"from");
7836 toc =
findcol(rowpp, nncols,
"to");
7837 onu =
findcol(rowpp, nncols,
"on_update");
7838 ond =
findcol(rowpp, nncols,
"on_delete");
7839 if (namec < 0 || seqc < 0 || fromc < 0 || toc < 0) {
7840 sqlite3_free_table(rowpp);
7843 for (k = 1; k <= nnrows; k++) {
7844 int pos = 0, roffs = (offs + 1) * s->
ncols;
7845 char *ptab =
unquote(rowpp[k * nncols + namec]);
7849 int len = strlen(ptab);
7851 if (len != plen || strncasecmp(pname, ptab, plen) != 0) {
7855#if defined(_WIN32) || defined(_WIN64)
7856 s->
rows[roffs + 0] =
xstrdup(d->xcelqrx ?
"main" :
"");
7863 s->
rows[roffs + 3] =
xstrdup(rowpp[k * nncols + toc]);
7867 s->
rows[roffs + 7] =
xstrdup(rowpp[k * nncols + fromc]);
7868 sscanf(rowpp[k * nncols + seqc],
"%d", &pos);
7869 sprintf(buf,
"%d", pos + 1);
7874 if (strcmp(rowpp[k * nncols + onu],
"SET NULL") == 0) {
7876 }
else if (strcmp(rowpp[k * nncols + onu],
"SET DEFAULT")
7878 s->
rows[roffs + 9] =
7880 }
else if (strcmp(rowpp[k * nncols + onu],
"CASCADE")
7883 }
else if (strcmp(rowpp[k * nncols + onu],
"RESTRICT")
7887 s->
rows[roffs + 9] =
7894 if (strcmp(rowpp[k * nncols + ond],
"SET NULL") == 0) {
7896 }
else if (strcmp(rowpp[k * nncols + ond],
"SET DEFAULT")
7898 s->
rows[roffs + 10] =
7900 }
else if (strcmp(rowpp[k * nncols + ond],
"CASCADE")
7903 }
else if (strcmp(rowpp[k * nncols + ond],
"RESTRICT")
7907 s->
rows[roffs + 10] =
7911 s->
rows[roffs + 11] = NULL;
7912 s->
rows[roffs + 12] = NULL;
7916 sqlite3_free_table(rowpp);
7918 sqlite3_free_table(rowp);
7943SQLForeignKeys(SQLHSTMT
stmt,
7944 SQLCHAR *PKcatalog, SQLSMALLINT PKcatalogLen,
7945 SQLCHAR *PKschema, SQLSMALLINT PKschemaLen,
7946 SQLCHAR *PKtable, SQLSMALLINT PKtableLen,
7947 SQLCHAR *FKcatalog, SQLSMALLINT FKcatalogLen,
7948 SQLCHAR *FKschema, SQLSMALLINT FKschemaLen,
7949 SQLCHAR *FKtable, SQLSMALLINT FKtableLen)
7951#if defined(_WIN32) || defined(_WIN64)
7952 char *pc = NULL, *ps = NULL, *pt = NULL;
7953 char *fc = NULL, *fs = NULL, *ft = NULL;
7958#if defined(_WIN32) || defined(_WIN64)
7961 PKcatalog, PKcatalogLen,
7962 PKschema, PKschemaLen, PKtable, PKtableLen,
7963 FKcatalog, FKcatalogLen,
7964 FKschema, FKschemaLen,
7965 FKtable, FKtableLen);
7969 pc = wmb_to_utf_c((
char *) PKcatalog, PKcatalogLen);
7976 ps = wmb_to_utf_c((
char *) PKschema, PKschemaLen);
7983 pt = wmb_to_utf_c((
char *) PKtable, PKtableLen);
7990 fc = wmb_to_utf_c((
char *) FKcatalog, FKcatalogLen);
7997 fs = wmb_to_utf_c((
char *) FKschema, FKschemaLen);
8004 ft = wmb_to_utf_c((
char *) FKtable, FKtableLen);
8011 (SQLCHAR *) ps, SQL_NTS, (SQLCHAR *) pt, SQL_NTS,
8012 (SQLCHAR *) fc, SQL_NTS, (SQLCHAR *) fs, SQL_NTS,
8013 (SQLCHAR *) ft, SQL_NTS);
8016 PKcatalog, PKcatalogLen,
8017 PKschema, PKschemaLen, PKtable, PKtableLen,
8018 FKcatalog, FKcatalogLen,
8019 FKschema, FKschemaLen,
8020 FKtable, FKtableLen);
8022#if defined(_WIN32) || defined(_WIN64)
8059 SQLWCHAR *PKcatalog, SQLSMALLINT PKcatalogLen,
8060 SQLWCHAR *PKschema, SQLSMALLINT PKschemaLen,
8061 SQLWCHAR *PKtable, SQLSMALLINT PKtableLen,
8062 SQLWCHAR *FKcatalog, SQLSMALLINT FKcatalogLen,
8063 SQLWCHAR *FKschema, SQLSMALLINT FKschemaLen,
8064 SQLWCHAR *FKtable, SQLSMALLINT FKtableLen)
8066 char *pc = NULL, *ps = NULL, *pt = NULL;
8067 char *fc = NULL, *fs = NULL, *ft = NULL;
8114 (SQLCHAR *) ps, SQL_NTS, (SQLCHAR *) pt, SQL_NTS,
8115 (SQLCHAR *) fc, SQL_NTS, (SQLCHAR *) fs, SQL_NTS,
8116 (SQLCHAR *) ft, SQL_NTS);
8138 int ret = SQL_SUCCESS, rc, busy_count = 0;
8144 rc = sqlite3_exec(d->
sqlite,
"BEGIN TRANSACTION", NULL, NULL, &errp);
8145 if (rc == SQLITE_BUSY) {
8155 if (rc != SQLITE_OK) {
8156 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
8157 errp ? errp :
"unknown error", rc);
8181 int ret, busy_count = 0;
8182 char *sql, *errp = NULL;
8185 setstatd(d, -1,
"not connected", (*d->
ov3) ?
"HY000" :
"S1000");
8193 sql =
"COMMIT TRANSACTION";
8196 sql =
"ROLLBACK TRANSACTION";
8198 ret = sqlite3_exec(d->
sqlite, sql, NULL, NULL, &errp);
8200 if (ret == SQLITE_BUSY && busy_count < 10) {
8209 if (ret != SQLITE_OK) {
8210 setstatd(d, ret,
"%s", (*d->
ov3) ?
"HY000" :
"S1000",
8211 errp ? errp :
"transaction failed");
8225 setstatd(d, -1,
"invalid completion type", (*d->
ov3) ?
"HY000" :
"S1000");
8238drvendtran(SQLSMALLINT type, SQLHANDLE handle, SQLSMALLINT comptype)
8243#if defined(_WIN32) || defined(_WIN64)
8248 case SQL_HANDLE_DBC:
8250 if (handle == SQL_NULL_HDBC) {
8251 return SQL_INVALID_HANDLE;
8257 case SQL_HANDLE_ENV:
8258 if (handle == SQL_NULL_HENV) {
8259 return SQL_INVALID_HANDLE;
8261#if defined(_WIN32) || defined(_WIN64)
8262 env = (
ENV *) handle;
8264 return SQL_INVALID_HANDLE;
8266 EnterCriticalSection(&env->cs);
8268 dbc = ((
ENV *) handle)->dbcs;
8273 if (ret != SQL_SUCCESS) {
8278#if defined(_WIN32) || defined(_WIN64)
8279 LeaveCriticalSection(&env->cs);
8281 return fail ? SQL_ERROR : SQL_SUCCESS;
8283 return SQL_INVALID_HANDLE;
8295SQLEndTran(SQLSMALLINT type, SQLHANDLE handle, SQLSMALLINT comptype)
8311 if (
dbc != SQL_NULL_HDBC) {
8314 return drvendtran(SQL_HANDLE_ENV, (SQLHANDLE) env, type);
8340SQLNativeSql(SQLHSTMT
stmt, SQLCHAR *sqlin, SQLINTEGER sqlinLen,
8341 SQLCHAR *sql, SQLINTEGER sqlMax, SQLINTEGER *sqlLen)
8344 SQLRETURN ret = SQL_SUCCESS;
8347 if (sqlinLen == SQL_NTS) {
8348 sqlinLen = strlen((
char *) sqlin);
8352 strncpy((
char *) sql, (
char *) sqlin, sqlMax - 1);
8353 sqlin[sqlMax - 1] =
'\0';
8354 outLen =
min(sqlMax - 1, sqlinLen);
8362 if (sql && outLen < sqlinLen) {
8364 ret = SQL_SUCCESS_WITH_INFO;
8385 SQLWCHAR *sql, SQLINTEGER sqlMax, SQLINTEGER *sqlLen)
8388 SQLRETURN ret = SQL_SUCCESS;
8391 if (sqlinLen == SQL_NTS) {
8397 sqlin[sqlMax - 1] = 0;
8398 outLen =
min(sqlMax - 1, sqlinLen);
8406 if (sql && outLen < sqlinLen) {
8408 ret = SQL_SUCCESS_WITH_INFO;
8420 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_QUALIFIER",
SCOL_VARCHAR, 50 },
8421 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_OWNER",
SCOL_VARCHAR, 50 },
8422 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_NAME",
SCOL_VARCHAR, 255 },
8423 {
"SYSTEM",
"PROCEDURE",
"NUM_INPUT_PARAMS", SQL_SMALLINT, 5 },
8424 {
"SYSTEM",
"PROCEDURE",
"NUM_OUTPUT_PARAMS", SQL_SMALLINT, 5 },
8425 {
"SYSTEM",
"PROCEDURE",
"NUM_RESULT_SETS", SQL_SMALLINT, 5 },
8426 {
"SYSTEM",
"PROCEDURE",
"REMARKS",
SCOL_VARCHAR, 255 },
8427 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_TYPE", SQL_SMALLINT, 5 }
8431 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_CAT",
SCOL_VARCHAR, 50 },
8432 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_SCHEM",
SCOL_VARCHAR, 50 },
8433 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_NAME",
SCOL_VARCHAR, 255 },
8434 {
"SYSTEM",
"PROCEDURE",
"NUM_INPUT_PARAMS", SQL_SMALLINT, 5 },
8435 {
"SYSTEM",
"PROCEDURE",
"NUM_OUTPUT_PARAMS", SQL_SMALLINT, 5 },
8436 {
"SYSTEM",
"PROCEDURE",
"NUM_RESULT_SETS", SQL_SMALLINT, 5 },
8437 {
"SYSTEM",
"PROCEDURE",
"REMARKS",
SCOL_VARCHAR, 255 },
8438 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_TYPE", SQL_SMALLINT, 5 }
8455SQLProcedures(SQLHSTMT
stmt,
8456 SQLCHAR *catalog, SQLSMALLINT catalogLen,
8457 SQLCHAR *schema, SQLSMALLINT schemaLen,
8458 SQLCHAR *proc, SQLSMALLINT procLen)
8485 SQLWCHAR *catalog, SQLSMALLINT catalogLen,
8486 SQLWCHAR *schema, SQLSMALLINT schemaLen,
8487 SQLWCHAR *proc, SQLSMALLINT procLen)
8504 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_QUALIFIER",
SCOL_VARCHAR, 50 },
8505 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_OWNER",
SCOL_VARCHAR, 50 },
8506 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_NAME",
SCOL_VARCHAR, 255 },
8507 {
"SYSTEM",
"PROCCOL",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
8508 {
"SYSTEM",
"PROCCOL",
"COLUMN_TYPE", SQL_SMALLINT, 5 },
8509 {
"SYSTEM",
"PROCCOL",
"DATA_TYPE", SQL_SMALLINT, 5 },
8510 {
"SYSTEM",
"PROCCOL",
"TYPE_NAME",
SCOL_VARCHAR, 50 },
8511 {
"SYSTEM",
"PROCCOL",
"PRECISION", SQL_INTEGER, 10 },
8512 {
"SYSTEM",
"PROCCOL",
"LENGTH", SQL_INTEGER, 10 },
8513 {
"SYSTEM",
"PROCCOL",
"SCALE", SQL_SMALLINT, 5 },
8514 {
"SYSTEM",
"PROCCOL",
"RADIX", SQL_SMALLINT, 5 },
8515 {
"SYSTEM",
"PROCCOL",
"NULLABLE", SQL_SMALLINT, 5 },
8517 {
"SYSTEM",
"PROCCOL",
"COLUMN_DEF",
SCOL_VARCHAR, 50 },
8518 {
"SYSTEM",
"PROCCOL",
"SQL_DATA_TYPE", SQL_SMALLINT, 5 },
8519 {
"SYSTEM",
"PROCCOL",
"SQL_DATETIME_SUB", SQL_SMALLINT, 5 },
8520 {
"SYSTEM",
"PROCCOL",
"CHAR_OCTET_LENGTH", SQL_SMALLINT, 5 },
8521 {
"SYSTEM",
"PROCCOL",
"ORDINAL_POSITION", SQL_SMALLINT, 5 },
8522 {
"SYSTEM",
"PROCCOL",
"IS_NULLABLE",
SCOL_VARCHAR, 50 }
8526 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_CAT",
SCOL_VARCHAR, 50 },
8527 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_SCHEM",
SCOL_VARCHAR, 50 },
8528 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_NAME",
SCOL_VARCHAR, 255 },
8529 {
"SYSTEM",
"PROCCOL",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
8530 {
"SYSTEM",
"PROCCOL",
"COLUMN_TYPE", SQL_SMALLINT, 5 },
8531 {
"SYSTEM",
"PROCCOL",
"DATA_TYPE", SQL_SMALLINT, 5 },
8532 {
"SYSTEM",
"PROCCOL",
"TYPE_NAME",
SCOL_VARCHAR, 50 },
8533 {
"SYSTEM",
"PROCCOL",
"COLUMN_SIZE", SQL_INTEGER, 10 },
8534 {
"SYSTEM",
"PROCCOL",
"BUFFER_LENGTH", SQL_INTEGER, 10 },
8535 {
"SYSTEM",
"PROCCOL",
"DECIMAL_DIGITS", SQL_SMALLINT, 5 },
8536 {
"SYSTEM",
"PROCCOL",
"NUM_PREC_RADIX", SQL_SMALLINT, 5 },
8537 {
"SYSTEM",
"PROCCOL",
"NULLABLE", SQL_SMALLINT, 5 },
8539 {
"SYSTEM",
"PROCCOL",
"COLUMN_DEF",
SCOL_VARCHAR, 50 },
8540 {
"SYSTEM",
"PROCCOL",
"SQL_DATA_TYPE", SQL_SMALLINT, 5 },
8541 {
"SYSTEM",
"PROCCOL",
"SQL_DATETIME_SUB", SQL_SMALLINT, 5 },
8542 {
"SYSTEM",
"PROCCOL",
"CHAR_OCTET_LENGTH", SQL_SMALLINT, 5 },
8543 {
"SYSTEM",
"PROCCOL",
"ORDINAL_POSITION", SQL_SMALLINT, 5 },
8544 {
"SYSTEM",
"PROCCOL",
"IS_NULLABLE",
SCOL_VARCHAR, 50 }
8563SQLProcedureColumns(SQLHSTMT
stmt,
8564 SQLCHAR *catalog, SQLSMALLINT catalogLen,
8565 SQLCHAR *schema, SQLSMALLINT schemaLen,
8566 SQLCHAR *proc, SQLSMALLINT procLen,
8567 SQLCHAR *column, SQLSMALLINT columnLen)
8597 SQLWCHAR *catalog, SQLSMALLINT catalogLen,
8598 SQLWCHAR *schema, SQLSMALLINT schemaLen,
8599 SQLWCHAR *proc, SQLSMALLINT procLen,
8600 SQLWCHAR *column, SQLSMALLINT columnLen)
8624 SQLINTEGER len, SQLINTEGER *lenp)
8627 SQLRETURN ret = SQL_ERROR;
8629 if (env == SQL_NULL_HENV) {
8630 return SQL_INVALID_HANDLE;
8634 return SQL_INVALID_HANDLE;
8636#if defined(_WIN32) || defined(_WIN64)
8637 EnterCriticalSection(&e->cs);
8640 case SQL_ATTR_CONNECTION_POOLING:
8642 *((SQLINTEGER *) val) = e->
pool ?
8643 SQL_CP_ONE_PER_DRIVER : SQL_CP_OFF;
8646 *lenp =
sizeof (SQLINTEGER);
8650 case SQL_ATTR_CP_MATCH:
8651 *((SQLINTEGER *) val) = SQL_CP_RELAXED_MATCH;
8653 *lenp =
sizeof (SQLINTEGER);
8657 case SQL_ATTR_OUTPUT_NTS:
8659 *((SQLINTEGER *) val) = SQL_TRUE;
8662 *lenp =
sizeof (SQLINTEGER);
8666 case SQL_ATTR_ODBC_VERSION:
8668 *((SQLINTEGER *) val) = e->
ov3 ? SQL_OV_ODBC3 : SQL_OV_ODBC2;
8671 *lenp =
sizeof (SQLINTEGER);
8676#if defined(_WIN32) || defined(_WIN64)
8677 LeaveCriticalSection(&e->cs);
8695 SQLRETURN ret = SQL_ERROR;
8697 if (env == SQL_NULL_HENV) {
8698 return SQL_INVALID_HANDLE;
8702 return SQL_INVALID_HANDLE;
8704#if defined(_WIN32) || defined(_WIN64)
8705 EnterCriticalSection(&e->cs);
8708 case SQL_ATTR_CONNECTION_POOLING:
8709 if (val == (SQLPOINTER) SQL_CP_ONE_PER_DRIVER) {
8712 }
else if (val == (SQLPOINTER) SQL_CP_OFF) {
8717 case SQL_ATTR_CP_MATCH:
8720 case SQL_ATTR_OUTPUT_NTS:
8721 if (val == (SQLPOINTER) SQL_TRUE) {
8725 case SQL_ATTR_ODBC_VERSION:
8729 if (val == (SQLPOINTER) SQL_OV_ODBC2) {
8732 }
else if (val == (SQLPOINTER) SQL_OV_ODBC3) {
8738#if defined(_WIN32) || defined(_WIN64)
8739 LeaveCriticalSection(&e->cs);
8759 SQLCHAR *sqlstate, SQLINTEGER *nativeerr, SQLCHAR *msg,
8760 SQLSMALLINT buflen, SQLSMALLINT *msglen)
8765 char *logmsg, *sqlst;
8766 SQLRETURN ret = SQL_ERROR;
8768 if (handle == SQL_NULL_HANDLE) {
8769 return SQL_INVALID_HANDLE;
8774 if (msg && buflen > 0) {
8784 case SQL_HANDLE_ENV:
8785 case SQL_HANDLE_DESC:
8787 case SQL_HANDLE_DBC:
8790 logmsg = (
char *) d->
logmsg;
8794 case SQL_HANDLE_STMT:
8796 s = (
STMT *) handle;
8797 logmsg = (
char *) s->
logmsg;
8802 return SQL_INVALID_HANDLE;
8811 len = strlen(logmsg);
8817 *nativeerr = naterr;
8820 strcpy((
char *) sqlstate, sqlst);
8825 if (len >= buflen) {
8826 if (msg && buflen > 0) {
8827 strncpy((
char *) msg, logmsg, buflen);
8828 msg[buflen - 1] =
'\0';
8832 strcpy((
char *) msg, logmsg);
8838 case SQL_HANDLE_DBC:
8841 case SQL_HANDLE_STMT:
8848#if !defined(WINTERFACE) || (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC))
8863SQLGetDiagRec(SQLSMALLINT htype, SQLHANDLE handle, SQLSMALLINT recno,
8864 SQLCHAR *sqlstate, SQLINTEGER *nativeerr, SQLCHAR *msg,
8865 SQLSMALLINT buflen, SQLSMALLINT *msglen)
8868 nativeerr, msg, buflen, msglen);
8872#if !defined(HAVE_UNIXODBC) || !(HAVE_UNIXODBC)
8890 SQLWCHAR *sqlstate, SQLINTEGER *nativeerr, SQLWCHAR *msg,
8891 SQLSMALLINT buflen, SQLSMALLINT *msglen)
8897 ret =
drvgetdiagrec(htype, handle, recno, (SQLCHAR *) state,
8898 nativeerr, (SQLCHAR *) msg, buflen, &len);
8899 if (ret == SQL_SUCCESS) {
8902 6 *
sizeof (SQLWCHAR));
8911 buflen /=
sizeof (SQLWCHAR);
8931 len *=
sizeof (SQLWCHAR);
8936 }
else if (ret == SQL_NO_DATA) {
8968 SQLSMALLINT
id, SQLPOINTER info,
8969 SQLSMALLINT buflen, SQLSMALLINT *stringlen)
8973 int len, naterr,
strbuf = 1;
8974 char *logmsg, *sqlst, *clrmsg = NULL;
8975 SQLRETURN ret = SQL_ERROR;
8977 if (handle == SQL_NULL_HANDLE) {
8978 return SQL_INVALID_HANDLE;
8984 case SQL_HANDLE_ENV:
8985 case SQL_HANDLE_DESC:
8987 case SQL_HANDLE_DBC:
8990 logmsg = (
char *) d->
logmsg;
8994 case SQL_HANDLE_STMT:
8996 s = (
STMT *) handle;
8998 logmsg = (
char *) s->
logmsg;
9003 return SQL_INVALID_HANDLE;
9007 case SQL_IS_POINTER:
9008 case SQL_IS_UINTEGER:
9009 case SQL_IS_INTEGER:
9010 case SQL_IS_USMALLINT:
9011 case SQL_IS_SMALLINT:
9024 case SQL_DIAG_CLASS_ORIGIN:
9025 logmsg =
"ISO 9075";
9026 if (sqlst[0] ==
'I' && sqlst[1] ==
'M') {
9027 logmsg =
"ODBC 3.0";
9030 case SQL_DIAG_SUBCLASS_ORIGIN:
9031 logmsg =
"ISO 9075";
9032 if (sqlst[0] ==
'I' && sqlst[1] ==
'M') {
9033 logmsg =
"ODBC 3.0";
9034 }
else if (sqlst[0] ==
'H' && sqlst[1] ==
'Y') {
9035 logmsg =
"ODBC 3.0";
9036 }
else if (sqlst[0] ==
'2' || sqlst[0] ==
'0' || sqlst[0] ==
'4') {
9037 logmsg =
"ODBC 3.0";
9040 case SQL_DIAG_CONNECTION_NAME:
9041 case SQL_DIAG_SERVER_NAME:
9042 logmsg = d->
dsn ? d->
dsn :
"No DSN";
9044 case SQL_DIAG_SQLSTATE:
9047 case SQL_DIAG_MESSAGE_TEXT:
9052 case SQL_DIAG_NUMBER:
9055 case SQL_DIAG_NATIVE:
9056 len = strlen(logmsg);
9062 *((SQLINTEGER *) info) = naterr;
9066 case SQL_DIAG_DYNAMIC_FUNCTION:
9069 case SQL_DIAG_CURSOR_ROW_COUNT:
9070 if (htype == SQL_HANDLE_STMT) {
9078 case SQL_DIAG_ROW_COUNT:
9079 if (htype == SQL_HANDLE_STMT) {
9090 if (info && buflen > 0) {
9091 ((
char *) info)[0] =
'\0';
9093 len = strlen(logmsg);
9102 if (len >= buflen) {
9103 if (info && buflen > 0) {
9105 *stringlen = buflen - 1;
9107 strncpy((
char *) info, logmsg, buflen);
9108 ((
char *) info)[buflen - 1] =
'\0';
9111 strcpy((
char *) info, logmsg);
9120 case SQL_HANDLE_DBC:
9123 case SQL_HANDLE_STMT:
9144SQLGetDiagField(SQLSMALLINT htype, SQLHANDLE handle, SQLSMALLINT recno,
9145 SQLSMALLINT
id, SQLPOINTER info,
9146 SQLSMALLINT buflen, SQLSMALLINT *stringlen)
9148 return drvgetdiagfield(htype, handle, recno,
id, info, buflen, stringlen);
9167 SQLSMALLINT
id, SQLPOINTER info,
9168 SQLSMALLINT buflen, SQLSMALLINT *stringlen)
9174 if (ret == SQL_SUCCESS) {
9177 case SQL_DIAG_CLASS_ORIGIN:
9178 case SQL_DIAG_SUBCLASS_ORIGIN:
9179 case SQL_DIAG_CONNECTION_NAME:
9180 case SQL_DIAG_SERVER_NAME:
9181 case SQL_DIAG_SQLSTATE:
9182 case SQL_DIAG_MESSAGE_TEXT:
9183 case SQL_DIAG_DYNAMIC_FUNCTION:
9190 buflen /=
sizeof (SQLWCHAR);
9198 len *=
sizeof (SQLWCHAR);
9206 ((SQLWCHAR *) info)[0] = 0;
9212 case SQL_DIAG_CLASS_ORIGIN:
9213 case SQL_DIAG_SUBCLASS_ORIGIN:
9214 case SQL_DIAG_CONNECTION_NAME:
9215 case SQL_DIAG_SERVER_NAME:
9216 case SQL_DIAG_SQLSTATE:
9217 case SQL_DIAG_MESSAGE_TEXT:
9218 case SQL_DIAG_DYNAMIC_FUNCTION:
9219 len *=
sizeof (SQLWCHAR);
9243 SQLINTEGER bufmax, SQLINTEGER *buflen)
9254 uval = (SQLPOINTER) dummybuf;
9257 case SQL_QUERY_TIMEOUT:
9261 case SQL_ATTR_CURSOR_TYPE:
9265 case SQL_ATTR_CURSOR_SCROLLABLE:
9266 *uval = (s->
curtype != SQL_CURSOR_FORWARD_ONLY) ?
9267 SQL_SCROLLABLE : SQL_NONSCROLLABLE;
9270#ifdef SQL_ATTR_CURSOR_SENSITIVITY
9271 case SQL_ATTR_CURSOR_SENSITIVITY:
9272 *uval = SQL_UNSPECIFIED;
9276 case SQL_ATTR_ROW_NUMBER:
9281 *uval = (s->
rowp < 0) ? SQL_ROW_NUMBER_UNKNOWN : (s->
rowp + 1);
9285 case SQL_ATTR_ASYNC_ENABLE:
9286 *uval = SQL_ASYNC_ENABLE_OFF;
9289 case SQL_CONCURRENCY:
9290 *uval = SQL_CONCUR_LOCK;
9293 case SQL_ATTR_RETRIEVE_DATA:
9297 case SQL_ROWSET_SIZE:
9298 case SQL_ATTR_ROW_ARRAY_SIZE:
9303 case SQL_ATTR_IMP_ROW_DESC:
9304 case SQL_ATTR_APP_ROW_DESC:
9305 case SQL_ATTR_IMP_PARAM_DESC:
9306 case SQL_ATTR_APP_PARAM_DESC:
9307 *((SQLHDESC *) uval) = (SQLHDESC)
DEAD_MAGIC;
9308 *buflen =
sizeof (SQLHDESC);
9310 case SQL_ATTR_ROW_STATUS_PTR:
9312 *buflen =
sizeof (SQLUSMALLINT *);
9314 case SQL_ATTR_ROWS_FETCHED_PTR:
9318 case SQL_ATTR_USE_BOOKMARKS: {
9321 *(SQLUINTEGER *) uval = s->
bkmrk;
9322 *buflen =
sizeof (SQLUINTEGER);
9325 case SQL_ATTR_FETCH_BOOKMARK_PTR:
9326 *(SQLPOINTER *) uval = s->
bkmrkptr;
9327 *buflen =
sizeof (SQLPOINTER);
9329 case SQL_ATTR_PARAM_BIND_OFFSET_PTR:
9333 case SQL_ATTR_PARAM_BIND_TYPE:
9337 case SQL_ATTR_PARAM_OPERATION_PTR:
9338 *((SQLUSMALLINT **) uval) = s->
parm_oper;
9339 *buflen =
sizeof (SQLUSMALLINT *);
9341 case SQL_ATTR_PARAM_STATUS_PTR:
9343 *buflen =
sizeof (SQLUSMALLINT *);
9345 case SQL_ATTR_PARAMS_PROCESSED_PTR:
9349 case SQL_ATTR_PARAMSET_SIZE:
9353 case SQL_ATTR_ROW_BIND_TYPE:
9357 case SQL_ATTR_ROW_BIND_OFFSET_PTR:
9361 case SQL_ATTR_MAX_ROWS:
9365 case SQL_ATTR_MAX_LENGTH:
9366 *((
SQLULEN *) uval) = 1000000000;
9369#ifdef SQL_ATTR_METADATA_ID
9370 case SQL_ATTR_METADATA_ID:
9371 *((
SQLULEN *) uval) = SQL_FALSE;
9379#if (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC)) || !defined(WINTERFACE)
9391SQLGetStmtAttr(SQLHSTMT
stmt, SQLINTEGER attr, SQLPOINTER val,
9392 SQLINTEGER bufmax, SQLINTEGER *buflen)
9416 SQLINTEGER bufmax, SQLINTEGER *buflen)
9441#if defined(SQL_BIGINT) && defined(__WORDSIZE) && (__WORDSIZE == 64)
9444 uval = (SQLBIGINT) val;
9451 case SQL_ATTR_CURSOR_TYPE:
9452 if (val == (SQLPOINTER) SQL_CURSOR_FORWARD_ONLY) {
9453 s->
curtype = SQL_CURSOR_FORWARD_ONLY;
9455 s->
curtype = SQL_CURSOR_STATIC;
9457 if (val != (SQLPOINTER) SQL_CURSOR_FORWARD_ONLY &&
9458 val != (SQLPOINTER) SQL_CURSOR_STATIC) {
9462 case SQL_ATTR_CURSOR_SCROLLABLE:
9463 if (val == (SQLPOINTER) SQL_NONSCROLLABLE) {
9464 s->
curtype = SQL_CURSOR_FORWARD_ONLY;
9466 s->
curtype = SQL_CURSOR_STATIC;
9469 case SQL_ATTR_ASYNC_ENABLE:
9470 if (val != (SQLPOINTER) SQL_ASYNC_ENABLE_OFF) {
9472 setstat(s, -1,
"option value changed",
"01S02");
9473 return SQL_SUCCESS_WITH_INFO;
9476 case SQL_CONCURRENCY:
9477 if (val != (SQLPOINTER) SQL_CONCUR_LOCK) {
9481#ifdef SQL_ATTR_CURSOR_SENSITIVITY
9482 case SQL_ATTR_CURSOR_SENSITIVITY:
9483 if (val != (SQLPOINTER) SQL_UNSPECIFIED) {
9488 case SQL_ATTR_QUERY_TIMEOUT:
9490 case SQL_ATTR_RETRIEVE_DATA:
9491 if (val != (SQLPOINTER) SQL_RD_ON &&
9492 val != (SQLPOINTER) SQL_RD_OFF) {
9497 case SQL_ROWSET_SIZE:
9498 case SQL_ATTR_ROW_ARRAY_SIZE:
9500 setstat(s, -1,
"invalid rowset size",
"HY000");
9506 rst =
xmalloc(
sizeof (SQLUSMALLINT) * uval);
9518 case SQL_ATTR_ROW_STATUS_PTR:
9521 case SQL_ATTR_ROWS_FETCHED_PTR:
9524 case SQL_ATTR_PARAM_BIND_OFFSET_PTR:
9527 case SQL_ATTR_PARAM_BIND_TYPE:
9530 case SQL_ATTR_PARAM_OPERATION_PTR:
9533 case SQL_ATTR_PARAM_STATUS_PTR:
9536 case SQL_ATTR_PARAMS_PROCESSED_PTR:
9539 case SQL_ATTR_PARAMSET_SIZE:
9546 case SQL_ATTR_ROW_BIND_TYPE:
9549 case SQL_ATTR_ROW_BIND_OFFSET_PTR:
9552 case SQL_ATTR_USE_BOOKMARKS:
9553 if (val != (SQLPOINTER) SQL_UB_OFF &&
9554 val != (SQLPOINTER) SQL_UB_ON &&
9555 val != (SQLPOINTER) SQL_UB_VARIABLE) {
9558 if (*s->
ov3 && val == (SQLPOINTER) SQL_UB_VARIABLE) {
9559 s->
bkmrk = SQL_UB_VARIABLE;
9562 if (val == (SQLPOINTER) SQL_UB_VARIABLE) {
9563 s->
bkmrk = SQL_UB_ON;
9566 s->
bkmrk = (val == (SQLPOINTER) SQL_UB_ON) ? SQL_UB_ON : SQL_UB_OFF;
9568 case SQL_ATTR_FETCH_BOOKMARK_PTR:
9571 case SQL_ATTR_MAX_ROWS:
9574 case SQL_ATTR_MAX_LENGTH:
9575 if (val != (SQLPOINTER) 1000000000) {
9579#ifdef SQL_ATTR_METADATA_ID
9580 case SQL_ATTR_METADATA_ID:
9581 if (val != (SQLPOINTER) SQL_FALSE) {
9590#if (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC)) || !defined(WINTERFACE)
9601SQLSetStmtAttr(SQLHSTMT
stmt, SQLINTEGER attr, SQLPOINTER val,
9648 SQLUINTEGER *ret = (SQLUINTEGER *) param;
9651 case SQL_QUERY_TIMEOUT:
9654 case SQL_CURSOR_TYPE:
9657 case SQL_ROW_NUMBER:
9662 *ret = (s->
rowp < 0) ? SQL_ROW_NUMBER_UNKNOWN : (s->
rowp + 1);
9665 case SQL_ASYNC_ENABLE:
9666 *ret = SQL_ASYNC_ENABLE_OFF;
9668 case SQL_CONCURRENCY:
9669 *ret = SQL_CONCUR_LOCK;
9671 case SQL_ATTR_RETRIEVE_DATA:
9674 case SQL_ROWSET_SIZE:
9675 case SQL_ATTR_ROW_ARRAY_SIZE:
9678 case SQL_ATTR_MAX_ROWS:
9681 case SQL_ATTR_MAX_LENGTH:
9742 case SQL_CURSOR_TYPE:
9743 if (param == SQL_CURSOR_FORWARD_ONLY) {
9746 s->
curtype = SQL_CURSOR_STATIC;
9748 if (param != SQL_CURSOR_FORWARD_ONLY &&
9749 param != SQL_CURSOR_STATIC) {
9753 case SQL_ASYNC_ENABLE:
9754 if (param != SQL_ASYNC_ENABLE_OFF) {
9758 case SQL_CONCURRENCY:
9759 if (param != SQL_CONCUR_LOCK) {
9763 case SQL_QUERY_TIMEOUT:
9765 case SQL_RETRIEVE_DATA:
9766 if (param != SQL_RD_ON && param != SQL_RD_OFF) {
9768 setstat(s, -1,
"option value changed",
"01S02");
9769 return SQL_SUCCESS_WITH_INFO;
9773 case SQL_ROWSET_SIZE:
9774 case SQL_ATTR_ROW_ARRAY_SIZE:
9776 setstat(s, -1,
"invalid rowset size",
"HY000");
9782 rst =
xmalloc(
sizeof (SQLUSMALLINT) * param);
9794 case SQL_ATTR_MAX_ROWS:
9797 case SQL_ATTR_MAX_LENGTH:
9798 if (param != 1000000000) {
9861 setstat(s, -1,
"unbound columns", (*s->
ov3) ?
"HY000" :
"S1000");
9864 for (i = 0; i < s->
ncols; i++) {
9867 if (b->
type == SQL_UNKNOWN_TYPE || !b->
valp) {
9896 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
9899 dp = (SQLPOINTER) ((
char *) b->
valp + b->
max * rsi);
9902 dp = (SQLPOINTER) ((
char *) dp + *s->
bind_offs);
9906 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
9916 setstat(s, -1,
"unbound column in positional update",
9917 (*s->
ov3) ?
"HY000" :
"S1000");
9920 if (*lp == SQL_NULL_DATA) {
9921 sqlite3_bind_null(
stmt, si);
9923 fprintf(d->
trace,
"-- parameter %d: NULL\n", si);
9929 case SQL_C_UTINYINT:
9931 case SQL_C_STINYINT:
9932 sqlite3_bind_int(
stmt, si, *(SQLCHAR *) dp);
9934 fprintf(d->
trace,
"-- parameter %d: %d\n", si, *(SQLCHAR *) dp);
9940 sqlite3_bind_int(
stmt, si, (*(SQLCHAR *) dp) ? 1 : 0);
9942 fprintf(d->
trace,
"-- parameter %d: %d\n", si,
9943 (*(SQLCHAR *) dp) ? 1 : 0);
9949 sqlite3_bind_int(
stmt, si, *(SQLUSMALLINT *) dp);
9951 fprintf(d->
trace,
"-- parameter %d: %d\n", si,
9952 *(SQLUSMALLINT *) dp);
9958 sqlite3_bind_int(
stmt, si, *(SQLSMALLINT *) dp);
9960 fprintf(d->
trace,
"-- parameter %d: %d\n", si,
9961 *(SQLSMALLINT *) dp);
9966 sqlite3_bind_int(
stmt, si, *(SQLUINTEGER *) dp);
9968 fprintf(d->
trace,
"-- parameter %d: %ld\n", si,
9969 (
long) *(SQLUINTEGER *) dp);
9975 sqlite3_bind_int(
stmt, si, *(SQLINTEGER *) dp);
9977 fprintf(d->
trace,
"-- parameter %d: %ld\n", si,
9978 (
long) *(SQLINTEGER *) dp);
9985 sqlite3_bind_int64(
stmt, si, *(SQLBIGINT *) dp);
9989 "-- parameter %d: %I64d\n",
9991 "-- parameter %d: %lld\n",
9993 si, (sqlite_int64) *(SQLBIGINT *) dp);
9999 sqlite3_bind_double(
stmt, si, *(
float *) dp);
10001 fprintf(d->
trace,
"-- parameter %d: %g\n", si,
10007 sqlite3_bind_double(
stmt, si, *(
double *) dp);
10009 fprintf(d->
trace,
"-- parameter %d: %g\n", si,
10015 sqlite3_bind_blob(
stmt, si, (
char *) dp, *lp, SQLITE_STATIC);
10017 fprintf(d->
trace,
"-- parameter %d: [BLOB]\n", si);
10027 sqlite3_bind_text(
stmt, si, cp, -1, SQLITE_TRANSIENT);
10029 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si, cp);
10036#if defined(_WIN32) || defined(_WIN64)
10038 cp = wmb_to_utf((
char *) dp, *lp);
10042 sqlite3_bind_text(
stmt, si, cp, -1, SQLITE_TRANSIENT);
10044 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si, cp);
10051 if (*lp == SQL_NTS) {
10052 sqlite3_bind_text(
stmt, si, (
char *) dp, -1,
10055 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si,
10060 sqlite3_bind_text(
stmt, si, (
char *) dp, *lp,
10063 fprintf(d->
trace,
"-- parameter %d: '%*s'\n", si,
10064 (
int) *lp, (
char *) dp);
10070#ifdef SQL_C_TYPE_DATE
10071 case SQL_C_TYPE_DATE:
10075 int a, b, x1, x2, y, m, dd;
10078 y = ((DATE_STRUCT *) dp)->year;
10079 m = ((DATE_STRUCT *) dp)->month;
10080 dd = ((DATE_STRUCT *) dp)->day;
10086 b = 2 - a + (a / 4);
10087 x1 = 36525 * (y + 4716) / 100;
10088 x2 = 306001 * (m + 1) / 10000;
10089 v = x1 + x2 + dd + b - 1524.5;
10090 sqlite3_bind_double(
stmt, si, v);
10092 fprintf(d->
trace,
"-- parameter %d: %g\n", si, v);
10096 sprintf(
strbuf,
"%04d-%02d-%02d",
10097 ((DATE_STRUCT *) dp)->year,
10098 ((DATE_STRUCT *) dp)->month,
10099 ((DATE_STRUCT *) dp)->day);
10100 sqlite3_bind_text(
stmt, si,
strbuf, -1, SQLITE_TRANSIENT);
10102 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si,
strbuf);
10107#ifdef SQL_C_TYPE_TIME
10108 case SQL_C_TYPE_TIME:
10115 (((TIME_STRUCT *) dp)->hour * 3600000.0 +
10116 ((TIME_STRUCT *) dp)->minute * 60000.0 +
10117 ((TIME_STRUCT *) dp)->second * 1000.0) / 86400000.0;
10118 sqlite3_bind_double(
stmt, si, v);
10120 fprintf(d->
trace,
"-- parameter %d: %g\n", si, v);
10124 sprintf(
strbuf,
"%02d:%02d:%02d",
10125 ((TIME_STRUCT *) dp)->hour,
10126 ((TIME_STRUCT *) dp)->minute,
10127 ((TIME_STRUCT *) dp)->second);
10128 sqlite3_bind_text(
stmt, si,
strbuf, -1, SQLITE_TRANSIENT);
10130 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si,
strbuf);
10135#ifdef SQL_C_TYPE_TIMESTAMP
10136 case SQL_C_TYPE_TIMESTAMP:
10138 case SQL_C_TIMESTAMP:
10140 int a, b, x1, x2, y, m, dd;
10143 y = ((TIMESTAMP_STRUCT *) dp)->year;
10144 m = ((TIMESTAMP_STRUCT *) dp)->month;
10145 dd = ((TIMESTAMP_STRUCT *) dp)->day;
10151 b = 2 - a + (a / 4);
10152 x1 = 36525 * (y + 4716) / 100;
10153 x2 = 306001 * (m + 1) / 10000;
10154 v = x1 + x2 + dd + b - 1524.5 +
10155 (((TIMESTAMP_STRUCT *) dp)->hour * 3600000.0 +
10156 ((TIMESTAMP_STRUCT *) dp)->minute * 60000.0 +
10157 ((TIMESTAMP_STRUCT *) dp)->second * 1000.0 +
10158 ((TIMESTAMP_STRUCT *) dp)->fraction / 1.0E6)
10160 sqlite3_bind_double(
stmt, si, v);
10162 fprintf(d->
trace,
"-- parameter %d: %g\n", si, v);
10168 frac = (int) ((TIMESTAMP_STRUCT *) dp)->fraction;
10170 frac = frac % 1000;
10175 sprintf(
strbuf,
"%04d-%02d-%02d %02d:%02d:00.000",
10176 ((TIMESTAMP_STRUCT *) dp)->year,
10177 ((TIMESTAMP_STRUCT *) dp)->month,
10178 ((TIMESTAMP_STRUCT *) dp)->day,
10179 ((TIMESTAMP_STRUCT *) dp)->hour,
10180 ((TIMESTAMP_STRUCT *) dp)->minute);
10181 }
else if (c->
prec && c->
prec <= 19) {
10182 sprintf(
strbuf,
"%04d-%02d-%02d %02d:%02d:%02d.000",
10183 ((TIMESTAMP_STRUCT *) dp)->year,
10184 ((TIMESTAMP_STRUCT *) dp)->month,
10185 ((TIMESTAMP_STRUCT *) dp)->day,
10186 ((TIMESTAMP_STRUCT *) dp)->hour,
10187 ((TIMESTAMP_STRUCT *) dp)->minute,
10188 ((TIMESTAMP_STRUCT *) dp)->second);
10190 sprintf(
strbuf,
"%04d-%02d-%02d %02d:%02d:%02d.%03d",
10191 ((TIMESTAMP_STRUCT *) dp)->year,
10192 ((TIMESTAMP_STRUCT *) dp)->month,
10193 ((TIMESTAMP_STRUCT *) dp)->day,
10194 ((TIMESTAMP_STRUCT *) dp)->hour,
10195 ((TIMESTAMP_STRUCT *) dp)->minute,
10196 ((TIMESTAMP_STRUCT *) dp)->second,
10199 sqlite3_bind_text(
stmt, si,
strbuf, -1, SQLITE_TRANSIENT);
10201 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si,
strbuf);
10207 setstat(s, -1,
"unsupported column type in positional update",
10208 (*s->
ov3) ?
"HY000" :
"S1000");
10211 return SQL_SUCCESS;
10234 setstat(s, -1,
"row out of range", (*s->
ov3) ?
"HY107" :
"S1107");
10239 if (*data == NULL) {
10240 sqlite3_bind_null(
stmt, si);
10242 fprintf(d->
trace,
"-- parameter %d: NULL\n", si);
10246 sqlite3_bind_text(
stmt, si, *data, -1, SQLITE_STATIC);
10248 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si, *data);
10252 return SQL_SUCCESS;
10265 int i, withinfo = 0;
10266 SQLRETURN ret = SQL_SUCCESS;
10275 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10278 dp = (SQLPOINTER) ((
char *) b->
valp + b->
max * rsi);
10281 dp = (SQLPOINTER) ((
char *) dp + *s->
bind_offs);
10285 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10288 lp = b->
lenp + rsi;
10295 int rowp = s->
rowp;
10301 if (!SQL_SUCCEEDED(ret)) {
10305 if (ret != SQL_SUCCESS) {
10307#ifdef SQL_ROW_SUCCESS_WITH_INFO
10313 if (SQL_SUCCEEDED(ret)) {
10314 ret = withinfo ? SQL_SUCCESS_WITH_INFO : SQL_SUCCESS;
10333 int rowp, i, k, rc, nretry = 0;
10336 sqlite3_stmt *s3stmt = NULL;
10339 if (lock != SQL_LOCK_NO_CHANGE) {
10340 setstat(s, -1,
"unsupported locking mode",
10341 (*s->
ov3) ?
"HY000" :
"S1000");
10345 setstat(s, -1,
"incompatible statement",
10346 (*s->
ov3) ?
"HY000" :
"S1000");
10349 if (op == SQL_ADD) {
10351 setstat(s, -1,
"incompatible rowset",
10352 (*s->
ov3) ?
"HY000" :
"S1000");
10359 if (ret != SQL_SUCCESS) {
10362 sql =
dsappend(sql,
"INSERT INTO ");
10368 for (i = 0; i < s->
ncols; i++) {
10369 sql =
dsappend(sql, (i > 0) ?
"," :
"(");
10373 for (i = 0; i < s->
ncols; i++) {
10374 sql =
dsappend(sql, (i > 0) ?
",?" :
"(?");
10381#if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10388#if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10389 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10395 if (rc != SQLITE_OK) {
10397 sqlite3_finalize(s3stmt);
10401 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10404 if (rc != SQLITE_OK) {
10406 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10407 sqlite3_errmsg(d->
sqlite), rc);
10410 sqlite3_finalize(s3stmt);
10416 if (ret != SQL_SUCCESS) {
10418 sqlite3_finalize(s3stmt);
10423 rc = sqlite3_step(s3stmt);
10424 if (rc != SQLITE_DONE) {
10427 sqlite3_finalize(s3stmt);
10428 if (sqlite3_changes(d->
sqlite) > 0 && row <= s->rowset_size) {
10436 return SQL_SUCCESS;
10437 }
else if (op == SQL_UPDATE || op == SQL_DELETE) {
10439 setstat(s, -1,
"incompatible rowset",
10440 (*s->
ov3) ?
"HY000" :
"S1000");
10447 if (!SQL_SUCCEEDED(ret)) {
10457 if (op != SQL_POSITION && op != SQL_REFRESH &&
10458 op != SQL_DELETE && op != SQL_UPDATE) {
10461 if (op == SQL_POSITION) {
10462 rowp = s->
rowp + row - 1;
10463 if (!s->
rows || row == 0 || rowp < -1 || rowp >= s->
nrows) {
10465 setstat(s, -1,
"row out of range", (*s->
ov3) ?
"HY107" :
"S1107");
10469 }
else if (op == SQL_REFRESH) {
10477 if (!SQL_SUCCEEDED(ret)) {
10484 }
else if (op == SQL_DELETE) {
10485 sql =
dsappend(sql,
"DELETE FROM ");
10491 for (i = k = 0; i < s->
ncols; i++) {
10495 sql =
dsappend(sql, (k > 0) ?
" AND " :
" WHERE ");
10504#if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10511#if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10512 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10518 if (rc != SQLITE_OK) {
10520 sqlite3_finalize(s3stmt);
10524 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10527 if (rc != SQLITE_OK) {
10529 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10530 sqlite3_errmsg(d->
sqlite), rc);
10533 sqlite3_finalize(s3stmt);
10542 if (ret != SQL_SUCCESS) {
10544 sqlite3_finalize(s3stmt);
10549 rc = sqlite3_step(s3stmt);
10550 if (rc != SQLITE_DONE) {
10553 sqlite3_finalize(s3stmt);
10554 if (sqlite3_changes(d->
sqlite) > 0) {
10562 return SQL_SUCCESS;
10563 }
else if (op == SQL_UPDATE) {
10565 if (ret != SQL_SUCCESS) {
10574 for (i = 0; i < s->
ncols; i++) {
10575 sql =
dsappend(sql, (i > 0) ?
", " :
" SET ");
10579 for (i = k = 0; i < s->
ncols; i++) {
10583 sql =
dsappend(sql, (k > 0) ?
" AND " :
" WHERE ");
10592#if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10599#if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10600 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10606 if (rc != SQLITE_OK) {
10608 sqlite3_finalize(s3stmt);
10612 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10615 if (rc != SQLITE_OK) {
10617 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10618 sqlite3_errmsg(d->
sqlite), rc);
10621 sqlite3_finalize(s3stmt);
10627 if (ret != SQL_SUCCESS) {
10629 sqlite3_finalize(s3stmt);
10639 if (ret != SQL_SUCCESS) {
10641 sqlite3_finalize(s3stmt);
10646 rc = sqlite3_step(s3stmt);
10647 if (rc != SQLITE_DONE) {
10650 sqlite3_finalize(s3stmt);
10651 if (sqlite3_changes(d->
sqlite) > 0) {
10659 return SQL_SUCCESS;
10661 return SQL_SUCCESS;
10696 int row, i, k, rc, nretry = 0;
10699 sqlite3_stmt *s3stmt = NULL;
10703 setstat(s, -1,
"incompatible statement",
10704 (*s->
ov3) ?
"HY000" :
"S1000");
10707 if (op == SQL_ADD) {
10709 setstat(s, -1,
"incompatible rowset",
10710 (*s->
ov3) ?
"HY000" :
"S1000");
10714 if (ret != SQL_SUCCESS) {
10717 sql =
dsappend(sql,
"INSERT INTO ");
10723 for (i = 0; i < s->
ncols; i++) {
10724 sql =
dsappend(sql, (i > 0) ?
"," :
"(");
10728 for (i = 0; i < s->
ncols; i++) {
10729 sql =
dsappend(sql, (i > 0) ?
",?" :
"(?");
10736#if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10743#if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10744 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10750 if (rc != SQLITE_OK) {
10752 sqlite3_finalize(s3stmt);
10756 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10759 if (rc != SQLITE_OK) {
10760 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10761 sqlite3_errmsg(d->
sqlite), rc);
10764 sqlite3_finalize(s3stmt);
10771 if (ret != SQL_SUCCESS) {
10780 sqlite3_finalize(s3stmt);
10785 rc = sqlite3_step(s3stmt);
10786 if (rc != SQLITE_DONE) {
10787 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10788 sqlite3_errmsg(d->
sqlite), rc);
10792 if (sqlite3_changes(d->
sqlite) > 0) {
10800 if (s->
bkmrk == SQL_UB_VARIABLE &&
10805 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10813 val = (SQLPOINTER) ((
char *) val + *s->
bind_offs);
10815 *(sqlite_int64 *) val = sqlite3_last_insert_rowid(d->
sqlite);
10819 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10828 *ival =
sizeof (sqlite_int64);
10832 sqlite3_reset(s3stmt);
10835 sqlite3_finalize(s3stmt);
10836 return SQL_SUCCESS;
10837 }
else if (op == SQL_DELETE_BY_BOOKMARK) {
10839 s->
bkmrk != SQL_UB_VARIABLE ||
10842 setstat(s, -1,
"incompatible rowset",
10843 (*s->
ov3) ?
"HY000" :
"S1000");
10846 sql =
dsappend(sql,
"DELETE FROM ");
10859#if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10866#if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
10867 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10873 if (rc != SQLITE_OK) {
10875 sqlite3_finalize(s3stmt);
10879 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10882 if (rc != SQLITE_OK) {
10883 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10884 sqlite3_errmsg(d->
sqlite), rc);
10887 sqlite3_finalize(s3stmt);
10893 sqlite_int64 rowid;
10895 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10903 val = (SQLPOINTER) ((
char *) val + *s->
bind_offs);
10908 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10917 if (*ival !=
sizeof (sqlite_int64)) {
10921 rowid = *(sqlite_int64 *) val;
10922 sqlite3_bind_int64(s3stmt, 1, rowid);
10926 "-- parameter 1: %I64d\n",
10928 "-- parameter 1: %lld\n",
10933 rc = sqlite3_step(s3stmt);
10934 if (rc != SQLITE_DONE) {
10935 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10936 sqlite3_errmsg(d->
sqlite), rc);
10944 sqlite3_finalize(s3stmt);
10947 if (sqlite3_changes(d->
sqlite) > 0) {
10956 sqlite3_reset(s3stmt);
10959 sqlite3_finalize(s3stmt);
10960 return SQL_SUCCESS;
10961 }
else if (op == SQL_UPDATE_BY_BOOKMARK) {
10963 s->
bkmrk != SQL_UB_VARIABLE ||
10966 setstat(s, -1,
"incompatible rowset",
10967 (*s->
ov3) ?
"HY000" :
"S1000");
10971 if (ret != SQL_SUCCESS) {
10980 for (i = 0, k = 0; i < s->
ncols; i++) {
10981 sql =
dsappend(sql, (k > 0) ?
", " :
" SET ");
10993#if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
11000#if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
11001 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
11007 if (rc != SQLITE_OK) {
11009 sqlite3_finalize(s3stmt);
11013 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
11016 if (rc != SQLITE_OK) {
11017 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
11018 sqlite3_errmsg(d->
sqlite), rc);
11021 sqlite3_finalize(s3stmt);
11027 sqlite_int64 rowid;
11029 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
11037 val = (SQLPOINTER) ((
char *) val + *s->
bind_offs);
11042 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
11051 if (*ival !=
sizeof (sqlite_int64)) {
11057 if (ret != SQL_SUCCESS) {
11066 sqlite3_finalize(s3stmt);
11071 rowid = *(sqlite_int64 *) val;
11072 sqlite3_bind_int64(s3stmt, k, rowid);
11076 "-- parameter %d: %I64d\n",
11078 "-- parameter %d: %lld\n",
11083 rc = sqlite3_step(s3stmt);
11084 if (rc != SQLITE_DONE) {
11085 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
11086 sqlite3_errmsg(d->
sqlite), rc);
11090 if (sqlite3_changes(d->
sqlite) > 0) {
11099 sqlite3_reset(s3stmt);
11102 sqlite3_finalize(s3stmt);
11103 return SQL_SUCCESS;
11105 setstat(s, -1,
"unsupported operation", (*s->
ov3) ?
"HY000" :
"S1000");
11134 SQLUSMALLINT rowset)
11144#define strmak(dst, src, max, lenp) { \
11145 int len = strlen(src); \
11146 int cnt = min(len + 1, max); \
11147 strncpy(dst, src, cnt); \
11148 *lenp = (cnt > len) ? len : cnt; \
11163 SQLSMALLINT *valLen)
11168#if defined(_WIN32) || defined(_WIN64)
11169 char pathbuf[301], *drvname;
11171 static char drvname[] =
"sqlite3odbc.so";
11174 if (
dbc == SQL_NULL_HDBC) {
11175 return SQL_INVALID_HANDLE;
11186 valMax =
sizeof (dummyc) - 1;
11189 case SQL_MAX_USER_NAME_LEN:
11190 *((SQLSMALLINT *) val) = 16;
11191 *valLen =
sizeof (SQLSMALLINT);
11193 case SQL_USER_NAME:
11194 strmak(val,
"", valMax, valLen);
11196 case SQL_DRIVER_ODBC_VER:
11198 strmak(val, (*d->
ov3) ?
"03.00" :
"02.50", valMax, valLen);
11200 strmak(val,
"03.00", valMax, valLen);
11203 case SQL_ACTIVE_CONNECTIONS:
11204 case SQL_ACTIVE_STATEMENTS:
11205 *((SQLSMALLINT *) val) = 0;
11206 *valLen =
sizeof (SQLSMALLINT);
11208#ifdef SQL_ASYNC_MODE
11209 case SQL_ASYNC_MODE:
11210 *((SQLUINTEGER *) val) = SQL_AM_NONE;
11211 *valLen =
sizeof (SQLUINTEGER);
11214#ifdef SQL_CREATE_TABLE
11215 case SQL_CREATE_TABLE:
11216 *((SQLUINTEGER *) val) = SQL_CT_CREATE_TABLE |
11217 SQL_CT_COLUMN_DEFAULT |
11218 SQL_CT_COLUMN_CONSTRAINT |
11219 SQL_CT_CONSTRAINT_NON_DEFERRABLE;
11220 *valLen =
sizeof (SQLUINTEGER);
11223#ifdef SQL_CREATE_VIEW
11224 case SQL_CREATE_VIEW:
11225 *((SQLUINTEGER *) val) = SQL_CV_CREATE_VIEW;
11226 *valLen =
sizeof (SQLUINTEGER);
11229#ifdef SQL_DDL_INDEX
11230 case SQL_DDL_INDEX:
11231 *((SQLUINTEGER *) val) = SQL_DI_CREATE_INDEX | SQL_DI_DROP_INDEX;
11232 *valLen =
sizeof (SQLUINTEGER);
11235#ifdef SQL_DROP_TABLE
11236 case SQL_DROP_TABLE:
11237 *((SQLUINTEGER *) val) = SQL_DT_DROP_TABLE;
11238 *valLen =
sizeof (SQLUINTEGER);
11241#ifdef SQL_DROP_VIEW
11242 case SQL_DROP_VIEW:
11243 *((SQLUINTEGER *) val) = SQL_DV_DROP_VIEW;
11244 *valLen =
sizeof (SQLUINTEGER);
11247#ifdef SQL_INDEX_KEYWORDS
11248 case SQL_INDEX_KEYWORDS:
11249 *((SQLUINTEGER *) val) = SQL_IK_ALL;
11250 *valLen =
sizeof (SQLUINTEGER);
11253 case SQL_DATA_SOURCE_NAME:
11256 case SQL_DRIVER_NAME:
11257#if defined(_WIN32) || defined(_WIN64)
11258 GetModuleFileName(hModule, pathbuf,
sizeof (pathbuf));
11259 drvname = strrchr(pathbuf,
'\\');
11260 if (drvname == NULL) {
11261 drvname = strrchr(pathbuf,
'/');
11263 if (drvname == NULL) {
11269 strmak(val, drvname, valMax, valLen);
11271 case SQL_DRIVER_VER:
11274 case SQL_FETCH_DIRECTION:
11275 *((SQLUINTEGER *) val) = SQL_FD_FETCH_NEXT | SQL_FD_FETCH_FIRST |
11276 SQL_FD_FETCH_LAST | SQL_FD_FETCH_PRIOR | SQL_FD_FETCH_ABSOLUTE;
11277 *valLen =
sizeof (SQLUINTEGER);
11280 strmak(val, (*d->
ov3) ?
"03.00" :
"02.50", valMax, valLen);
11282 case SQL_ODBC_SAG_CLI_CONFORMANCE:
11283 *((SQLSMALLINT *) val) = SQL_OSCC_NOT_COMPLIANT;
11284 *valLen =
sizeof (SQLSMALLINT);
11286 case SQL_STANDARD_CLI_CONFORMANCE:
11287 *((SQLUINTEGER *) val) = SQL_SCC_XOPEN_CLI_VERSION1;
11288 *valLen =
sizeof (SQLUINTEGER);
11290 case SQL_SQL_CONFORMANCE:
11291 *((SQLUINTEGER *) val) = SQL_SC_SQL92_ENTRY;
11292 *valLen =
sizeof (SQLUINTEGER);
11294 case SQL_SERVER_NAME:
11295 case SQL_DATABASE_NAME:
11298 case SQL_SEARCH_PATTERN_ESCAPE:
11299 strmak(val,
"\\", valMax, valLen);
11301 case SQL_ODBC_SQL_CONFORMANCE:
11302 *((SQLSMALLINT *) val) = SQL_OSC_MINIMUM;
11303 *valLen =
sizeof (SQLSMALLINT);
11305 case SQL_ODBC_API_CONFORMANCE:
11306 *((SQLSMALLINT *) val) = SQL_OAC_LEVEL1;
11307 *valLen =
sizeof (SQLSMALLINT);
11309 case SQL_DBMS_NAME:
11310 strmak(val,
"SQLite", valMax, valLen);
11313 strmak(val, SQLITE_VERSION, valMax, valLen);
11315 case SQL_COLUMN_ALIAS:
11316 case SQL_NEED_LONG_DATA_LEN:
11317 case SQL_OUTER_JOINS:
11318 strmak(val,
"Y", valMax, valLen);
11320 case SQL_ROW_UPDATES:
11321 case SQL_ACCESSIBLE_PROCEDURES:
11322 case SQL_PROCEDURES:
11323 case SQL_EXPRESSIONS_IN_ORDERBY:
11324 case SQL_ODBC_SQL_OPT_IEF:
11325 case SQL_LIKE_ESCAPE_CLAUSE:
11326 case SQL_ORDER_BY_COLUMNS_IN_SELECT:
11327 case SQL_ACCESSIBLE_TABLES:
11328 case SQL_MULT_RESULT_SETS:
11329 case SQL_MULTIPLE_ACTIVE_TXN:
11330 case SQL_MAX_ROW_SIZE_INCLUDES_LONG:
11331 strmak(val,
"N", valMax, valLen);
11333#ifdef SQL_CATALOG_NAME
11334 case SQL_CATALOG_NAME:
11335#if defined(_WIN32) || defined(_WIN64)
11336 strmak(val, d->xcelqrx ?
"Y" :
"N", valMax, valLen);
11338 strmak(val,
"N", valMax, valLen);
11342 case SQL_DATA_SOURCE_READ_ONLY:
11343 strmak(val,
"N", valMax, valLen);
11345#ifdef SQL_OJ_CAPABILITIES
11346 case SQL_OJ_CAPABILITIES:
11347 *((SQLUINTEGER *) val) = SQL_OJ_LEFT;
11348 *valLen =
sizeof (SQLUINTEGER);
11351#ifdef SQL_MAX_IDENTIFIER_LEN
11352 case SQL_MAX_IDENTIFIER_LEN:
11353 *((SQLUSMALLINT *) val) = 255;
11354 *valLen =
sizeof (SQLUSMALLINT);
11357 case SQL_CONCAT_NULL_BEHAVIOR:
11358 *((SQLSMALLINT *) val) = SQL_CB_NULL;
11359 *valLen =
sizeof (SQLSMALLINT);
11361 case SQL_CURSOR_COMMIT_BEHAVIOR:
11362 case SQL_CURSOR_ROLLBACK_BEHAVIOR:
11363 *((SQLSMALLINT *) val) = SQL_CB_PRESERVE;
11364 *valLen =
sizeof (SQLSMALLINT);
11366#ifdef SQL_CURSOR_SENSITIVITY
11367 case SQL_CURSOR_SENSITIVITY:
11368 *((SQLUINTEGER *) val) = SQL_UNSPECIFIED;
11369 *valLen =
sizeof (SQLUINTEGER);
11372 case SQL_DEFAULT_TXN_ISOLATION:
11373 *((SQLUINTEGER *) val) = SQL_TXN_SERIALIZABLE;
11374 *valLen =
sizeof (SQLUINTEGER);
11376#ifdef SQL_DESCRIBE_PARAMETER
11377 case SQL_DESCRIBE_PARAMETER:
11378 strmak(val,
"Y", valMax, valLen);
11381 case SQL_TXN_ISOLATION_OPTION:
11382 *((SQLUINTEGER *) val) = SQL_TXN_SERIALIZABLE;
11383 *valLen =
sizeof (SQLUINTEGER);
11385 case SQL_IDENTIFIER_CASE:
11386 *((SQLSMALLINT *) val) = SQL_IC_SENSITIVE;
11387 *valLen =
sizeof (SQLSMALLINT);
11389 case SQL_IDENTIFIER_QUOTE_CHAR:
11390 strmak(val,
"\"", valMax, valLen);
11392 case SQL_MAX_TABLE_NAME_LEN:
11393 case SQL_MAX_COLUMN_NAME_LEN:
11394 *((SQLSMALLINT *) val) = 255;
11395 *valLen =
sizeof (SQLSMALLINT);
11397 case SQL_MAX_CURSOR_NAME_LEN:
11398 *((SQLSMALLINT *) val) = 255;
11399 *valLen =
sizeof (SQLSMALLINT);
11401 case SQL_MAX_PROCEDURE_NAME_LEN:
11402 *((SQLSMALLINT *) val) = 0;
11404 case SQL_MAX_QUALIFIER_NAME_LEN:
11405 case SQL_MAX_OWNER_NAME_LEN:
11406 *((SQLSMALLINT *) val) = 255;
11408 case SQL_OWNER_TERM:
11409 strmak(val,
"", valMax, valLen);
11411 case SQL_PROCEDURE_TERM:
11412 strmak(val,
"PROCEDURE", valMax, valLen);
11414 case SQL_QUALIFIER_NAME_SEPARATOR:
11415 strmak(val,
".", valMax, valLen);
11417 case SQL_QUALIFIER_TERM:
11418#if defined(_WIN32) || defined(_WIN64)
11419 strmak(val, d->xcelqrx ?
"catalog" :
"", valMax, valLen);
11421 strmak(val,
"", valMax, valLen);
11424 case SQL_QUALIFIER_USAGE:
11425#if defined(_WIN32) || defined(_WIN64)
11426 *((SQLUINTEGER *) val) = d->xcelqrx ?
11427 (SQL_CU_DML_STATEMENTS | SQL_CU_INDEX_DEFINITION |
11428 SQL_CU_TABLE_DEFINITION) : 0;
11430 *((SQLUINTEGER *) val) = 0;
11432 *valLen =
sizeof (SQLUINTEGER);
11434 case SQL_SCROLL_CONCURRENCY:
11435 *((SQLUINTEGER *) val) = SQL_SCCO_LOCK;
11436 *valLen =
sizeof (SQLUINTEGER);
11438 case SQL_SCROLL_OPTIONS:
11439 *((SQLUINTEGER *) val) = SQL_SO_STATIC | SQL_SO_FORWARD_ONLY;
11440 *valLen =
sizeof (SQLUINTEGER);
11442 case SQL_TABLE_TERM:
11443 strmak(val,
"TABLE", valMax, valLen);
11445 case SQL_TXN_CAPABLE:
11446 *((SQLSMALLINT *) val) = SQL_TC_ALL;
11447 *valLen =
sizeof (SQLSMALLINT);
11449 case SQL_CONVERT_FUNCTIONS:
11450 *((SQLUINTEGER *) val) = 0;
11451 *valLen =
sizeof (SQLUINTEGER);
11453 case SQL_SYSTEM_FUNCTIONS:
11454 case SQL_NUMERIC_FUNCTIONS:
11455 case SQL_STRING_FUNCTIONS:
11456 case SQL_TIMEDATE_FUNCTIONS:
11457 *((SQLUINTEGER *) val) = 0;
11458 *valLen =
sizeof (SQLUINTEGER);
11460 case SQL_CONVERT_BIGINT:
11461 case SQL_CONVERT_BIT:
11462 case SQL_CONVERT_CHAR:
11463 case SQL_CONVERT_DATE:
11464 case SQL_CONVERT_DECIMAL:
11465 case SQL_CONVERT_DOUBLE:
11466 case SQL_CONVERT_FLOAT:
11467 case SQL_CONVERT_INTEGER:
11468 case SQL_CONVERT_LONGVARCHAR:
11469 case SQL_CONVERT_NUMERIC:
11470 case SQL_CONVERT_REAL:
11471 case SQL_CONVERT_SMALLINT:
11472 case SQL_CONVERT_TIME:
11473 case SQL_CONVERT_TIMESTAMP:
11474 case SQL_CONVERT_TINYINT:
11475 case SQL_CONVERT_VARCHAR:
11476 *((SQLUINTEGER *) val) =
11477 SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL |
11478 SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT | SQL_CVT_REAL |
11479 SQL_CVT_DOUBLE | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR |
11480 SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_BIGINT |
11481 SQL_CVT_DATE | SQL_CVT_TIME | SQL_CVT_TIMESTAMP;
11482 *valLen =
sizeof (SQLUINTEGER);
11484 case SQL_CONVERT_BINARY:
11485 case SQL_CONVERT_VARBINARY:
11486 case SQL_CONVERT_LONGVARBINARY:
11487 *((SQLUINTEGER *) val) = 0;
11488 *valLen =
sizeof (SQLUINTEGER);
11490 case SQL_POSITIONED_STATEMENTS:
11491 *((SQLUINTEGER *) val) = 0;
11492 *valLen =
sizeof (SQLUINTEGER);
11494 case SQL_LOCK_TYPES:
11495 *((SQLUINTEGER *) val) = SQL_LCK_NO_CHANGE;
11496 *valLen =
sizeof (SQLUINTEGER);
11498 case SQL_BOOKMARK_PERSISTENCE:
11499 *((SQLUINTEGER *) val) = SQL_BP_SCROLL;
11500 *valLen =
sizeof (SQLUINTEGER);
11503 *((SQLUINTEGER *) val) = SQL_U_UNION | SQL_U_UNION_ALL;
11504 *valLen =
sizeof (SQLUINTEGER);
11506 case SQL_OWNER_USAGE:
11507 case SQL_SUBQUERIES:
11508 case SQL_TIMEDATE_ADD_INTERVALS:
11509 case SQL_TIMEDATE_DIFF_INTERVALS:
11510 *((SQLUINTEGER *) val) = 0;
11511 *valLen =
sizeof (SQLUINTEGER);
11513 case SQL_QUOTED_IDENTIFIER_CASE:
11514 *((SQLUSMALLINT *) val) = SQL_IC_SENSITIVE;
11515 *valLen =
sizeof (SQLUSMALLINT);
11517 case SQL_POS_OPERATIONS:
11518 *((SQLUINTEGER *) val) = SQL_POS_POSITION | SQL_POS_UPDATE |
11519 SQL_POS_DELETE | SQL_POS_ADD | SQL_POS_REFRESH;
11520 *valLen =
sizeof (SQLUINTEGER);
11522 case SQL_ALTER_TABLE:
11523 *((SQLUINTEGER *) val) = 0;
11524 *valLen =
sizeof (SQLUINTEGER);
11526 case SQL_CORRELATION_NAME:
11527 *((SQLSMALLINT *) val) = SQL_CN_ANY;
11528 *valLen =
sizeof (SQLSMALLINT);
11530 case SQL_NON_NULLABLE_COLUMNS:
11531 *((SQLSMALLINT *) val) = SQL_NNC_NON_NULL;
11532 *valLen =
sizeof (SQLSMALLINT);
11534 case SQL_NULL_COLLATION:
11535 *((SQLSMALLINT *) val) = SQL_NC_START;
11536 *valLen =
sizeof (SQLSMALLINT);
11538 case SQL_MAX_COLUMNS_IN_GROUP_BY:
11539 case SQL_MAX_COLUMNS_IN_ORDER_BY:
11540 case SQL_MAX_COLUMNS_IN_SELECT:
11541 case SQL_MAX_COLUMNS_IN_TABLE:
11542 case SQL_MAX_ROW_SIZE:
11543 case SQL_MAX_TABLES_IN_SELECT:
11544 *((SQLSMALLINT *) val) = 0;
11545 *valLen =
sizeof (SQLSMALLINT);
11547 case SQL_MAX_BINARY_LITERAL_LEN:
11548 case SQL_MAX_CHAR_LITERAL_LEN:
11549 *((SQLUINTEGER *) val) = 0;
11550 *valLen =
sizeof (SQLUINTEGER);
11552 case SQL_MAX_COLUMNS_IN_INDEX:
11553 *((SQLSMALLINT *) val) = 0;
11554 *valLen =
sizeof (SQLSMALLINT);
11556 case SQL_MAX_INDEX_SIZE:
11557 *((SQLUINTEGER *) val) = 0;
11558 *valLen =
sizeof (SQLUINTEGER);
11560#ifdef SQL_MAX_IDENTIFIER_LENGTH
11561 case SQL_MAX_IDENTIFIER_LENGTH:
11562 *((SQLUINTEGER *) val) = 255;
11563 *valLen =
sizeof (SQLUINTEGER);
11566 case SQL_MAX_STATEMENT_LEN:
11567 *((SQLUINTEGER *) val) = 16384;
11568 *valLen =
sizeof (SQLUINTEGER);
11570 case SQL_QUALIFIER_LOCATION:
11571 *((SQLSMALLINT *) val) = SQL_QL_START;
11572 *valLen =
sizeof (SQLSMALLINT);
11574 case SQL_GETDATA_EXTENSIONS:
11575 *((SQLUINTEGER *) val) =
11576 SQL_GD_ANY_COLUMN | SQL_GD_ANY_ORDER | SQL_GD_BOUND;
11577 *valLen =
sizeof (SQLUINTEGER);
11579 case SQL_STATIC_SENSITIVITY:
11580 *((SQLUINTEGER *) val) = 0;
11581 *valLen =
sizeof (SQLUINTEGER);
11583 case SQL_FILE_USAGE:
11584#if defined(_WIN32) || defined(_WIN64)
11585 *((SQLSMALLINT *) val) =
11586 d->xcelqrx ? SQL_FILE_CATALOG : SQL_FILE_NOT_SUPPORTED;
11588 *((SQLSMALLINT *) val) = SQL_FILE_NOT_SUPPORTED;
11590 *valLen =
sizeof (SQLSMALLINT);
11593 *((SQLSMALLINT *) val) = SQL_GB_GROUP_BY_EQUALS_SELECT;
11594 *valLen =
sizeof (SQLSMALLINT);
11597 strmak(val,
"CREATE,SELECT,DROP,DELETE,UPDATE,INSERT,"
11598 "INTO,VALUES,TABLE,INDEX,FROM,SET,WHERE,AND,CURRENT,OF",
11601 case SQL_SPECIAL_CHARACTERS:
11602#ifdef SQL_COLLATION_SEQ
11603 case SQL_COLLATION_SEQ:
11605 strmak(val,
"", valMax, valLen);
11607 case SQL_BATCH_SUPPORT:
11608 case SQL_BATCH_ROW_COUNT:
11609 case SQL_PARAM_ARRAY_ROW_COUNTS:
11610 *((SQLUINTEGER *) val) = 0;
11611 *valLen =
sizeof (SQLUINTEGER);
11613 case SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1:
11614 *((SQLUINTEGER *) val) = SQL_CA1_NEXT | SQL_CA1_BOOKMARK;
11615 *valLen =
sizeof (SQLUINTEGER);
11617 case SQL_STATIC_CURSOR_ATTRIBUTES1:
11618 *((SQLUINTEGER *) val) = SQL_CA1_NEXT | SQL_CA1_ABSOLUTE |
11619 SQL_CA1_RELATIVE | SQL_CA1_BOOKMARK | SQL_CA1_POS_POSITION |
11620 SQL_CA1_POS_DELETE | SQL_CA1_POS_UPDATE | SQL_CA1_POS_REFRESH |
11621 SQL_CA1_LOCK_NO_CHANGE | SQL_CA1_BULK_ADD |
11622 SQL_CA1_BULK_UPDATE_BY_BOOKMARK | SQL_CA1_BULK_DELETE_BY_BOOKMARK;
11623 *valLen =
sizeof (SQLUINTEGER);
11625 case SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2:
11626 case SQL_STATIC_CURSOR_ATTRIBUTES2:
11627 *((SQLUINTEGER *) val) = SQL_CA2_READ_ONLY_CONCURRENCY |
11628 SQL_CA2_LOCK_CONCURRENCY;
11629 *valLen =
sizeof (SQLUINTEGER);
11631 case SQL_KEYSET_CURSOR_ATTRIBUTES1:
11632 case SQL_KEYSET_CURSOR_ATTRIBUTES2:
11633 case SQL_DYNAMIC_CURSOR_ATTRIBUTES1:
11634 case SQL_DYNAMIC_CURSOR_ATTRIBUTES2:
11635 *((SQLUINTEGER *) val) = 0;
11636 *valLen =
sizeof (SQLUINTEGER);
11638 case SQL_ODBC_INTERFACE_CONFORMANCE:
11639 *((SQLUINTEGER *) val) = SQL_OIC_CORE;
11640 *valLen =
sizeof (SQLUINTEGER);
11643 setstatd(d, -1,
"unsupported info option %d",
11644 (*d->
ov3) ?
"HYC00" :
"S1C00", type);
11647 return SQL_SUCCESS;
11650#if (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC)) || !defined(WINTERFACE)
11662SQLGetInfo(SQLHDBC
dbc, SQLUSMALLINT type, SQLPOINTER val, SQLSMALLINT valMax,
11663 SQLSMALLINT *valLen)
11687 SQLSMALLINT *valLen)
11690 SQLSMALLINT len = 0;
11695 if (ret == SQL_SUCCESS) {
11696 SQLWCHAR *v = NULL;
11699 case SQL_USER_NAME:
11700 case SQL_DRIVER_ODBC_VER:
11701 case SQL_DATA_SOURCE_NAME:
11702 case SQL_DRIVER_NAME:
11703 case SQL_DRIVER_VER:
11705 case SQL_SERVER_NAME:
11706 case SQL_DATABASE_NAME:
11707 case SQL_SEARCH_PATTERN_ESCAPE:
11708 case SQL_DBMS_NAME:
11710 case SQL_NEED_LONG_DATA_LEN:
11711 case SQL_ROW_UPDATES:
11712 case SQL_ACCESSIBLE_PROCEDURES:
11713 case SQL_PROCEDURES:
11714 case SQL_EXPRESSIONS_IN_ORDERBY:
11715 case SQL_ODBC_SQL_OPT_IEF:
11716 case SQL_LIKE_ESCAPE_CLAUSE:
11717 case SQL_ORDER_BY_COLUMNS_IN_SELECT:
11718 case SQL_OUTER_JOINS:
11719 case SQL_COLUMN_ALIAS:
11720 case SQL_ACCESSIBLE_TABLES:
11721 case SQL_MULT_RESULT_SETS:
11722 case SQL_MULTIPLE_ACTIVE_TXN:
11723 case SQL_MAX_ROW_SIZE_INCLUDES_LONG:
11724 case SQL_DATA_SOURCE_READ_ONLY:
11725#ifdef SQL_DESCRIBE_PARAMETER
11726 case SQL_DESCRIBE_PARAMETER:
11728 case SQL_IDENTIFIER_QUOTE_CHAR:
11729 case SQL_OWNER_TERM:
11730 case SQL_PROCEDURE_TERM:
11731 case SQL_QUALIFIER_NAME_SEPARATOR:
11732 case SQL_QUALIFIER_TERM:
11733 case SQL_TABLE_TERM:
11735 case SQL_SPECIAL_CHARACTERS:
11736#ifdef SQL_CATALOG_NAME
11737 case SQL_CATALOG_NAME:
11739#ifdef SQL_COLLATION_SEQ
11740 case SQL_COLLATION_SEQ:
11746 int vmax = valMax /
sizeof (SQLWCHAR);
11756 len *=
sizeof (SQLWCHAR);
11763 if (valMax >=
sizeof (SQLWCHAR)) {
11764 *((SQLWCHAR *)val) = 0;
11768 len *=
sizeof (SQLWCHAR);
11790 SQLUSMALLINT *flags)
11793 SQLUSMALLINT exists[100];
11795 if (
dbc == SQL_NULL_HDBC) {
11796 return SQL_INVALID_HANDLE;
11799 exists[i] = SQL_FALSE;
11801 exists[SQL_API_SQLALLOCCONNECT] = SQL_TRUE;
11802 exists[SQL_API_SQLFETCH] = SQL_TRUE;
11803 exists[SQL_API_SQLALLOCENV] = SQL_TRUE;
11804 exists[SQL_API_SQLFREECONNECT] = SQL_TRUE;
11805 exists[SQL_API_SQLALLOCSTMT] = SQL_TRUE;
11806 exists[SQL_API_SQLFREEENV] = SQL_TRUE;
11807 exists[SQL_API_SQLBINDCOL] = SQL_TRUE;
11808 exists[SQL_API_SQLFREESTMT] = SQL_TRUE;
11809 exists[SQL_API_SQLCANCEL] = SQL_TRUE;
11810 exists[SQL_API_SQLGETCURSORNAME] = SQL_TRUE;
11811 exists[SQL_API_SQLCOLATTRIBUTES] = SQL_TRUE;
11812 exists[SQL_API_SQLNUMRESULTCOLS] = SQL_TRUE;
11813 exists[SQL_API_SQLCONNECT] = SQL_TRUE;
11814 exists[SQL_API_SQLPREPARE] = SQL_TRUE;
11815 exists[SQL_API_SQLDESCRIBECOL] = SQL_TRUE;
11816 exists[SQL_API_SQLROWCOUNT] = SQL_TRUE;
11817 exists[SQL_API_SQLDISCONNECT] = SQL_TRUE;
11818 exists[SQL_API_SQLSETCURSORNAME] = SQL_FALSE;
11819 exists[SQL_API_SQLERROR] = SQL_TRUE;
11820 exists[SQL_API_SQLSETPARAM] = SQL_TRUE;
11821 exists[SQL_API_SQLEXECDIRECT] = SQL_TRUE;
11822 exists[SQL_API_SQLTRANSACT] = SQL_TRUE;
11823 exists[SQL_API_SQLBULKOPERATIONS] = SQL_TRUE;
11824 exists[SQL_API_SQLEXECUTE] = SQL_TRUE;
11825 exists[SQL_API_SQLBINDPARAMETER] = SQL_TRUE;
11826 exists[SQL_API_SQLGETTYPEINFO] = SQL_TRUE;
11827 exists[SQL_API_SQLCOLUMNS] = SQL_TRUE;
11828 exists[SQL_API_SQLPARAMDATA] = SQL_TRUE;
11829 exists[SQL_API_SQLDRIVERCONNECT] = SQL_TRUE;
11830 exists[SQL_API_SQLPUTDATA] = SQL_TRUE;
11831 exists[SQL_API_SQLGETCONNECTOPTION] = SQL_TRUE;
11832 exists[SQL_API_SQLSETCONNECTOPTION] = SQL_TRUE;
11833 exists[SQL_API_SQLGETDATA] = SQL_TRUE;
11834 exists[SQL_API_SQLSETSTMTOPTION] = SQL_TRUE;
11835 exists[SQL_API_SQLGETFUNCTIONS] = SQL_TRUE;
11836 exists[SQL_API_SQLSPECIALCOLUMNS] = SQL_TRUE;
11837 exists[SQL_API_SQLGETINFO] = SQL_TRUE;
11838 exists[SQL_API_SQLSTATISTICS] = SQL_TRUE;
11839 exists[SQL_API_SQLGETSTMTOPTION] = SQL_TRUE;
11840 exists[SQL_API_SQLTABLES] = SQL_TRUE;
11841 exists[SQL_API_SQLBROWSECONNECT] = SQL_FALSE;
11842 exists[SQL_API_SQLNUMPARAMS] = SQL_TRUE;
11843 exists[SQL_API_SQLCOLUMNPRIVILEGES] = SQL_FALSE;
11844 exists[SQL_API_SQLPARAMOPTIONS] = SQL_FALSE;
11845 exists[SQL_API_SQLDATASOURCES] = SQL_TRUE;
11846 exists[SQL_API_SQLPRIMARYKEYS] = SQL_TRUE;
11847 exists[SQL_API_SQLDESCRIBEPARAM] = SQL_TRUE;
11848 exists[SQL_API_SQLPROCEDURECOLUMNS] = SQL_TRUE;
11849 exists[SQL_API_SQLDRIVERS] = SQL_FALSE;
11850 exists[SQL_API_SQLPROCEDURES] = SQL_TRUE;
11851 exists[SQL_API_SQLEXTENDEDFETCH] = SQL_TRUE;
11852 exists[SQL_API_SQLSETPOS] = SQL_TRUE;
11853 exists[SQL_API_SQLFOREIGNKEYS] = SQL_TRUE;
11854 exists[SQL_API_SQLSETSCROLLOPTIONS] = SQL_TRUE;
11855 exists[SQL_API_SQLMORERESULTS] = SQL_TRUE;
11856 exists[SQL_API_SQLTABLEPRIVILEGES] = SQL_TRUE;
11857 exists[SQL_API_SQLNATIVESQL] = SQL_TRUE;
11858 if (func == SQL_API_ALL_FUNCTIONS) {
11859 memcpy(flags, exists,
sizeof (exists));
11860 }
else if (func == SQL_API_ODBC3_ALL_FUNCTIONS) {
11862#define SET_EXISTS(x) \
11863 flags[(x) >> 4] |= (1 << ((x) & 0xF))
11864#define CLR_EXISTS(x) \
11865 flags[(x) >> 4] &= ~(1 << ((x) & 0xF))
11868 sizeof (SQLUSMALLINT) * SQL_API_ODBC3_ALL_FUNCTIONS_SIZE);
11871 flags[i >> 4] |= (1 << (i & 0xF));
11884#if !defined(HAVE_UNIXODBC) || !(HAVE_UNIXODBC)
11897 *flags = exists[func];
11900 case SQL_API_SQLALLOCHANDLE:
11901 case SQL_API_SQLFREEHANDLE:
11902 case SQL_API_SQLGETSTMTATTR:
11903 case SQL_API_SQLSETSTMTATTR:
11904 case SQL_API_SQLGETCONNECTATTR:
11905 case SQL_API_SQLSETCONNECTATTR:
11906 case SQL_API_SQLGETENVATTR:
11907 case SQL_API_SQLSETENVATTR:
11908 case SQL_API_SQLCLOSECURSOR:
11909 case SQL_API_SQLBINDPARAM:
11910#if !defined(HAVE_UNIXODBC) || !(HAVE_UNIXODBC)
11916 case SQL_API_SQLGETDIAGREC:
11918 case SQL_API_SQLGETDIAGFIELD:
11919 case SQL_API_SQLFETCHSCROLL:
11920 case SQL_API_SQLENDTRAN:
11924 *flags = SQL_FALSE;
11928 return SQL_SUCCESS;
11943 return SQL_INVALID_HANDLE;
11947 *env = SQL_NULL_HENV;
11953#if defined(_WIN32) || defined(_WIN64)
11954 InitializeCriticalSection(&e->cs);
11956#if defined(ENABLE_NVFS) && (ENABLE_NVFS)
11961 *env = (SQLHENV) e;
11962 return SQL_SUCCESS;
11988 if (env == SQL_NULL_HENV) {
11989 return SQL_INVALID_HANDLE;
11993 return SQL_SUCCESS;
11995#if defined(_WIN32) || defined(_WIN64)
11996 EnterCriticalSection(&e->cs);
11999#if defined(_WIN32) || defined(_WIN64)
12000 LeaveCriticalSection(&e->cs);
12005#if defined(_WIN32) || defined(_WIN64)
12006 LeaveCriticalSection(&e->cs);
12007 DeleteCriticalSection(&e->cs);
12010 return SQL_SUCCESS;
12037 const char *verstr;
12038 int maj = 0,
min = 0, lev = 0;
12045 *
dbc = SQL_NULL_HDBC;
12048 memset(d, 0,
sizeof (
DBC));
12049 d->
curtype = SQL_CURSOR_STATIC;
12051 verstr = sqlite3_libversion();
12052 sscanf(verstr,
"%d.%d.%d", &maj, &
min, &lev);
12055#if defined(_WIN32) || defined(_WIN64)
12057 EnterCriticalSection(&e->cs);
12077#if defined(_WIN32) || defined(_WIN64)
12078 InitializeCriticalSection(&d->cs);
12081 LeaveCriticalSection(&e->cs);
12087 *
dbc = (SQLHDBC) d;
12089 return SQL_SUCCESS;
12116 SQLRETURN ret = SQL_ERROR;
12118 if (
dbc == SQL_NULL_HDBC) {
12119 return SQL_INVALID_HANDLE;
12123 return SQL_INVALID_HANDLE;
12127#if defined(_WIN32) || defined(_WIN64)
12128 EnterCriticalSection(&e->cs);
12135 setstatd(d, -1,
"not disconnected", (*d->
ov3) ?
"HY000" :
"S1000");
12167#if defined(_WIN32) || defined(_WIN64)
12169 LeaveCriticalSection(&d->cs);
12170 DeleteCriticalSection(&d->cs);
12175#if defined(_WIN32) || defined(_WIN64)
12177 LeaveCriticalSection(&e->cs);
12207 SQLINTEGER bufmax, SQLINTEGER *buflen)
12212 if (
dbc == SQL_NULL_HDBC) {
12213 return SQL_INVALID_HANDLE;
12217 val = (SQLPOINTER) &dummy;
12223 case SQL_ATTR_CONNECTION_DEAD:
12224 *((SQLINTEGER *) val) = d->
sqlite ? SQL_CD_FALSE : SQL_CD_TRUE;
12225 *buflen =
sizeof (SQLINTEGER);
12227 case SQL_ATTR_ACCESS_MODE:
12228 *((SQLINTEGER *) val) = SQL_MODE_READ_WRITE;
12229 *buflen =
sizeof (SQLINTEGER);
12231 case SQL_ATTR_AUTOCOMMIT:
12232 *((SQLINTEGER *) val) =
12233 d->
autocommit ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF;
12234 *buflen =
sizeof (SQLINTEGER);
12236 case SQL_ATTR_LOGIN_TIMEOUT:
12237 *((SQLINTEGER *) val) = 100;
12238 *buflen =
sizeof (SQLINTEGER);
12240 case SQL_ATTR_ODBC_CURSORS:
12241 *((SQLINTEGER *) val) = SQL_CUR_USE_DRIVER;
12242 *buflen =
sizeof (SQLINTEGER);
12244 case SQL_ATTR_PACKET_SIZE:
12245 *((SQLINTEGER *) val) = 16384;
12246 *buflen =
sizeof (SQLINTEGER);
12248 case SQL_ATTR_TXN_ISOLATION:
12249 *((SQLINTEGER *) val) = SQL_TXN_SERIALIZABLE;
12250 *buflen =
sizeof (SQLINTEGER);
12252 case SQL_ATTR_TRACEFILE:
12253 case SQL_ATTR_TRANSLATE_LIB:
12254 *((SQLCHAR *) val) = 0;
12257 case SQL_ATTR_CURRENT_CATALOG:
12258#if defined(_WIN32) || defined(_WIN64)
12260 if ((bufmax > 4) && (val != (SQLPOINTER) &dummy)) {
12261 strcpy((
char *) val,
"main");
12267 *((SQLCHAR *) val) = 0;
12270 case SQL_ATTR_TRACE:
12271 case SQL_ATTR_QUIET_MODE:
12272 case SQL_ATTR_TRANSLATE_OPTION:
12273 case SQL_ATTR_KEYSET_SIZE:
12274 case SQL_ATTR_QUERY_TIMEOUT:
12275 *((SQLINTEGER *) val) = 0;
12276 *buflen =
sizeof (SQLINTEGER);
12278 case SQL_ATTR_PARAM_BIND_TYPE:
12279 *((
SQLULEN *) val) = SQL_PARAM_BIND_BY_COLUMN;
12280 *buflen =
sizeof (SQLUINTEGER);
12282 case SQL_ATTR_ROW_BIND_TYPE:
12283 *((
SQLULEN *) val) = SQL_BIND_BY_COLUMN;
12286 case SQL_ATTR_USE_BOOKMARKS:
12287 *((SQLINTEGER *) val) = SQL_UB_OFF;
12288 *buflen =
sizeof (SQLINTEGER);
12290 case SQL_ATTR_ASYNC_ENABLE:
12291 *((SQLINTEGER *) val) = SQL_ASYNC_ENABLE_OFF;
12292 *buflen =
sizeof (SQLINTEGER);
12294 case SQL_ATTR_NOSCAN:
12295 *((SQLINTEGER *) val) = SQL_NOSCAN_ON;
12296 *buflen =
sizeof (SQLINTEGER);
12298 case SQL_ATTR_CONCURRENCY:
12299 *((SQLINTEGER *) val) = SQL_CONCUR_LOCK;
12300 *buflen =
sizeof (SQLINTEGER);
12302#ifdef SQL_ATTR_CURSOR_SENSITIVITY
12303 case SQL_ATTR_CURSOR_SENSITIVITY:
12304 *((SQLINTEGER *) val) = SQL_UNSPECIFIED;
12305 *buflen =
sizeof (SQLINTEGER);
12308 case SQL_ATTR_SIMULATE_CURSOR:
12309 *((SQLINTEGER *) val) = SQL_SC_NON_UNIQUE;
12310 *buflen =
sizeof (SQLINTEGER);
12312 case SQL_ATTR_MAX_ROWS:
12313 *((SQLINTEGER *) val) = 0;
12314 *buflen =
sizeof (SQLINTEGER);
12315 case SQL_ATTR_MAX_LENGTH:
12316 *((SQLINTEGER *) val) = 1000000000;
12317 *buflen =
sizeof (SQLINTEGER);
12319 case SQL_ATTR_CURSOR_TYPE:
12320 *((SQLINTEGER *) val) = d->
curtype;
12321 *buflen =
sizeof (SQLINTEGER);
12323 case SQL_ATTR_RETRIEVE_DATA:
12324 *((SQLINTEGER *) val) = SQL_RD_ON;
12325 *buflen =
sizeof (SQLINTEGER);
12327#ifdef SQL_ATTR_METADATA_ID
12328 case SQL_ATTR_METADATA_ID:
12329 *((
SQLULEN *) val) = SQL_FALSE;
12330 return SQL_SUCCESS;
12333 *((SQLINTEGER *) val) = 0;
12334 *buflen =
sizeof (SQLINTEGER);
12335 setstatd(d, -1,
"unsupported connect attribute %d",
12336 (*d->
ov3) ?
"HYC00" :
"S1C00", (
int) attr);
12339 return SQL_SUCCESS;
12354SQLGetConnectAttr(SQLHDBC
dbc, SQLINTEGER attr, SQLPOINTER val,
12355 SQLINTEGER bufmax, SQLINTEGER *buflen)
12379 SQLINTEGER bufmax, SQLINTEGER *buflen)
12382 SQLINTEGER len = 0;
12386 if (ret == SQL_SUCCESS) {
12387 SQLWCHAR *v = NULL;
12390 case SQL_ATTR_TRACEFILE:
12391 case SQL_ATTR_CURRENT_CATALOG:
12392 case SQL_ATTR_TRANSLATE_LIB:
12397 int vmax = bufmax /
sizeof (SQLWCHAR);
12407 len *=
sizeof (SQLWCHAR);
12414 if (bufmax >=
sizeof (SQLWCHAR)) {
12415 *((SQLWCHAR *)val) = 0;
12419 len *=
sizeof (SQLWCHAR);
12447 if (
dbc == SQL_NULL_HDBC) {
12448 return SQL_INVALID_HANDLE;
12452 case SQL_AUTOCOMMIT:
12453 d->
autocommit = val == (SQLPOINTER) SQL_AUTOCOMMIT_ON;
12455 return endtran(d, SQL_COMMIT, 1);
12460#ifdef SQL_ATTR_METADATA_ID
12461 case SQL_ATTR_METADATA_ID:
12462 if (val == (SQLPOINTER) SQL_FALSE) {
12468 setstatd(d, -1,
"option value changed",
"01S02");
12469 return SQL_SUCCESS_WITH_INFO;
12471 return SQL_SUCCESS;
12485SQLSetConnectAttr(SQLHDBC
dbc, SQLINTEGER attr, SQLPOINTER val,
12534 if (
dbc == SQL_NULL_HDBC) {
12535 return SQL_INVALID_HANDLE;
12539 param = (SQLPOINTER) &dummy;
12542 case SQL_ACCESS_MODE:
12543 *((SQLINTEGER *) param) = SQL_MODE_READ_WRITE;
12545 case SQL_AUTOCOMMIT:
12546 *((SQLINTEGER *) param) =
12547 d->
autocommit ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF;
12549 case SQL_LOGIN_TIMEOUT:
12550 *((SQLINTEGER *) param) = 100;
12552 case SQL_ODBC_CURSORS:
12553 *((SQLINTEGER *) param) = SQL_CUR_USE_DRIVER;
12555 case SQL_PACKET_SIZE:
12556 *((SQLINTEGER *) param) = 16384;
12558 case SQL_TXN_ISOLATION:
12559 *((SQLINTEGER *) param) = SQL_TXN_SERIALIZABLE;
12561 case SQL_OPT_TRACE:
12562 case SQL_OPT_TRACEFILE:
12563 case SQL_QUIET_MODE:
12564 case SQL_TRANSLATE_DLL:
12565 case SQL_TRANSLATE_OPTION:
12566 case SQL_KEYSET_SIZE:
12567 case SQL_QUERY_TIMEOUT:
12568 case SQL_BIND_TYPE:
12569 case SQL_CURRENT_QUALIFIER:
12570 *((SQLINTEGER *) param) = 0;
12572 case SQL_USE_BOOKMARKS:
12573 *((SQLINTEGER *) param) = SQL_UB_OFF;
12575 case SQL_ASYNC_ENABLE:
12576 *((SQLINTEGER *) param) = SQL_ASYNC_ENABLE_OFF;
12579 *((SQLINTEGER *) param) = SQL_NOSCAN_ON;
12581 case SQL_CONCURRENCY:
12582 *((SQLINTEGER *) param) = SQL_CONCUR_LOCK;
12584 case SQL_SIMULATE_CURSOR:
12585 *((SQLINTEGER *) param) = SQL_SC_NON_UNIQUE;
12588 *((SQLINTEGER *) param) = 0;
12590 case SQL_ROWSET_SIZE:
12591 case SQL_MAX_LENGTH:
12592 *((SQLINTEGER *) param) = 1000000000;
12594 case SQL_CURSOR_TYPE:
12595 *((SQLINTEGER *) param) = d->
curtype;
12597 case SQL_RETRIEVE_DATA:
12598 *((SQLINTEGER *) param) = SQL_RD_ON;
12601 *((SQLINTEGER *) param) = 0;
12602 setstatd(d, -1,
"unsupported connect option %d",
12603 (*d->
ov3) ?
"HYC00" :
"S1C00", opt);
12606 return SQL_SUCCESS;
12619SQLGetConnectOption(SQLHDBC
dbc, SQLUSMALLINT opt, SQLPOINTER param)
12646 if (SQL_SUCCEEDED(ret)) {
12648 case SQL_OPT_TRACEFILE:
12649 case SQL_CURRENT_QUALIFIER:
12650 case SQL_TRANSLATE_DLL:
12652 *(SQLWCHAR *) param = 0;
12675 if (
dbc == SQL_NULL_HDBC) {
12676 return SQL_INVALID_HANDLE;
12680 case SQL_AUTOCOMMIT:
12683 return endtran(d, SQL_COMMIT, 1);
12689 setstatd(d, -1,
"option value changed",
"01S02");
12690 return SQL_SUCCESS_WITH_INFO;
12692 return SQL_SUCCESS;
12705SQLSetConnectOption(SQLHDBC
dbc, SQLUSMALLINT opt,
SQLULEN param)
12737#if defined(WITHOUT_DRIVERMGR) || (!defined(_WIN32) && !defined(_WIN64))
12752 char *str = dsn, *start;
12753 int len = strlen(attr);
12756 while (*str && *str ==
';') {
12760 if ((str = strchr(str,
'=')) == NULL) {
12763 if (str - start == len && strncasecmp(start, attr, len) == 0) {
12765 while (*str && *str !=
';') {
12768 len =
min(outLen - 1, str - start);
12769 strncpy(out, start, len);
12773 while (*str && *str !=
';') {
12794 int pwdLen,
int isu)
12799 char buf[SQL_MAX_MESSAGE_LENGTH * 6], dbname[SQL_MAX_MESSAGE_LENGTH];
12800 char busy[SQL_MAX_MESSAGE_LENGTH / 4], tracef[SQL_MAX_MESSAGE_LENGTH];
12801 char loadext[SQL_MAX_MESSAGE_LENGTH], attas[SQL_MAX_MESSAGE_LENGTH];
12802 char sflag[32], spflag[32], ntflag[32], nwflag[32], biflag[32];
12803 char snflag[32], lnflag[32], ncflag[32], fkflag[32], jmode[32];
12804 char jdflag[32], ilflag[32];
12805#if defined(_WIN32) || defined(_WIN64)
12809 if (
dbc == SQL_NULL_HDBC) {
12810 return SQL_INVALID_HANDLE;
12814 return SQL_INVALID_HANDLE;
12816 if (d->
sqlite != NULL) {
12817 setstatd(d, -1,
"connection already established",
"08002");
12821 if (dsnLen == SQL_NTS) {
12822 len =
sizeof (buf) - 1;
12824 len =
min(
sizeof (buf) - 1, dsnLen);
12827 strncpy(buf, (
char *) dsn, len);
12830 if (buf[0] ==
'\0') {
12831 setstatd(d, -1,
"invalid DSN", (*d->
ov3) ?
"HY090" :
"S1090");
12834#if defined(_WIN32) || defined(_WIN64)
12840 char *cdsn = utf_to_wmb(buf, len);
12843 setstatd(d, -1,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
12852#ifdef WITHOUT_DRIVERMGR
12853 getdsnattr(buf,
"database", dbname,
sizeof (dbname));
12854 if (dbname[0] ==
'\0') {
12855 strncpy(dbname, buf,
sizeof (dbname));
12856 dbname[
sizeof (dbname) - 1] =
'\0';
12858 getdsnattr(buf,
"timeout", busy,
sizeof (busy));
12860 getdsnattr(buf,
"stepapi", sflag,
sizeof (sflag));
12862 getdsnattr(buf,
"syncpragma", spflag,
sizeof (spflag));
12864 getdsnattr(buf,
"notxn", ntflag,
sizeof (ntflag));
12866 getdsnattr(buf,
"nowchar", nwflag,
sizeof (nwflag));
12868 getdsnattr(buf,
"shortnames", snflag,
sizeof (snflag));
12870 getdsnattr(buf,
"longnames", lnflag,
sizeof (lnflag));
12872 getdsnattr(buf,
"nocreat", ncflag,
sizeof (ncflag));
12874 getdsnattr(buf,
"fksupport", fkflag,
sizeof (fkflag));
12876 getdsnattr(buf,
"loadext", loadext,
sizeof (loadext));
12878 getdsnattr(buf,
"journalmode", jmode,
sizeof (jmode));
12880 getdsnattr(buf,
"jdconv", jdflag,
sizeof (jdflag));
12881#if defined(_WIN32) || defined(_WIN64)
12883 getdsnattr(buf,
"oemcp", oemcp,
sizeof (oemcp));
12886 getdsnattr(buf,
"bigint", biflag,
sizeof (biflag));
12888 getdsnattr(buf,
"attachas", attas,
sizeof (attas));
12890 getdsnattr(buf,
"ilike", ilflag,
sizeof (ilflag));
12892 SQLGetPrivateProfileString(buf,
"timeout",
"100000",
12894 SQLGetPrivateProfileString(buf,
"database",
"",
12895 dbname,
sizeof (dbname),
ODBC_INI);
12896#if defined(_WIN32) || defined(_WIN64)
12900 SQLGetPrivateProfileString(buf,
"stepapi",
"",
12902 SQLGetPrivateProfileString(buf,
"syncpragma",
"NORMAL",
12903 spflag,
sizeof (spflag),
ODBC_INI);
12904 SQLGetPrivateProfileString(buf,
"notxn",
"",
12905 ntflag,
sizeof (ntflag),
ODBC_INI);
12906 SQLGetPrivateProfileString(buf,
"nowchar",
"",
12907 nwflag,
sizeof (nwflag),
ODBC_INI);
12908 SQLGetPrivateProfileString(buf,
"shortnames",
"",
12909 snflag,
sizeof (snflag),
ODBC_INI);
12910 SQLGetPrivateProfileString(buf,
"longnames",
"",
12911 lnflag,
sizeof (lnflag),
ODBC_INI);
12912 SQLGetPrivateProfileString(buf,
"nocreat",
"",
12913 ncflag,
sizeof (ncflag),
ODBC_INI);
12914 SQLGetPrivateProfileString(buf,
"fksupport",
"",
12915 fkflag,
sizeof (fkflag),
ODBC_INI);
12916 SQLGetPrivateProfileString(buf,
"loadext",
"",
12917 loadext,
sizeof (loadext),
ODBC_INI);
12918 SQLGetPrivateProfileString(buf,
"journalmode",
"",
12920 SQLGetPrivateProfileString(buf,
"jdconv",
"",
12921 jdflag,
sizeof (jdflag),
ODBC_INI);
12922#if defined(_WIN32) || defined(_WIN64)
12923 SQLGetPrivateProfileString(buf,
"oemcp",
"1",
12926 SQLGetPrivateProfileString(buf,
"bigint",
"",
12927 biflag,
sizeof (biflag),
ODBC_INI);
12928 SQLGetPrivateProfileString(buf,
"attachas",
"",
12930 SQLGetPrivateProfileString(buf,
"ilike",
"",
12931 ilflag,
sizeof (ilflag),
ODBC_INI);
12934#ifdef WITHOUT_DRIVERMGR
12935 getdsnattr(buf,
"tracefile", tracef,
sizeof (tracef));
12937 SQLGetPrivateProfileString(buf,
"tracefile",
"",
12938 tracef,
sizeof (tracef),
ODBC_INI);
12940 if (tracef[0] !=
'\0') {
12941 d->
trace = fopen(tracef,
"a");
12950#if defined(_WIN32) || defined(_WIN64)
12959 d->
pwdLen = (pwdLen == SQL_NTS) ? strlen(d->
pwd) : pwdLen;
12961 ret =
dbopen(d, dbname, isu, (
char *) dsn, sflag, spflag, ntflag,
12963 if (ret == SQL_SUCCESS) {
12984SQLConnect(SQLHDBC
dbc, SQLCHAR *dsn, SQLSMALLINT dsnLen,
12985 SQLCHAR *uid, SQLSMALLINT uidLen,
12986 SQLCHAR *pwd, SQLSMALLINT pwdLen)
12991 ret =
drvconnect(
dbc, dsn, dsnLen, (
char *) pwd, pwdLen, 0);
13012 SQLWCHAR *uid, SQLSMALLINT uidLen,
13013 SQLWCHAR *pwd, SQLSMALLINT pwdLen)
13025 setstatd(d, -1,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
13035 setstatd(d, -1,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
13040 ret =
drvconnect(
dbc, (SQLCHAR *) dsna, SQL_NTS, pwda, SQL_NTS, 1);
13061 if (
dbc == SQL_NULL_HDBC) {
13062 return SQL_INVALID_HANDLE;
13066 return SQL_INVALID_HANDLE;
13069 setstatd(d, -1,
"incomplete transaction",
"25000");
13077 fprintf(d->
trace,
"-- sqlite3_close: '%s'\n",
13081 rc = sqlite3_close(d->
sqlite);
13082 if (rc == SQLITE_BUSY) {
13083 setstatd(d, -1,
"unfinished statements",
"25000");
13090 return SQL_SUCCESS;
13110#if defined(WITHOUT_DRIVERMGR) || (!defined(_WIN32) && !defined(_WIN64))
13127 SQLCHAR *connIn, SQLSMALLINT connInLen,
13128 SQLCHAR *connOut, SQLSMALLINT connOutMax,
13129 SQLSMALLINT *connOutLen, SQLUSMALLINT drvcompl)
13134 char buf[SQL_MAX_MESSAGE_LENGTH * 8], dbname[SQL_MAX_MESSAGE_LENGTH];
13135 char dsn[SQL_MAX_MESSAGE_LENGTH], busy[SQL_MAX_MESSAGE_LENGTH / 4];
13136 char tracef[SQL_MAX_MESSAGE_LENGTH], loadext[SQL_MAX_MESSAGE_LENGTH];
13137 char pwd[SQL_MAX_MESSAGE_LENGTH], attas[SQL_MAX_MESSAGE_LENGTH];
13138 char sflag[32], spflag[32], ntflag[32], snflag[32], lnflag[32];
13139 char ncflag[32], nwflag[32], fkflag[32], jmode[32], biflag[32];
13140 char jdflag[32], ilflag[32];
13142 if (
dbc == SQL_NULL_HDBC) {
13143 return SQL_INVALID_HANDLE;
13145 if (drvcompl != SQL_DRIVER_COMPLETE &&
13146 drvcompl != SQL_DRIVER_COMPLETE_REQUIRED &&
13147 drvcompl != SQL_DRIVER_PROMPT &&
13148 drvcompl != SQL_DRIVER_NOPROMPT) {
13149 return SQL_NO_DATA;
13153 setstatd(d, -1,
"connection already established",
"08002");
13157 if (connInLen == SQL_NTS) {
13158 len =
sizeof (buf) - 1;
13160 len =
min(connInLen,
sizeof (buf) - 1);
13162 if (connIn != NULL) {
13163 strncpy(buf, (
char *) connIn, len);
13167 setstatd(d, -1,
"invalid connect attributes",
13168 (*d->
ov3) ?
"HY090" :
"S1090");
13175 if (!dsn[0] && !strchr(buf,
';') && !strchr(buf,
'=')) {
13176 strncpy(dsn, buf,
sizeof (dsn) - 1);
13177 dsn[
sizeof (dsn) - 1] =
'\0';
13181 getdsnattr(buf,
"timeout", busy,
sizeof (busy));
13182#ifndef WITHOUT_DRIVERMGR
13183 if (dsn[0] && !busy[0]) {
13184 SQLGetPrivateProfileString(dsn,
"timeout",
"100000",
13189 getdsnattr(buf,
"database", dbname,
sizeof (dbname));
13190#ifndef WITHOUT_DRIVERMGR
13191 if (dsn[0] && !dbname[0]) {
13192 SQLGetPrivateProfileString(dsn,
"database",
"",
13193 dbname,
sizeof (dbname),
ODBC_INI);
13197 getdsnattr(buf,
"stepapi", sflag,
sizeof (sflag));
13198#ifndef WITHOUT_DRIVERMGR
13199 if (dsn[0] && !sflag[0]) {
13200 SQLGetPrivateProfileString(dsn,
"stepapi",
"",
13205 getdsnattr(buf,
"syncpragma", spflag,
sizeof (spflag));
13206#ifndef WITHOUT_DRIVERMGR
13207 if (dsn[0] && !spflag[0]) {
13208 SQLGetPrivateProfileString(dsn,
"syncpragma",
"NORMAL",
13209 spflag,
sizeof (spflag),
ODBC_INI);
13213 getdsnattr(buf,
"notxn", ntflag,
sizeof (ntflag));
13214#ifndef WITHOUT_DRIVERMGR
13215 if (dsn[0] && !ntflag[0]) {
13216 SQLGetPrivateProfileString(dsn,
"notxn",
"",
13217 ntflag,
sizeof (ntflag),
ODBC_INI);
13221 getdsnattr(buf,
"shortnames", snflag,
sizeof (snflag));
13222#ifndef WITHOUT_DRIVERMGR
13223 if (dsn[0] && !snflag[0]) {
13224 SQLGetPrivateProfileString(dsn,
"shortnames",
"",
13225 snflag,
sizeof (snflag),
ODBC_INI);
13229 getdsnattr(buf,
"longnames", lnflag,
sizeof (lnflag));
13230#ifndef WITHOUT_DRIVERMGR
13231 if (dsn[0] && !lnflag[0]) {
13232 SQLGetPrivateProfileString(dsn,
"longnames",
"",
13233 lnflag,
sizeof (lnflag),
ODBC_INI);
13237 getdsnattr(buf,
"nocreat", ncflag,
sizeof (ncflag));
13238#ifndef WITHOUT_DRIVERMGR
13239 if (dsn[0] && !ncflag[0]) {
13240 SQLGetPrivateProfileString(dsn,
"nocreat",
"",
13241 ncflag,
sizeof (ncflag),
ODBC_INI);
13245 getdsnattr(buf,
"nowchar", nwflag,
sizeof (nwflag));
13246#ifndef WITHOUT_DRIVERMGR
13247 if (dsn[0] && !nwflag[0]) {
13248 SQLGetPrivateProfileString(dsn,
"nowchar",
"",
13249 nwflag,
sizeof (nwflag),
ODBC_INI);
13253 getdsnattr(buf,
"fksupport", fkflag,
sizeof (fkflag));
13254#ifndef WITHOUT_DRIVERMGR
13255 if (dsn[0] && !fkflag[0]) {
13256 SQLGetPrivateProfileString(dsn,
"fksupport",
"",
13257 fkflag,
sizeof (fkflag),
ODBC_INI);
13261 getdsnattr(buf,
"loadext", loadext,
sizeof (loadext));
13262#ifndef WITHOUT_DRIVERMGR
13263 if (dsn[0] && !loadext[0]) {
13264 SQLGetPrivateProfileString(dsn,
"loadext",
"",
13265 loadext,
sizeof (loadext),
ODBC_INI);
13269 getdsnattr(buf,
"journalmode", jmode,
sizeof (jmode));
13270#ifndef WITHOUT_DRIVERMGR
13271 if (dsn[0] && !jmode[0]) {
13272 SQLGetPrivateProfileString(dsn,
"journalmode",
"",
13277 getdsnattr(buf,
"bigint", biflag,
sizeof (biflag));
13278#ifndef WITHOUT_DRIVERMGR
13279 if (dsn[0] && !biflag[0]) {
13280 SQLGetPrivateProfileString(dsn,
"bigint",
"",
13281 biflag,
sizeof (biflag),
ODBC_INI);
13285 getdsnattr(buf,
"jdconv", jdflag,
sizeof (jdflag));
13286#ifndef WITHOUT_DRIVERMGR
13287 if (dsn[0] && !jdflag[0]) {
13288 SQLGetPrivateProfileString(dsn,
"jdconv",
"",
13289 jdflag,
sizeof (jdflag),
ODBC_INI);
13294#ifndef WITHOUT_DRIVERMGR
13295 if (dsn[0] && !pwd[0]) {
13296 SQLGetPrivateProfileString(dsn,
"pwd",
"",
13301 getdsnattr(buf,
"attachas", attas,
sizeof (attas));
13302#ifndef WITHOUT_DRIVERMGR
13303 if (dsn[0] && !attas[0]) {
13304 SQLGetPrivateProfileString(dsn,
"attachas",
"",
13309 getdsnattr(buf,
"ilike", ilflag,
sizeof (ilflag));
13310#ifndef WITHOUT_DRIVERMGR
13311 if (dsn[0] && !ilflag[0]) {
13312 SQLGetPrivateProfileString(dsn,
"ilike",
"",
13313 ilflag,
sizeof (ilflag),
ODBC_INI);
13317 if (!dbname[0] && !dsn[0]) {
13318 strcpy(dsn,
"SQLite");
13319 strncpy(dbname, buf,
sizeof (dbname));
13320 dbname[
sizeof (dbname) - 1] =
'\0';
13323 getdsnattr(buf,
"tracefile", tracef,
sizeof (tracef));
13324#ifndef WITHOUT_DRIVERMGR
13325 if (dsn[0] && !tracef[0]) {
13326 SQLGetPrivateProfileString(dsn,
"tracefile",
"",
13327 tracef,
sizeof (tracef),
ODBC_INI);
13330 if (connOut || connOutLen) {
13334 count = snprintf(buf,
sizeof (buf),
13335 "DSN=%s;Database=%s;StepAPI=%s;Timeout=%s;"
13336 "SyncPragma=%s;NoTXN=%s;ShortNames=%s;LongNames=%s;"
13337 "NoCreat=%s;NoWCHAR=%s;FKSupport=%s;Tracefile=%s;"
13338 "JournalMode=%s;LoadExt=%s;BigInt=%s;JDConv=%s;"
13339 "PWD=%s;AttachAs=%s;ILike=%s",
13340 dsn, dbname, sflag, busy, spflag, ntflag,
13341 snflag, lnflag, ncflag, nwflag, fkflag, tracef,
13342 jmode, loadext, biflag, jdflag, pwd, attas, ilflag);
13344 buf[
sizeof (buf) - 1] =
'\0';
13346 len =
min(connOutMax - 1, strlen(buf));
13348 strncpy((
char *) connOut, buf, len);
13349 connOut[len] =
'\0';
13355 if (tracef[0] !=
'\0') {
13356 d->
trace = fopen(tracef,
"a");
13367 d->
pwdLen = strlen(pwd);
13369 ret =
dbopen(d, dbname, 0, dsn, sflag, spflag, ntflag, jmode, busy);
13370 memset(pwd, 0,
sizeof (pwd));
13371 if (ret == SQL_SUCCESS) {
13391 if (
stmt == SQL_NULL_HSTMT) {
13392 return SQL_INVALID_HANDLE;
13427 return SQL_SUCCESS;
13443 if (
dbc == SQL_NULL_HDBC) {
13444 return SQL_INVALID_HANDLE;
13448 return SQL_INVALID_HANDLE;
13452 *
stmt = SQL_NULL_HSTMT;
13455 *
stmt = (SQLHSTMT) s;
13456 memset(s, 0,
sizeof (
STMT));
13459 s->
bkmrk = SQL_UB_OFF;
13481 sprintf((
char *) s->
cursorname,
"CUR_%I64X", (SQLUBIGINT) *
stmt);
13496 return SQL_SUCCESS;
13528 SQLRETURN ret = SQL_SUCCESS;
13531 if (
stmt == SQL_NULL_HSTMT) {
13532 return SQL_INVALID_HANDLE;
13538 case SQL_RESET_PARAMS:
13553 setstat(s, -1,
"unsupported option", (*s->
ov3) ?
"HYC00" :
"S1C00");
13583 if (
stmt != SQL_NULL_HSTMT) {
13585#if defined(_WIN32) || defined(_WIN64)
13587 if (d->
magic ==
DBC_MAGIC && d->owner != GetCurrentThreadId() &&
13590 sqlite3_interrupt(d->
sqlite);
13591 return SQL_SUCCESS;
13596 sqlite3_interrupt(d->
sqlite);
13618 if (
stmt == SQL_NULL_HSTMT) {
13619 return SQL_INVALID_HANDLE;
13622 if (lenp && !cursor) {
13624 return SQL_SUCCESS;
13628 strncpy((
char *) cursor, (
char *) s->
cursorname, buflen - 1);
13629 cursor[buflen - 1] =
'\0';
13635 return SQL_SUCCESS;
13649SQLGetCursorName(SQLHSTMT
stmt, SQLCHAR *cursor, SQLSMALLINT buflen,
13653#if defined(_WIN32) || defined(_WIN64)
13654 SQLSMALLINT len = 0;
13658#if defined(_WIN32) || defined(_WIN64)
13664 if (ret == SQL_SUCCESS) {
13668 c = utf_to_wmb((
char *) cursor, len);
13676 strncpy((
char *) cursor, c, buflen - 1);
13677 cursor[buflen - 1] = 0;
13682 *lenp =
min(len, buflen - 1);
13710 SQLSMALLINT len = 0;
13714 if (ret == SQL_SUCCESS) {
13715 SQLWCHAR *c = NULL;
13727 cursor[buflen - 1] = 0;
13732 *lenp =
min(len, buflen - 1);
13754 if (
stmt == SQL_NULL_HSTMT) {
13755 return SQL_INVALID_HANDLE;
13759 !((cursor[0] >=
'A' && cursor[0] <=
'Z') ||
13760 (cursor[0] >=
'a' && cursor[0] <=
'z'))) {
13761 setstat(s, -1,
"invalid cursor name", (*s->
ov3) ?
"HYC00" :
"S1C00");
13764 if (len == SQL_NTS) {
13769 strncpy((
char *) s->
cursorname, (
char *) cursor, len);
13771 return SQL_SUCCESS;
13784SQLSetCursorName(SQLHSTMT
stmt, SQLCHAR *cursor, SQLSMALLINT len)
13786#if defined(_WIN32) || defined(_WIN64)
13792#if defined(_WIN32) || defined(_WIN64)
13798 c = wmb_to_utf_c((
char *) cursor, len);
13808#if defined(_WIN32) || defined(_WIN64)
13876 case SQL_HANDLE_ENV:
13878 if (ret == SQL_SUCCESS) {
13879 ENV *e = (
ENV *) *output;
13886 case SQL_HANDLE_DBC:
13888 case SQL_HANDLE_STMT:
13890 ret =
drvallocstmt((SQLHDBC) input, (SQLHSTMT *) output);
13908 case SQL_HANDLE_ENV:
13910 case SQL_HANDLE_DBC:
13912 case SQL_HANDLE_STMT:
13929 for (i = 0; i < s->
dcols; i++) {
14020 for (i = s->
nbindcols; i < ncols; i++) {
14021 bindcols[i].
type = SQL_UNKNOWN_TYPE;
14022 bindcols[i].
max = 0;
14023 bindcols[i].
lenp = NULL;
14024 bindcols[i].
valp = NULL;
14025 bindcols[i].
index = i;
14026 bindcols[i].
offs = 0;
14031 }
else if (ncols > 0) {
14039 return SQL_SUCCESS;
14057 SQLPOINTER val, SQLINTEGER len,
SQLLEN *lenp,
int partial)
14059 char **data, valdummy[16];
14061 SQLINTEGER *ilenp = NULL;
14064 SQLRETURN sret = SQL_NO_DATA;
14070 if (((SQLINTEGER *) lenp) + 1 == (SQLINTEGER *) val) {
14071 ilenp = (SQLINTEGER *) lenp;
14074 if (col >= s->
ncols) {
14075 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009" :
"S1002");
14079 return SQL_SUCCESS;
14082 *lenp = SQL_NULL_DATA;
14086 *lenp = SQL_NULL_DATA;
14091#if (defined(_WIN32) || defined(_WIN64)) && defined(WINTERFACE)
14093 if (type == SQL_C_WCHAR && otype == SQL_C_DEFAULT) {
14100 val = (SQLPOINTER) valdummy;
14102 if (*data == NULL) {
14103 *lenp = SQL_NULL_DATA;
14105 case SQL_C_UTINYINT:
14106 case SQL_C_TINYINT:
14107 case SQL_C_STINYINT:
14111 *((SQLCHAR *) val) = 0;
14116 *((SQLSMALLINT *) val) = 0;
14121 *((SQLINTEGER *) val) = 0;
14124 case SQL_C_SBIGINT:
14125 case SQL_C_UBIGINT:
14126 *((SQLBIGINT *) val) = 0;
14130 *((
float *) val) = 0;
14133 *((
double *) val) = 0;
14138 *((SQLCHAR *) val) =
'\0';
14144 *((SQLWCHAR *) val) =
'\0';
14148#ifdef SQL_C_TYPE_DATE
14149 case SQL_C_TYPE_DATE:
14152 memset((DATE_STRUCT *) val, 0,
sizeof (DATE_STRUCT));
14154#ifdef SQL_C_TYPE_TIME
14155 case SQL_C_TYPE_TIME:
14158 memset((TIME_STRUCT *) val, 0,
sizeof (TIME_STRUCT));
14160#ifdef SQL_C_TYPE_TIMESTAMP
14161 case SQL_C_TYPE_TIMESTAMP:
14163 case SQL_C_TIMESTAMP:
14164 memset((TIMESTAMP_STRUCT *) val, 0,
sizeof (TIMESTAMP_STRUCT));
14171#if defined(_WIN32) || defined(_WIN64)
14178 case SQL_C_UTINYINT:
14179 case SQL_C_TINYINT:
14180 case SQL_C_STINYINT:
14181 *((SQLCHAR *) val) = strtol(*data, &endp, 0);
14182 if (endp && endp == *data) {
14183 *lenp = SQL_NULL_DATA;
14185 *lenp =
sizeof (SQLCHAR);
14190 *((SQLCHAR *) val) =
getbool(*data);
14191 *lenp =
sizeof (SQLCHAR);
14197 *((SQLSMALLINT *) val) = strtol(*data, &endp, 0);
14198 if (endp && endp == *data) {
14199 *lenp = SQL_NULL_DATA;
14201 *lenp =
sizeof (SQLSMALLINT);
14207 *((SQLINTEGER *) val) = strtol(*data, &endp, 0);
14208 if (endp && endp == *data) {
14209 *lenp = SQL_NULL_DATA;
14211 *lenp =
sizeof (SQLINTEGER);
14215 case SQL_C_UBIGINT:
14216#if defined(_WIN32) || defined(_WIN64)
14217 if (sscanf(*data,
"%I64u%c", (SQLUBIGINT *) val, &endc) != 1) {
14218 *lenp = SQL_NULL_DATA;
14220 *lenp =
sizeof (SQLUBIGINT);
14224 *((SQLUBIGINT *) val) = strtoul(*data, &endp, 0);
14226 *((SQLUBIGINT *) val) = strtoull(*data, &endp, 0);
14228 if (endp && endp == *data) {
14229 *lenp = SQL_NULL_DATA;
14231 *lenp =
sizeof (SQLUBIGINT);
14235 case SQL_C_SBIGINT:
14236#if defined(_WIN32) || defined(_WIN64)
14237 if (sscanf(*data,
"%I64d%c", (SQLBIGINT *) val, &endc) != 1) {
14238 *lenp = SQL_NULL_DATA;
14240 *lenp =
sizeof (SQLBIGINT);
14244 *((SQLBIGINT *) val) = strtol(*data, &endp, 0);
14246 *((SQLBIGINT *) val) = strtoll(*data, &endp, 0);
14248 if (endp && endp == *data) {
14249 *lenp = SQL_NULL_DATA;
14251 *lenp =
sizeof (SQLBIGINT);
14257 *((
float *) val) =
ln_strtod(*data, &endp);
14258 if (endp && endp == *data) {
14259 *lenp = SQL_NULL_DATA;
14261 *lenp =
sizeof (float);
14265 *((
double *) val) =
ln_strtod(*data, &endp);
14266 if (endp && endp == *data) {
14267 *lenp = SQL_NULL_DATA;
14269 *lenp =
sizeof (double);
14272 case SQL_C_BINARY: {
14273 int dlen, offs = 0;
14297 if (!(dp[0] ==
'x' || dp[0] ==
'X') || dp[1] !=
'\'' ||
14298 dp[dlen - 1] !=
'\'') {
14309 memset(bin, 0, dlen);
14311 for (i = 0; i < dlen; i++) {
14315 if (!*dp || !(x = strchr(
xdigits, *dp))) {
14319 bin[i] = (v >= 16) ? ((v - 6) << 4) : (v << 4);
14321 if (!*dp || !(x = strchr(
xdigits, *dp))) {
14325 setstat(s, -1,
"conversion error",
14326 (*s->
ov3) ?
"HY000" :
"S1000");
14330 bin[i] |= (v >= 16) ? (v - 6) : v;
14335 if (partial && len && s->
bindcols) {
14340 sret = SQL_SUCCESS;
14344 sret = SQL_NO_DATA;
14351 memcpy(val, bin + offs,
min(len, dlen));
14356 *lenp =
min(len, dlen);
14357 if (*lenp == len && *lenp != dlen) {
14358 *lenp = SQL_NO_TOTAL;
14361 if (partial && len && s->
bindcols) {
14362 if (*lenp == SQL_NO_TOTAL) {
14365 setstat(s, -1,
"data right truncated",
"01004");
14369 sret = SQL_SUCCESS_WITH_INFO;
14374 if (*lenp == SQL_NO_TOTAL) {
14376 setstat(s, -1,
"data right truncated",
"01004");
14377 sret = SQL_SUCCESS_WITH_INFO;
14387 int doz, zlen = len - 1;
14388 int dlen = strlen(*data);
14391 SQLWCHAR *ucdata = NULL;
14392 SQLCHAR *cdata = (SQLCHAR *) *data;
14395#if (defined(_WIN32) || defined(_WIN64)) && defined(WINTERFACE)
14398 (s->
cols == statSpec2P || s->
cols == statSpec3P) &&
14399 type == SQL_C_WCHAR) {
14400 if (len > 0 && len <=
sizeof (SQLWCHAR)) {
14401 ((
char *) val)[0] = data[0][0];
14402 memset((
char *) val + 1, 0, len - 1);
14404 sret = SQL_SUCCESS;
14416 doz =
sizeof (SQLWCHAR);
14422 if (type == SQL_C_WCHAR) {
14427 dlen =
uc_strlen(ucdata) *
sizeof (SQLWCHAR);
14429#if defined(_WIN32) || defined(_WIN64)
14430 else if (*s->
oemcp && type == SQL_C_CHAR) {
14431 ucdata = (SQLWCHAR *) utf_to_wmb((
char *) cdata, dlen);
14435 cdata = (SQLCHAR *) ucdata;
14436 dlen = strlen((
char *) cdata);
14440 doz = (type == SQL_C_CHAR) ? 1 : 0;
14442 if (partial && len && s->
bindcols) {
14450 if (type == SQL_C_WCHAR) {
14451 ((SQLWCHAR *) val)[0] = 0;
14453 ((
char *) val)[0] =
'\0';
14456 ((
char *) val)[0] =
'\0';
14461 sret = SQL_SUCCESS;
14465 sret = SQL_NO_DATA;
14471 if (val && !valnull && len) {
14473 if (type == SQL_C_WCHAR) {
14474 uc_strncpy(val, ucdata + offs /
sizeof (SQLWCHAR),
14475 (len - doz) /
sizeof (SQLWCHAR));
14477 strncpy(val, (
char *) cdata + offs, len - doz);
14480 strncpy(val, *data + offs, len - doz);
14483 if (valnull || len < 1) {
14486 *lenp =
min(len - doz, dlen);
14487 if (*lenp == len - doz && *lenp != dlen) {
14488 *lenp = SQL_NO_TOTAL;
14489 }
else if (*lenp < zlen) {
14493 if (len && !valnull && doz) {
14495 if (type == SQL_C_WCHAR) {
14496 ((SQLWCHAR *) val)[zlen /
sizeof (SQLWCHAR)] = 0;
14498 ((
char *) val)[zlen] =
'\0';
14501 ((
char *) val)[zlen] =
'\0';
14507 if (partial && len && s->
bindcols) {
14508 if (*lenp == SQL_NO_TOTAL) {
14511 setstat(s, -1,
"data right truncated",
"01004");
14515 sret = SQL_SUCCESS_WITH_INFO;
14520 if (*lenp == SQL_NO_TOTAL) {
14522 setstat(s, -1,
"data right truncated",
"01004");
14523 sret = SQL_SUCCESS_WITH_INFO;
14528#ifdef SQL_C_TYPE_DATE
14529 case SQL_C_TYPE_DATE:
14533 *lenp = SQL_NULL_DATA;
14535 *lenp =
sizeof (DATE_STRUCT);
14538#ifdef SQL_C_TYPE_TIME
14539 case SQL_C_TYPE_TIME:
14543 *lenp = SQL_NULL_DATA;
14545 *lenp =
sizeof (TIME_STRUCT);
14548#ifdef SQL_C_TYPE_TIMESTAMP
14549 case SQL_C_TYPE_TIMESTAMP:
14551 case SQL_C_TIMESTAMP:
14553 (TIMESTAMP_STRUCT *) val) < 0) {
14554 *lenp = SQL_NULL_DATA;
14556 *lenp =
sizeof (TIMESTAMP_STRUCT);
14560 ((TIMESTAMP_STRUCT *) val)->fraction = 0;
14563 ((TIMESTAMP_STRUCT *) val)->fraction /= 100000000;
14564 ((TIMESTAMP_STRUCT *) val)->fraction *= 100000000;
14567 ((TIMESTAMP_STRUCT *) val)->fraction /= 10000000;
14568 ((TIMESTAMP_STRUCT *) val)->fraction *= 10000000;
14576 sret = SQL_SUCCESS;
14602 if (
stmt == SQL_NULL_HSTMT) {
14603 return SQL_INVALID_HANDLE;
14607 if (col == 0 && s->
bkmrk == SQL_UB_ON &&
14608 type == SQL_C_BOOKMARK) {
14617 return SQL_SUCCESS;
14618 }
else if (col == 0 && s->
bkmrk == SQL_UB_VARIABLE &&
14619 type == SQL_C_VARBOOKMARK &&
14620 max >= sizeof (sqlite_int64)) {
14629 return SQL_SUCCESS;
14631 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009" :
"S1002");
14638 if (type == SQL_C_DEFAULT) {
14646 sz =
sizeof (SQLINTEGER);
14648 case SQL_C_TINYINT:
14649 case SQL_C_UTINYINT:
14650 case SQL_C_STINYINT:
14651 sz =
sizeof (SQLCHAR);
14656 sz =
sizeof (SQLSMALLINT);
14659 sz =
sizeof (SQLFLOAT);
14662 sz =
sizeof (SQLDOUBLE);
14664 case SQL_C_TIMESTAMP:
14665 sz =
sizeof (SQL_TIMESTAMP_STRUCT);
14668 sz =
sizeof (SQL_TIME_STRUCT);
14671 sz =
sizeof (SQL_DATE_STRUCT);
14679#ifdef SQL_C_TYPE_DATE
14680 case SQL_C_TYPE_DATE:
14681 sz =
sizeof (SQL_DATE_STRUCT);
14684#ifdef SQL_C_TYPE_TIME
14685 case SQL_C_TYPE_TIME:
14686 sz =
sizeof (SQL_TIME_STRUCT);
14689#ifdef SQL_C_TYPE_TIMESTAMP
14690 case SQL_C_TYPE_TIMESTAMP:
14691 sz =
sizeof (SQL_TIMESTAMP_STRUCT);
14696 sz =
sizeof (SQLCHAR);
14702 case SQL_C_SBIGINT:
14703 case SQL_C_UBIGINT:
14704 sz =
sizeof (SQLBIGINT);
14712 setstat(s, -1,
"invalid type %d",
"HY003", type);
14723 if (sz == 0 &&
max < 0) {
14724 setstat(s, -1,
"invalid length",
"HY090");
14736 return SQL_SUCCESS;
14767 {
"SYSTEM",
"COLUMN",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
14768 {
"SYSTEM",
"COLUMN",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
14769 {
"SYSTEM",
"COLUMN",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
14770 {
"SYSTEM",
"COLUMN",
"TABLE_TYPE",
SCOL_VARCHAR, 50 },
14775 {
"SYSTEM",
"COLUMN",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
14776 {
"SYSTEM",
"COLUMN",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
14777 {
"SYSTEM",
"COLUMN",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
14778 {
"SYSTEM",
"COLUMN",
"TABLE_TYPE",
SCOL_VARCHAR, 50 },
14798 SQLCHAR *cat, SQLSMALLINT catLen,
14799 SQLCHAR *schema, SQLSMALLINT schemaLen,
14800 SQLCHAR *table, SQLSMALLINT tableLen,
14801 SQLCHAR *type, SQLSMALLINT typeLen)
14806 int ncols, asize, rc, size, npatt;
14807 char *errp = NULL, *sql, tname[512];
14808 char *where =
"(type = 'table' or type = 'view')";
14812 if (ret != SQL_SUCCESS) {
14817 if (type && (typeLen > 0 || typeLen == SQL_NTS) && type[0] ==
'%') {
14818 int size = 3 * asize;
14825 memset(s->
rows, 0, sizeof (
char *) * size);
14842 return SQL_SUCCESS;
14844 if (cat && (catLen > 0 || catLen == SQL_NTS) && cat[0] ==
'%') {
14848 if (schema && (schemaLen > 0 || schemaLen == SQL_NTS) &&
14849 schema[0] ==
'%') {
14850 if ((!cat || catLen == 0 || !cat[0]) &&
14851 (!table || tableLen == 0 || !table[0])) {
14856 if (type && (typeLen > 0 || typeLen == SQL_NTS) && type[0] !=
'\0') {
14858 int with_view = 0, with_table = 0;
14860 if (typeLen == SQL_NTS) {
14861 strncpy(tmp, (
char *) type,
sizeof (tmp));
14862 tmp[
sizeof (tmp) - 1] =
'\0';
14864 int len =
min(
sizeof (tmp) - 1, typeLen);
14866 strncpy(tmp, (
char *) type, len);
14877 if (t[0] ==
'\'') {
14880 if (strncmp(t,
"table", 5) == 0) {
14882 }
else if (strncmp(t,
"view", 4) == 0) {
14885 t = strchr(t,
',');
14890 if (with_view && with_table) {
14892 }
else if (with_view && !with_table) {
14893 where =
"type = 'view'";
14894 }
else if (!with_view && with_table) {
14895 where =
"type = 'table'";
14897 return SQL_SUCCESS;
14905 if (tableLen == SQL_NTS) {
14906 size =
sizeof (tname) - 1;
14908 size =
min(
sizeof (tname) - 1, tableLen);
14910 strncpy(tname, (
char *) table, size);
14912 tname[size] =
'\0';
14914#if defined(_WIN32) || defined(_WIN64)
14916 sql = sqlite3_mprintf(
"select %s as 'TABLE_CAT', "
14917 "%s as 'TABLE_SCHEM', "
14918 "tbl_name as 'TABLE_NAME', "
14919 "upper(type) as 'TABLE_TYPE', "
14920 "NULL as 'REMARKS' "
14921 "from sqlite_master where %s "
14922 "and tbl_name like %Q",
14923 d->xcelqrx ?
"'main'" :
"NULL",
14924 d->xcelqrx ?
"''" :
"NULL",
14927 sql = sqlite3_mprintf(
"select %s as 'TABLE_CAT', "
14928 "%s as 'TABLE_SCHEM', "
14929 "tbl_name as 'TABLE_NAME', "
14930 "upper(type) as 'TABLE_TYPE', "
14931 "NULL as 'REMARKS' "
14932 "from sqlite_master where %s "
14933 "and lower(tbl_name) = lower(%Q)",
14934 d->xcelqrx ?
"'main'" :
"NULL",
14935 d->xcelqrx ?
"''" :
"NULL",
14940 sql = sqlite3_mprintf(
"select NULL as 'TABLE_QUALIFIER', "
14941 "NULL as 'TABLE_OWNER', "
14942 "tbl_name as 'TABLE_NAME', "
14943 "upper(type) as 'TABLE_TYPE', "
14944 "NULL as 'REMARKS' "
14945 "from sqlite_master where %s "
14946 "and tbl_name like %Q",
14949 sql = sqlite3_mprintf(
"select NULL as 'TABLE_QUALIFIER', "
14950 "NULL as 'TABLE_OWNER', "
14951 "tbl_name as 'TABLE_NAME', "
14952 "upper(type) as 'TABLE_TYPE', "
14953 "NULL as 'REMARKS' "
14954 "from sqlite_master where %s "
14955 "and lower(tbl_name) = lower(%Q)",
14963 if (ret != SQL_SUCCESS) {
14968 rc = sqlite3_get_table(d->
sqlite, sql, &s->
rows, &s->
nrows, &ncols, &errp);
14970 if (rc == SQLITE_OK) {
14971 if (ncols != s->
ncols) {
14975 s->
rowfree = sqlite3_free_table;
14983 sqlite3_free(errp);
14987 return SQL_SUCCESS;
15006SQLTables(SQLHSTMT
stmt,
15007 SQLCHAR *cat, SQLSMALLINT catLen,
15008 SQLCHAR *schema, SQLSMALLINT schemaLen,
15009 SQLCHAR *table, SQLSMALLINT tableLen,
15010 SQLCHAR *type, SQLSMALLINT typeLen)
15012#if defined(_WIN32) || defined(_WIN64)
15013 char *c = NULL, *s = NULL, *t = NULL, *y = NULL;
15018#if defined(_WIN32) || defined(_WIN64)
15021 table, tableLen, type, typeLen);
15025 c = wmb_to_utf_c((
char *) cat, catLen);
15032 s = wmb_to_utf_c((
char *) schema, schemaLen);
15039 t = wmb_to_utf_c((
char *) table, tableLen);
15046 y = wmb_to_utf_c((
char *) type, typeLen);
15052 ret =
drvtables(
stmt, (SQLCHAR *) c, SQL_NTS, (SQLCHAR *) s, SQL_NTS,
15053 (SQLCHAR *) t, SQL_NTS, (SQLCHAR *) y, SQL_NTS);
15056 table, tableLen, type, typeLen);
15058#if defined(_WIN32) || defined(_WIN64)
15089 SQLWCHAR *cat, SQLSMALLINT catLen,
15090 SQLWCHAR *schema, SQLSMALLINT schemaLen,
15091 SQLWCHAR *table, SQLSMALLINT tableLen,
15092 SQLWCHAR *type, SQLSMALLINT typeLen)
15094 char *c = NULL, *s = NULL, *t = NULL, *y = NULL;
15126 ret =
drvtables(
stmt, (SQLCHAR *) c, SQL_NTS, (SQLCHAR *) s, SQL_NTS,
15127 (SQLCHAR *) t, SQL_NTS, (SQLCHAR *) y, SQL_NTS);
15143 {
"SYSTEM",
"COLUMN",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
15144 {
"SYSTEM",
"COLUMN",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
15145 {
"SYSTEM",
"COLUMN",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
15146 {
"SYSTEM",
"COLUMN",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
15147 {
"SYSTEM",
"COLUMN",
"DATA_TYPE", SQL_SMALLINT, 50 },
15148 {
"SYSTEM",
"COLUMN",
"TYPE_NAME",
SCOL_VARCHAR, 50 },
15149 {
"SYSTEM",
"COLUMN",
"PRECISION", SQL_INTEGER, 50 },
15150 {
"SYSTEM",
"COLUMN",
"LENGTH", SQL_INTEGER, 50 },
15151 {
"SYSTEM",
"COLUMN",
"SCALE", SQL_SMALLINT, 50 },
15152 {
"SYSTEM",
"COLUMN",
"RADIX", SQL_SMALLINT, 50 },
15153 {
"SYSTEM",
"COLUMN",
"NULLABLE", SQL_SMALLINT, 50 },
15155 {
"SYSTEM",
"COLUMN",
"COLUMN_DEF",
SCOL_VARCHAR, 50 },
15156 {
"SYSTEM",
"COLUMN",
"SQL_DATA_TYPE", SQL_SMALLINT, 50 },
15157 {
"SYSTEM",
"COLUMN",
"SQL_DATETIME_SUB", SQL_SMALLINT, 50 },
15158 {
"SYSTEM",
"COLUMN",
"CHAR_OCTET_LENGTH", SQL_SMALLINT, 50 },
15159 {
"SYSTEM",
"COLUMN",
"ORDINAL_POSITION", SQL_SMALLINT, 50 },
15160 {
"SYSTEM",
"COLUMN",
"IS_NULLABLE",
SCOL_VARCHAR, 50 }
15164 {
"SYSTEM",
"COLUMN",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
15165 {
"SYSTEM",
"COLUMN",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
15166 {
"SYSTEM",
"COLUMN",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
15167 {
"SYSTEM",
"COLUMN",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
15168 {
"SYSTEM",
"COLUMN",
"DATA_TYPE", SQL_SMALLINT, 50 },
15169 {
"SYSTEM",
"COLUMN",
"TYPE_NAME",
SCOL_VARCHAR, 50 },
15170 {
"SYSTEM",
"COLUMN",
"COLUMN_SIZE", SQL_INTEGER, 50 },
15171 {
"SYSTEM",
"COLUMN",
"BUFFER_LENGTH", SQL_INTEGER, 50 },
15172 {
"SYSTEM",
"COLUMN",
"DECIMAL_DIGITS", SQL_SMALLINT, 50 },
15173 {
"SYSTEM",
"COLUMN",
"NUM_PREC_RADIX", SQL_SMALLINT, 50 },
15174 {
"SYSTEM",
"COLUMN",
"NULLABLE", SQL_SMALLINT, 50 },
15176 {
"SYSTEM",
"COLUMN",
"COLUMN_DEF",
SCOL_VARCHAR, 50 },
15177 {
"SYSTEM",
"COLUMN",
"SQL_DATA_TYPE", SQL_SMALLINT, 50 },
15178 {
"SYSTEM",
"COLUMN",
"SQL_DATETIME_SUB", SQL_SMALLINT, 50 },
15179 {
"SYSTEM",
"COLUMN",
"CHAR_OCTET_LENGTH", SQL_SMALLINT, 50 },
15180 {
"SYSTEM",
"COLUMN",
"ORDINAL_POSITION", SQL_SMALLINT, 50 },
15181 {
"SYSTEM",
"COLUMN",
"IS_NULLABLE",
SCOL_VARCHAR, 50 }
15200 SQLCHAR *cat, SQLSMALLINT catLen,
15201 SQLCHAR *schema, SQLSMALLINT schemaLen,
15202 SQLCHAR *table, SQLSMALLINT tableLen,
15203 SQLCHAR *col, SQLSMALLINT colLen)
15208 int ret, nrows, ncols, asize, i, k, roffs, namec;
15209 int tnrows, tncols, npatt;
15211 char *errp = NULL, *sql, tname[512], cname[512], **rowp, **trows;
15215 if (sret != SQL_SUCCESS) {
15224 if (tableLen == SQL_NTS) {
15225 size =
sizeof (tname) - 1;
15227 size =
min(
sizeof (tname) - 1, tableLen);
15229 strncpy(tname, (
char *) table, size);
15231 tname[size] =
'\0';
15235 if (colLen == SQL_NTS) {
15236 size =
sizeof (cname) - 1;
15238 size =
min(
sizeof (cname) - 1, colLen);
15240 strncpy(cname, (
char *) col, size);
15242 cname[size] =
'\0';
15243 if (!strcmp(cname,
"%")) {
15247 sql = sqlite3_mprintf(
"select tbl_name from sqlite_master where "
15248 "(type = 'table' or type = 'view') "
15249 "and tbl_name like %Q", tname);
15251 sql = sqlite3_mprintf(
"select tbl_name from sqlite_master where "
15252 "(type = 'table' or type = 'view') "
15253 "and lower(tbl_name) = lower(%Q)", tname);
15259 if (sret != SQL_SUCCESS) {
15264 ret = sqlite3_get_table(d->
sqlite, sql, &trows, &tnrows, &tncols, &errp);
15266 if (ret != SQLITE_OK) {
15267 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
15268 errp ? errp :
"unknown error", ret);
15270 sqlite3_free(errp);
15276 sqlite3_free(errp);
15280 if (tncols * tnrows <= 0) {
15281 sqlite3_free_table(trows);
15282 return SQL_SUCCESS;
15285 for (i = 1; i <= tnrows; i++) {
15286 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", trows[i]);
15288 sqlite3_free_table(trows);
15292 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
15294 if (ret != SQLITE_OK) {
15295 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
15296 errp ? errp :
"unknown error", ret);
15298 sqlite3_free(errp);
15301 sqlite3_free_table(trows);
15305 sqlite3_free(errp);
15308 if (ncols * nrows > 0) {
15310 for (k = 0; k < ncols; k++) {
15311 if (strcmp(rowp[k],
"name") == 0) {
15318 for (k = 1; k <= nrows; k++) {
15319 if (
namematch(rowp[k * ncols + namec], cname, 1)) {
15328 sqlite3_free_table(rowp);
15332 sqlite3_free_table(trows);
15333 return SQL_SUCCESS;
15336 size = (size + 1) * asize;
15340 sqlite3_free_table(trows);
15343 s->
rows[0] = (
char *) size;
15345 memset(s->
rows, 0, sizeof (
char *) * size);
15348 for (i = 1; i <= tnrows; i++) {
15349 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", trows[i]);
15351 sqlite3_free_table(trows);
15355 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
15357 if (ret != SQLITE_OK) {
15358 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
15359 errp ? errp :
"unknown error", ret);
15361 sqlite3_free(errp);
15364 sqlite3_free_table(trows);
15368 sqlite3_free(errp);
15371 if (ncols * nrows > 0) {
15372 int m, mr, nr = nrows;
15375 for (k = 0; k < ncols; k++) {
15376 if (strcmp(rowp[k],
"name") == 0) {
15384 for (k = 1; k <= nrows; k++) {
15385 if (
namematch(rowp[k * ncols + namec], cname, 1)) {
15391 for (k = 0; k < nr; k++) {
15392 m = asize * (roffs + k);
15393#if defined(_WIN32) || defined(_WIN64)
15394 s->
rows[m + 0] =
xstrdup(d->xcelqrx ?
"main" :
"");
15405 for (k = 0; nr && k < ncols; k++) {
15406 if (strcmp(rowp[k],
"cid") == 0) {
15407 for (mr = 0, m = 1; m <= nrows; m++) {
15412 !
namematch(rowp[m * ncols + namec], cname, 1)) {
15415 ir = asize * (roffs + mr);
15416 sscanf(rowp[m * ncols + k],
"%d", &coln);
15417 sprintf(buf,
"%d", coln + 1);
15421 }
else if (k == namec) {
15422 for (mr = 0, m = 1; m <= nrows; m++) {
15426 !
namematch(rowp[m * ncols + namec], cname, 1)) {
15429 ir = asize * (roffs + mr);
15433 }
else if (strcmp(rowp[k],
"notnull") == 0) {
15434 for (mr = 0, m = 1; m <= nrows; m++) {
15438 !
namematch(rowp[m * ncols + namec], cname, 1)) {
15441 ir = asize * (roffs + mr);
15442 if (*rowp[m * ncols + k] !=
'0') {
15448 xstrdup((*rowp[m * ncols + k] !=
'0') ?
15452 }
else if (strcmp(rowp[k],
"dflt_value") == 0) {
15453 for (mr = 0, m = 1; m <= nrows; m++) {
15454 char *dflt =
unquote(rowp[m * ncols + k]);
15458 !
namematch(rowp[m * ncols + namec], cname, 1)) {
15461 ir = asize * (roffs + mr);
15462 s->
rows[ir + 12] =
xstrdup(dflt ? dflt :
"NULL");
15465 }
else if (strcmp(rowp[k],
"type") == 0) {
15466 for (mr = 0, m = 1; m <= nrows; m++) {
15467 char *
typename = rowp[m * ncols + k];
15468 int sqltype, mm, dd, ir;
15472 !
namematch(rowp[m * ncols + namec], cname, 1)) {
15475 ir = asize * (roffs + mr);
15479 getmd(
typename, sqltype, &mm, &dd);
15480#ifdef SQL_LONGVARCHAR
15481 if (sqltype == SQL_VARCHAR && mm > 255) {
15482 sqltype = SQL_LONGVARCHAR;
15486#ifdef SQL_WLONGVARCHAR
15487 if (sqltype == SQL_WVARCHAR && mm > 255) {
15488 sqltype = SQL_WLONGVARCHAR;
15492 if (sqltype == SQL_VARBINARY && mm > 255) {
15493 sqltype = SQL_LONGVARBINARY;
15495 sprintf(buf,
"%d", sqltype);
15498 sprintf(buf,
"%d", mm);
15500 sprintf(buf,
"%d", dd);
15508 sqlite3_free_table(rowp);
15510 sqlite3_free_table(trows);
15511 return SQL_SUCCESS;
15530SQLColumns(SQLHSTMT
stmt,
15531 SQLCHAR *cat, SQLSMALLINT catLen,
15532 SQLCHAR *schema, SQLSMALLINT schemaLen,
15533 SQLCHAR *table, SQLSMALLINT tableLen,
15534 SQLCHAR *col, SQLSMALLINT colLen)
15536#if defined(_WIN32) || defined(_WIN64)
15537 char *c = NULL, *s = NULL, *t = NULL, *k = NULL;
15542#if defined(_WIN32) || defined(_WIN64)
15545 table, tableLen, col, colLen);
15549 c = wmb_to_utf_c((
char *) cat, catLen);
15556 s = wmb_to_utf_c((
char *) schema, schemaLen);
15563 t = wmb_to_utf_c((
char *) table, tableLen);
15570 k = wmb_to_utf_c((
char *) col, colLen);
15576 ret =
drvcolumns(
stmt, (SQLCHAR *) c, SQL_NTS, (SQLCHAR *) s, SQL_NTS,
15577 (SQLCHAR *) t, SQL_NTS, (SQLCHAR *) k, SQL_NTS);
15580 table, tableLen, col, colLen);
15582#if defined(_WIN32) || defined(_WIN64)
15613 SQLWCHAR *cat, SQLSMALLINT catLen,
15614 SQLWCHAR *schema, SQLSMALLINT schemaLen,
15615 SQLWCHAR *table, SQLSMALLINT tableLen,
15616 SQLWCHAR *col, SQLSMALLINT colLen)
15618 char *c = NULL, *s = NULL, *t = NULL, *k = NULL;
15650 ret =
drvcolumns(
stmt, (SQLCHAR *) c, SQL_NTS, (SQLCHAR *) s, SQL_NTS,
15651 (SQLCHAR *) t, SQL_NTS, (SQLCHAR *) k, SQL_NTS);
15669 {
"SYSTEM",
"TYPE",
"DATA_TYPE", SQL_SMALLINT, 2 },
15670 {
"SYSTEM",
"TYPE",
"PRECISION", SQL_INTEGER, 9 },
15671 {
"SYSTEM",
"TYPE",
"LITERAL_PREFIX",
SCOL_VARCHAR, 50 },
15672 {
"SYSTEM",
"TYPE",
"LITERAL_SUFFIX",
SCOL_VARCHAR, 50 },
15673 {
"SYSTEM",
"TYPE",
"CREATE_PARAMS",
SCOL_VARCHAR, 50 },
15674 {
"SYSTEM",
"TYPE",
"NULLABLE", SQL_SMALLINT, 2 },
15675 {
"SYSTEM",
"TYPE",
"CASE_SENSITIVE", SQL_SMALLINT, 2 },
15676 {
"SYSTEM",
"TYPE",
"SEARCHABLE", SQL_SMALLINT, 2 },
15677 {
"SYSTEM",
"TYPE",
"UNSIGNED_ATTRIBUTE", SQL_SMALLINT, 2 },
15678 {
"SYSTEM",
"TYPE",
"MONEY", SQL_SMALLINT, 2 },
15679 {
"SYSTEM",
"TYPE",
"AUTO_INCREMENT", SQL_SMALLINT, 2 },
15680 {
"SYSTEM",
"TYPE",
"LOCAL_TYPE_NAME",
SCOL_VARCHAR, 50 },
15681 {
"SYSTEM",
"TYPE",
"MINIMUM_SCALE", SQL_SMALLINT, 2 },
15682 {
"SYSTEM",
"TYPE",
"MAXIMUM_SCALE", SQL_SMALLINT, 2 }
15687 {
"SYSTEM",
"TYPE",
"DATA_TYPE", SQL_SMALLINT, 2 },
15688 {
"SYSTEM",
"TYPE",
"COLUMN_SIZE", SQL_INTEGER, 9 },
15689 {
"SYSTEM",
"TYPE",
"LITERAL_PREFIX",
SCOL_VARCHAR, 50 },
15690 {
"SYSTEM",
"TYPE",
"LITERAL_SUFFIX",
SCOL_VARCHAR, 50 },
15691 {
"SYSTEM",
"TYPE",
"CREATE_PARAMS",
SCOL_VARCHAR, 50 },
15692 {
"SYSTEM",
"TYPE",
"NULLABLE", SQL_SMALLINT, 2 },
15693 {
"SYSTEM",
"TYPE",
"CASE_SENSITIVE", SQL_SMALLINT, 2 },
15694 {
"SYSTEM",
"TYPE",
"SEARCHABLE", SQL_SMALLINT, 2 },
15695 {
"SYSTEM",
"TYPE",
"UNSIGNED_ATTRIBUTE", SQL_SMALLINT, 2 },
15696 {
"SYSTEM",
"TYPE",
"FIXED_PREC_SCALE", SQL_SMALLINT, 2 },
15697 {
"SYSTEM",
"TYPE",
"AUTO_UNIQUE_VALUE", SQL_SMALLINT, 2 },
15698 {
"SYSTEM",
"TYPE",
"LOCAL_TYPE_NAME",
SCOL_VARCHAR, 50 },
15699 {
"SYSTEM",
"TYPE",
"MINIMUM_SCALE", SQL_SMALLINT, 2 },
15700 {
"SYSTEM",
"TYPE",
"MAXIMUM_SCALE", SQL_SMALLINT, 2 },
15701 {
"SYSTEM",
"TYPE",
"SQL_DATA_TYPE", SQL_SMALLINT, 2 },
15702 {
"SYSTEM",
"TYPE",
"SQL_DATETIME_SUB", SQL_SMALLINT, 2 },
15703 {
"SYSTEM",
"TYPE",
"NUM_PREC_RADIX", SQL_INTEGER, 4 },
15704 {
"SYSTEM",
"TYPE",
"INTERVAL_PRECISION", SQL_SMALLINT, 2 }
15720 int offs = row * asize;
15721 char *tcode, *crpar = NULL, *sign =
stringify(SQL_FALSE);
15722 char *quote[2] = { NULL, NULL };
15723 static char tcodes[32 * 32];
15728 tcode = tcodes + tind * 32;
15729 sprintf(tcode,
"%d", type);
15730 s->
rows[offs + 0] =
typename;
15731 s->
rows[offs + 1] = tcode;
15733 s->
rows[offs + 15] = tcode;
15734 s->
rows[offs + 16] =
"0";
15738#ifdef SQL_LONGVARCHAR
15739 case SQL_LONGVARCHAR:
15741 case SQL_WLONGVARCHAR:
15744 quote[0] = quote[1] =
"'";
15746 s->
rows[offs + 2] =
"65536";
15752 s->
rows[offs + 2] =
"1";
15761 s->
rows[offs + 2] =
"255";
15763 quote[0] = quote[1] =
"'";
15767 s->
rows[offs + 2] =
"3";
15770 s->
rows[offs + 2] =
"5";
15773 s->
rows[offs + 2] =
"9";
15777 s->
rows[offs + 2] =
"19";
15781 s->
rows[offs + 2] =
"7";
15784 s->
rows[offs + 2] =
"15";
15786#ifdef SQL_TYPE_DATE
15787 case SQL_TYPE_DATE:
15790 s->
rows[offs + 2] =
"10";
15791 quote[0] = quote[1] =
"'";
15794#ifdef SQL_TYPE_TIME
15795 case SQL_TYPE_TIME:
15798 s->
rows[offs + 2] =
"8";
15799 quote[0] = quote[1] =
"'";
15802#ifdef SQL_TYPE_TIMESTAMP
15803 case SQL_TYPE_TIMESTAMP:
15805 case SQL_TIMESTAMP:
15806 s->
rows[offs + 2] =
"32";
15807 quote[0] = quote[1] =
"'";
15810 case SQL_VARBINARY:
15813 s->
rows[offs + 2] =
"255";
15815 case SQL_LONGVARBINARY:
15818 s->
rows[offs + 2] =
"65536";
15821 s->
rows[offs + 3] = quote[0];
15822 s->
rows[offs + 4] = quote[1];
15823 s->
rows[offs + 5] = crpar;
15827 s->
rows[offs + 9] = sign;
15830 s->
rows[offs + 12] =
typename;
15834 s->
rows[offs + 13] =
"0";
15835 s->
rows[offs + 14] =
"0";
15837#ifdef SQL_TYPE_TIMESTAMP
15838 case SQL_TYPE_TIMESTAMP:
15840 case SQL_TIMESTAMP:
15841 s->
rows[offs + 13] =
"0";
15842 s->
rows[offs + 14] =
"3";
15845 s->
rows[offs + 13] = NULL;
15846 s->
rows[offs + 14] = NULL;
15862 char **pa = (
char **) a;
15863 char **pb = (
char **) b;
15866 na = strtol(pa[1], NULL, 0);
15867 nb = strtol(pb[1], NULL, 0);
15887 if (ret != SQL_SUCCESS) {
15891#ifdef SQL_LONGVARCHAR
15892 s->
nrows = (sqltype == SQL_ALL_TYPES) ? 13 : 1;
15894 s->
nrows = (sqltype == SQL_ALL_TYPES) ? 12 : 1;
15896 if (sqltype == SQL_ALL_TYPES) {
15899#ifdef SQL_WLONGVARCHAR
15904 if (sqltype == SQL_ALL_TYPES) {
15923 memset(s->
rows, 0, sizeof (
char *) * (s->
nrows + 1) * asize);
15924 if (sqltype == SQL_ALL_TYPES) {
15927 mktypeinfo(s, cc++, asize,
"varchar", SQL_VARCHAR, 0);
15928 mktypeinfo(s, cc++, asize,
"tinyint", SQL_TINYINT, 0);
15929 mktypeinfo(s, cc++, asize,
"smallint", SQL_SMALLINT, 0);
15930 mktypeinfo(s, cc++, asize,
"integer", SQL_INTEGER, 0);
15931 mktypeinfo(s, cc++, asize,
"float", SQL_FLOAT, 0);
15932 mktypeinfo(s, cc++, asize,
"double", SQL_DOUBLE, 0);
15933#ifdef SQL_TYPE_DATE
15935 (*s->
ov3) ? SQL_TYPE_DATE : SQL_DATE, 0);
15937 mktypeinfo(s, cc++, asize,
"date", SQL_DATE, 0);
15939#ifdef SQL_TYPE_TIME
15941 (*s->
ov3) ? SQL_TYPE_TIME : SQL_TIME, 0);
15943 mktypeinfo(s, cc++, asize,
"time", SQL_TIME, 0);
15945#ifdef SQL_TYPE_TIMESTAMP
15947 (*s->
ov3) ? SQL_TYPE_TIMESTAMP : SQL_TIMESTAMP, 0);
15949 mktypeinfo(s, cc++, asize,
"timestamp", SQL_TIMESTAMP, 0);
15951 mktypeinfo(s, cc++, asize,
"char", SQL_CHAR, 0);
15952 mktypeinfo(s, cc++, asize,
"numeric", SQL_DOUBLE, 0);
15953#ifdef SQL_LONGVARCHAR
15954 mktypeinfo(s, cc++, asize,
"text", SQL_LONGVARCHAR, 0);
15955 mktypeinfo(s, cc++, asize,
"longvarchar", SQL_LONGVARCHAR, 0);
15957 mktypeinfo(s, cc++, asize,
"text", SQL_VARCHAR, 0);
15959 mktypeinfo(s, cc++, asize,
"varbinary", SQL_VARBINARY, 0);
15960 mktypeinfo(s, cc++, asize,
"longvarbinary", SQL_LONGVARBINARY, 0);
15962 mktypeinfo(s, cc++, asize,
"bit", SQL_BIT, 0);
15965 mktypeinfo(s, cc++, asize,
"bigint", SQL_BIGINT, 0);
15968 mktypeinfo(s, cc++, asize,
"wvarchar", SQL_WVARCHAR, 0);
15969 mktypeinfo(s, cc++, asize,
"wchar", SQL_WCHAR, 0);
15970#ifdef SQL_WLONGVARCHAR
15971 mktypeinfo(s, cc++, asize,
"wtext", SQL_WLONGVARCHAR, 0);
15972 mktypeinfo(s, cc++, asize,
"longwvarchar", SQL_WLONGVARCHAR, 0);
15975 qsort(s->
rows + asize, s->
nrows, sizeof (
char *) * asize,
15980 mktypeinfo(s, 1, asize,
"char", SQL_CHAR, 10);
15983 mktypeinfo(s, 1, asize,
"varchar", SQL_VARCHAR, 1);
15986 mktypeinfo(s, 1, asize,
"tinyint", SQL_TINYINT, 2);
15989 mktypeinfo(s, 1, asize,
"smallint", SQL_SMALLINT, 3);
15992 mktypeinfo(s, 1, asize,
"integer", SQL_INTEGER, 4);
15995 mktypeinfo(s, 1, asize,
"float", SQL_FLOAT, 5);
15998 mktypeinfo(s, 1, asize,
"double", SQL_DOUBLE, 6);
16000#ifdef SQL_TYPE_DATE
16001 case SQL_TYPE_DATE:
16002 mktypeinfo(s, 1, asize,
"date", SQL_TYPE_DATE, 25);
16006 mktypeinfo(s, 1, asize,
"date", SQL_DATE, 7);
16008#ifdef SQL_TYPE_TIME
16009 case SQL_TYPE_TIME:
16010 mktypeinfo(s, 1, asize,
"time", SQL_TYPE_TIME, 26);
16014 mktypeinfo(s, 1, asize,
"time", SQL_TIME, 8);
16016#ifdef SQL_TYPE_TIMESTAMP
16017 case SQL_TYPE_TIMESTAMP:
16018 mktypeinfo(s, 1, asize,
"timestamp", SQL_TYPE_TIMESTAMP, 27);
16021 case SQL_TIMESTAMP:
16022 mktypeinfo(s, 1, asize,
"timestamp", SQL_TIMESTAMP, 9);
16024#ifdef SQL_LONGVARCHAR
16025 case SQL_LONGVARCHAR:
16026 mktypeinfo(s, 1, asize,
"longvarchar", SQL_LONGVARCHAR, 12);
16029 case SQL_VARBINARY:
16030 mktypeinfo(s, 1, asize,
"varbinary", SQL_VARBINARY, 30);
16032 case SQL_LONGVARBINARY:
16033 mktypeinfo(s, 1, asize,
"longvarbinary", SQL_LONGVARBINARY, 31);
16037 mktypeinfo(s, 1, asize,
"bit", SQL_BIT, 29);
16042 mktypeinfo(s, 1, asize,
"bigint", SQL_BIGINT, 28);
16048 mktypeinfo(s, 1, asize,
"wchar", SQL_WCHAR, 18);
16053 mktypeinfo(s, 1, asize,
"wvarchar", SQL_WVARCHAR, 19);
16056#ifdef SQL_WLONGVARCHAR
16057 case SQL_WLONGVARCHAR:
16058 mktypeinfo(s, 1, asize,
"longwvarchar", SQL_WLONGVARCHAR, 20);
16066 return SQL_SUCCESS;
16078SQLGetTypeInfo(SQLHSTMT
stmt, SQLSMALLINT sqltype)
16114 {
"SYSTEM",
"STATISTICS",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
16115 {
"SYSTEM",
"STATISTICS",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
16116 {
"SYSTEM",
"STATISTICS",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
16117 {
"SYSTEM",
"STATISTICS",
"NON_UNIQUE", SQL_SMALLINT, 50 },
16118 {
"SYSTEM",
"STATISTICS",
"INDEX_QUALIFIER",
SCOL_VARCHAR, 255 },
16119 {
"SYSTEM",
"STATISTICS",
"INDEX_NAME",
SCOL_VARCHAR, 255 },
16120 {
"SYSTEM",
"STATISTICS",
"TYPE", SQL_SMALLINT, 50 },
16121 {
"SYSTEM",
"STATISTICS",
"SEQ_IN_INDEX", SQL_SMALLINT, 50 },
16122 {
"SYSTEM",
"STATISTICS",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
16123 {
"SYSTEM",
"STATISTICS",
"COLLATION",
SCOL_CHAR, 1 },
16124 {
"SYSTEM",
"STATISTICS",
"CARDINALITY", SQL_INTEGER, 50 },
16125 {
"SYSTEM",
"STATISTICS",
"PAGES", SQL_INTEGER, 50 },
16126 {
"SYSTEM",
"STATISTICS",
"FILTER_CONDITION",
SCOL_VARCHAR, 255 }
16130 {
"SYSTEM",
"STATISTICS",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
16131 {
"SYSTEM",
"STATISTICS",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
16132 {
"SYSTEM",
"STATISTICS",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
16133 {
"SYSTEM",
"STATISTICS",
"NON_UNIQUE", SQL_SMALLINT, 50 },
16134 {
"SYSTEM",
"STATISTICS",
"INDEX_QUALIFIER",
SCOL_VARCHAR, 255 },
16135 {
"SYSTEM",
"STATISTICS",
"INDEX_NAME",
SCOL_VARCHAR, 255 },
16136 {
"SYSTEM",
"STATISTICS",
"TYPE", SQL_SMALLINT, 50 },
16137 {
"SYSTEM",
"STATISTICS",
"ORDINAL_POSITION", SQL_SMALLINT, 50 },
16138 {
"SYSTEM",
"STATISTICS",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
16139 {
"SYSTEM",
"STATISTICS",
"ASC_OR_DESC",
SCOL_CHAR, 1 },
16140 {
"SYSTEM",
"STATISTICS",
"CARDINALITY", SQL_INTEGER, 50 },
16141 {
"SYSTEM",
"STATISTICS",
"PAGES", SQL_INTEGER, 50 },
16142 {
"SYSTEM",
"STATISTICS",
"FILTER_CONDITION",
SCOL_VARCHAR, 255 }
16161 SQLCHAR *schema, SQLSMALLINT schemaLen,
16162 SQLCHAR *table, SQLSMALLINT tableLen,
16163 SQLUSMALLINT itype, SQLUSMALLINT resv)
16168 int i, asize, ret, nrows, ncols, offs, namec, uniquec, addipk = 0;
16170 char **rowp, *errp = NULL, *sql, tname[512];
16174 if (sret != SQL_SUCCESS) {
16179 if (!table || table[0] ==
'\0' || table[0] ==
'%') {
16180 setstat(s, -1,
"need table name", (*s->
ov3) ?
"HY000" :
"S1000");
16183 if (tableLen == SQL_NTS) {
16184 size =
sizeof (tname) - 1;
16186 size =
min(
sizeof (tname) - 1, tableLen);
16188 strncpy(tname, (
char *) table, size);
16189 tname[size] =
'\0';
16192 if (sret != SQL_SUCCESS) {
16198 if (itype == SQL_INDEX_UNIQUE || itype == SQL_INDEX_ALL) {
16200 ret = SQLITE_ERROR;
16201 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", tname);
16204 ret = sqlite3_get_table(d->
sqlite, sql, &rowp,
16205 &nrows, &ncols, NULL);
16208 if (ret == SQLITE_OK) {
16209 int colid, typec, npk = 0, npkint = 0;
16211 namec =
findcol(rowp, ncols,
"name");
16212 uniquec =
findcol(rowp, ncols,
"pk");
16213 typec =
findcol(rowp, ncols,
"type");
16214 colid =
findcol(rowp, ncols,
"cid");
16215 if (namec < 0 || uniquec < 0 || typec < 0 || colid < 0) {
16218 for (i = 1; i <= nrows; i++) {
16219 if (*rowp[i * ncols + uniquec] !=
'0') {
16221 if (strlen(rowp[i * ncols + typec]) == 7 &&
16222 strncasecmp(rowp[i * ncols + typec],
"integer", 7)
16228 if (npkint == 1 && npk == npkint) {
16233 sqlite3_free_table(rowp);
16235 sql = sqlite3_mprintf(
"PRAGMA index_list(%Q)", tname);
16240 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
16242 if (ret != SQLITE_OK) {
16243 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
16244 errp ? errp :
"unknown error", ret);
16246 sqlite3_free(errp);
16252 sqlite3_free(errp);
16256 namec =
findcol(rowp, ncols,
"name");
16257 uniquec =
findcol(rowp, ncols,
"unique");
16258 if (namec < 0 || uniquec < 0) {
16261 for (i = 1; i <= nrows; i++) {
16262 int nnrows, nncols;
16266 isuniq = *rowp[i * ncols + uniquec] !=
'0';
16267 if (isuniq || itype == SQL_INDEX_ALL) {
16268 ret = SQLITE_ERROR;
16269 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
16270 rowp[i * ncols + namec]);
16273 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
16274 &nnrows, &nncols, NULL);
16277 if (ret == SQLITE_OK) {
16279 sqlite3_free_table(rowpp);
16288 sqlite3_free_table(rowp);
16289 return SQL_SUCCESS;
16292 size = (size + 1) * asize;
16298 s->
rows[0] = (
char *) size;
16300 memset(s->
rows, 0, sizeof (
char *) * size);
16305 int nrows2, ncols2;
16307 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", tname);
16310 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
16311 &nrows2, &ncols2, NULL);
16314 if (ret == SQLITE_OK) {
16315 int colid, typec, roffs, namecc, uniquecc;
16317 namecc =
findcol(rowpp, ncols2,
"name");
16318 uniquecc =
findcol(rowpp, ncols2,
"pk");
16319 typec =
findcol(rowpp, ncols2,
"type");
16320 colid =
findcol(rowpp, ncols2,
"cid");
16321 if (namecc < 0 || uniquecc < 0 || typec < 0 || colid < 0) {
16326 for (i = 1; i <= nrows2; i++) {
16327 if (*rowpp[i * ncols2 + uniquecc] !=
'0' &&
16328 strlen(rowpp[i * ncols2 + typec]) == 7 &&
16329 strncasecmp(rowpp[i * ncols2 + typec],
"integer", 7)
16340#if defined(_WIN32) || defined(_WIN64)
16341 s->
rows[roffs + 0] =
xstrdup(d->xcelqrx ?
"main" :
"");
16349 s->
rows[roffs + 5] =
xstrdup(
"sqlite_autoindex_0");
16352 s->
rows[roffs + 8] =
xstrdup(rowpp[i * ncols2 + namecc]);
16356 sqlite3_free_table(rowpp);
16358 for (i = 1; i <= nrows; i++) {
16359 int nnrows, nncols;
16362 if (*rowp[i * ncols + uniquec] !=
'0' || itype == SQL_INDEX_ALL) {
16365 ret = SQLITE_ERROR;
16366 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
16367 rowp[i * ncols + namec]);
16370 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
16371 &nnrows, &nncols, NULL);
16374 if (ret != SQLITE_OK) {
16377 for (k = 0; nnrows && k < nncols; k++) {
16378 if (strcmp(rowpp[k],
"name") == 0) {
16381 for (m = 1; m <= nnrows; m++) {
16382 int roffs = (offs + addipk + m) * s->
ncols;
16385 isuniq = *rowp[i * ncols + uniquec] !=
'0';
16394 s->
rows[roffs + 5] =
xstrdup(rowp[i * ncols + namec]);
16395 s->
rows[roffs + 6] =
16397 s->
rows[roffs + 8] =
xstrdup(rowpp[m * nncols + k]);
16400 }
else if (strcmp(rowpp[k],
"seqno") == 0) {
16403 for (m = 1; m <= nnrows; m++) {
16404 int roffs = (offs + addipk + m) * s->
ncols;
16408 sscanf(rowpp[m * nncols + k],
"%d", &pos);
16409 sprintf(buf,
"%d", pos + 1);
16415 sqlite3_free_table(rowpp);
16418 sqlite3_free_table(rowp);
16419 return SQL_SUCCESS;
16438SQLStatistics(SQLHSTMT
stmt, SQLCHAR *cat, SQLSMALLINT catLen,
16439 SQLCHAR *schema, SQLSMALLINT schemaLen,
16440 SQLCHAR *table, SQLSMALLINT tableLen,
16441 SQLUSMALLINT itype, SQLUSMALLINT resv)
16443#if defined(_WIN32) || defined(_WIN64)
16444 char *c = NULL, *s = NULL, *t = NULL;
16449#if defined(_WIN32) || defined(_WIN64)
16452 table, tableLen, itype, resv);
16456 c = wmb_to_utf_c((
char *) cat, catLen);
16463 s = wmb_to_utf_c((
char *) schema, schemaLen);
16470 t = wmb_to_utf_c((
char *) table, tableLen);
16477 (SQLCHAR *) t, SQL_NTS, itype, resv);
16480 table, tableLen, itype, resv);
16482#if defined(_WIN32) || defined(_WIN64)
16512 SQLWCHAR *schema, SQLSMALLINT schemaLen,
16513 SQLWCHAR *table, SQLSMALLINT tableLen,
16514 SQLUSMALLINT itype, SQLUSMALLINT resv)
16516 char *c = NULL, *s = NULL, *t = NULL;
16542 (SQLCHAR *) t, SQL_NTS, itype, resv);
16568 SQLRETURN ret = SQL_ERROR;
16571 if (
stmt == SQL_NULL_HSTMT) {
16572 return SQL_INVALID_HANDLE;
16575 if (col == 0 && s->
bkmrk != SQL_UB_OFF) {
16576 if (s->
bkmrk == SQL_UB_ON && type == SQL_C_BOOKMARK) {
16577 *((SQLINTEGER *) val) = s->
rowp;
16579 *lenp =
sizeof (SQLINTEGER);
16583 }
else if (s->
bkmrk == SQL_UB_VARIABLE && type == SQL_C_VARBOOKMARK) {
16585 char **data, *endp = 0;
16590 *((sqlite_int64 *) val) = strtol(*data, &endp, 0);
16592 *((sqlite_int64 *) val) = strtoll(*data, &endp, 0);
16595 *((sqlite_int64 *) val) = s->
rowp;
16598 *lenp =
sizeof (sqlite_int64);
16604 if (col < 1 || col > s->
ncols) {
16605 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009" :
"S1002");
16609 ret =
getrowdata(s, col, type, val, len, lenp, 1);
16625 int ret, i, withinfo = 0;
16629 int bsize =
sizeof (SQLINTEGER);
16634 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
16642 val = (SQLPOINTER) ((
char *) val + *s->
bind_offs);
16645 char **data, *endp = 0;
16650 *(sqlite_int64 *) val = strtol(*data, &endp, 0);
16652 *(sqlite_int64 *) val = strtoll(*data, &endp, 0);
16655 *(sqlite_int64 *) val = s->
rowp;
16657 bsize =
sizeof (sqlite_int64);
16661 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
16662 val = (SQLINTEGER *)
16668 val = (SQLINTEGER *) ((
char *) val + *s->
bind_offs);
16675 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
16695 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
16698 dp = (SQLPOINTER) ((
char *) b->
valp + b->
max * rsi);
16701 dp = (SQLPOINTER) ((
char *) dp + *s->
bind_offs);
16705 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
16708 lp = b->
lenp + rsi;
16716 if (!SQL_SUCCEEDED(ret)) {
16720 if (ret != SQL_SUCCESS) {
16722#ifdef SQL_ROW_SUCCESS_WITH_INFO
16728 if (SQL_SUCCEEDED(ret)) {
16729 ret = withinfo ? SQL_SUCCESS_WITH_INFO : SQL_SUCCESS;
16746 int i, withinfo = 0;
16749 if (
stmt == SQL_NULL_HSTMT) {
16750 return SQL_INVALID_HANDLE;
16774 setstat(s, -1,
"no result set available",
"24000");
16782 if (s->
curtype == SQL_CURSOR_FORWARD_ONLY && orient != SQL_FETCH_NEXT) {
16783 setstat(s, -1,
"wrong fetch direction",
"01000");
16790 if (((
DBC *) (s->
dbc))->cur_s3stmt == s && s->
s3stmt) {
16794 ret = (i == 0) ? SQL_NO_DATA : SQL_SUCCESS;
16798 if (ret != SQL_SUCCESS) {
16802 if (s->
nrows < 1) {
16806 if (!SQL_SUCCEEDED(ret)) {
16808 }
else if (ret == SQL_SUCCESS_WITH_INFO) {
16812 }
else if (s->
rows) {
16814 case SQL_FETCH_NEXT:
16815 if (s->
nrows < 1) {
16816 return SQL_NO_DATA;
16823 return SQL_NO_DATA;
16826 case SQL_FETCH_PRIOR:
16829 return SQL_NO_DATA;
16832 if (s->
rowp < -1) {
16834 return SQL_NO_DATA;
16837 case SQL_FETCH_FIRST:
16838 if (s->
nrows < 1) {
16839 return SQL_NO_DATA;
16843 case SQL_FETCH_LAST:
16844 if (s->
nrows < 1) {
16845 return SQL_NO_DATA;
16848 if (--s->
rowp < -1) {
16852 case SQL_FETCH_ABSOLUTE:
16855 return SQL_NO_DATA;
16856 }
else if (offset < 0) {
16857 if (0 - offset <= s->nrows) {
16862 return SQL_NO_DATA;
16863 }
else if (offset > s->
nrows) {
16865 return SQL_NO_DATA;
16867 s->
rowp = offset - 1 - 1;
16869 case SQL_FETCH_RELATIVE:
16874 return SQL_NO_DATA;
16878 if (s->
rowp < -1) {
16880 return SQL_NO_DATA;
16884 case SQL_FETCH_BOOKMARK:
16886 if (offset < 0 || offset >= s->
nrows) {
16887 return SQL_NO_DATA;
16889 s->
rowp = offset - 1;
16895 if (s->
bkmrk == SQL_UB_VARIABLE) {
16897 sqlite_int64 bkmrk, rowid;
16899 bkmrk = *(sqlite_int64 *) s->
bkmrkptr;
16900 for (rowp = 0; rowp < s->
nrows; rowp++) {
16901 char **data, *endp = 0;
16906 rowid = strtol(*data, &endp, 0);
16908 rowid = strtoll(*data, &endp, 0);
16910 if (rowid == bkmrk) {
16915 rowp = *(sqlite_int64 *) s->
bkmrkptr;
16920 if (rowp + offset < 0 || rowp + offset >= s->
nrows) {
16921 return SQL_NO_DATA;
16923 s->
rowp = rowp + offset - 1;
16939 if (!SQL_SUCCEEDED(ret)) {
16941 }
else if (ret == SQL_SUCCESS_WITH_INFO) {
16948 if (SQL_SUCCEEDED(ret)) {
16949 return SQL_NO_DATA;
16953 if (SQL_SUCCEEDED(ret)) {
16954 ret = withinfo ? SQL_SUCCESS_WITH_INFO : SQL_SUCCESS;
17021 SQLINTEGER *bkmrkptr;
17024 if (
stmt == SQL_NULL_HSTMT) {
17025 return SQL_INVALID_HANDLE;
17060 if (
stmt == SQL_NULL_HSTMT) {
17061 return SQL_INVALID_HANDLE;
17068 return SQL_SUCCESS;
17084 if (
stmt == SQL_NULL_HSTMT) {
17085 return SQL_INVALID_HANDLE;
17092 return SQL_SUCCESS;
17111 SQLSMALLINT nameMax, SQLSMALLINT *nameLen,
17112 SQLSMALLINT *type,
SQLULEN *size,
17113 SQLSMALLINT *digits, SQLSMALLINT *nullable)
17119 if (
stmt == SQL_NULL_HSTMT) {
17120 return SQL_INVALID_HANDLE;
17124 setstat(s, -1,
"no columns", (*s->
ov3) ?
"07009" :
"S1002");
17127 if (col < 1 || col > s->
ncols) {
17128 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009" :
"S1002");
17131 c = s->
cols + col - 1;
17132 if (name && nameMax > 0) {
17133 strncpy((
char *) name, c->
column, nameMax);
17134 name[nameMax - 1] =
'\0';
17139 *nameLen = strlen((
char *) name);
17141 *nameLen = strlen(c->
column);
17153 *type = SQL_VARCHAR;
17155#ifdef SQL_LONGVARCHAR
17156 case SQL_WLONGVARCHAR:
17157 *type = SQL_LONGVARCHAR;
17173 return SQL_SUCCESS;
17192SQLDescribeCol(SQLHSTMT
stmt, SQLUSMALLINT col, SQLCHAR *name,
17193 SQLSMALLINT nameMax, SQLSMALLINT *nameLen,
17194 SQLSMALLINT *type,
SQLULEN *size,
17195 SQLSMALLINT *digits, SQLSMALLINT *nullable)
17197#if defined(_WIN32) || defined(_WIN64)
17198 SQLSMALLINT len = 0;
17203#if defined(_WIN32) || defined(_WIN64)
17206 type, size, digits, nullable);
17210 &len, type, size, digits, nullable);
17211 if (ret == SQL_SUCCESS) {
17216 n = (SQLCHAR *) utf_to_wmb((
char *) name, len);
17218 strncpy((
char *) name, (
char *) n, nameMax);
17220 len =
min(nameMax, strlen((
char *) n));
17238 len = strlen(c->
column);
17249 type, size, digits, nullable);
17273 SQLSMALLINT nameMax, SQLSMALLINT *nameLen,
17274 SQLSMALLINT *type,
SQLULEN *size,
17275 SQLSMALLINT *digits, SQLSMALLINT *nullable)
17278 SQLSMALLINT len = 0;
17282 (SQLSMALLINT) (nameMax *
sizeof (SQLWCHAR)),
17283 &len, type, size, digits, nullable);
17284 if (ret == SQL_SUCCESS) {
17287 SQLWCHAR *n = NULL;
17311 len = strlen(c->
column);
17337 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17343 char *valc = (
char *) val;
17345 if (
stmt == SQL_NULL_HSTMT) {
17346 return SQL_INVALID_HANDLE;
17355 if (
id == SQL_COLUMN_COUNT) {
17359 *valLen =
sizeof (int);
17360 return SQL_SUCCESS;
17362 if (
id == SQL_COLUMN_TYPE && col == 0) {
17364 *val2 = SQL_INTEGER;
17366 *valLen =
sizeof (int);
17367 return SQL_SUCCESS;
17369#ifdef SQL_DESC_OCTET_LENGTH
17370 if (
id == SQL_DESC_OCTET_LENGTH && col == 0) {
17374 *valLen =
sizeof (int);
17375 return SQL_SUCCESS;
17378 if (col < 1 || col > s->
ncols) {
17379 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009":
"S1002");
17382 c = s->
cols + col - 1;
17385 case SQL_COLUMN_LABEL:
17387 if (valc && valMax > 0) {
17388 strncpy(valc, c->
label, valMax);
17389 valc[valMax - 1] =
'\0';
17391 *valLen = strlen(c->
label);
17395 case SQL_COLUMN_NAME:
17396 case SQL_DESC_NAME:
17397 if (valc && valMax > 0) {
17398 strncpy(valc, c->
column, valMax);
17399 valc[valMax - 1] =
'\0';
17401 *valLen = strlen(c->
column);
17403 if (*valLen >= valMax) {
17404 setstat(s, -1,
"data right truncated",
"01004");
17405 return SQL_SUCCESS_WITH_INFO;
17407 return SQL_SUCCESS;
17408#ifdef SQL_DESC_BASE_COLUMN_NAME
17409 case SQL_DESC_BASE_COLUMN_NAME:
17410 if (strchr(c->
column,
'(') || strchr(c->
column,
')')) {
17411 if (valc && valMax > 0) {
17415 }
else if (valc && valMax > 0) {
17416 strncpy(valc, c->
column, valMax);
17417 valc[valMax - 1] =
'\0';
17418 *valLen = strlen(c->
column);
17422 case SQL_COLUMN_TYPE:
17423 case SQL_DESC_TYPE:
17426 int type = c->
type;
17434 type = SQL_VARCHAR;
17436#ifdef SQL_LONGVARCHAR
17437 case SQL_WLONGVARCHAR:
17438 type = SQL_LONGVARCHAR;
17452 *valLen =
sizeof (int);
17453 return SQL_SUCCESS;
17454 case SQL_COLUMN_DISPLAY_SIZE:
17458 *valLen =
sizeof (int);
17459 return SQL_SUCCESS;
17460 case SQL_COLUMN_UNSIGNED:
17462 *val2 = c->
nosign ? SQL_TRUE : SQL_FALSE;
17464 *valLen =
sizeof (int);
17465 return SQL_SUCCESS;
17466 case SQL_COLUMN_SCALE:
17467 case SQL_DESC_SCALE:
17471 *valLen =
sizeof (int);
17472 return SQL_SUCCESS;
17473 case SQL_COLUMN_PRECISION:
17474 case SQL_DESC_PRECISION:
17494#ifdef SQL_TYPE_TIMESTAMP
17495 case SQL_TYPE_TIMESTAMP:
17497 case SQL_TIMESTAMP:
17505 *valLen =
sizeof (int);
17506 return SQL_SUCCESS;
17507 case SQL_COLUMN_MONEY:
17511 *valLen =
sizeof (int);
17512 return SQL_SUCCESS;
17513 case SQL_COLUMN_AUTO_INCREMENT:
17517 *valLen =
sizeof (int);
17518 return SQL_SUCCESS;
17519 case SQL_COLUMN_LENGTH:
17520 case SQL_DESC_LENGTH:
17524 *valLen =
sizeof (int);
17525 return SQL_SUCCESS;
17526 case SQL_COLUMN_NULLABLE:
17527 case SQL_DESC_NULLABLE:
17531 *valLen =
sizeof (int);
17532 return SQL_SUCCESS;
17533 case SQL_COLUMN_SEARCHABLE:
17535 *val2 = SQL_SEARCHABLE;
17537 *valLen =
sizeof (int);
17538 return SQL_SUCCESS;
17539 case SQL_COLUMN_CASE_SENSITIVE:
17543 *valLen =
sizeof (int);
17544 return SQL_SUCCESS;
17545 case SQL_COLUMN_UPDATABLE:
17549 *valLen =
sizeof (int);
17550 return SQL_SUCCESS;
17551 case SQL_DESC_COUNT:
17555 *valLen =
sizeof (int);
17556 return SQL_SUCCESS;
17557 case SQL_COLUMN_TYPE_NAME: {
17561 if (c->
type == SQL_WCHAR ||
17562 c->
type == SQL_WVARCHAR ||
17563 c->
type == SQL_WLONGVARCHAR) {
17565 if (strcasecmp(tn,
"varchar") == 0) {
17571 if (valc && valMax > 0) {
17572 strncpy(valc, tn, valMax);
17573 valc[valMax - 1] =
'\0';
17574 p = strchr(valc,
'(');
17577 while (p > valc &&
ISSPACE(p[-1])) {
17582 *valLen = strlen(valc);
17584 *valLen = strlen(tn);
17585 p = strchr(tn,
'(');
17588 while (p > tn &&
ISSPACE(p[-1])) {
17596 case SQL_COLUMN_OWNER_NAME:
17597 case SQL_COLUMN_QUALIFIER_NAME: {
17600 if (valc && valMax > 0) {
17601 strncpy(valc, z, valMax);
17602 valc[valMax - 1] =
'\0';
17604 *valLen = strlen(z);
17607 case SQL_COLUMN_TABLE_NAME:
17608#if (SQL_COLUMN_TABLE_NAME != SQL_DESC_TABLE_NAME)
17609 case SQL_DESC_TABLE_NAME:
17611#ifdef SQL_DESC_BASE_TABLE_NAME
17612 case SQL_DESC_BASE_TABLE_NAME:
17614 if (valc && valMax > 0) {
17615 strncpy(valc, c->
table, valMax);
17616 valc[valMax - 1] =
'\0';
17618 *valLen = strlen(c->
table);
17620#ifdef SQL_DESC_NUM_PREC_RADIX
17621 case SQL_DESC_NUM_PREC_RADIX:
17627#ifdef SQL_LONGVARCHAR
17628 case SQL_WLONGVARCHAR:
17633#ifdef SQL_LONGVARCHAR
17634 case SQL_LONGVARCHAR:
17637 case SQL_VARBINARY:
17638 case SQL_LONGVARBINARY:
17645 *valLen =
sizeof (int);
17646 return SQL_SUCCESS;
17649 setstat(s, -1,
"unsupported column attributes %d",
"HY091",
id);
17667SQLColAttributes(SQLHSTMT
stmt, SQLUSMALLINT col, SQLUSMALLINT
id,
17668 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17671#if defined(_WIN32) || defined(_WIN64)
17672 SQLSMALLINT len = 0;
17677#if defined(_WIN32) || defined(_WIN64)
17683 if (SQL_SUCCEEDED(ret)) {
17687 case SQL_COLUMN_LABEL:
17688 case SQL_COLUMN_NAME:
17689 case SQL_DESC_NAME:
17690 case SQL_COLUMN_TYPE_NAME:
17691 case SQL_COLUMN_OWNER_NAME:
17692 case SQL_COLUMN_QUALIFIER_NAME:
17693 case SQL_COLUMN_TABLE_NAME:
17694#if (SQL_COLUMN_TABLE_NAME != SQL_DESC_TABLE_NAME)
17695 case SQL_DESC_TABLE_NAME:
17697#ifdef SQL_DESC_BASE_COLUMN_NAME
17698 case SQL_DESC_BASE_COLUMN_NAME:
17700#ifdef SQL_DESC_BASE_TABLE_NAME
17701 case SQL_DESC_BASE_TABLE_NAME:
17703 if (val && valMax > 0) {
17706 v = utf_to_wmb((
char *) val, SQL_NTS);
17708 strncpy(val, v, vmax);
17709 len =
min(vmax, strlen(v));
17714 v[vmax - 1] =
'\0';
17750SQLColAttributesW(SQLHSTMT
stmt, SQLUSMALLINT col, SQLUSMALLINT
id,
17751 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17755 SQLSMALLINT len = 0;
17759 if (SQL_SUCCEEDED(ret)) {
17760 SQLWCHAR *v = NULL;
17763 case SQL_COLUMN_LABEL:
17764 case SQL_COLUMN_NAME:
17765 case SQL_DESC_NAME:
17766 case SQL_COLUMN_TYPE_NAME:
17767 case SQL_COLUMN_OWNER_NAME:
17768 case SQL_COLUMN_QUALIFIER_NAME:
17769 case SQL_COLUMN_TABLE_NAME:
17770#if (SQL_COLUMN_TABLE_NAME != SQL_DESC_TABLE_NAME)
17771 case SQL_DESC_TABLE_NAME:
17773#ifdef SQL_DESC_BASE_COLUMN_NAME
17774 case SQL_DESC_BASE_COLUMN_NAME:
17776#ifdef SQL_DESC_BASE_TABLE_NAME
17777 case SQL_DESC_BASE_TABLE_NAME:
17779 if (val && valMax > 0) {
17780 int vmax = valMax /
sizeof (SQLWCHAR);
17787 len *=
sizeof (SQLWCHAR);
17790 v = (SQLWCHAR *) val;
17791 v[vmax - 1] =
'\0';
17821drvcolattribute(SQLHSTMT
stmt, SQLUSMALLINT col, SQLUSMALLINT
id,
17822 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17828 char *valc = (
char *) val;
17831 if (
stmt == SQL_NULL_HSTMT) {
17832 return SQL_INVALID_HANDLE;
17838 if (col < 1 || col > s->
ncols) {
17839 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009" :
"S1002");
17845 c = s->
cols + col - 1;
17847 case SQL_DESC_COUNT:
17850 case SQL_DESC_CATALOG_NAME:
17851 if (valc && valMax > 0) {
17852 strncpy(valc, c->
db, valMax);
17853 valc[valMax - 1] =
'\0';
17855 *valLen = strlen(c->
db);
17857 if (*valLen >= valMax) {
17858 setstat(s, -1,
"data right truncated",
"01004");
17859 return SQL_SUCCESS_WITH_INFO;
17862 case SQL_COLUMN_LENGTH:
17863 case SQL_DESC_LENGTH:
17866 case SQL_COLUMN_LABEL:
17868 if (valc && valMax > 0) {
17869 strncpy(valc, c->
label, valMax);
17870 valc[valMax - 1] =
'\0';
17872 *valLen = strlen(c->
label);
17876 case SQL_COLUMN_NAME:
17877 case SQL_DESC_NAME:
17878 if (valc && valMax > 0) {
17879 strncpy(valc, c->
column, valMax);
17880 valc[valMax - 1] =
'\0';
17882 *valLen = strlen(c->
column);
17884 case SQL_DESC_SCHEMA_NAME: {
17887 if (valc && valMax > 0) {
17888 strncpy(valc, z, valMax);
17889 valc[valMax - 1] =
'\0';
17891 *valLen = strlen(z);
17894#ifdef SQL_DESC_BASE_COLUMN_NAME
17895 case SQL_DESC_BASE_COLUMN_NAME:
17896 if (strchr(c->
column,
'(') || strchr(c->
column,
')')) {
17899 }
else if (valc && valMax > 0) {
17900 strncpy(valc, c->
column, valMax);
17901 valc[valMax - 1] =
'\0';
17902 *valLen = strlen(c->
column);
17906 case SQL_DESC_TYPE_NAME: {
17910 if (c->
type == SQL_WCHAR ||
17911 c->
type == SQL_WVARCHAR ||
17912 c->
type == SQL_WLONGVARCHAR) {
17914 if (strcasecmp(tn,
"varchar") == 0) {
17920 if (valc && valMax > 0) {
17921 strncpy(valc, tn, valMax);
17922 valc[valMax - 1] =
'\0';
17923 p = strchr(valc,
'(');
17926 while (p > valc &&
ISSPACE(p[-1])) {
17931 *valLen = strlen(valc);
17933 *valLen = strlen(tn);
17934 p = strchr(tn,
'(');
17937 while (p > tn &&
ISSPACE(p[-1])) {
17945 case SQL_DESC_OCTET_LENGTH:
17948 if (c->
type == SQL_WCHAR ||
17949 c->
type == SQL_WVARCHAR ||
17950 c->
type == SQL_WLONGVARCHAR) {
17952 v *=
sizeof (SQLWCHAR);
17957#if (SQL_COLUMN_TABLE_NAME != SQL_DESC_TABLE_NAME)
17958 case SQL_COLUMN_TABLE_NAME:
17960#ifdef SQL_DESC_BASE_TABLE_NAME
17961 case SQL_DESC_BASE_TABLE_NAME:
17963 case SQL_DESC_TABLE_NAME:
17964 if (valc && valMax > 0) {
17965 strncpy(valc, c->
table, valMax);
17966 valc[valMax - 1] =
'\0';
17968 *valLen = strlen(c->
table);
17970 case SQL_DESC_TYPE:
17981#ifdef SQL_LONGVARCHAR
17982 case SQL_WLONGVARCHAR:
17983 v = SQL_LONGVARCHAR;
17990 case SQL_DESC_CONCISE_TYPE:
18007 case SQL_TIMESTAMP:
18008 v = SQL_C_TIMESTAMP;
18016#ifdef SQL_C_TYPE_TIMESTAMP
18017 case SQL_TYPE_TIMESTAMP:
18018 v = SQL_C_TYPE_TIMESTAMP;
18021#ifdef SQL_C_TYPE_TIME
18022 case SQL_TYPE_TIME:
18023 v = SQL_C_TYPE_TIME;
18026#ifdef SQL_C_TYPE_DATE
18027 case SQL_TYPE_DATE:
18028 v = SQL_C_TYPE_DATE;
18043 v = (s->
nowchar[0] || s->
nowchar[1]) ? SQL_C_CHAR : SQL_C_WCHAR;
18050 case SQL_DESC_UPDATABLE:
18053 case SQL_COLUMN_DISPLAY_SIZE:
18056 case SQL_COLUMN_UNSIGNED:
18057 v = c->
nosign ? SQL_TRUE : SQL_FALSE;
18059 case SQL_COLUMN_SEARCHABLE:
18060 v = SQL_SEARCHABLE;
18062 case SQL_COLUMN_SCALE:
18063 case SQL_DESC_SCALE:
18066 case SQL_COLUMN_PRECISION:
18067 case SQL_DESC_PRECISION:
18086#ifdef SQL_TYPE_TIMESTAMP
18087 case SQL_TYPE_TIMESTAMP:
18089 case SQL_TIMESTAMP:
18097 case SQL_COLUMN_MONEY:
18100 case SQL_COLUMN_AUTO_INCREMENT:
18103 case SQL_DESC_NULLABLE:
18106#ifdef SQL_DESC_NUM_PREC_RADIX
18107 case SQL_DESC_NUM_PREC_RADIX:
18112#ifdef SQL_LONGVARCHAR
18113 case SQL_WLONGVARCHAR:
18118#ifdef SQL_LONGVARCHAR
18119 case SQL_LONGVARCHAR:
18122 case SQL_VARBINARY:
18123 case SQL_LONGVARBINARY:
18132 setstat(s, -1,
"unsupported column attribute %d",
"HY091",
id);
18138 return SQL_SUCCESS;
18155SQLColAttribute(SQLHSTMT
stmt, SQLUSMALLINT col, SQLUSMALLINT
id,
18156 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
18159#if defined(_WIN32) || defined(_WIN64)
18160 SQLSMALLINT len = 0;
18165#if defined(_WIN32) || defined(_WIN64)
18167 ret = drvcolattribute(
stmt, col,
id, val, valMax, valLen,
18168 (SQLPOINTER) val2);
18171 ret = drvcolattribute(
stmt, col,
id, val, valMax, &len,
18172 (SQLPOINTER) val2);
18173 if (SQL_SUCCEEDED(ret)) {
18177 case SQL_DESC_SCHEMA_NAME:
18178 case SQL_DESC_CATALOG_NAME:
18179 case SQL_COLUMN_LABEL:
18180 case SQL_DESC_NAME:
18181 case SQL_DESC_TABLE_NAME:
18182#ifdef SQL_DESC_BASE_TABLE_NAME
18183 case SQL_DESC_BASE_TABLE_NAME:
18185#ifdef SQL_DESC_BASE_COLUMN_NAME
18186 case SQL_DESC_BASE_COLUMN_NAME:
18188 case SQL_DESC_TYPE_NAME:
18189 if (val && valMax > 0) {
18192 v = utf_to_wmb((
char *) val, SQL_NTS);
18194 strncpy(val, v, vmax);
18195 len =
min(vmax, strlen(v));
18200 v[vmax - 1] =
'\0';
18215 ret = drvcolattribute(
stmt, col,
id, val, valMax, valLen,
18216 (SQLPOINTER) val2);
18237SQLColAttributeW(SQLHSTMT
stmt, SQLUSMALLINT col, SQLUSMALLINT
id,
18238 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
18242 SQLSMALLINT len = 0;
18245 ret = drvcolattribute(
stmt, col,
id, val, valMax, &len,
18246 (SQLPOINTER) val2);
18247 if (SQL_SUCCEEDED(ret)) {
18248 SQLWCHAR *v = NULL;
18251 case SQL_DESC_SCHEMA_NAME:
18252 case SQL_DESC_CATALOG_NAME:
18253 case SQL_COLUMN_LABEL:
18254 case SQL_DESC_NAME:
18255 case SQL_DESC_TABLE_NAME:
18256#ifdef SQL_DESC_BASE_TABLE_NAME
18257 case SQL_DESC_BASE_TABLE_NAME:
18259#ifdef SQL_DESC_BASE_COLUMN_NAME
18260 case SQL_DESC_BASE_COLUMN_NAME:
18262 case SQL_DESC_TYPE_NAME:
18263 if (val && valMax > 0) {
18264 int vmax = valMax /
sizeof (SQLWCHAR);
18271 len *=
sizeof (SQLWCHAR);
18274 v = (SQLWCHAR *) val;
18275 v[vmax - 1] =
'\0';
18306drverror(SQLHENV env, SQLHDBC
dbc, SQLHSTMT
stmt,
18307 SQLCHAR *sqlState, SQLINTEGER *nativeErr,
18308 SQLCHAR *errmsg, SQLSMALLINT errmax, SQLSMALLINT *errlen)
18312 SQLSMALLINT dummy2;
18314 if (env == SQL_NULL_HENV &&
18315 dbc == SQL_NULL_HDBC &&
18316 stmt == SQL_NULL_HSTMT) {
18317 return SQL_INVALID_HANDLE;
18320 sqlState[0] =
'\0';
18325 nativeErr = &dummy1;
18344 if (s->
logmsg[0] ==
'\0') {
18349 strcpy((
char *) sqlState, s->
sqlstate);
18350 if (errmax == SQL_NTS) {
18351 strcpy((
char *) errmsg,
"[SQLite]");
18352 strcat((
char *) errmsg, (
char *) s->
logmsg);
18353 *errlen = strlen((
char *) errmsg);
18355 strncpy((
char *) errmsg,
"[SQLite]", errmax);
18356 if (errmax - 8 > 0) {
18357 strncpy((
char *) errmsg + 8, (
char *) s->
logmsg, errmax - 8);
18359 *errlen =
min(strlen((
char *) s->
logmsg) + 8, errmax);
18363 return SQL_SUCCESS;
18374 strcpy((
char *) sqlState, d->
sqlstate);
18375 if (errmax == SQL_NTS) {
18376 strcpy((
char *) errmsg,
"[SQLite]");
18377 strcat((
char *) errmsg, (
char *) d->
logmsg);
18378 *errlen = strlen((
char *) errmsg);
18380 strncpy((
char *) errmsg,
"[SQLite]", errmax);
18381 if (errmax - 8 > 0) {
18382 strncpy((
char *) errmsg + 8, (
char *) d->
logmsg, errmax - 8);
18384 *errlen =
min(strlen((
char *) d->
logmsg) + 8, errmax);
18388 return SQL_SUCCESS;
18391 sqlState[0] =
'\0';
18395 return SQL_NO_DATA;
18413SQLError(SQLHENV env, SQLHDBC
dbc, SQLHSTMT
stmt,
18414 SQLCHAR *sqlState, SQLINTEGER *nativeErr,
18415 SQLCHAR *errmsg, SQLSMALLINT errmax, SQLSMALLINT *errlen)
18417 return drverror(env,
dbc,
stmt, sqlState, nativeErr,
18418 errmsg, errmax, errlen);
18437SQLErrorW(SQLHENV env, SQLHDBC
dbc, SQLHSTMT
stmt,
18438 SQLWCHAR *sqlState, SQLINTEGER *nativeErr,
18439 SQLWCHAR *errmsg, SQLSMALLINT errmax, SQLSMALLINT *errlen)
18442 SQLSMALLINT len = 0;
18445 ret = drverror(env,
dbc,
stmt, (SQLCHAR *) state, nativeErr,
18446 (SQLCHAR *) errmsg, errmax, &len);
18447 if (ret == SQL_SUCCESS) {
18450 6 *
sizeof (SQLWCHAR));
18454 SQLWCHAR *e = NULL;
18482 }
else if (ret == SQL_NO_DATA) {
18506SQLMoreResults(SQLHSTMT
stmt)
18509 if (
stmt == SQL_NULL_HSTMT) {
18510 return SQL_INVALID_HANDLE;
18513 return SQL_NO_DATA;
18527 int ncols = *ncolsp, guessed_types = 0;
18528 SQLRETURN ret = SQL_SUCCESS;
18536 const char *colname, *
typename;
18537#if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME)
18540#if defined(HAVE_SQLITE3COLUMNDATABASENAME) && (HAVE_SQLITE3COLUMNDATABASENAME)
18544 for (i = size = 0; i < ncols; i++) {
18545 colname = sqlite3_column_name(s3stmt, i);
18546 size += 3 + 3 * strlen(colname);
18548#if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME)
18549 tblname = (
char *) size;
18550 for (i = 0; i < ncols; i++) {
18551 p = (
char *) sqlite3_column_table_name(s3stmt, i);
18552 size += 2 + (p ? strlen(p) : 0);
18555#if defined(HAVE_SQLITE3COLUMNDATABASENAME) && (HAVE_SQLITE3COLUMNDATABASENAME)
18556 dbname = (
char *) size;
18557 for (i = 0; i < ncols; i++) {
18558 p = (
char *) sqlite3_column_database_name(s3stmt, i);
18559 size += 2 + (p ? strlen(p) : 0);
18562 dyncols =
xmalloc(ncols *
sizeof (
COL) + size);
18568 p = (
char *) (dyncols + ncols);
18569#if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME)
18572#if defined(HAVE_SQLITE3COLUMNDATABASENAME) && (HAVE_SQLITE3COLUMNDATABASENAME)
18575 for (i = 0; i < ncols; i++) {
18578 colname = sqlite3_column_name(s3stmt, i);
18580 fprintf(d->
trace,
"-- column %d name: '%s'\n",
18584#if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME)
18585 q = (
char *) sqlite3_column_table_name(s3stmt, i);
18586 strcpy(tblname, q ? q :
"");
18588 fprintf(d->
trace,
"-- table %d name: '%s'\n",
18592 dyncols[i].table = tblname;
18593 tblname += strlen(tblname) + 1;
18595#if defined(HAVE_SQLITE3COLUMNDATABASENAME) && (HAVE_SQLITE3COLUMNDATABASENAME)
18596 q = (
char *) sqlite3_column_database_name(s3stmt, i);
18597 strcpy(dbname, q ? q :
"");
18599 fprintf(d->
trace,
"-- database %d name: '%s'\n",
18603 dyncols[i].db = dbname;
18604 dbname += strlen(dbname) + 1;
18606 dyncols[i].db = ((
DBC *) (s->
dbc))->dbname;
18609 strcpy(p, colname);
18610 dyncols[i].label = p;
18611 p += strlen(p) + 1;
18612 q = strchr(colname,
'.');
18614 char *q2 = strchr(q + 1,
'.');
18622#if !defined(HAVE_SQLITE3COLUMNTABLENAME) || !(HAVE_SQLITE3COLUMNTABLENAME)
18623 dyncols[i].table = p;
18625 strncpy(p, colname, q - colname);
18626 p[q - colname] =
'\0';
18627 p += strlen(p) + 1;
18629 dyncols[i].column = p;
18630 p += strlen(p) + 1;
18632#if !defined(HAVE_SQLITE3COLUMNTABLENAME) || !(HAVE_SQLITE3COLUMNTABLENAME)
18633 dyncols[i].table =
"";
18635 strcpy(p, colname);
18636 dyncols[i].column = p;
18637 p += strlen(p) + 1;
18640 dyncols[i].column = dyncols[i].label;
18642#ifdef SQL_LONGVARCHAR
18643 dyncols[i].type = SQL_LONGVARCHAR;
18644 dyncols[i].size = 65535;
18646 dyncols[i].type = SQL_VARCHAR;
18647 dyncols[i].size = 255;
18649 dyncols[i].index = i;
18650 dyncols[i].scale = 0;
18651 dyncols[i].prec = 0;
18652 dyncols[i].nosign = 1;
18653 dyncols[i].autoinc = SQL_FALSE;
18654 dyncols[i].notnull = SQL_NULLABLE;
18655 dyncols[i].ispk = -1;
18656 dyncols[i].isrowid = -1;
18657#ifdef FULL_METADATA
18658 s3stmt_addmeta(s3stmt, i, d, &dyncols[i]);
18660 dyncols[i].typename =
xstrdup(
typename);
18681drvprepare(SQLHSTMT
stmt, SQLCHAR *query, SQLINTEGER queryLen)
18688 if (
stmt == SQL_NULL_HSTMT) {
18689 return SQL_INVALID_HANDLE;
18692 if (s->
dbc == SQL_NULL_HDBC) {
18703 if (sret != SQL_SUCCESS) {
18712 setstat(s, -1,
"%s", (*s->
ov3) ?
"HY000" :
"S1000", errp);
18723 int ret, ncols, nretry = 0;
18725 sqlite3_stmt *s3stmt = NULL;
18727#if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
18734#if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2)
18735 ret = sqlite3_prepare_v2(d->
sqlite, (
char *) s->
query, -1,
18738 ret = sqlite3_prepare(d->
sqlite, (
char *) s->
query, -1,
18741 if (ret != SQLITE_OK) {
18743 sqlite3_finalize(s3stmt);
18747 }
while (ret == SQLITE_SCHEMA && (++nretry) < 2);
18749 if (ret != SQLITE_OK) {
18752 sqlite3_finalize(s3stmt);
18754 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
18755 sqlite3_errmsg(d->
sqlite), ret);
18758 if (sqlite3_bind_parameter_count(s3stmt) != s->
nparams) {
18760 sqlite3_finalize(s3stmt);
18761 setstat(s, SQLITE_ERROR,
"parameter marker count incorrect",
18762 (*s->
ov3) ?
"HY000" :
"S1000");
18765 ncols = sqlite3_column_count(s3stmt);
18775 return SQL_SUCCESS;
18791 int rc, i, ncols = 0, nrows = 0, busy_count;
18794 if (
stmt == SQL_NULL_HSTMT) {
18795 return SQL_INVALID_HANDLE;
18798 if (s->
dbc == SQL_NULL_HDBC) {
18807 setstat(s, -1,
"no query prepared", (*s->
ov3) ?
"HY000" :
"S1000");
18812 setstat(s, -1,
"unbound parameters in query",
18813 (*s->
ov3) ?
"HY000" :
"S1000");
18816 for (i = 0; i < s->
nparams; i++) {
18825 if (lenp && *lenp < 0 && *lenp > SQL_LEN_DATA_AT_EXEC_OFFSET &&
18826 *lenp != SQL_NTS && *lenp != SQL_NULL_DATA &&
18827 *lenp != SQL_DATA_AT_EXEC) {
18828 setstat(s, -1,
"invalid length reference",
"HY009");
18831 if (lenp && (*lenp <= SQL_LEN_DATA_AT_EXEC_OFFSET ||
18832 *lenp == SQL_DATA_AT_EXEC)) {
18840 if (ret != SQL_SUCCESS) {
18849 for (i = 0; i < s->
nparams; i++) {
18856 if (p->
need <= 0 &&
18857 p->
lenp && (*p->
lenp <= SQL_LEN_DATA_AT_EXEC_OFFSET ||
18858 *p->
lenp == SQL_DATA_AT_EXEC)) {
18866 for (i = 0; i < s->
nparams; i++) {
18868 if (ret != SQL_SUCCESS) {
18875 s->
curtype == SQL_CURSOR_FORWARD_ONLY &&
18879 if (ret == SQL_SUCCESS) {
18886 if (rc == SQLITE_BUSY) {
18889 sqlite3_free(errp);
18892 for (i = 0; i < s->
nparams; i++) {
18899 if (!p->
lenp || (*p->
lenp > SQL_LEN_DATA_AT_EXEC_OFFSET &&
18900 *p->
lenp != SQL_DATA_AT_EXEC)) {
18909 if (rc != SQLITE_OK) {
18910 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
18911 errp ? errp :
"unknown error", rc);
18913 sqlite3_free(errp);
18920 sqlite3_free(errp);
18930 if (s->
isselect != 0 || ncols == 0) {
18932 nrows += sqlite3_changes(d->sqlite);
18939 if (s->
ncols != ncols) {
18943 setstat(s, -1,
"broken result set %d/%d",
18944 (*s->
ov3) ?
"HY000" :
"S1000", s->
ncols, ncols);
18956 for (i = 0; i < s->
nparams; i++) {
18967 }
else if (p->
lenp0 && p->
inc > 0) {
18970 if (!p->
lenp || (*p->
lenp > SQL_LEN_DATA_AT_EXEC_OFFSET &&
18971 *p->
lenp != SQL_DATA_AT_EXEC)) {
18980 }
else if (p->
lenp && (*p->
lenp <= SQL_LEN_DATA_AT_EXEC_OFFSET ||
18981 *p->
lenp == SQL_DATA_AT_EXEC)) {
18990 if (ret != SQL_NEED_DATA) {
18991 for (i = 0; i < s->
nparams; i++) {
18998 if (!p->
lenp || (*p->
lenp > SQL_LEN_DATA_AT_EXEC_OFFSET &&
18999 *p->
lenp != SQL_DATA_AT_EXEC)) {
19016 ret == SQL_SUCCESS && nrows == 0) {
19032SQLPrepare(SQLHSTMT
stmt, SQLCHAR *query, SQLINTEGER queryLen)
19035#if defined(_WIN32) || defined(_WIN64)
19040#if defined(_WIN32) || defined(_WIN64)
19042 ret = drvprepare(
stmt, query, queryLen);
19045 q = wmb_to_utf_c((
char *) query, queryLen);
19050 query = (SQLCHAR *) q;
19051 queryLen = SQL_NTS;
19053 ret = drvprepare(
stmt, query, queryLen);
19054#if defined(_WIN32) || defined(_WIN64)
19074SQLPrepareW(SQLHSTMT
stmt, SQLWCHAR *query, SQLINTEGER queryLen)
19084 ret = drvprepare(
stmt, (SQLCHAR *) q, SQL_NTS);
19099SQLExecute(SQLHSTMT
stmt)
19119SQLExecDirect(SQLHSTMT
stmt, SQLCHAR *query, SQLINTEGER queryLen)
19122#if defined(_WIN32) || defined(_WIN64)
19127#if defined(_WIN32) || defined(_WIN64)
19129 ret = drvprepare(
stmt, query, queryLen);
19130 if (ret == SQL_SUCCESS) {
19135 q = wmb_to_utf_c((
char *) query, queryLen);
19140 query = (SQLCHAR *) q;
19141 queryLen = SQL_NTS;
19143 ret = drvprepare(
stmt, query, queryLen);
19144 if (ret == SQL_SUCCESS) {
19147#if defined(_WIN32) || defined(_WIN64)
19167SQLExecDirectW(SQLHSTMT
stmt, SQLWCHAR *query, SQLINTEGER queryLen)
19177 ret = drvprepare(
stmt, (SQLCHAR *) q, SQL_NTS);
19179 if (ret == SQL_SUCCESS) {
19189#if defined(_WIN32) || defined(_WIN64)
19190#ifndef WITHOUT_DRIVERMGR
19196#include <windowsx.h>
19197#include <winuser.h>
19199#define MAXPATHLEN (259+1)
19200#define MAXKEYLEN (15+1)
19201#define MAXDESC (255+1)
19202#define MAXDSNAME (255+1)
19203#define MAXTONAME (32+1)
19204#define MAXDBNAME MAXPATHLEN
19210#define KEY_DBNAME 2
19212#define KEY_DRIVER 4
19213#define KEY_STEPAPI 5
19216#define KEY_SHORTNAM 8
19217#define KEY_LONGNAM 9
19218#define KEY_NOCREAT 10
19219#define KEY_NOWCHAR 11
19220#define KEY_LOADEXT 12
19221#define KEY_JMODE 13
19222#define KEY_FKSUPPORT 14
19223#define KEY_OEMCP 15
19224#define KEY_BIGINT 16
19225#define KEY_PASSWD 17
19226#define KEY_JDCONV 18
19227#define KEY_ATTAS 19
19228#define KEY_ILIKE 20
19229#define NUMOFKEYS 21
19233 char attr[MAXPATHLEN*4];
19239 ATTR attr[NUMOFKEYS];
19240 char DSN[MAXDSNAME];
19249 {
"DSN", KEY_DSN },
19250 {
"DESC", KEY_DESC },
19251 {
"Description", KEY_DESC},
19252 {
"Database", KEY_DBNAME },
19253 {
"Timeout", KEY_BUSY },
19254 {
"Driver", KEY_DRIVER },
19255 {
"StepAPI", KEY_STEPAPI },
19256 {
"SyncPragma", KEY_SYNCP },
19257 {
"NoTXN", KEY_NOTXN },
19258 {
"ShortNames", KEY_SHORTNAM },
19259 {
"LongNames", KEY_LONGNAM },
19260 {
"NoCreat", KEY_NOCREAT },
19261 {
"NoWCHAR", KEY_NOWCHAR },
19262 {
"LoadExt", KEY_LOADEXT },
19263 {
"JournalMode", KEY_JMODE },
19264 {
"FKSupport", KEY_FKSUPPORT },
19265 {
"OEMCP", KEY_OEMCP },
19266 {
"BigInt", KEY_BIGINT },
19267 {
"PWD", KEY_PASSWD },
19268 {
"JDConv", KEY_JDCONV },
19269 {
"AttachAs", KEY_ATTAS },
19270 {
"ILike", KEY_ILIKE },
19281ParseAttributes(LPCSTR attribs, SETUPDLG *setupdlg)
19283 char *str = (
char *) attribs, *start, key[MAXKEYLEN];
19288 if ((str = strchr(str,
'=')) == NULL) {
19292 nkey = str - start;
19293 if (nkey <
sizeof (key)) {
19296 memcpy(key, start, nkey);
19298 for (i = 0; attrLookup[i].key; i++) {
19299 if (strcasecmp(attrLookup[i].key, key) == 0) {
19300 elem = attrLookup[i].ikey;
19306 while (*str && *str !=
';') {
19310 int end =
min(str - start,
sizeof (setupdlg->attr[elem].attr) - 1);
19312 setupdlg->attr[elem].supplied = TRUE;
19313 memcpy(setupdlg->attr[elem].attr, start, end);
19314 setupdlg->attr[elem].attr[end] =
'\0';
19328SetDSNAttributes(HWND parent, SETUPDLG *setupdlg)
19330 char *dsn = setupdlg->attr[KEY_DSN].attr;
19332 if (setupdlg->newDSN && strlen(dsn) == 0) {
19335 if (!SQLWriteDSNToIni(dsn, setupdlg->driver)) {
19337 char buf[MAXPATHLEN], msg[MAXPATHLEN];
19339 LoadString(hModule, IDS_BADDSN, buf,
sizeof (buf));
19340 wsprintf(msg, buf, dsn);
19341 LoadString(hModule, IDS_MSGTITLE, buf,
sizeof (buf));
19342 MessageBox(parent, msg, buf,
19343 MB_ICONEXCLAMATION | MB_OK | MB_TASKMODAL |
19348 if (parent || setupdlg->attr[KEY_DESC].supplied) {
19349 SQLWritePrivateProfileString(dsn,
"Description",
19350 setupdlg->attr[KEY_DESC].attr,
19353 if (parent || setupdlg->attr[KEY_DBNAME].supplied) {
19354 SQLWritePrivateProfileString(dsn,
"Database",
19355 setupdlg->attr[KEY_DBNAME].attr,
19358 if (parent || setupdlg->attr[KEY_BUSY].supplied) {
19359 SQLWritePrivateProfileString(dsn,
"Timeout",
19360 setupdlg->attr[KEY_BUSY].attr,
19363 if (parent || setupdlg->attr[KEY_STEPAPI].supplied) {
19364 SQLWritePrivateProfileString(dsn,
"StepAPI",
19365 setupdlg->attr[KEY_STEPAPI].attr,
19368 if (parent || setupdlg->attr[KEY_SYNCP].supplied) {
19369 SQLWritePrivateProfileString(dsn,
"SyncPragma",
19370 setupdlg->attr[KEY_SYNCP].attr,
19373 if (parent || setupdlg->attr[KEY_NOTXN].supplied) {
19374 SQLWritePrivateProfileString(dsn,
"NoTXN",
19375 setupdlg->attr[KEY_NOTXN].attr,
19378 if (parent || setupdlg->attr[KEY_SHORTNAM].supplied) {
19379 SQLWritePrivateProfileString(dsn,
"ShortNames",
19380 setupdlg->attr[KEY_SHORTNAM].attr,
19383 if (parent || setupdlg->attr[KEY_LONGNAM].supplied) {
19384 SQLWritePrivateProfileString(dsn,
"LongNames",
19385 setupdlg->attr[KEY_LONGNAM].attr,
19388 if (parent || setupdlg->attr[KEY_NOCREAT].supplied) {
19389 SQLWritePrivateProfileString(dsn,
"NoCreat",
19390 setupdlg->attr[KEY_NOCREAT].attr,
19393 if (parent || setupdlg->attr[KEY_NOWCHAR].supplied) {
19394 SQLWritePrivateProfileString(dsn,
"NoWCHAR",
19395 setupdlg->attr[KEY_NOWCHAR].attr,
19398 if (parent || setupdlg->attr[KEY_FKSUPPORT].supplied) {
19399 SQLWritePrivateProfileString(dsn,
"FKSupport",
19400 setupdlg->attr[KEY_FKSUPPORT].attr,
19403 if (parent || setupdlg->attr[KEY_OEMCP].supplied) {
19404 SQLWritePrivateProfileString(dsn,
"OEMCP",
19405 setupdlg->attr[KEY_OEMCP].attr,
19408 if (parent || setupdlg->attr[KEY_LOADEXT].supplied) {
19409 SQLWritePrivateProfileString(dsn,
"LoadExt",
19410 setupdlg->attr[KEY_LOADEXT].attr,
19413 if (parent || setupdlg->attr[KEY_BIGINT].supplied) {
19414 SQLWritePrivateProfileString(dsn,
"BigInt",
19415 setupdlg->attr[KEY_BIGINT].attr,
19418 if (parent || setupdlg->attr[KEY_JDCONV].supplied) {
19419 SQLWritePrivateProfileString(dsn,
"JDConv",
19420 setupdlg->attr[KEY_JDCONV].attr,
19423 if (parent || setupdlg->attr[KEY_ATTAS].supplied) {
19424 SQLWritePrivateProfileString(dsn,
"AttachAs",
19425 setupdlg->attr[KEY_ATTAS].attr,
19428 if (parent || setupdlg->attr[KEY_ILIKE].supplied) {
19429 SQLWritePrivateProfileString(dsn,
"ILike",
19430 setupdlg->attr[KEY_ILIKE].attr,
19433 if (parent || setupdlg->attr[KEY_PASSWD].supplied) {
19434 SQLWritePrivateProfileString(dsn,
"PWD",
19435 setupdlg->attr[KEY_PASSWD].attr,
19438 if (setupdlg->attr[KEY_DSN].supplied &&
19439 strcasecmp(setupdlg->DSN, setupdlg->attr[KEY_DSN].attr)) {
19440 SQLRemoveDSNFromIni(setupdlg->DSN);
19451GetAttributes(SETUPDLG *setupdlg)
19453 char *dsn = setupdlg->attr[KEY_DSN].attr;
19455 if (!setupdlg->attr[KEY_DESC].supplied) {
19456 SQLGetPrivateProfileString(dsn,
"Description",
"",
19457 setupdlg->attr[KEY_DESC].attr,
19458 sizeof (setupdlg->attr[KEY_DESC].attr),
19461 if (!setupdlg->attr[KEY_DBNAME].supplied) {
19462 SQLGetPrivateProfileString(dsn,
"Database",
"",
19463 setupdlg->attr[KEY_DBNAME].attr,
19464 sizeof (setupdlg->attr[KEY_DBNAME].attr),
19467 if (!setupdlg->attr[KEY_BUSY].supplied) {
19468 SQLGetPrivateProfileString(dsn,
"Timeout",
"100000",
19469 setupdlg->attr[KEY_BUSY].attr,
19470 sizeof (setupdlg->attr[KEY_BUSY].attr),
19473 if (!setupdlg->attr[KEY_STEPAPI].supplied) {
19474 SQLGetPrivateProfileString(dsn,
"StepAPI",
"0",
19475 setupdlg->attr[KEY_STEPAPI].attr,
19476 sizeof (setupdlg->attr[KEY_STEPAPI].attr),
19479 if (!setupdlg->attr[KEY_SYNCP].supplied) {
19480 SQLGetPrivateProfileString(dsn,
"SyncPragma",
"NORMAL",
19481 setupdlg->attr[KEY_SYNCP].attr,
19482 sizeof (setupdlg->attr[KEY_SYNCP].attr),
19485 if (!setupdlg->attr[KEY_NOTXN].supplied) {
19486 SQLGetPrivateProfileString(dsn,
"NoTXN",
"",
19487 setupdlg->attr[KEY_NOTXN].attr,
19488 sizeof (setupdlg->attr[KEY_NOTXN].attr),
19491 if (!setupdlg->attr[KEY_SHORTNAM].supplied) {
19492 SQLGetPrivateProfileString(dsn,
"ShortNames",
"",
19493 setupdlg->attr[KEY_SHORTNAM].attr,
19494 sizeof (setupdlg->attr[KEY_SHORTNAM].attr),
19497 if (!setupdlg->attr[KEY_LONGNAM].supplied) {
19498 SQLGetPrivateProfileString(dsn,
"LongNames",
"",
19499 setupdlg->attr[KEY_LONGNAM].attr,
19500 sizeof (setupdlg->attr[KEY_LONGNAM].attr),
19503 if (!setupdlg->attr[KEY_NOCREAT].supplied) {
19504 SQLGetPrivateProfileString(dsn,
"NoCreat",
"",
19505 setupdlg->attr[KEY_NOCREAT].attr,
19506 sizeof (setupdlg->attr[KEY_NOCREAT].attr),
19509 if (!setupdlg->attr[KEY_NOWCHAR].supplied) {
19510 SQLGetPrivateProfileString(dsn,
"NoWCHAR",
"",
19511 setupdlg->attr[KEY_NOWCHAR].attr,
19512 sizeof (setupdlg->attr[KEY_NOWCHAR].attr),
19515 if (!setupdlg->attr[KEY_FKSUPPORT].supplied) {
19516 SQLGetPrivateProfileString(dsn,
"FKSupport",
"",
19517 setupdlg->attr[KEY_FKSUPPORT].attr,
19518 sizeof (setupdlg->attr[KEY_FKSUPPORT].attr),
19521 if (!setupdlg->attr[KEY_OEMCP].supplied) {
19522 SQLGetPrivateProfileString(dsn,
"OEMCP",
"",
19523 setupdlg->attr[KEY_OEMCP].attr,
19524 sizeof (setupdlg->attr[KEY_OEMCP].attr),
19527 if (!setupdlg->attr[KEY_LOADEXT].supplied) {
19528 SQLGetPrivateProfileString(dsn,
"LoadExt",
"",
19529 setupdlg->attr[KEY_LOADEXT].attr,
19530 sizeof (setupdlg->attr[KEY_LOADEXT].attr),
19533 if (!setupdlg->attr[KEY_JMODE].supplied) {
19534 SQLGetPrivateProfileString(dsn,
"JournalMode",
"",
19535 setupdlg->attr[KEY_JMODE].attr,
19536 sizeof (setupdlg->attr[KEY_JMODE].attr),
19539 if (!setupdlg->attr[KEY_BIGINT].supplied) {
19540 SQLGetPrivateProfileString(dsn,
"BigInt",
"",
19541 setupdlg->attr[KEY_BIGINT].attr,
19542 sizeof (setupdlg->attr[KEY_BIGINT].attr),
19545 if (!setupdlg->attr[KEY_PASSWD].supplied) {
19546 SQLGetPrivateProfileString(dsn,
"PWD",
"",
19547 setupdlg->attr[KEY_PASSWD].attr,
19548 sizeof (setupdlg->attr[KEY_PASSWD].attr),
19551 if (!setupdlg->attr[KEY_JDCONV].supplied) {
19552 SQLGetPrivateProfileString(dsn,
"JDConv",
"",
19553 setupdlg->attr[KEY_JDCONV].attr,
19554 sizeof (setupdlg->attr[KEY_JDCONV].attr),
19557 if (!setupdlg->attr[KEY_ATTAS].supplied) {
19558 SQLGetPrivateProfileString(dsn,
"AttachAs",
"",
19559 setupdlg->attr[KEY_ATTAS].attr,
19560 sizeof (setupdlg->attr[KEY_ATTAS].attr),
19563 if (!setupdlg->attr[KEY_ILIKE].supplied) {
19564 SQLGetPrivateProfileString(dsn,
"ILike",
"",
19565 setupdlg->attr[KEY_ILIKE].attr,
19566 sizeof (setupdlg->attr[KEY_ILIKE].attr),
19577GetDBFile(HWND hdlg)
19580 SETUPDLG *setupdlg = (SETUPDLG *) GetWindowLongPtr(hdlg, DWLP_USER);
19582 SETUPDLG *setupdlg = (SETUPDLG *) GetWindowLong(hdlg, DWL_USER);
19586 memset(&ofn, 0,
sizeof (ofn));
19587 ofn.lStructSize =
sizeof (ofn);
19588 ofn.hwndOwner = hdlg;
19590 ofn.hInstance = (HINSTANCE) GetWindowLongPtr(hdlg, GWLP_HINSTANCE);
19592 ofn.hInstance = (HINSTANCE) GetWindowLong(hdlg, GWL_HINSTANCE);
19594 ofn.lpstrFile = (LPTSTR) setupdlg->attr[KEY_DBNAME].attr;
19595 ofn.nMaxFile = MAXPATHLEN;
19596 ofn.Flags = OFN_HIDEREADONLY | OFN_PATHMUSTEXIST |
19597 OFN_NOCHANGEDIR | OFN_EXPLORER | OFN_FILEMUSTEXIST;
19598 if (GetOpenFileName(&ofn)) {
19599 SetDlgItemText(hdlg, IDC_DBNAME, setupdlg->attr[KEY_DBNAME].attr);
19600 setupdlg->attr[KEY_DBNAME].supplied = TRUE;
19613static BOOL CALLBACK
19614ConfigDlgProc(HWND hdlg, WORD wmsg, WPARAM wparam, LPARAM lparam)
19616 SETUPDLG *setupdlg = NULL;
19620 case WM_INITDIALOG:
19622 SetWindowLongPtr(hdlg, DWLP_USER, lparam);
19624 SetWindowLong(hdlg, DWL_USER, lparam);
19626 setupdlg = (SETUPDLG *) lparam;
19627 GetAttributes(setupdlg);
19628 SetDlgItemText(hdlg, IDC_DSNAME, setupdlg->attr[KEY_DSN].attr);
19629 SetDlgItemText(hdlg, IDC_DESC, setupdlg->attr[KEY_DESC].attr);
19630 SetDlgItemText(hdlg, IDC_DBNAME, setupdlg->attr[KEY_DBNAME].attr);
19631 SetDlgItemText(hdlg, IDC_TONAME, setupdlg->attr[KEY_BUSY].attr);
19632 SetDlgItemText(hdlg, IDC_LOADEXT, setupdlg->attr[KEY_LOADEXT].attr);
19633 SendDlgItemMessage(hdlg, IDC_DSNAME, EM_LIMITTEXT,
19634 (WPARAM) (MAXDSNAME - 1), (LPARAM) 0);
19635 SendDlgItemMessage(hdlg, IDC_DESC, EM_LIMITTEXT,
19636 (WPARAM) (MAXDESC - 1), (LPARAM) 0);
19637 SendDlgItemMessage(hdlg, IDC_DBNAME, EM_LIMITTEXT,
19638 (WPARAM) (MAXDBNAME - 1), (LPARAM) 0);
19639 SendDlgItemMessage(hdlg, IDC_TONAME, EM_LIMITTEXT,
19640 (WPARAM) (MAXTONAME - 1), (LPARAM) 0);
19641 SendDlgItemMessage(hdlg, IDC_LOADEXT, EM_LIMITTEXT,
19642 (WPARAM) (MAXPATHLEN*4 - 1), (LPARAM) 0);
19643 CheckDlgButton(hdlg, IDC_STEPAPI,
19644 getbool(setupdlg->attr[KEY_STEPAPI].attr) ?
19645 BST_CHECKED : BST_UNCHECKED);
19646 CheckDlgButton(hdlg, IDC_NOTXN,
19647 getbool(setupdlg->attr[KEY_NOTXN].attr) ?
19648 BST_CHECKED : BST_UNCHECKED);
19649 CheckDlgButton(hdlg, IDC_SHORTNAM,
19650 getbool(setupdlg->attr[KEY_SHORTNAM].attr) ?
19651 BST_CHECKED : BST_UNCHECKED);
19652 CheckDlgButton(hdlg, IDC_LONGNAM,
19653 getbool(setupdlg->attr[KEY_LONGNAM].attr) ?
19654 BST_CHECKED : BST_UNCHECKED);
19655 CheckDlgButton(hdlg, IDC_NOCREAT,
19656 getbool(setupdlg->attr[KEY_NOCREAT].attr) ?
19657 BST_CHECKED : BST_UNCHECKED);
19658 CheckDlgButton(hdlg, IDC_NOWCHAR,
19659 getbool(setupdlg->attr[KEY_NOWCHAR].attr) ?
19660 BST_CHECKED : BST_UNCHECKED);
19661 CheckDlgButton(hdlg, IDC_FKSUPPORT,
19662 getbool(setupdlg->attr[KEY_FKSUPPORT].attr) ?
19663 BST_CHECKED : BST_UNCHECKED);
19664 CheckDlgButton(hdlg, IDC_OEMCP,
19665 getbool(setupdlg->attr[KEY_OEMCP].attr) ?
19666 BST_CHECKED : BST_UNCHECKED);
19667 CheckDlgButton(hdlg, IDC_BIGINT,
19668 getbool(setupdlg->attr[KEY_BIGINT].attr) ?
19669 BST_CHECKED : BST_UNCHECKED);
19670 CheckDlgButton(hdlg, IDC_JDCONV,
19671 getbool(setupdlg->attr[KEY_JDCONV].attr) ?
19672 BST_CHECKED : BST_UNCHECKED);
19673 SetDlgItemText(hdlg, IDC_ATTAS, setupdlg->attr[KEY_ATTAS].attr);
19674 CheckDlgButton(hdlg, IDC_ILIKE,
19675 getbool(setupdlg->attr[KEY_ILIKE].attr) ?
19676 BST_CHECKED : BST_UNCHECKED);
19677 SendDlgItemMessage(hdlg, IDC_SYNCP,
19678 CB_LIMITTEXT, (WPARAM) 10, (LPARAM) 0);
19679 SendDlgItemMessage(hdlg, IDC_SYNCP,
19680 CB_ADDSTRING, 0, (LPARAM)
"NORMAL");
19681 SendDlgItemMessage(hdlg, IDC_SYNCP,
19682 CB_ADDSTRING, 0, (LPARAM)
"OFF");
19683 SendDlgItemMessage(hdlg, IDC_SYNCP,
19684 CB_ADDSTRING, 0, (LPARAM)
"FULL");
19685 SendDlgItemMessage(hdlg, IDC_SYNCP,
19686 CB_SELECTSTRING, (WPARAM) -1,
19687 (LPARAM) setupdlg->attr[KEY_SYNCP].attr);
19688 if (setupdlg->defDSN) {
19689 EnableWindow(GetDlgItem(hdlg, IDC_DSNAME), FALSE);
19690 EnableWindow(GetDlgItem(hdlg, IDC_DSNAMETEXT), FALSE);
19694 switch (GET_WM_COMMAND_ID(wparam, lparam)) {
19696 if (GET_WM_COMMAND_CMD(wparam, lparam) == EN_CHANGE) {
19697 char item[MAXDSNAME];
19699 EnableWindow(GetDlgItem(hdlg, IDOK),
19700 GetDlgItemText(hdlg, IDC_DSNAME,
19701 item,
sizeof (item)));
19710 setupdlg = (SETUPDLG *) GetWindowLongPtr(hdlg, DWLP_USER);
19712 setupdlg = (SETUPDLG *) GetWindowLong(hdlg, DWL_USER);
19714 if (!setupdlg->defDSN) {
19715 GetDlgItemText(hdlg, IDC_DSNAME,
19716 setupdlg->attr[KEY_DSN].attr,
19717 sizeof (setupdlg->attr[KEY_DSN].attr));
19719 GetDlgItemText(hdlg, IDC_DESC,
19720 setupdlg->attr[KEY_DESC].attr,
19721 sizeof (setupdlg->attr[KEY_DESC].attr));
19722 GetDlgItemText(hdlg, IDC_DBNAME,
19723 setupdlg->attr[KEY_DBNAME].attr,
19724 sizeof (setupdlg->attr[KEY_DBNAME].attr));
19725 GetDlgItemText(hdlg, IDC_TONAME,
19726 setupdlg->attr[KEY_BUSY].attr,
19727 sizeof (setupdlg->attr[KEY_BUSY].attr));
19728 GetDlgItemText(hdlg, IDC_LOADEXT,
19729 setupdlg->attr[KEY_LOADEXT].attr,
19730 sizeof (setupdlg->attr[KEY_LOADEXT].attr));
19731 index = SendDlgItemMessage(hdlg, IDC_SYNCP,
19732 CB_GETCURSEL, (WPARAM) 0, (LPARAM) 0);
19733 if (index != (WORD) CB_ERR) {
19734 SendDlgItemMessage(hdlg, IDC_SYNCP,
19735 CB_GETLBTEXT, index,
19736 (LPARAM) setupdlg->attr[KEY_SYNCP].attr);
19738 strcpy(setupdlg->attr[KEY_STEPAPI].attr,
19739 (IsDlgButtonChecked(hdlg, IDC_STEPAPI) == BST_CHECKED) ?
19741 strcpy(setupdlg->attr[KEY_NOTXN].attr,
19742 (IsDlgButtonChecked(hdlg, IDC_NOTXN) == BST_CHECKED) ?
19744 strcpy(setupdlg->attr[KEY_SHORTNAM].attr,
19745 (IsDlgButtonChecked(hdlg, IDC_SHORTNAM) == BST_CHECKED) ?
19747 strcpy(setupdlg->attr[KEY_LONGNAM].attr,
19748 (IsDlgButtonChecked(hdlg, IDC_LONGNAM) == BST_CHECKED) ?
19750 strcpy(setupdlg->attr[KEY_NOCREAT].attr,
19751 (IsDlgButtonChecked(hdlg, IDC_NOCREAT) == BST_CHECKED) ?
19753 strcpy(setupdlg->attr[KEY_NOWCHAR].attr,
19754 (IsDlgButtonChecked(hdlg, IDC_NOWCHAR) == BST_CHECKED) ?
19756 strcpy(setupdlg->attr[KEY_FKSUPPORT].attr,
19757 (IsDlgButtonChecked(hdlg, IDC_FKSUPPORT) == BST_CHECKED) ?
19759 strcpy(setupdlg->attr[KEY_OEMCP].attr,
19760 (IsDlgButtonChecked(hdlg, IDC_OEMCP) == BST_CHECKED) ?
19762 strcpy(setupdlg->attr[KEY_BIGINT].attr,
19763 (IsDlgButtonChecked(hdlg, IDC_BIGINT) == BST_CHECKED) ?
19765 strcpy(setupdlg->attr[KEY_JDCONV].attr,
19766 (IsDlgButtonChecked(hdlg, IDC_JDCONV) == BST_CHECKED) ?
19768 GetDlgItemText(hdlg, IDC_ATTAS,
19769 setupdlg->attr[KEY_ATTAS].attr,
19770 sizeof (setupdlg->attr[KEY_ATTAS].attr));
19771 strcpy(setupdlg->attr[KEY_ILIKE].attr,
19772 (IsDlgButtonChecked(hdlg, IDC_ILIKE) == BST_CHECKED) ?
19774 SetDSNAttributes(hdlg, setupdlg);
19777 EndDialog(hdlg, wparam);
19795ConfigDSN(HWND hwnd, WORD request, LPCSTR driver, LPCSTR attribs)
19798 SETUPDLG *setupdlg;
19800 setupdlg = (SETUPDLG *)
xmalloc(
sizeof (SETUPDLG));
19801 if (setupdlg == NULL) {
19804 memset(setupdlg, 0,
sizeof (SETUPDLG));
19806 ParseAttributes(attribs, setupdlg);
19808 if (setupdlg->attr[KEY_DSN].supplied) {
19809 strcpy(setupdlg->DSN, setupdlg->attr[KEY_DSN].attr);
19811 setupdlg->DSN[0] =
'\0';
19813 if (request == ODBC_REMOVE_DSN) {
19814 if (!setupdlg->attr[KEY_DSN].supplied) {
19817 success = SQLRemoveDSNFromIni(setupdlg->attr[KEY_DSN].attr);
19820 setupdlg->parent = hwnd;
19821 setupdlg->driver = driver;
19822 setupdlg->newDSN = request == ODBC_ADD_DSN;
19823 setupdlg->defDSN = strcasecmp(setupdlg->attr[KEY_DSN].attr,
19826 success = DialogBoxParam(hModule, MAKEINTRESOURCE(CONFIGDSN),
19827 hwnd, (DLGPROC) ConfigDlgProc,
19828 (LPARAM) setupdlg) == IDOK;
19829 }
else if (setupdlg->attr[KEY_DSN].supplied) {
19830 success = SetDSNAttributes(hwnd, setupdlg);
19848static BOOL CALLBACK
19849DriverConnectProc(HWND hdlg, WORD wmsg, WPARAM wparam, LPARAM lparam)
19851 SETUPDLG *setupdlg;
19855 case WM_INITDIALOG:
19857 SetWindowLongPtr(hdlg, DWLP_USER, lparam);
19859 SetWindowLong(hdlg, DWL_USER, lparam);
19861 setupdlg = (SETUPDLG *) lparam;
19862 SetDlgItemText(hdlg, IDC_DSNAME, setupdlg->attr[KEY_DSN].attr);
19863 SetDlgItemText(hdlg, IDC_DESC, setupdlg->attr[KEY_DESC].attr);
19864 SetDlgItemText(hdlg, IDC_DBNAME, setupdlg->attr[KEY_DBNAME].attr);
19865 SetDlgItemText(hdlg, IDC_TONAME, setupdlg->attr[KEY_BUSY].attr);
19866 SetDlgItemText(hdlg, IDC_LOADEXT, setupdlg->attr[KEY_LOADEXT].attr);
19867 SendDlgItemMessage(hdlg, IDC_DSNAME, EM_LIMITTEXT,
19868 (WPARAM) (MAXDSNAME - 1), (LPARAM) 0);
19869 SendDlgItemMessage(hdlg, IDC_DESC, EM_LIMITTEXT,
19870 (WPARAM) (MAXDESC - 1), (LPARAM) 0);
19871 SendDlgItemMessage(hdlg, IDC_DBNAME, EM_LIMITTEXT,
19872 (WPARAM) (MAXDBNAME - 1), (LPARAM) 0);
19873 SendDlgItemMessage(hdlg, IDC_TONAME, EM_LIMITTEXT,
19874 (WPARAM) (MAXTONAME - 1), (LPARAM) 0);
19875 SendDlgItemMessage(hdlg, IDC_LOADEXT, EM_LIMITTEXT,
19876 (WPARAM) (MAXPATHLEN*4 - 1), (LPARAM) 0);
19877 CheckDlgButton(hdlg, IDC_STEPAPI,
19878 getbool(setupdlg->attr[KEY_STEPAPI].attr) ?
19879 BST_CHECKED : BST_UNCHECKED);
19880 CheckDlgButton(hdlg, IDC_NOTXN,
19881 getbool(setupdlg->attr[KEY_NOTXN].attr) ?
19882 BST_CHECKED : BST_UNCHECKED);
19883 CheckDlgButton(hdlg, IDC_SHORTNAM,
19884 getbool(setupdlg->attr[KEY_SHORTNAM].attr) ?
19885 BST_CHECKED : BST_UNCHECKED);
19886 CheckDlgButton(hdlg, IDC_LONGNAM,
19887 getbool(setupdlg->attr[KEY_LONGNAM].attr) ?
19888 BST_CHECKED : BST_UNCHECKED);
19889 CheckDlgButton(hdlg, IDC_NOCREAT,
19890 getbool(setupdlg->attr[KEY_NOCREAT].attr) ?
19891 BST_CHECKED : BST_UNCHECKED);
19892 CheckDlgButton(hdlg, IDC_NOWCHAR,
19893 getbool(setupdlg->attr[KEY_NOWCHAR].attr) ?
19894 BST_CHECKED : BST_UNCHECKED);
19895 CheckDlgButton(hdlg, IDC_FKSUPPORT,
19896 getbool(setupdlg->attr[KEY_FKSUPPORT].attr) ?
19897 BST_CHECKED : BST_UNCHECKED);
19898 CheckDlgButton(hdlg, IDC_OEMCP,
19899 getbool(setupdlg->attr[KEY_OEMCP].attr) ?
19900 BST_CHECKED : BST_UNCHECKED);
19901 CheckDlgButton(hdlg, IDC_BIGINT,
19902 getbool(setupdlg->attr[KEY_BIGINT].attr) ?
19903 BST_CHECKED : BST_UNCHECKED);
19904 CheckDlgButton(hdlg, IDC_JDCONV,
19905 getbool(setupdlg->attr[KEY_JDCONV].attr) ?
19906 BST_CHECKED : BST_UNCHECKED);
19907 SendDlgItemMessage(hdlg, IDC_SYNCP,
19908 CB_LIMITTEXT, (WPARAM) 10, (LPARAM) 0);
19909 SendDlgItemMessage(hdlg, IDC_SYNCP,
19910 CB_ADDSTRING, 0, (LPARAM)
"NORMAL");
19911 SendDlgItemMessage(hdlg, IDC_SYNCP,
19912 CB_ADDSTRING, 0, (LPARAM)
"OFF");
19913 SendDlgItemMessage(hdlg, IDC_SYNCP,
19914 CB_ADDSTRING, 0, (LPARAM)
"FULL");
19915 SendDlgItemMessage(hdlg, IDC_SYNCP,
19916 CB_SELECTSTRING, (WORD) -1,
19917 (LPARAM) setupdlg->attr[KEY_SYNCP].attr);
19918 if (setupdlg->defDSN) {
19919 EnableWindow(GetDlgItem(hdlg, IDC_DSNAME), FALSE);
19920 EnableWindow(GetDlgItem(hdlg, IDC_DSNAMETEXT), FALSE);
19922 SetDlgItemText(hdlg, IDC_ATTAS, setupdlg->attr[KEY_ATTAS].attr);
19923 CheckDlgButton(hdlg, IDC_ILIKE,
19924 getbool(setupdlg->attr[KEY_ILIKE].attr) ?
19925 BST_CHECKED : BST_UNCHECKED);
19928 switch (GET_WM_COMMAND_ID(wparam, lparam)) {
19934 setupdlg = (SETUPDLG *) GetWindowLongPtr(hdlg, DWLP_USER);
19936 setupdlg = (SETUPDLG *) GetWindowLong(hdlg, DWL_USER);
19938 GetDlgItemText(hdlg, IDC_DSNAME,
19939 setupdlg->attr[KEY_DSN].attr,
19940 sizeof (setupdlg->attr[KEY_DSN].attr));
19941 GetDlgItemText(hdlg, IDC_DBNAME,
19942 setupdlg->attr[KEY_DBNAME].attr,
19943 sizeof (setupdlg->attr[KEY_DBNAME].attr));
19944 GetDlgItemText(hdlg, IDC_TONAME,
19945 setupdlg->attr[KEY_BUSY].attr,
19946 sizeof (setupdlg->attr[KEY_BUSY].attr));
19947 GetDlgItemText(hdlg, IDC_LOADEXT,
19948 setupdlg->attr[KEY_LOADEXT].attr,
19949 sizeof (setupdlg->attr[KEY_LOADEXT].attr));
19950 index = SendDlgItemMessage(hdlg, IDC_SYNCP,
19951 CB_GETCURSEL, (WPARAM) 0, (LPARAM) 0);
19952 if (index != (WORD) CB_ERR) {
19953 SendDlgItemMessage(hdlg, IDC_SYNCP,
19954 CB_GETLBTEXT, index,
19955 (LPARAM) setupdlg->attr[KEY_SYNCP].attr);
19957 strcpy(setupdlg->attr[KEY_STEPAPI].attr,
19958 (IsDlgButtonChecked(hdlg, IDC_STEPAPI) == BST_CHECKED) ?
19960 strcpy(setupdlg->attr[KEY_NOTXN].attr,
19961 (IsDlgButtonChecked(hdlg, IDC_NOTXN) == BST_CHECKED) ?
19963 strcpy(setupdlg->attr[KEY_SHORTNAM].attr,
19964 (IsDlgButtonChecked(hdlg, IDC_SHORTNAM) == BST_CHECKED) ?
19966 strcpy(setupdlg->attr[KEY_LONGNAM].attr,
19967 (IsDlgButtonChecked(hdlg, IDC_LONGNAM) == BST_CHECKED) ?
19969 strcpy(setupdlg->attr[KEY_NOCREAT].attr,
19970 (IsDlgButtonChecked(hdlg, IDC_NOCREAT) == BST_CHECKED) ?
19972 strcpy(setupdlg->attr[KEY_NOWCHAR].attr,
19973 (IsDlgButtonChecked(hdlg, IDC_NOWCHAR) == BST_CHECKED) ?
19975 strcpy(setupdlg->attr[KEY_FKSUPPORT].attr,
19976 (IsDlgButtonChecked(hdlg, IDC_FKSUPPORT) == BST_CHECKED) ?
19978 strcpy(setupdlg->attr[KEY_OEMCP].attr,
19979 (IsDlgButtonChecked(hdlg, IDC_OEMCP) == BST_CHECKED) ?
19981 strcpy(setupdlg->attr[KEY_BIGINT].attr,
19982 (IsDlgButtonChecked(hdlg, IDC_BIGINT) == BST_CHECKED) ?
19984 strcpy(setupdlg->attr[KEY_JDCONV].attr,
19985 (IsDlgButtonChecked(hdlg, IDC_JDCONV) == BST_CHECKED) ?
19987 GetDlgItemText(hdlg, IDC_ATTAS,
19988 setupdlg->attr[KEY_ATTAS].attr,
19989 sizeof (setupdlg->attr[KEY_ATTAS].attr));
19990 strcpy(setupdlg->attr[KEY_ILIKE].attr,
19991 (IsDlgButtonChecked(hdlg, IDC_ILIKE) == BST_CHECKED) ?
19995 EndDialog(hdlg, GET_WM_COMMAND_ID(wparam, lparam) == IDOK);
20017 SQLCHAR *connIn, SQLSMALLINT connInLen,
20018 SQLCHAR *connOut, SQLSMALLINT connOutMax,
20019 SQLSMALLINT *connOutLen, SQLUSMALLINT drvcompl)
20021 BOOL maybeprompt, prompt = FALSE, defaultdsn = FALSE;
20023 SETUPDLG *setupdlg;
20025 char *dsn = NULL, *driver = NULL, *dbname = NULL;
20027 if (
dbc == SQL_NULL_HDBC) {
20028 return SQL_INVALID_HANDLE;
20032 setstatd(d, -1,
"connection already established",
"08002");
20035 setupdlg = (SETUPDLG *)
xmalloc(
sizeof (SETUPDLG));
20036 if (setupdlg == NULL) {
20039 memset(setupdlg, 0,
sizeof (SETUPDLG));
20040 maybeprompt = drvcompl == SQL_DRIVER_COMPLETE ||
20041 drvcompl == SQL_DRIVER_COMPLETE_REQUIRED;
20042 if (connIn == NULL || !connInLen ||
20043 (connInLen == SQL_NTS && !connIn[0])) {
20046 ParseAttributes((LPCSTR) connIn, setupdlg);
20047 if (!setupdlg->attr[KEY_DSN].attr[0] &&
20048 drvcompl == SQL_DRIVER_COMPLETE_REQUIRED) {
20049 strcpy(setupdlg->attr[KEY_DSN].attr,
"DEFAULT");
20052 GetAttributes(setupdlg);
20053 if (drvcompl == SQL_DRIVER_PROMPT ||
20055 !setupdlg->attr[KEY_DBNAME].attr[0])) {
20063 setupdlg->defDSN = setupdlg->attr[KEY_DRIVER].attr[0] !=
'\0';
20064 dlgret = DialogBoxParam(hModule, MAKEINTRESOURCE(DRIVERCONNECT),
20065 hwnd, (DLGPROC) DriverConnectProc,
20066 (LPARAM) setupdlg);
20068 if (!dlgret || dlgret == -1) {
20070 return SQL_NO_DATA;
20073 dsn = setupdlg->attr[KEY_DSN].attr;
20074 driver = setupdlg->attr[KEY_DRIVER].attr;
20075 dbname = setupdlg->attr[KEY_DBNAME].attr;
20076 if (connOut || connOutLen) {
20077 char buf[SQL_MAX_MESSAGE_LENGTH * 8];
20079 char dsn_0 = (dsn && !defaultdsn) ? dsn[0] :
'\0';
20080 char drv_0 = driver ? driver[0] :
'\0';
20083 count = snprintf(buf,
sizeof (buf),
20084 "%s%s%s%s%s%sDatabase=%s;StepAPI=%s;"
20085 "SyncPragma=%s;NoTXN=%s;Timeout=%s;"
20086 "ShortNames=%s;LongNames=%s;"
20087 "NoCreat=%s;NoWCHAR=%s;"
20088 "FKSupport=%s;JournalMode=%s;OEMCP=%s;LoadExt=%s;"
20089 "BigInt=%s;JDConv=%s;PWD=%s;AttachAs=%s;ILike=%s",
20090 dsn_0 ?
"DSN=" :
"",
20093 drv_0 ?
"Driver=" :
"",
20094 drv_0 ? driver :
"",
20096 dbname ? dbname :
"",
20097 setupdlg->attr[KEY_STEPAPI].attr,
20098 setupdlg->attr[KEY_SYNCP].attr,
20099 setupdlg->attr[KEY_NOTXN].attr,
20100 setupdlg->attr[KEY_BUSY].attr,
20101 setupdlg->attr[KEY_SHORTNAM].attr,
20102 setupdlg->attr[KEY_LONGNAM].attr,
20103 setupdlg->attr[KEY_NOCREAT].attr,
20104 setupdlg->attr[KEY_NOWCHAR].attr,
20105 setupdlg->attr[KEY_FKSUPPORT].attr,
20106 setupdlg->attr[KEY_JMODE].attr,
20107 setupdlg->attr[KEY_OEMCP].attr,
20108 setupdlg->attr[KEY_LOADEXT].attr,
20109 setupdlg->attr[KEY_BIGINT].attr,
20110 setupdlg->attr[KEY_JDCONV].attr,
20111 setupdlg->attr[KEY_PASSWD].attr,
20112 setupdlg->attr[KEY_ATTAS].attr,
20113 setupdlg->attr[KEY_ILIKE].attr);
20115 buf[
sizeof (buf) - 1] =
'\0';
20117 len =
min(connOutMax - 1, strlen(buf));
20119 strncpy((
char *) connOut, buf, len);
20120 connOut[len] =
'\0';
20127 char tracef[SQL_MAX_MESSAGE_LENGTH];
20130 SQLGetPrivateProfileString(setupdlg->attr[KEY_DSN].attr,
20131 "tracefile",
"", tracef,
20133 if (tracef[0] !=
'\0') {
20134 d->
trace = fopen(tracef,
"a");
20146 d->
pwdLen = strlen(setupdlg->attr[KEY_PASSWD].attr);
20147 d->
pwd = (d->
pwdLen > 0) ? setupdlg->attr[KEY_PASSWD].attr : NULL;
20148 ret =
dbopen(d, dbname ? dbname :
"", 0,
20150 setupdlg->attr[KEY_STEPAPI].attr,
20151 setupdlg->attr[KEY_SYNCP].attr,
20152 setupdlg->attr[KEY_NOTXN].attr,
20153 setupdlg->attr[KEY_JMODE].attr,
20154 setupdlg->attr[KEY_BUSY].attr);
20155 if (ret != SQL_SUCCESS) {
20156 if (maybeprompt && !prompt) {
20161 memset(setupdlg->attr[KEY_PASSWD].attr, 0,
20162 sizeof (setupdlg->attr[KEY_PASSWD].attr));
20163 if (ret == SQL_SUCCESS) {
20164 dbloadext(d, setupdlg->attr[KEY_LOADEXT].attr);
20165 dbattas(d, setupdlg->attr[KEY_ATTAS].attr);
20189SQLDriverConnect(SQLHDBC
dbc, SQLHWND hwnd,
20190 SQLCHAR *connIn, SQLSMALLINT connInLen,
20191 SQLCHAR *connOut, SQLSMALLINT connOutMax,
20192 SQLSMALLINT *connOutLen, SQLUSMALLINT drvcompl)
20198 connOut, connOutMax, connOutLen, drvcompl);
20219SQLDriverConnectW(SQLHDBC
dbc, SQLHWND hwnd,
20220 SQLWCHAR *connIn, SQLSMALLINT connInLen,
20221 SQLWCHAR *connOut, SQLSMALLINT connOutMax,
20222 SQLSMALLINT *connOutLen, SQLUSMALLINT drvcompl)
20226 SQLSMALLINT len = 0;
20230#if defined(_WIN32) || defined(_WIN64)
20231 if (connInLen == SQL_NTS) {
20234 ci = uc_to_wmb(connIn, connInLen);
20241 setstatd(d, -1,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
20247 (SQLCHAR *) connOut, connOutMax, &len, drvcompl);
20250 if (ret == SQL_SUCCESS) {
20251 SQLWCHAR *co = NULL;
20255#if defined(_WIN32) || defined(_WIN64)
20256 co = wmb_to_uc((
char *) connOut, len);
20261 uc_strncpy(connOut, co, connOutMax /
sizeof (SQLWCHAR));
20262 len =
min(connOutMax /
sizeof (SQLWCHAR),
uc_strlen(co));
20283#if defined(_WIN32) || defined(_WIN64)
20294LibMain(HANDLE hinst, DWORD reason, LPVOID reserved)
20299 case DLL_PROCESS_ATTACH:
20307#ifdef SQLITE_DYNLOAD
20310#ifdef SQLITE_HAS_CODEC
20311 sqlite3_activate_see(SQLITE_ACTIVATION_KEY);
20314#if defined(ENABLE_NVFS) && (ENABLE_NVFS)
20318 case DLL_THREAD_ATTACH:
20320 case DLL_PROCESS_DETACH:
20322#ifdef SQLITE_DYNLOAD
20327 case DLL_THREAD_DETACH:
20344DllMain(HANDLE hinst, DWORD reason, LPVOID reserved)
20346 return LibMain(hinst, reason, reserved);
20349#ifndef WITHOUT_INSTALLER
20358InUnError(
char *name)
20363 WORD errlen, errmax =
sizeof (errmsg) - 1;
20369 sqlret = SQLInstallerError(err, &code, errmsg, errmax, &errlen);
20370 if (SQL_SUCCEEDED(sqlret)) {
20371 MessageBox(NULL, errmsg, name,
20372 MB_ICONSTOP | MB_OK | MB_TASKMODAL | MB_SETFOREGROUND);
20376 }
while (sqlret != SQL_NO_DATA);
20387InUn(
int remove,
char *cmdline)
20389#ifdef SQLITE_HAS_CODEC
20390 static char *drivername =
"SQLite3 ODBC Driver (SEE)";
20391 static char *dsname =
"SQLite3 SEE Datasource";
20393 static char *drivername =
"SQLite3 ODBC Driver";
20394 static char *dsname =
"SQLite3 Datasource";
20397 char dllbuf[301], path[301], driver[300], attr[300], inst[400];
20398 WORD pathmax =
sizeof (path) - 1, pathlen;
20399 DWORD usecnt, mincnt;
20403 GetModuleFileName(hModule, dllbuf,
sizeof (dllbuf));
20404 p = strrchr(dllbuf,
'\\');
20405 dllname = p ? (p + 1) : dllbuf;
20406 quiet = cmdline && strstr(cmdline,
"quiet");
20407 if (SQLInstallDriverManager(path, pathmax, &pathlen)) {
20408 sprintf(driver,
"%s;Driver=%s;Setup=%s;",
20409 drivername, dllname, dllname);
20419 SQLInstallDriverEx(driver, NULL, path, pathmax, NULL,
20420 ODBC_INSTALL_INQUIRY, &usecnt);
20421 pathlen = strlen(path);
20422 while (pathlen > 0 && path[pathlen - 1] ==
'\\') {
20424 path[pathlen] =
'\0';
20426 sprintf(driver,
"%s;Driver=%s\\%s;Setup=%s\\%s;",
20427 drivername, path, dllname, path, dllname);
20435 sprintf(inst,
"%s\\%s", path, dllname);
20436 if (!remove && usecnt > 0) {
20438 if (GetFileAttributesA(dllbuf) != INVALID_FILE_ATTRIBUTES &&
20439 CopyFile(dllbuf, inst, 0)) {
20443 sprintf(buf,
"%s replaced.", drivername);
20444 MessageBox(NULL, buf,
"Info",
20445 MB_ICONINFORMATION | MB_OK | MB_TASKMODAL |
20451 mincnt = remove ? 1 : 0;
20452 while (usecnt != mincnt) {
20453 if (!SQLRemoveDriver(driver, TRUE, &usecnt)) {
20458 if (usecnt && !SQLRemoveDriver(driver, TRUE, &usecnt)) {
20459 InUnError(
"SQLRemoveDriver");
20467 sprintf(buf,
"%s uninstalled.", drivername);
20468 MessageBox(NULL, buf,
"Info",
20469 MB_ICONINFORMATION |MB_OK | MB_TASKMODAL |
20473 sprintf(attr,
"DSN=%s;Database=;", dsname);
20481 SQLConfigDataSource(NULL, ODBC_REMOVE_SYS_DSN, drivername, attr);
20484 if (GetFileAttributesA(dllbuf) == INVALID_FILE_ATTRIBUTES) {
20487 if (strcasecmp(dllbuf, inst) != 0 && !CopyFile(dllbuf, inst, 0)) {
20490 sprintf(buf,
"Copy %s to %s failed.", dllbuf, inst);
20491 MessageBox(NULL, buf,
"CopyFile",
20492 MB_ICONSTOP |MB_OK | MB_TASKMODAL | MB_SETFOREGROUND);
20495 if (!SQLInstallDriverEx(driver, path, path, pathmax, &pathlen,
20496 ODBC_INSTALL_COMPLETE, &usecnt)) {
20497 InUnError(
"SQLInstallDriverEx");
20500 sprintf(attr,
"DSN=%s;Database=;", dsname);
20508 SQLConfigDataSource(NULL, ODBC_REMOVE_SYS_DSN, drivername, attr);
20509 if (!SQLConfigDataSource(NULL, ODBC_ADD_SYS_DSN, drivername, attr)) {
20510 InUnError(
"SQLConfigDataSource");
20516 sprintf(buf,
"%s installed.", drivername);
20517 MessageBox(NULL, buf,
"Info",
20518 MB_ICONINFORMATION | MB_OK | MB_TASKMODAL |
20522 InUnError(
"SQLInstallDriverManager");
20537install(HWND hwnd, HINSTANCE hinst, LPSTR lpszCmdLine,
int nCmdShow)
20539 InUn(0, lpszCmdLine);
20551uninstall(HWND hwnd, HINSTANCE hinst, LPSTR lpszCmdLine,
int nCmdShow)
20553 InUn(1, lpszCmdLine);
20558#ifndef WITHOUT_SHELL
20569setargv(
int *argcp,
char ***argvp,
char *cmdline,
char *argv0)
20571 char *p, *arg, *argspace, **argv;
20572 int argc, size, inquote, copy, slashes;
20574 size = 2 + (argv0 ? 1 : 0);
20575 for (p = cmdline; *p !=
'\0'; p++) {
20586 argspace = malloc(size *
sizeof (
char *) + strlen(cmdline) + 1);
20587 argv = (
char **) argspace;
20588 argspace += size *
sizeof (
char *);
20592 argv[argc++] = argv0;
20595 for (; argc < size; argc++) {
20596 argv[argc] = arg = argspace;
20607 while (*p ==
'\\') {
20612 if ((slashes & 1) == 0) {
20614 if (inquote && p[1] ==
'"') {
20618 inquote = !inquote;
20628 if (*p ==
'\0' || (!inquote &&
ISSPACE(*p))) {
20638 argspace = arg + 1;
20654shell(HWND hwnd, HINSTANCE hinst, LPSTR lpszCmdLine,
int nCmdShow)
20656 int argc, needcon = 0;
20658 extern int sqlite3_main(
int,
char **);
20659 static const char *name =
"SQLite3 Shell";
20660 DWORD ftype0, ftype1, ftype2;
20662 ftype0 = GetFileType(GetStdHandle(STD_INPUT_HANDLE));
20663 ftype1 = GetFileType(GetStdHandle(STD_OUTPUT_HANDLE));
20664 ftype2 = GetFileType(GetStdHandle(STD_ERROR_HANDLE));
20665 if (ftype0 != FILE_TYPE_DISK && ftype0 != FILE_TYPE_CHAR &&
20666 ftype0 != FILE_TYPE_PIPE) {
20669 ftype0 = FILE_TYPE_UNKNOWN;
20671 if (ftype1 != FILE_TYPE_DISK && ftype1 != FILE_TYPE_CHAR &&
20672 ftype1 != FILE_TYPE_PIPE) {
20675 ftype1 = FILE_TYPE_UNKNOWN;
20677 if (ftype2 != FILE_TYPE_DISK && ftype2 != FILE_TYPE_CHAR &&
20678 ftype2 != FILE_TYPE_PIPE) {
20681 ftype2 = FILE_TYPE_UNKNOWN;
20685 SetConsoleTitle(name);
20687 if (ftype0 == FILE_TYPE_UNKNOWN) {
20688 freopen(
"CONIN$",
"r", stdin);
20690 if (ftype1 == FILE_TYPE_UNKNOWN) {
20691 freopen(
"CONOUT$",
"w", stdout);
20693 if (ftype2 == FILE_TYPE_UNKNOWN) {
20694 freopen(
"CONOUT$",
"w", stderr);
20696 setargv(&argc, &argv, lpszCmdLine, (
char *) name);
20697#if defined(ENABLE_NVFS) && (ENABLE_NVFS)
20700 sqlite3_main(argc, argv);
20707#if defined(HAVE_ODBCINSTEXT_H) && (HAVE_ODBCINSTEXT_H)
20714#include <odbcinstext.h>
20717ODBCINSTGetProperties(HODBCINSTPROPERTY prop)
20719 static const char *instYN[] = {
"No",
"Yes", NULL };
20720 static const char *syncPragma[] = {
"NORMAL",
"OFF",
"FULL", NULL };
20721 static const char *jmPragma[] = {
20722 "DELETE",
"PERSIST",
"OFF",
"TRUNCATE",
"MEMORY",
"WAL", NULL
20725 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20726 prop = prop->pNext;
20727 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20728 prop->nPromptType = ODBCINST_PROMPTTYPE_FILENAME;
20729 strncpy(prop->szName,
"Database", INI_MAX_PROPERTY_NAME);
20730 strncpy(prop->szValue,
"", INI_MAX_PROPERTY_VALUE);
20731 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20732 prop = prop->pNext;
20733 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20734 prop->nPromptType = ODBCINST_PROMPTTYPE_TEXTEDIT;
20735 strncpy(prop->szName,
"Timeout", INI_MAX_PROPERTY_NAME);
20736 strncpy(prop->szValue,
"100000", INI_MAX_PROPERTY_VALUE);
20737 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20738 prop = prop->pNext;
20739 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20740 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20741 prop->aPromptData = malloc(
sizeof (instYN));
20742 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20743 strncpy(prop->szName,
"StepAPI", INI_MAX_PROPERTY_NAME);
20744 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20745 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20746 prop = prop->pNext;
20747 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20748 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20749 prop->aPromptData = malloc(
sizeof (instYN));
20750 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20751 strncpy(prop->szName,
"ShortNames", INI_MAX_PROPERTY_NAME);
20752 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20753 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20754 prop = prop->pNext;
20755 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20756 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20757 prop->aPromptData = malloc(
sizeof (instYN));
20758 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20759 strncpy(prop->szName,
"LongNames", INI_MAX_PROPERTY_NAME);
20760 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20761 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20762 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20763 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20764 prop->aPromptData = malloc(
sizeof (instYN));
20765 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20766 strncpy(prop->szName,
"NoCreat", INI_MAX_PROPERTY_NAME);
20767 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20769 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20770 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20771 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20772 prop->aPromptData = malloc(
sizeof (instYN));
20773 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20774 strncpy(prop->szName,
"NoWCHAR", INI_MAX_PROPERTY_NAME);
20775 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20777 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20778 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20779 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20780 prop->aPromptData = malloc(
sizeof (instYN));
20781 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20782 strncpy(prop->szName,
"FKSupport", INI_MAX_PROPERTY_NAME);
20783 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20784 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20785 prop = prop->pNext;
20786 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20787 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20788 prop->aPromptData = malloc(
sizeof (syncPragma));
20789 memcpy(prop->aPromptData, syncPragma, sizeof (syncPragma));
20790 strncpy(prop->szName,
"SyncPragma", INI_MAX_PROPERTY_NAME);
20791 strncpy(prop->szValue,
"NORMAL", INI_MAX_PROPERTY_VALUE);
20792 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20793 prop = prop->pNext;
20794 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20795 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20796 prop->aPromptData = malloc(
sizeof (jmPragma));
20797 memcpy(prop->aPromptData, jmPragma, sizeof (jmPragma));
20798 strncpy(prop->szName,
"JournalMode", INI_MAX_PROPERTY_NAME);
20799 strncpy(prop->szValue,
"DELETE", INI_MAX_PROPERTY_VALUE);
20800 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20801 prop = prop->pNext;
20802 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20803 prop->nPromptType = ODBCINST_PROMPTTYPE_TEXTEDIT;
20804 strncpy(prop->szName,
"LoadExt", INI_MAX_PROPERTY_NAME);
20805 strncpy(prop->szValue,
"", INI_MAX_PROPERTY_VALUE);
20806 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20807 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20808 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20809 prop->aPromptData = malloc(
sizeof (instYN));
20810 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20811 strncpy(prop->szName,
"BigInt", INI_MAX_PROPERTY_NAME);
20812 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20818#ifdef SQLITE_DYNLOAD
20832 return SQLITE_ERROR;
20868 return SQLITE_NULL;
20871#define DLS_ENT(name, func) \
20872 { "sqlite3_" #name, offsetof(struct dl_sqlite3_funcs, name), \
20875#define DLS_ENT3(name, off, func) \
20876 { "sqlite3_" #name, offsetof(struct dl_sqlite3_funcs, off), \
20879#define DLS_END { NULL, 0, NULL }
20886 DLS_ENT(activate_see, dls_void),
20887 DLS_ENT(bind_blob, dls_error),
20888 DLS_ENT(bind_double, dls_error),
20889 DLS_ENT(bind_int, dls_error),
20890 DLS_ENT(bind_int64, dls_error),
20891 DLS_ENT(bind_null, dls_error),
20892 DLS_ENT(bind_parameter_count, dls_0),
20893 DLS_ENT(bind_text, dls_error),
20895 DLS_ENT(changes, dls_0),
20896 DLS_ENT(close, dls_error),
20897 DLS_ENT(column_blob, dls_null),
20898 DLS_ENT(column_bytes, dls_0),
20899 DLS_ENT(column_count, dls_0),
20900 DLS_ENT(column_database_name, dls_empty),
20901 DLS_ENT(column_decltype, dls_empty),
20902 DLS_ENT(column_double, dls_00),
20903 DLS_ENT(column_name, dls_empty),
20904 DLS_ENT(column_origin_name, dls_null),
20905 DLS_ENT(column_table_name, dls_null),
20906 DLS_ENT(column_text, dls_null),
20907 DLS_ENT(column_type, dls_snull),
20908 DLS_ENT(create_function, dls_error),
20909 DLS_ENT(enable_load_extension, dls_error),
20910 DLS_ENT(errcode, dls_error),
20911 DLS_ENT(errmsg, dls_empty),
20912 DLS_ENT(exec, dls_error),
20913 DLS_ENT(finalize, dls_error),
20914 DLS_ENT(free, free),
20915 DLS_ENT(free_table, dls_void),
20916 DLS_ENT(get_table, dls_error),
20917 DLS_ENT(interrupt, dls_void),
20918 DLS_ENT(key, dls_error),
20919 DLS_ENT(last_insert_rowid, dls_0LL),
20920 DLS_ENT(libversion, dls_empty),
20921 DLS_ENT(load_extension, dls_error),
20922 DLS_ENT(malloc, malloc),
20923 DLS_ENT(mprintf, dls_null),
20924 DLS_ENT(open, dls_error),
20925 DLS_ENT(open16, dls_error),
20926 DLS_ENT(open_v2, dls_error),
20927 DLS_ENT(prepare, dls_error),
20928 DLS_ENT(prepare_v2, dls_error),
20929 DLS_ENT(profile, dls_null),
20930 DLS_ENT(realloc, realloc),
20931 DLS_ENT(rekey, dls_error),
20932 DLS_ENT(reset, dls_error),
20933 DLS_ENT(result_blob, dls_void),
20934 DLS_ENT(result_error, dls_void),
20935 DLS_ENT(result_int, dls_void),
20936 DLS_ENT(result_null, dls_void),
20937 DLS_ENT(step, dls_error),
20938#if defined(_WIN32) || defined(_WIN64)
20939 DLS_ENT3(strnicmp, xstrnicmp, _strnicmp),
20941 DLS_ENT3(strnicmp, xstrnicmp, strncasecmp),
20943 DLS_ENT(table_column_metadata, dls_error),
20944 DLS_ENT(trace, dls_null),
20945 DLS_ENT(user_data, dls_null),
20946 DLS_ENT(value_blob, dls_null),
20947 DLS_ENT(value_bytes, dls_0),
20948 DLS_ENT(value_text, dls_empty),
20949 DLS_ENT(value_type, dls_snull),
20953#if defined(_WIN32) || defined(_WIN64)
20955static HMODULE sqlite3_dll = 0;
20961 static const char *dll_names[] = {
20962 "System.Data.SQLite.dll",
20968 while (dll_names[i]) {
20969 sqlite3_dll = LoadLibrary(dll_names[i]);
20976 while (dls_nametab[i].name) {
20977 void *func = 0, **loc;
20980 func = (
void *) GetProcAddress(sqlite3_dll, dls_nametab[i].name);
20983 func = dls_nametab[i].func;
20985 loc = (
void **) ((
char *) &dls_funcs + dls_nametab[i].offset);
20989 if (!sqlite3_dll) {
20990 char buf[MAXPATHLEN], msg[MAXPATHLEN];
20992 LoadString(hModule, IDS_DRVTITLE, buf,
sizeof (buf));
20993 LoadString(hModule, IDS_DLLERR, msg,
sizeof (msg));
20994 MessageBox(NULL, msg, buf,
20995 MB_ICONEXCLAMATION | MB_OK | MB_TASKMODAL |
21004 FreeLibrary(sqlite3_dll);
21013static void *libsqlite3_so = 0;
21020 libsqlite3_so = dlopen(
"libsqlite3.so.0", RTLD_NOW | RTLD_GLOBAL);
21022 while (dls_nametab[i].name) {
21023 void *func = 0, **loc;
21025 if (libsqlite3_so) {
21026 func = dlsym(libsqlite3_so, dls_nametab[i].name);
21029 func = dls_nametab[i].func;
21031 loc = (
void **) ((
char *) &dls_funcs + dls_nametab[i].offset);
21035 if (!libsqlite3_so) {
21036 const char errmsg[] =
"SQLite3 shared library not found.\n";
21038 write(2, errmsg,
sizeof (errmsg) - 1);
21045 if (libsqlite3_so) {
21046 dlclose(libsqlite3_so);
static BOOL InUn(int remove, char *drivername, char *dllname, char *dll2name, char *dsname)
Driver installer/uninstaller.
static int getmdays(int year, int month)
Return number of month days.
static COL procColSpec3[]
static SQLRETURN drvgetstmtattr(SQLHSTMT stmt, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER bufmax, SQLINTEGER *buflen)
Internal get option of HSTMT.
SQLRETURN SQL_API SQLCloseCursor(SQLHSTMT stmt)
Close open cursor.
SQLRETURN SQL_API SQLFreeConnect(SQLHDBC dbc)
Free connection (HDBC).
static SQLRETURN drvfreeenv(SQLHENV env)
Internal free HENV.
SQLRETURN SQL_API SQLSetPos(SQLHSTMT stmt, SQLSETPOSIROW row, SQLUSMALLINT op, SQLUSMALLINT lock)
Set position on result in HSTMT.
SQLRETURN SQL_API SQLSpecialColumnsW(SQLHSTMT stmt, SQLUSMALLINT id, SQLWCHAR *cat, SQLSMALLINT catLen, SQLWCHAR *schema, SQLSMALLINT schemaLen, SQLWCHAR *table, SQLSMALLINT tableLen, SQLUSMALLINT scope, SQLUSMALLINT nullable)
Retrieve information about indexed columns (UNICODE version).
static SQLRETURN drvprimarykeys(SQLHSTMT stmt, SQLCHAR *cat, SQLSMALLINT catLen, SQLCHAR *schema, SQLSMALLINT schemaLen, SQLCHAR *table, SQLSMALLINT tableLen)
Internal retrieve information about indexed columns.
static SQLRETURN nomem(STMT *s)
Report S1000 (out of memory) SQL error given STMT.
SQLRETURN SQL_API SQLSetStmtAttrW(SQLHSTMT stmt, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER buflen)
Set option on HSTMT (UNICODE version).
static SQLRETURN setupparbuf(STMT *s, BINDPARM *p)
Setup parameter buffer for deferred parameter.
SQLRETURN SQL_API SQLGetEnvAttr(SQLHENV env, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER len, SQLINTEGER *lenp)
Get information of HENV.
SQLRETURN SQL_API SQLSetStmtOptionW(SQLHSTMT stmt, SQLUSMALLINT opt, SETSTMTOPTION_LAST_ARG_TYPE param)
Set option on HSTMT (UNICODE version).
static SQLRETURN setposbind(STMT *s, sqlite3_stmt *stmt, int i, int si, int rsi)
Internal handler to setup parameters for positional updates from bound user buffers.
#define SETSTMTOPTION_LAST_ARG_TYPE
static SQLWCHAR * uc_strncpy(SQLWCHAR *dest, SQLWCHAR *src, int len)
Copy UNICODE string like strncpy().
static void dbtrace(void *arg, const char *msg, sqlite_uint64 et)
SQLite trace or profile callback.
SQLRETURN SQL_API SQLSetDescRec(SQLHDESC handle, SQLSMALLINT recno, SQLSMALLINT type, SQLSMALLINT subtype, SQLLEN len, SQLSMALLINT prec, SQLSMALLINT scale, SQLPOINTER data, SQLLEN *strlen, SQLLEN *indicator)
Function not implemented.
static SQLRETURN drvendtran(SQLSMALLINT type, SQLHANDLE handle, SQLSMALLINT comptype)
Internal commit or rollback transaction.
static void freeresult(STMT *s, int clrcols)
Free statement's result.
SQLRETURN SQL_API SQLConnectW(SQLHDBC dbc, SQLWCHAR *dsn, SQLSMALLINT dsnLen, SQLWCHAR *uid, SQLSMALLINT uidLen, SQLWCHAR *pwd, SQLSMALLINT pwdLen)
Connect to SQLite database.
static void getmd(const char *typename, int sqltype, int *mp, int *dp)
Get maximum display size and number of digits after decimal point from field type specification.
static SQLRETURN drvdriverconnect(SQLHDBC dbc, SQLHWND hwnd, SQLCHAR *connIn, SQLSMALLINT connInLen, SQLCHAR *connOut, SQLSMALLINT connOutMax, SQLSMALLINT *connOutLen, SQLUSMALLINT drvcompl)
Internal standalone (w/o driver manager) database connect.
static char * s3stmt_coltype(sqlite3_stmt *s3stmt, int col, DBC *d, int *guessed_types)
Find out column type.
static const char digit_chars[]
SQLRETURN SQL_API SQLGetStmtOption(SQLHSTMT stmt, SQLUSMALLINT opt, SQLPOINTER param)
Get option of HSTMT.
SQLRETURN SQL_API SQLGetConnectAttrW(SQLHDBC dbc, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER bufmax, SQLINTEGER *buflen)
Get connect attribute of HDBC (UNICODE version).
SQLRETURN SQL_API SQLAllocConnect(SQLHENV env, SQLHDBC *dbc)
Allocate HDBC.
static SQLRETURN drvspecialcolumns(SQLHSTMT stmt, SQLUSMALLINT id, SQLCHAR *cat, SQLSMALLINT catLen, SQLCHAR *schema, SQLSMALLINT schemaLen, SQLCHAR *table, SQLSMALLINT tableLen, SQLUSMALLINT scope, SQLUSMALLINT nullable)
Internal retrieve information about indexed columns.
static SQLRETURN drvgetinfo(SQLHDBC dbc, SQLUSMALLINT type, SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen)
Internal return information about what this ODBC driver supports.
static SQLRETURN mkbindcols(STMT *s, int ncols)
Reallocate space for bound columns.
static void freedyncols(STMT *s)
Free dynamically allocated column descriptions of STMT.
static SQLRETURN setupparam(STMT *s, char *sql, int pnum)
Setup SQLite3 parameter for statement parameter.
SQLRETURN SQL_API SQLGetDescFieldW(SQLHDESC handle, SQLSMALLINT recno, SQLSMALLINT fieldid, SQLPOINTER value, SQLINTEGER buflen, SQLINTEGER *strlen)
Function not implemented.
static void convJD2HMS(double jd, TIME_STRUCT *ts, int *fp)
Convert julian day to hour/minute/second.
SQLRETURN SQL_API SQLProceduresW(SQLHSTMT stmt, SQLWCHAR *catalog, SQLSMALLINT catalogLen, SQLWCHAR *schema, SQLSMALLINT schemaLen, SQLWCHAR *proc, SQLSMALLINT procLen)
Retrieve information about stored procedures (UNICODE version).
static void mktypeinfo(STMT *s, int row, int asize, char *typename, int type, int tind)
Internal function to build up data type information as row in result set.
SQLRETURN SQL_API SQLDescribeParam(SQLHSTMT stmt, SQLUSMALLINT pnum, SQLSMALLINT *dtype, SQLULEN *size, SQLSMALLINT *decdigits, SQLSMALLINT *nullable)
Return information about parameter.
static SQLRETURN drvgetconnectoption(SQLHDBC dbc, SQLUSMALLINT opt, SQLPOINTER param)
Internal get connect option of HDBC.
static int namematch(char *str, char *pat, int esc)
SQL LIKE string match with optional backslash escape handling.
static SQLRETURN mkresultset(HSTMT stmt, COL *colspec, int ncols, COL *colspec3, int ncols3, int *nret)
Setup empty result set from constant column specification.
SQLRETURN SQL_API SQLTablesW(SQLHSTMT stmt, SQLWCHAR *cat, SQLSMALLINT catLen, SQLWCHAR *schema, SQLSMALLINT schemaLen, SQLWCHAR *table, SQLSMALLINT tableLen, SQLWCHAR *type, SQLSMALLINT typeLen)
Retrieve information on tables and/or views.
SQLRETURN SQL_API SQLTransact(SQLHENV env, SQLHDBC dbc, SQLUSMALLINT type)
Commit or rollback transaction.
SQLRETURN SQL_API SQLNumParams(SQLHSTMT stmt, SQLSMALLINT *nparam)
Return number of parameters.
static const char * xdigits
static COL scolSpec2[]
Columns for result set of SQLSpecialColumns().
SQLRETURN SQL_API SQLGetTypeInfoW(SQLHSTMT stmt, SQLSMALLINT sqltype)
Return data type information (UNICODE version).
static int drvgettable(STMT *s, const char *sql, char ***resp, int *nrowp, int *ncolp, char **errp, int nparam, BINDPARM *p)
static int TOLOWER(int c)
SQLRETURN SQL_API SQLGetDiagFieldW(SQLSMALLINT htype, SQLHANDLE handle, SQLSMALLINT recno, SQLSMALLINT id, SQLPOINTER info, SQLSMALLINT buflen, SQLSMALLINT *stringlen)
Get error record given handle (HDBC or HSTMT).
SQLRETURN SQL_API SQLSetConnectAttrW(SQLHDBC dbc, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER len)
Set connect attribute of HDBC (UNICODE version).
static void s3bind(DBC *d, sqlite3_stmt *stmt, int nparams, BINDPARM *p)
static SQLRETURN drvunimpldbc(HDBC dbc)
Report IM001 (not implemented) SQL error code for HDBC.
static COL procColSpec2[]
Columns for result set of SQLProcedureColumns().
static SQLRETURN drvsetstmtoption(SQLHSTMT stmt, SQLUSMALLINT opt, SQLUINTEGER param)
Internal set option on HSTMT.
static SQLRETURN drvgetdiagfield(SQLSMALLINT htype, SQLHANDLE handle, SQLSMALLINT recno, SQLSMALLINT id, SQLPOINTER info, SQLSMALLINT buflen, SQLSMALLINT *stringlen)
Get error record given handle (HDBC or HSTMT).
static SQLRETURN drvfreeconnect(SQLHDBC dbc)
Internal free connection (HDBC).
static SQLRETURN drvallocconnect(SQLHENV env, SQLHDBC *dbc)
Internal allocate HDBC.
static void fixupdyncols(STMT *s, DBC *d)
Fixup column information for a running statement.
static SQLRETURN getrowdata(STMT *s, SQLUSMALLINT col, SQLSMALLINT otype, SQLPOINTER val, SQLINTEGER len, SQLLEN *lenp, int partial)
Internal function to retrieve row data, used by SQLFetch() and friends and SQLGetData().
SQLRETURN SQL_API SQLAllocStmt(SQLHDBC dbc, SQLHSTMT *stmt)
Allocate HSTMT given HDBC.
static void uc_free(void *str)
Free converted UTF8 or UNICODE string.
static SQLWCHAR * uc_from_utf(unsigned char *str, int len)
Make UNICODE string from UTF8 string.
SQLRETURN SQL_API SQLGetFunctions(SQLHDBC dbc, SQLUSMALLINT func, SQLUSMALLINT *flags)
Return information about supported ODBC API functions.
SQLRETURN SQL_API SQLNativeSqlW(SQLHSTMT stmt, SQLWCHAR *sqlin, SQLINTEGER sqlinLen, SQLWCHAR *sql, SQLINTEGER sqlMax, SQLINTEGER *sqlLen)
Translate SQL string (UNICODE version).
static SQLRETURN drvtables(SQLHSTMT stmt, SQLCHAR *cat, SQLSMALLINT catLen, SQLCHAR *schema, SQLSMALLINT schemaLen, SQLCHAR *table, SQLSMALLINT tableLen, SQLCHAR *type, SQLSMALLINT typeLen)
Retrieve information on tables and/or views.
#define COLATTRIBUTE_LAST_ARG_TYPE
SQLRETURN SQL_API SQLSetStmtOption(SQLHSTMT stmt, SQLUSMALLINT opt, SETSTMTOPTION_LAST_ARG_TYPE param)
Set option on HSTMT.
static int str2timestamp(int jdconv, char *str, TIMESTAMP_STRUCT *tss)
Convert string to ODBC TIMESTAMP_STRUCT.
SQLRETURN SQL_API SQLFreeHandle(SQLSMALLINT type, SQLHANDLE h)
Free a HENV, HDBC, or HSTMT handle.
static int setsqliteopts(sqlite3 *x, DBC *d)
Set SQLite options (PRAGMAs) given SQLite handle.
SQLRETURN SQL_API SQLNumResultCols(SQLHSTMT stmt, SQLSMALLINT *ncols)
Return number of columns of result set given HSTMT.
SQLRETURN SQL_API SQLGetStmtAttrW(SQLHSTMT stmt, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER bufmax, SQLINTEGER *buflen)
Get option of HSTMT (UNICODE version).
static SQLRETURN drvgetcursorname(SQLHSTMT stmt, SQLCHAR *cursor, SQLSMALLINT buflen, SQLSMALLINT *lenp)
Internal function to get cursor name of STMT.
static SQLRETURN drvgetstmtoption(SQLHSTMT stmt, SQLUSMALLINT opt, SQLPOINTER param)
Internal get option of HSTMT.
static SQLRETURN drvstatistics(SQLHSTMT stmt, SQLCHAR *cat, SQLSMALLINT catLen, SQLCHAR *schema, SQLSMALLINT schemaLen, SQLCHAR *table, SQLSMALLINT tableLen, SQLUSMALLINT itype, SQLUSMALLINT resv)
Internal return statistic information on table indices.
SQLRETURN SQL_API SQLGetData(SQLHSTMT stmt, SQLUSMALLINT col, SQLSMALLINT type, SQLPOINTER val, SQLLEN len, SQLLEN *lenp)
Retrieve row data after fetch.
static SQLRETURN s3stmt_start(STMT *s)
Start sqlite statement for execution of SELECT statement.
static char * strdup_(const char *str)
Duplicate string using xmalloc().
static SQLRETURN setposibind(STMT *s, sqlite3_stmt *stmt, int i, int si, int rsi)
Internal handler to setup parameters for positional updates from driver side result set.
static void uc_from_utf_buf(unsigned char *str, int len, SQLWCHAR *uc, int ucLen)
Make UNICODE string from UTF8 string into buffer.
static COL colSpec2[]
Columns for result set of SQLColumns().
static void dbattas(DBC *d, char *attas)
Perform ATTACH commands to same database file.
static SQLRETURN noconn(STMT *s)
Report S1000 (not connected) SQL error given STMT.
static int drvgettable_row(TBLRES *t, int ncol, int rc)
SQLRETURN SQL_API SQLTablePrivilegesW(SQLHSTMT stmt, SQLWCHAR *catalog, SQLSMALLINT catalogLen, SQLWCHAR *schema, SQLSMALLINT schemaLen, SQLWCHAR *table, SQLSMALLINT tableLen)
Retrieve privileges on tables and/or views (UNICODE version).
static SQLRETURN drvsetconnectoption(SQLHDBC dbc, SQLUSMALLINT opt, SQLUINTEGER param)
Internal set option on HDBC.
static SQLRETURN freeparams(STMT *s)
Clear out parameter bindings, if any.
SQLRETURN SQL_API SQLSetScrollOptions(SQLHSTMT stmt, SQLUSMALLINT concur, SQLLEN rowkeyset, SQLUSMALLINT rowset)
Function not implemented.
static SQLRETURN endtran(DBC *d, SQLSMALLINT comptype, int force)
Internal commit or rollback transaction.
static SQLRETURN drvallocenv(SQLHENV *env)
Internal allocate HENV.
SQLRETURN SQL_API SQLAllocHandle(SQLSMALLINT type, SQLHANDLE input, SQLHANDLE *output)
Allocate a HENV, HDBC, or HSTMT handle.
static COL statSpec2[]
Columns for result set of SQLStatistics().
static int unescpat(char *str)
Unescape search pattern for e.g.
static SQLRETURN drvconnect(SQLHDBC dbc, SQLCHAR *dsn, SQLSMALLINT dsnLen, char *pwd, int pwdLen, int isu)
Internal connect to SQLite database.
SQLRETURN SQL_API SQLCopyDesc(SQLHDESC source, SQLHDESC target)
Function not implemented.
SQLRETURN SQL_API SQLSetParam(SQLHSTMT stmt, SQLUSMALLINT par, SQLSMALLINT type, SQLSMALLINT sqltype, SQLULEN coldef, SQLSMALLINT scale, SQLPOINTER val, SQLLEN *nval)
Set information on parameter.
static SQLRETURN drvgetconnectattr(SQLHDBC dbc, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER bufmax, SQLINTEGER *buflen)
Internal get connect attribute of HDBC.
static COL colPrivSpec3[]
SQLRETURN SQL_API SQLDriversW(SQLHENV env, SQLUSMALLINT dir, SQLWCHAR *drvdesc, SQLSMALLINT descmax, SQLSMALLINT *desclenp, SQLWCHAR *drvattr, SQLSMALLINT attrmax, SQLSMALLINT *attrlenp)
Function not implemented.
SQLRETURN SQL_API SQLDescribeColW(SQLHSTMT stmt, SQLUSMALLINT col, SQLWCHAR *name, SQLSMALLINT nameMax, SQLSMALLINT *nameLen, SQLSMALLINT *type, SQLULEN *size, SQLSMALLINT *digits, SQLSMALLINT *nullable)
Describe column information (UNICODE version).
static SQLRETURN drvbindcol(SQLHSTMT stmt, SQLUSMALLINT col, SQLSMALLINT type, SQLPOINTER val, SQLLEN max, SQLLEN *lenp)
Internal bind C variable to column of result set.
static SQLRETURN drvsetstmtattr(SQLHSTMT stmt, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER buflen)
Internal set option on HSTMT.
SQLRETURN SQL_API SQLFreeStmt(SQLHSTMT stmt, SQLUSMALLINT opt)
Free HSTMT.
static const char upper_chars[]
static SQLRETURN drvgettypeinfo(SQLHSTMT stmt, SQLSMALLINT sqltype)
Internal return data type information.
SQLRETURN SQL_API SQLFetchScroll(SQLHSTMT stmt, SQLSMALLINT orient, SQLLEN offset)
Fetch result row with scrolling.
SQLRETURN SQL_API SQLParamData(SQLHSTMT stmt, SQLPOINTER *pind)
Retrieve next parameter for sending data to executing query.
SQLRETURN SQL_API SQLPutData(SQLHSTMT stmt, SQLPOINTER data, SQLLEN len)
Put (partial) parameter data into executing statement.
static const char lower_chars[]
SQLRETURN SQL_API SQLGetStmtOptionW(SQLHSTMT stmt, SQLUSMALLINT opt, SQLPOINTER param)
Get option of HSTMT (UNICODE version).
static int getdsnattr(char *dsn, char *attr, char *out, int outLen)
Handling of SQLConnect() connection attributes for standalone operation without driver manager.
static COL tableSpec2[]
Columns for result set of SQLTables().
SQLRETURN SQL_API SQLExtendedFetch(SQLHSTMT stmt, SQLUSMALLINT orient, SQLROWOFFSET offset, SQLROWSETSIZE *rowcount, SQLUSMALLINT *rowstatus)
Fetch result row with scrolling and row status.
static void dbtraceapi(DBC *d, char *fn, const char *sql)
Trace function for SQLite API calls.
SQLRETURN SQL_API SQLBrowseConnectW(SQLHDBC dbc, SQLWCHAR *connin, SQLSMALLINT conninLen, SQLWCHAR *connout, SQLSMALLINT connoutMax, SQLSMALLINT *connoutLen)
Function not implemented.
SQLRETURN SQL_API SQLForeignKeysW(SQLHSTMT stmt, SQLWCHAR *PKcatalog, SQLSMALLINT PKcatalogLen, SQLWCHAR *PKschema, SQLSMALLINT PKschemaLen, SQLWCHAR *PKtable, SQLSMALLINT PKtableLen, SQLWCHAR *FKcatalog, SQLSMALLINT FKcatalogLen, SQLWCHAR *FKschema, SQLSMALLINT FKschemaLen, SQLWCHAR *FKtable, SQLSMALLINT FKtableLen)
Retrieve information about primary/foreign keys (UNICODE version).
static int s3stmt_step(STMT *s)
Do one sqlite statement step gathering one result row.
static int dserr(dstr *dsp)
Check error on dynamic string.
static SQLRETURN drvfreestmt(SQLHSTMT stmt, SQLUSMALLINT opt)
Internal function to perform certain kinds of free/close on STMT.
static SQLRETURN drvdescribecol(SQLHSTMT stmt, SQLUSMALLINT col, SQLCHAR *name, SQLSMALLINT nameMax, SQLSMALLINT *nameLen, SQLSMALLINT *type, SQLULEN *size, SQLSMALLINT *digits, SQLSMALLINT *nullable)
Internal describe column information.
static double ln_strtod(const char *data, char **endp)
Internal locale neutral strtod function.
static void s3stmt_drop(STMT *s)
Drop running sqlite statement in STMT.
static char * uc_to_utf_c(SQLWCHAR *str, int len)
Make UTF8 string from UNICODE string.
SQLRETURN SQL_API SQLGetCursorNameW(SQLHSTMT stmt, SQLWCHAR *cursor, SQLSMALLINT buflen, SQLSMALLINT *lenp)
Get cursor name of STMT (UNICODE version).
static const char * dsval(dstr *dsp)
Return dynamic string's value.
SQLRETURN SQL_API SQLEndTran(SQLSMALLINT type, SQLHANDLE handle, SQLSMALLINT comptype)
Commit or rollback transaction.
static char * unquote(char *str)
Strip quotes from quoted string in-place.
#define strmak(dst, src, max, lenp)
static int uc_strlen(SQLWCHAR *str)
Return length of UNICODE string.
SQLRETURN SQL_API SQLSetCursorNameW(SQLHSTMT stmt, SQLWCHAR *cursor, SQLSMALLINT len)
Set cursor name on STMT (UNICODE version).
SQLRETURN SQL_API SQLGetDiagRecW(SQLSMALLINT htype, SQLHANDLE handle, SQLSMALLINT recno, SQLWCHAR *sqlstate, SQLINTEGER *nativeerr, SQLWCHAR *msg, SQLSMALLINT buflen, SQLSMALLINT *msglen)
Get error message given handle (HENV, HDBC, or HSTMT) (UNICODE version).
static void dsfree(dstr *dsp)
Free dynamic string.
SQLRETURN SQL_API SQLBindParam(SQLHSTMT stmt, SQLUSMALLINT pnum, SQLSMALLINT vtype, SQLSMALLINT ptype, SQLULEN lenprec, SQLSMALLINT scale, SQLPOINTER val, SQLLEN *lenp)
Bind parameter on HSTMT.
static void setstat(STMT *s, int naterr, char *msg, char *st,...)
Set error message and SQL state on statement.
static SQLRETURN drvallocstmt(SQLHDBC dbc, SQLHSTMT *stmt)
Allocate HSTMT given HDBC (driver internal version).
static SQLRETURN drvsetconnectattr(SQLHDBC dbc, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER len)
Internal set connect attribute of HDBC.
static int mapsqltype(const char *typename, int *nosign, int ov3, int nowchar, int dobigint)
Map SQL field type from string to ODBC integer type code.
static SQLRETURN drvputdata(SQLHSTMT stmt, SQLPOINTER data, SQLLEN len)
Internal put (partial) parameter data into executing statement.
SQLRETURN SQL_API SQLGetConnectOptionW(SQLHDBC dbc, SQLUSMALLINT opt, SQLPOINTER param)
Get connect option of HDBC (UNICODE version).
static void replilike(char *sql)
Replace ILIKE with LIKE in-place given query string.
static SQLRETURN dofetchbind(STMT *s, int rsi)
Internal: fetch and bind from statement's current row.
static SQLRETURN drvsetcursorname(SQLHSTMT stmt, SQLCHAR *cursor, SQLSMALLINT len)
Internal function to set cursor name on STMT.
SQLRETURN SQL_API SQLParamOptions(SQLHSTMT stmt, SQLULEN rows, SQLULEN *rowp)
Function not implemented.
SQLRETURN SQL_API SQLColumnPrivilegesW(SQLHSTMT stmt, SQLWCHAR *catalog, SQLSMALLINT catalogLen, SQLWCHAR *schema, SQLSMALLINT schemaLen, SQLWCHAR *table, SQLSMALLINT tableLen, SQLWCHAR *column, SQLSMALLINT columnLen)
Retrieve privileges on columns (UNICODE version).
static SQLRETURN setupdyncols(STMT *s, sqlite3_stmt *s3stmt, int *ncolsp)
SQLRETURN SQL_API SQLFetch(SQLHSTMT stmt)
Fetch next result row.
SQLRETURN SQL_API SQLCancel(SQLHSTMT stmt)
Cancel HSTMT closing cursor.
static COL pkeySpec2[]
Columns for result set of SQLPrimaryKeys().
static SQLRETURN drvbindparam(SQLHSTMT stmt, SQLUSMALLINT pnum, SQLSMALLINT iotype, SQLSMALLINT buftype, SQLSMALLINT ptype, SQLUINTEGER coldef, SQLSMALLINT scale, SQLPOINTER data, SQLINTEGER buflen, SQLLEN *len)
Internal bind parameter on HSTMT.
static void dbloadext(DBC *d, char *exts)
Load SQLite extension modules, if any.
static void blob_import(sqlite3_context *ctx, int nargs, sqlite3_value **args)
SQLite function to import a BLOB from a file.
SQLRETURN SQL_API SQLBulkOperations(SQLHSTMT stmt, SQLSMALLINT oper)
Perform bulk operation on HSTMT.
static int str2time(int jdconv, char *str, TIME_STRUCT *ts)
Convert string to ODBC TIME_STRUCT.
static int getbool(char *string)
Get boolean flag from string.
static dstr * dsappendq(dstr *dsp, const char *str)
Append a string double quoted to dynamic string.
SQLRETURN SQL_API SQLSetEnvAttr(SQLHENV env, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER len)
Set information in HENV.
static int typeinfosort(const void *a, const void *b)
Helper function to sort type information.
static SQLRETURN chkunbound(STMT *s)
Check for unbound result columns.
static int mapdeftype(int type, int stype, int nosign, int nowchar)
Map SQL_C_DEFAULT to proper C type.
static void freep(void *x)
Free memory given pointer to memory pointer.
static void blob_export(sqlite3_context *ctx, int nargs, sqlite3_value **args)
SQLite function to export a BLOB to a file.
SQLRETURN SQL_API SQLFreeEnv(SQLHENV env)
Free HENV.
static int busy_handler(void *udata, int count)
Busy callback for SQLite.
SQLRETURN SQL_API SQLSetDescFieldW(SQLHDESC handle, SQLSMALLINT recno, SQLSMALLINT fieldid, SQLPOINTER value, SQLINTEGER buflen)
Function not implemented.
#define HDBC_UNLOCK(hdbc)
static SQLRETURN starttran(STMT *s)
Start transaction when autocommit off.
#define verinfo(maj, min, lev)
static SQLRETURN setposrefr(STMT *s, int rsi)
Internal handler to refresh user buffers from driver side result set.
SQLRETURN SQL_API SQLGetDescRecW(SQLHDESC handle, SQLSMALLINT recno, SQLWCHAR *name, SQLSMALLINT buflen, SQLSMALLINT *strlen, SQLSMALLINT *type, SQLSMALLINT *subtype, SQLLEN *len, SQLSMALLINT *prec, SQLSMALLINT *scale, SQLSMALLINT *nullable)
Function not implemented.
SQLRETURN SQL_API SQLAllocEnv(SQLHENV *env)
Allocate HENV.
static void freerows(char **rowp)
Free counted array of char pointers.
static COL tablePrivSpec3[]
static SQLRETURN drvexecute(SQLHSTMT stmt, int initial)
static SQLRETURN SQL_API drvforeignkeys(SQLHSTMT stmt, SQLCHAR *PKcatalog, SQLSMALLINT PKcatalogLen, SQLCHAR *PKschema, SQLSMALLINT PKschemaLen, SQLCHAR *PKtable, SQLSMALLINT PKtableLen, SQLCHAR *FKcatalog, SQLSMALLINT FKcatalogLen, SQLCHAR *FKschema, SQLSMALLINT FKschemaLen, SQLCHAR *FKtable, SQLSMALLINT FKtableLen)
Internal retrieve information about primary/foreign keys.
static void s3stmt_end_if(STMT *s)
Conditionally stop running sqlite statement.
static SQLRETURN drvcolattributes(SQLHSTMT stmt, SQLUSMALLINT col, SQLUSMALLINT id, SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen, SQLLEN *val2)
Internal retrieve column attributes.
SQLRETURN SQL_API SQLGetInfoW(SQLHDBC dbc, SQLUSMALLINT type, SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen)
Return information about what this ODBC driver supports.
SQLRETURN SQL_API SQLBindCol(SQLHSTMT stmt, SQLUSMALLINT col, SQLSMALLINT type, SQLPOINTER val, SQLLEN max, SQLLEN *lenp)
Bind C variable to column of result set.
static SQLRETURN drvbulkoperations(SQLHSTMT stmt, SQLSMALLINT op)
Internal perform bulk operation on HSTMT.
static SQLRETURN drvgetdiagrec(SQLSMALLINT htype, SQLHANDLE handle, SQLSMALLINT recno, SQLCHAR *sqlstate, SQLINTEGER *nativeerr, SQLCHAR *msg, SQLSMALLINT buflen, SQLSMALLINT *msglen)
Internal get error message given handle (HENV, HDBC, or HSTMT).
static void s3stmt_end(STMT *s)
Stop running sqlite statement.
static SQLRETURN drvtableprivileges(SQLHSTMT stmt, SQLCHAR *cat, SQLSMALLINT catLen, SQLCHAR *schema, SQLSMALLINT schemaLen, SQLCHAR *table, SQLSMALLINT tableLen)
Retrieve privileges on tables and/or views.
static COL tablePrivSpec2[]
Columns for result set of SQLTablePrivileges().
static COL typeSpec2[]
Columns for result set of SQLGetTypeInfo().
static SQLRETURN dbopen(DBC *d, char *name, int isu, char *dsn, char *sflag, char *spflag, char *ntflag, char *jmode, char *busy)
Open SQLite database file given file name and flags.
SQLRETURN SQL_API SQLBindParameter(SQLHSTMT stmt, SQLUSMALLINT pnum, SQLSMALLINT iotype, SQLSMALLINT buftype, SQLSMALLINT ptype, SQLULEN coldef, SQLSMALLINT scale, SQLPOINTER data, SQLLEN buflen, SQLLEN *len)
Bind parameter on HSTMT.
static void dbtracerc(DBC *d, int rc, char *err)
Trace function for SQLite return codes.
static void convJD2YMD(double jd, DATE_STRUCT *ds)
Convert julian day to year/month/day.
static SQLRETURN drvsetpos(SQLHSTMT stmt, SQLSETPOSIROW row, SQLUSMALLINT op, SQLUSMALLINT lock)
Internal set position on result in HSTMT.
static dstr * dsappend(dstr *dsp, const char *str)
Append string to dynamic string.
SQLRETURN SQL_API SQLDisconnect(SQLHDBC dbc)
Disconnect given HDBC.
SQLRETURN SQL_API SQLSetConnectOptionW(SQLHDBC dbc, SQLUSMALLINT opt, SQLULEN param)
Set option on HDBC (UNICODE version).
SQLRETURN SQL_API SQLPrimaryKeysW(SQLHSTMT stmt, SQLWCHAR *cat, SQLSMALLINT catLen, SQLWCHAR *schema, SQLSMALLINT schemaLen, SQLWCHAR *table, SQLSMALLINT tableLen)
Retrieve information about indexed columns (UNICODE version).
static char * fixupsql(char *sql, int sqlLen, int cte, int *nparam, int *isselect, char **errmsg)
Fixup query string with optional parameter markers.
static void unbindcols(STMT *s)
Reset bound columns to unbound state.
static SQLRETURN drvdisconnect(SQLHDBC dbc)
Internal disconnect given HDBC.
static int checkddl(char *sql)
Check if query is a DDL statement.
static SQLRETURN drvfetchscroll(SQLHSTMT stmt, SQLSMALLINT orient, SQLINTEGER offset)
Internal fetch function for SQLFetchScroll() and SQLExtendedFetch().
static SQLRETURN drvunimplstmt(HSTMT stmt)
Report IM001 (not implemented) SQL error code for HSTMT.
static void setstatd(DBC *d, int naterr, char *msg, char *st,...)
Set error message and SQL state on DBC.
static COL colPrivSpec2[]
Columns for result set of SQLColumnPrivileges().
SQLRETURN SQL_API SQLProcedureColumnsW(SQLHSTMT stmt, SQLWCHAR *catalog, SQLSMALLINT catalogLen, SQLWCHAR *schema, SQLSMALLINT schemaLen, SQLWCHAR *proc, SQLSMALLINT procLen, SQLWCHAR *column, SQLSMALLINT columnLen)
Retrieve information about columns in result set of stored procedures (UNICODE version).
static SQLRETURN drvcolumns(SQLHSTMT stmt, SQLCHAR *cat, SQLSMALLINT catLen, SQLCHAR *schema, SQLSMALLINT schemaLen, SQLCHAR *table, SQLSMALLINT tableLen, SQLCHAR *col, SQLSMALLINT colLen)
Internal retrieve column information on table.
static COL procSpec2[]
Columns for result set of SQLProcedures().
SQLRETURN SQL_API SQLColumnsW(SQLHSTMT stmt, SQLWCHAR *cat, SQLSMALLINT catLen, SQLWCHAR *schema, SQLSMALLINT schemaLen, SQLWCHAR *table, SQLSMALLINT tableLen, SQLWCHAR *col, SQLSMALLINT colLen)
Retrieve column information on table (UNICODE version).
#define HSTMT_UNLOCK(hdbc)
SQLRETURN SQL_API SQLDataSourcesW(SQLHENV env, SQLUSMALLINT dir, SQLWCHAR *srvname, SQLSMALLINT buflen1, SQLSMALLINT *lenp1, SQLWCHAR *desc, SQLSMALLINT buflen2, SQLSMALLINT *lenp2)
Function not implemented.
static char * uc_to_utf(SQLWCHAR *str, int len)
Make UTF8 string from UNICODE string.
static const char space_chars[]
SQLRETURN SQL_API SQLStatisticsW(SQLHSTMT stmt, SQLWCHAR *cat, SQLSMALLINT catLen, SQLWCHAR *schema, SQLSMALLINT schemaLen, SQLWCHAR *table, SQLSMALLINT tableLen, SQLUSMALLINT itype, SQLUSMALLINT resv)
Return statistic information on table indices (UNICODE version).
static COL fkeySpec2[]
Columns for result set of SQLForeignKeys().
SQLRETURN SQL_API SQLRowCount(SQLHSTMT stmt, SQLLEN *nrows)
Return number of affected rows of HSTMT.
static SQLRETURN freestmt(HSTMT stmt)
static int findcol(char **cols, int ncols, char *name)
Find column given name in string array.
static int str2date(int jdconv, char *str, DATE_STRUCT *ds)
Convert string to ODBC DATE_STRUCT.
Header file for SQLite3 ODBC driver.
Internal structure for bound column (SQLBindCol).
SQLLEN * lenp
Value return, actual size of value buffer.
SQLPOINTER valp
Value buffer.
int offs
Byte offset for SQLGetData()
SQLSMALLINT type
ODBC type.
int index
Index of column in result.
Internal structure for bound parameter (SQLBindParameter).
double s3dval
SQLite3 float value.
void * param0
Parameter buffer, initial value.
int need
True when SQL_LEN_DATA_AT_EXEC.
int scale
from SQLBindParameter()
int len
Offset/length for SQLParamData()/SQLPutData()
void * param
Parameter buffer.
void * parbuf
Buffer for SQL_LEN_DATA_AT_EXEC etc.
int inc
Increment for paramset size > 1.
SQLLEN * lenp0
Actual size of parameter buffer, initial value.
void * s3val
SQLite3 value buffer.
int stype
ODBC and SQL types.
char strbuf[64]
String buffer for scalar data.
int bound
True when SQLBindParameter() called.
sqlite_int64 s3lival
SQLite3 64bit integer value.
int s3ival
SQLite3 integer value.
SQLLEN * lenp
Actual size of parameter buffer.
Internal structure to describe a column in a result set.
char * column
Column name.
char * label
Column label or NULL.
char * typename
Column type name or NULL.
int notnull
NOT NULL constraint on column.
int ispk
Flag for primary key (> 0)
int prec
Precision of column.
int type
Data type of column.
int isrowid
Flag for ROWID column (> 0)
int scale
Scale of column.
int autoinc
AUTO_INCREMENT column.
int index
Index of column in result.
Driver internal structure for environment (HENV).
int pool
True for SQL_CP_ONE_PER_DRIVER.
int ov3
True for SQL_OV_ODBC3.
struct dbc * dbcs
Pointer to first DBC.
Driver internal structure for database connection (HDBC).
int busyint
Interrupt busy handler from SQLCancel()
char * pwd
Password or NULL.
int s3stmt_needmeta
True to get meta data in s3stmt_step().
int nowchar
Don't try to use WCHAR.
struct stmt * cur_s3stmt
Current STMT executing sqlite statement.
long t0
Start time for SQLITE busy handler.
int curtype
Default cursor type.
int step_enable
True for sqlite_compile/step/finalize.
int intrans
True when transaction started.
char * dsn
ODBC data source name.
struct stmt * stmt
STMT list of this DBC.
int pwdLen
Length of password.
int * ov3
True for SQL_OV_ODBC3.
FILE * trace
sqlite3_trace() file pointer or NULL
int oemcp
True for Win32 OEM CP translation.
int longnames
Don't shorten column names.
int trans_disable
True for no transaction support.
ENV * env
Pointer to environment.
int dobigint
Force SQL_BIGINT for INTEGER columns.
int fksupport
Foreign keys on or off.
int ilike
True for ILIKE fixup.
int naterr
Native error code.
char sqlstate[6]
SQL state for SQLError()
int version
SQLITE version number.
int autocommit
Auto commit state.
int jdconv
True for julian day conversion.
struct dbc * next
Pointer to next DBC.
char * dbname
SQLITE database name.
int shortnames
Always use short column names.
SQLCHAR logmsg[1024]
Message for SQLError()
int ov3val
True for SQL_OV_ODBC3.
int nocreat
Don't auto create database file.
sqlite3 * sqlite
SQLITE database handle.
int timeout
Lock timeout value.
Internal structure representing dynamic strings.
int oom
True when out of memory.
int max
Maximum length of buffer.
char buffer[1]
String buffer.
Driver internal structure representing SQL statement (HSTMT).
SQLUSMALLINT * row_status0
Internal status array.
int * ov3
True for SQL_OV_ODBC3.
SQLUSMALLINT row_status1
Internal status array for 1 row rowsets.
BINDCOL * bindcols
Array of bound columns.
int naterr
Native error code.
SQLULEN * parm_bind_offs
SQL_ATTR_PARAM_BIND_OFFSET_PTR.
int dcols
Number of entries in dyncols.
SQLULEN bind_type
SQL_ATTR_ROW_BIND_TYPE.
BINDCOL bkmrkcol
Bookmark bound column.
int nbindparms
Number bound parameters.
COL * dyncols
Column array, but malloc()ed.
COL * cols
Result column array.
int dobigint
Force SQL_BIGINT for INTEGER columns.
int s3stmt_rownum
Current row number.
SQLCHAR logmsg[1024]
Message for SQLError()
int ncols
Number of result columns.
SQLULEN * row_count
Row count pointer.
SQLULEN paramset_count
Internal for paramset.
SQLUSMALLINT * parm_oper
SQL_ATTR_PARAM_OPERATION_PTR.
int nowchar[2]
Don't try to use WCHAR.
int binlen
Length of blob data.
int longnames
Don't shorten column names.
SQLULEN parm_bind_type
SQL_ATTR_PARAM_BIND_TYPE.
int guessed_types
Flag for drvprepare()/drvexecute()
char * bincell
Cache for blob data.
SQLCHAR cursorname[32]
Cursor name.
int nrows
Number of result rows.
SQLULEN paramset_size
SQL_ATTR_PARAMSET_SIZE.
int bkmrk
True when bookmarks used.
int * jdconv
True for julian day conversion.
SQLULEN * parm_proc
SQL_ATTR_PARAMS_PROCESSED_PTR.
sqlite3_stmt * s3stmt
SQLite statement handle or NULL.
SQLULEN * bind_offs
SQL_ATTR_ROW_BIND_OFFSET_PTR.
SQLULEN retr_data
SQL_ATTR_RETRIEVE_DATA.
SQLULEN max_rows
SQL_ATTR_MAX_ROWS.
BINDPARM * bindparms
Array of bound parameters.
int has_rowid
Flag for ROWID (>= 0 or -1)
SQLUSMALLINT * parm_status
SQL_ATTR_PARAMS_STATUS_PTR.
int one_tbl
Flag for single table (> 0)
int rowprs
Current start row of rowset.
char ** rows
2-dim array, result set
int s3stmt_noreset
False when sqlite3_reset() needed.
SQLULEN rowset_size
Size of rowset.
int nparams
Number of parameters in query.
SQLUINTEGER paramset_nrows
Row count for paramset handling.
int nbindcols
Number of entries in bindcols.
SQLCHAR * query
Current query, raw string.
int * oemcp
True for Win32 OEM CP translation.
int rowp
Current result row.
char * bincache
Cache for blob data.
int pdcount
SQLParamData() counter.
SQLUSMALLINT * row_status
Row status pointer.
int has_pk
Flag for primary key (> 0)
char sqlstate[6]
SQL state for SQLError()
struct stmt * next
Linkage for STMT list in DBC.
int * ilike
True for ILIKE fixup.
SQLULEN row_count0
Row count.
void(* rowfree)()
Free function for rows.
SQLINTEGER * bkmrkptr
SQL_ATTR_FETCH_BOOKMARK_PTR.
Internal dynamic string buffer.
Internal structure for managing driver's sqlite3_get_table() implementation.
sqlite3_stmt * stmt
SQLite3 statement pointer.
int rc
SQLite return code.
int ncol
number of columns in result array
char ** resarr
result array
int nrow
number of rows in result array
PTRDIFF_T ndata
index into result array
int nalloc
alloc'ed size of result array
STMT * s
Driver statement pointer.
char * errmsg
error message or NULL