14 #if defined(SQLITE_HAS_CODEC) && defined(SQLITE_API) 15 #undef WITH_SQLITE_DLLS 20 #if defined(WITH_SQLITE_DLLS) && (WITH_SQLITE_DLLS > 1) 21 #define SQLITE_DYNLOAD 1 22 #undef HAVE_SQLITE3CLOSEV2 31 #if defined(_WIN32) || defined(_WIN64) 32 static void dls_init(
void);
33 static void dls_fini(
void);
39 static struct dl_sqlite3_funcs {
40 void (*activate_see)(
const char *p0);
41 int (*bind_blob)(sqlite3_stmt *p0,
int p1,
const void *p2,
int p3,
43 int (*bind_double)(sqlite3_stmt *p0,
int p1,
double p2);
44 int (*bind_int)(sqlite3_stmt *p0,
int p1,
int p2);
45 int (*bind_int64)(sqlite3_stmt *p0,
int p1, sqlite_int64 p2);
46 int (*bind_null)(sqlite3_stmt *p0,
int p1);
47 int (*bind_parameter_count)(sqlite3_stmt *p0);
48 int (*bind_text)(sqlite3_stmt *p0,
int p1,
const char *p2,
int p3,
50 int (*
busy_handler)(sqlite3 *p0, int (*p2)(
void *, int),
void *p3);
51 int (*changes)(sqlite3 *p0);
52 int (*close)(sqlite3 *p0);
53 const void * (*column_blob)(sqlite3_stmt *p0,
int p1);
54 int (*column_bytes)(sqlite3_stmt *p0,
int p1);
55 int (*column_count)(sqlite3_stmt *p0);
56 const char * (*column_database_name)(sqlite3_stmt *p0,
int p1);
57 const char * (*column_decltype)(sqlite3_stmt *p0,
int p1);
58 double (*column_double)(sqlite3_stmt *p0,
int p1);
59 const char * (*column_name)(sqlite3_stmt *p0,
int p1);
60 const char * (*column_origin_name)(sqlite3_stmt *p0,
int p1);
61 const char * (*column_table_name)(sqlite3_stmt *p0,
int p1);
62 const unsigned char * (*column_text)(sqlite3_stmt *p0,
int p1);
63 int (*column_type)(sqlite3_stmt *p0,
int p1);
64 int (*create_function)(sqlite3 *p0,
const char *p1,
int p2,
int p3,
66 void (*p5)(sqlite3_context *, int, sqlite3_value **),
67 void (*p6)(sqlite3_context *, int, sqlite3_value **),
68 void (*p7)(sqlite3_context *));
69 int (*enable_load_extension)(sqlite3 *p0,
int p1);
70 int (*errcode)(sqlite3 *p0);
71 const char * (*errmsg)(sqlite3 *p0);
72 int (*exec)(sqlite3 *p0,
const char *p1,
73 int (*p2)(
void *, int,
char **,
char **),
75 int (*finalize)(sqlite3_stmt *p0);
76 void (*free)(
void *p0);
77 void (*free_table)(
char **p0);
78 int (*get_table)(sqlite3 *p0,
const char *p1,
char ***p2,
79 int *p3,
int *p4,
char **p5);
80 void (*interrupt)(sqlite3 *p0);
81 int (*key)(sqlite3 *p0,
const void *p1,
int p2);
82 sqlite_int64 (*last_insert_rowid)(sqlite3 *p0);
83 const char * (*libversion)(void);
84 int (*load_extension)(sqlite3 *p0,
const char *p1,
const char *p2,
86 void * (*malloc)(
int p0);
87 char * (*mprintf)(
const char *p0, ...);
88 int (*open)(
const char *p0, sqlite3 **p1);
89 int (*open16)(
const void *p0, sqlite3 **p1);
90 int (*open_v2)(
const char *p0, sqlite3 **p1,
int p2,
const char *p3);
91 int (*prepare)(sqlite3 *p0,
const char *p1,
int p2, sqlite3_stmt **p3,
93 int (*prepare_v2)(sqlite3 *p0,
const char *p1,
int p2, sqlite3_stmt **p3,
95 void * (*profile)(sqlite3 *p0,
96 void (*p1)(
void *,
const char *, sqlite3_uint64),
98 void * (*realloc)(
void *p0,
int p1);
99 int (*rekey)(sqlite3 *p0,
const void *p1,
int p2);
100 int (*reset)(sqlite3_stmt *p0);
101 void (*result_blob)(sqlite3_context *p0,
const void *p1,
102 int p2, void (*p3)(
void *));
103 void (*result_error)(sqlite3_context *p0,
const char *p1,
int p2);
104 void (*result_int)(sqlite3_context *p0,
int p1);
105 void (*result_null)(sqlite3_context *p0);
106 int (*step)(sqlite3_stmt *p0);
107 int (*xstrnicmp)(
const char *p0,
const char *p1,
int p2);
108 int (*table_column_metadata)(sqlite3 *p0,
const char *p1,
109 const char *p2,
const char *p3,
110 char const **p4,
char const **p5,
111 int *p6,
int *p7,
int *p8);
112 void * (*trace)(sqlite3 *p0, void (*p1)(
void *,
const char *),
void *p2);
113 void * (*user_data)(sqlite3_context *p0);
114 const void * (*value_blob)(sqlite3_value *p0);
115 int (*value_bytes)(sqlite3_value *p0);
116 const unsigned char * (*value_text)(sqlite3_value *p0);
117 int (*value_type)(sqlite3_value *p0);
120 #define sqlite3_activate_see dls_funcs.activate_see 121 #define sqlite3_bind_blob dls_funcs.bind_blob 122 #define sqlite3_bind_double dls_funcs.bind_double 123 #define sqlite3_bind_int dls_funcs.bind_int 124 #define sqlite3_bind_int64 dls_funcs.bind_int64 125 #define sqlite3_bind_null dls_funcs.bind_null 126 #define sqlite3_bind_parameter_count dls_funcs.bind_parameter_count 127 #define sqlite3_bind_text dls_funcs.bind_text 128 #define sqlite3_busy_handler dls_funcs.busy_handler 129 #define sqlite3_changes dls_funcs.changes 130 #define sqlite3_close dls_funcs.close 131 #define sqlite3_column_blob dls_funcs.column_blob 132 #define sqlite3_column_bytes dls_funcs.column_bytes 133 #define sqlite3_column_count dls_funcs.column_count 134 #define sqlite3_column_database_name dls_funcs.column_database_name 135 #define sqlite3_column_decltype dls_funcs.column_decltype 136 #define sqlite3_column_double dls_funcs.column_double 137 #define sqlite3_column_name dls_funcs.column_name 138 #define sqlite3_column_origin_name dls_funcs.column_origin_name 139 #define sqlite3_column_table_name dls_funcs.column_table_name 140 #define sqlite3_column_text dls_funcs.column_text 141 #define sqlite3_column_type dls_funcs.column_type 142 #define sqlite3_create_function dls_funcs.create_function 143 #define sqlite3_enable_load_extension dls_funcs.enable_load_extension 144 #define sqlite3_errcode dls_funcs.errcode 145 #define sqlite3_errmsg dls_funcs.errmsg 146 #define sqlite3_exec dls_funcs.exec 147 #define sqlite3_finalize dls_funcs.finalize 148 #define sqlite3_free dls_funcs.free 149 #define sqlite3_free_table dls_funcs.free_table 150 #define sqlite3_get_table dls_funcs.get_table 151 #define sqlite3_interrupt dls_funcs.interrupt 152 #define sqlite3_key dls_funcs.key 153 #define sqlite3_last_insert_rowid dls_funcs.last_insert_rowid 154 #define sqlite3_libversion dls_funcs.libversion 155 #define sqlite3_load_extension dls_funcs.load_extension 156 #define sqlite3_malloc dls_funcs.malloc 157 #define sqlite3_mprintf dls_funcs.mprintf 158 #define sqlite3_open dls_funcs.open 159 #define sqlite3_open16 dls_funcs.open16 160 #define sqlite3_open_v2 dls_funcs.open_v2 161 #define sqlite3_prepare dls_funcs.prepare 162 #define sqlite3_prepare_v2 dls_funcs.prepare_v2 163 #define sqlite3_profile dls_funcs.profile 164 #define sqlite3_realloc dls_funcs.realloc 165 #define sqlite3_rekey dls_funcs.rekey 166 #define sqlite3_reset dls_funcs.reset 167 #define sqlite3_result_blob dls_funcs.result_blob 168 #define sqlite3_result_error dls_funcs.result_error 169 #define sqlite3_result_int dls_funcs.result_int 170 #define sqlite3_result_null dls_funcs.result_null 171 #define sqlite3_step dls_funcs.step 172 #define sqlite3_strnicmp dls_funcs.xstrnicmp 173 #define sqlite3_table_column_metadata dls_funcs.table_column_metadata 174 #define sqlite3_trace dls_funcs.trace 175 #define sqlite3_user_data dls_funcs.user_data 176 #define sqlite3_value_blob dls_funcs.value_blob 177 #define sqlite3_value_bytes dls_funcs.value_bytes 178 #define sqlite3_value_text dls_funcs.value_text 179 #define sqlite3_value_type dls_funcs.value_type 183 #ifndef WITHOUT_WINTERFACE 188 #if !defined(_WIN32) && !defined(_WIN64) 189 #if !defined(WCHARSUPPORT) && defined(HAVE_SQLWCHAR) && (HAVE_SQLWCHAR) 194 #if defined(WINTERFACE) 195 #include <sqlucode.h> 198 #if defined(_WIN32) || defined(_WIN64) 199 #include "resource3.h" 200 #define ODBC_INI "ODBC.INI" 201 #ifndef DRIVER_VER_INFO 202 #define DRIVER_VER_INFO VERSION 205 #define ODBC_INI ".odbc.ini" 208 #ifndef DRIVER_VER_INFO 209 #define DRIVER_VER_INFO "0.0" 212 #ifndef COLATTRIBUTE_LAST_ARG_TYPE 214 #define COLATTRIBUTE_LAST_ARG_TYPE SQLLEN * 216 #define COLATTRIBUTE_LAST_ARG_TYPE SQLPOINTER 220 #ifndef SETSTMTOPTION_LAST_ARG_TYPE 221 #define SETSTMTOPTION_LAST_ARG_TYPE SQLROWCOUNT 225 #define min(a, b) ((a) < (b) ? (a) : (b)) 227 #define max(a, b) ((a) < (b) ? (b) : (a)) 230 #define PTRDIFF_T int 233 #define array_size(x) (sizeof (x) / sizeof (x[0])) 235 #define stringify1(s) #s 236 #define stringify(s) stringify1(s) 238 #define verinfo(maj, min, lev) ((maj) << 16 | (min) << 8 | (lev)) 242 #if defined(HAVE_SQLITE3TABLECOLUMNMETADATA) && (HAVE_SQLITE3TABLECOLUMNMETADATA) 243 #if defined(HAVE_SQLITE3COLUMNDATABASENAME) && (HAVE_SQLITE3COLUMNDATABASENAME) 244 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME) 245 #if defined(HAVE_SQLITE3COLUMNORIGINNAME) && (HAVE_SQLITE3COLUMNORIGINNAME) 246 #define FULL_METADATA 1 254 #if defined(WINTERFACE) && !defined(_WIN32) && !defined(_WIN64) 255 #define SCOL_VARCHAR SQL_WVARCHAR 256 #define SCOL_CHAR SQL_WCHAR 258 #define SCOL_VARCHAR SQL_VARCHAR 259 #define SCOL_CHAR SQL_CHAR 262 #define ENV_MAGIC 0x53544145 263 #define DBC_MAGIC 0x53544144 264 #define DEAD_MAGIC 0xdeadbeef 279 static const char *
xdigits =
"0123456789ABCDEFabcdef";
284 xmalloc_(
int n,
char *file,
int line)
286 int nn = n + 4 *
sizeof (long);
291 #if (MEMORY_DEBUG > 1) 292 fprintf(stderr,
"malloc\t%d\tNULL\t%s:%d\n", n, file, line);
297 nn = nn /
sizeof (long) - 1;
300 #if (MEMORY_DEBUG > 1) 301 fprintf(stderr,
"malloc\t%d\t%p\t%s:%d\n", n, &p[2], file, line);
303 return (
void *) &p[2];
307 xrealloc_(
void *old,
int n,
char *file,
int line)
309 int nn = n + 4 *
sizeof (long), nnn;
312 if (n == 0 || !old) {
313 return xmalloc_(n, file, line);
315 p = &((
long *) old)[-2];
316 if (p[0] != 0xdead1234) {
317 fprintf(stderr,
"*** low end corruption @ %p\n", old);
320 nnn = p[1] + 4 *
sizeof (long);
321 nnn = nnn /
sizeof (long) - 1;
322 if (p[nnn] != 0xdead5678) {
323 fprintf(stderr,
"*** high end corruption @ %p\n", old);
328 #if (MEMORY_DEBUG > 1) 329 fprintf(stderr,
"realloc\t%p,%d\tNULL\t%s:%d\n", old, n, file, line);
333 #if (MEMORY_DEBUG > 1) 334 fprintf(stderr,
"realloc\t%p,%d\t%p\t%s:%d\n", old, n, &pp[2], file, line);
338 nn = nn /
sizeof (long) - 1;
340 return (
void *) &p[2];
344 xfree_(
void *x,
char *file,
int line)
352 p = &((
long *) x)[-2];
353 if (p[0] != 0xdead1234) {
354 fprintf(stderr,
"*** low end corruption @ %p\n", x);
357 n = p[1] + 4 *
sizeof (long);
358 n = n /
sizeof (long) - 1;
359 if (p[n] != 0xdead5678) {
360 fprintf(stderr,
"*** high end corruption @ %p\n", x);
363 #if (MEMORY_DEBUG > 1) 364 fprintf(stderr,
"free\t%p\t\t%s:%d\n", x, file, line);
372 xfree_(x,
"unknown location", 0);
376 xstrdup_(
const char *str,
char *file,
int line)
381 #if (MEMORY_DEBUG > 1) 382 fprintf(stderr,
"strdup\tNULL\tNULL\t%s:%d\n", file, line);
386 p = xmalloc_(strlen(str) + 1, file, line);
390 #if (MEMORY_DEBUG > 1) 391 fprintf(stderr,
"strdup\t%p\t%p\t%s:%d\n", str, p, file, line);
396 #define xmalloc(x) xmalloc_(x, __FILE__, __LINE__) 397 #define xrealloc(x,y) xrealloc_(x, y, __FILE__, __LINE__) 398 #define xfree(x) xfree_(x, __FILE__, __LINE__) 399 #define xstrdup(x) xstrdup_(x, __FILE__, __LINE__) 403 #define xmalloc(x) sqlite3_malloc(x) 404 #define xrealloc(x,y) sqlite3_realloc(x, y) 405 #define xfree(x) sqlite3_free(x) 406 #define xstrdup(x) strdup_(x) 410 #if defined(_WIN32) || defined(_WIN64) 412 #define vsnprintf _vsnprintf 413 #define snprintf _snprintf 414 #define strcasecmp _stricmp 415 #define strncasecmp _strnicmp 418 #define strtoll _strtoi64 419 #define strtoull _strtoui64 422 static HINSTANCE NEAR hModule;
426 #ifdef HAVE_SQLITE3STRNICMP 428 #define strncasecmp(A,B,C) sqlite3_strnicmp(A,B,C) 430 #define strcasecmp(A,B) strcasecmp_(A,B) 432 #if defined(__GNUC__) && (__GNUC__ >= 2) 433 static int strcasecmp_(
const char *a,
const char *b)
434 __attribute__((__unused__));
437 static int strcasecmp_(
const char *a,
const char *b)
439 int c = strlen(a), d = strlen(b);
442 return strncasecmp(a, b, c);
444 return strncasecmp(a, b, d);
448 #if defined(_WIN32) || defined(_WIN64) 456 #define HDBC_LOCK(hdbc) \ 460 if ((hdbc) == SQL_NULL_HDBC) { \ 461 return SQL_INVALID_HANDLE; \ 463 d = (DBC *) (hdbc); \ 464 if (d->magic != DBC_MAGIC) { \ 465 return SQL_INVALID_HANDLE; \ 467 EnterCriticalSection(&d->cs); \ 468 d->owner = GetCurrentThreadId(); \ 471 #define HDBC_UNLOCK(hdbc) \ 472 if ((hdbc) != SQL_NULL_HDBC) { \ 475 d = (DBC *) (hdbc); \ 476 if (d->magic == DBC_MAGIC) { \ 478 LeaveCriticalSection(&d->cs); \ 482 #define HSTMT_LOCK(hstmt) \ 486 if ((hstmt) == SQL_NULL_HSTMT) { \ 487 return SQL_INVALID_HANDLE; \ 489 d = (DBC *) ((STMT *) (hstmt))->dbc; \ 490 if (d->magic != DBC_MAGIC) { \ 491 return SQL_INVALID_HANDLE; \ 493 EnterCriticalSection(&d->cs); \ 494 d->owner = GetCurrentThreadId(); \ 497 #define HSTMT_UNLOCK(hstmt) \ 498 if ((hstmt) != SQL_NULL_HSTMT) { \ 501 d = (DBC *) ((STMT *) (hstmt))->dbc; \ 502 if (d->magic == DBC_MAGIC) { \ 504 LeaveCriticalSection(&d->cs); \ 530 #define HDBC_LOCK(hdbc) 531 #define HDBC_UNLOCK(hdbc) 532 #define HSTMT_LOCK(hdbc) 533 #define HSTMT_UNLOCK(hdbc) 537 #if defined(ENABLE_NVFS) && (ENABLE_NVFS) 538 extern void nvfs_init(
void);
539 extern const char *nvfs_makevfs(
const char *);
569 ((c) && strchr(digit_chars, (c)) != NULL) 578 ((c) && strchr(space_chars, (c)) != NULL) 599 static SQLRETURN
getrowdata(
STMT *s, SQLUSMALLINT col, SQLSMALLINT otype,
600 SQLPOINTER val, SQLINTEGER len,
SQLLEN *lenp,
603 #if (defined(_WIN32) || defined(_WIN64)) && defined(WINTERFACE) 605 static COL *statSpec2P, *statSpec3P;
608 #if (MEMORY_DEBUG < 1) 663 if (dsp->
len + len > dsp->
max) {
664 int max = dsp->
max + len + 256;
668 strcpy(dsp->
buffer,
"OUT OF MEMORY");
700 for (p = str; *p; ++p) {
723 if (dsp->
len + len > dsp->
max) {
724 int max = dsp->
max + len + 256;
728 strcpy(dsp->
buffer,
"OUT OF MEMORY");
739 for (p = str; *p; ++p) {
761 return (
const char *) dsp->
buffer;
775 return !dsp || dsp->
oom;
850 ucLen = ucLen /
sizeof (SQLWCHAR);
851 if (!uc || ucLen < 0) {
861 while (i < len && *str && i < ucLen) {
862 unsigned char c = str[0];
867 }
else if (c <= 0xc1 || c >= 0xf5) {
870 }
else if (c < 0xe0) {
871 if ((str[1] & 0xc0) == 0x80) {
872 unsigned long t = ((c & 0x1f) << 6) | (str[1] & 0x3f);
880 }
else if (c < 0xf0) {
881 if ((str[1] & 0xc0) == 0x80 && (str[2] & 0xc0) == 0x80) {
882 unsigned long t = ((c & 0x0f) << 12) |
883 ((str[1] & 0x3f) << 6) | (str[2] & 0x3f);
891 }
else if (c < 0xf8) {
892 if ((str[1] & 0xc0) == 0x80 && (str[2] & 0xc0) == 0x80 &&
893 (str[3] & 0xc0) == 0x80) {
894 unsigned long t = ((c & 0x03) << 18) |
895 ((str[1] & 0x3f) << 12) | ((str[2] & 0x3f) << 6) |
898 if (
sizeof (SQLWCHAR) == 2 *
sizeof (char) &&
901 uc[i++] = 0xd800 | ((t >> 10) & 0x3ff);
905 t = 0xdc00 | (t & 0x3ff);
938 if (len == SQL_NTS) {
939 len = strlen((
char *) str);
941 ucLen =
sizeof (SQLWCHAR) * (len + 1);
961 char *cp, *ret = NULL;
966 if (len == SQL_NTS) {
969 len = len /
sizeof (SQLWCHAR);
976 for (i = 0; i < len; i++) {
977 unsigned long c = str[i];
979 if (
sizeof (SQLWCHAR) == 2 *
sizeof (
char)) {
984 }
else if (c < 0x800) {
985 *cp++ = 0xc0 | ((c >> 6) & 0x1f);
986 *cp++ = 0x80 | (c & 0x3f);
987 }
else if (c < 0x10000) {
988 if (
sizeof (SQLWCHAR) == 2 *
sizeof (char) &&
989 c >= 0xd800 && c <= 0xdbff && i + 1 < len) {
990 unsigned long c2 = str[i + 1] & 0xffff;
992 if (c2 >= 0xdc00 && c2 <= 0xdfff) {
993 c = (((c & 0x3ff) << 10) | (c2 & 0x3ff)) + 0x10000;
994 *cp++ = 0xf0 | ((c >> 18) & 0x07);
995 *cp++ = 0x80 | ((c >> 12) & 0x3f);
996 *cp++ = 0x80 | ((c >> 6) & 0x3f);
997 *cp++ = 0x80 | (c & 0x3f);
1002 *cp++ = 0xe0 | ((c >> 12) & 0x0f);
1003 *cp++ = 0x80 | ((c >> 6) & 0x3f);
1004 *cp++ = 0x80 | (c & 0x3f);
1005 }
else if (c <= 0x10ffff) {
1006 *cp++ = 0xf0 | ((c >> 18) & 0x07);
1007 *cp++ = 0x80 | ((c >> 12) & 0x3f);
1008 *cp++ = 0x80 | ((c >> 6) & 0x3f);
1009 *cp++ = 0x80 | (c & 0x3f);
1030 if (len != SQL_NTS) {
1031 len = len *
sizeof (SQLWCHAR);
1038 #if defined(WCHARSUPPORT) || defined(_WIN32) || defined(_WIN64) 1055 #if defined(_WIN32) || defined(_WIN64) 1065 wmb_to_utf(
char *str,
int len)
1069 int nchar, is2k, cp = CP_OEMCP;
1071 ovi.dwOSVersionInfoSize =
sizeof (ovi);
1073 is2k = ovi.dwPlatformId == VER_PLATFORM_WIN32_NT && ovi.dwMajorVersion > 4;
1074 if (AreFileApisANSI()) {
1075 cp = is2k ? CP_THREAD_ACP : CP_ACP;
1077 nchar = MultiByteToWideChar(cp, 0, str, len, NULL, 0);
1078 wstr =
xmalloc((nchar + 1) *
sizeof (WCHAR));
1083 nchar = MultiByteToWideChar(cp, 0, str, len, wstr, nchar);
1085 str =
xmalloc((nchar + 1) * 7);
1091 nchar = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, str, nchar * 7, 0, 0);
1107 wmb_to_utf_c(
char *str,
int len)
1109 if (len == SQL_NTS) {
1112 return wmb_to_utf(str, len);
1125 utf_to_wmb(
char *str,
int len)
1129 int nchar, is2k, cp = CP_OEMCP;
1131 ovi.dwOSVersionInfoSize =
sizeof (ovi);
1133 is2k = ovi.dwPlatformId == VER_PLATFORM_WIN32_NT && ovi.dwMajorVersion > 4;
1134 if (AreFileApisANSI()) {
1135 cp = is2k ? CP_THREAD_ACP : CP_ACP;
1137 nchar = MultiByteToWideChar(CP_UTF8, 0, str, len, NULL, 0);
1138 wstr =
xmalloc((nchar + 1) *
sizeof (WCHAR));
1143 nchar = MultiByteToWideChar(CP_UTF8, 0, str, len, wstr, nchar);
1145 str =
xmalloc((nchar + 1) * 7);
1151 nchar = WideCharToMultiByte(cp, 0, wstr, -1, str, nchar * 7, 0, 0);
1167 wmb_to_uc(
char *str,
int len)
1171 int nchar, is2k, cp = CP_OEMCP;
1173 ovi.dwOSVersionInfoSize =
sizeof (ovi);
1175 is2k = ovi.dwPlatformId == VER_PLATFORM_WIN32_NT && ovi.dwMajorVersion > 4;
1176 if (AreFileApisANSI()) {
1177 cp = is2k ? CP_THREAD_ACP : CP_ACP;
1179 nchar = MultiByteToWideChar(cp, 0, str, len, NULL, 0);
1180 wstr =
xmalloc((nchar + 1) *
sizeof (WCHAR));
1185 nchar = MultiByteToWideChar(cp, 0, str, len, wstr, nchar);
1198 uc_to_wmb(WCHAR *wstr,
int len)
1202 int nchar, is2k, cp = CP_OEMCP;
1204 ovi.dwOSVersionInfoSize =
sizeof (ovi);
1206 is2k = ovi.dwPlatformId == VER_PLATFORM_WIN32_NT && ovi.dwMajorVersion > 4;
1207 if (AreFileApisANSI()) {
1208 cp = is2k ? CP_THREAD_ACP : CP_ACP;
1210 nchar = WideCharToMultiByte(cp, 0, wstr, len, NULL, 0, 0, 0);
1211 str =
xmalloc((nchar + 1) * 2);
1216 nchar = WideCharToMultiByte(cp, 0, wstr, len, str, nchar * 2, 0, 0);
1226 #ifdef USE_DLOPEN_FOR_GPPS 1230 #define SQLGetPrivateProfileString(A,B,C,D,E,F) drvgpps(d,A,B,C,D,E,F) 1245 lib = dlopen(
"libodbcinst.so.2", RTLD_LAZY);
1247 lib = dlopen(
"libodbcinst.so.1", RTLD_LAZY);
1250 lib = dlopen(
"libodbcinst.so", RTLD_LAZY);
1253 lib = dlopen(
"libiodbcinst.so.2", RTLD_LAZY);
1256 lib = dlopen(
"libiodbcinst.so", RTLD_LAZY);
1259 gpps = (int (*)()) dlsym(lib,
"SQLGetPrivateProfileString");
1273 dlclose(d->instlib);
1279 drvgpps(
DBC *d,
char *sect,
char *ent,
char *def,
char *buf,
1280 int bufsiz,
char *fname)
1283 return d->gpps(sect, ent, def, buf, bufsiz, fname);
1285 strncpy(buf, def, bufsiz);
1286 buf[bufsiz - 1] =
'\0';
1290 #include <odbcinst.h> 1291 #define drvgetgpps(d) 1292 #define drvrelgpps(d) 1304 if (
stmt && p && nparams > 0) {
1305 for (i = 0; i < nparams; i++, p++) {
1309 sqlite3_bind_null(
stmt, i + 1);
1311 fprintf(d->
trace,
"-- parameter %d: NULL\n", i + 1);
1319 fprintf(d->
trace,
"-- parameter %d: '%*s'\n", i + 1,
1328 fprintf(d->
trace,
"-- parameter %d: [BLOB]'\n", i + 1);
1335 fprintf(d->
trace,
"-- parameter %d: %g\n",
1340 case SQLITE_INTEGER:
1341 if (p->
s3size > sizeof (
int)) {
1346 "-- parameter %d: %I64d\n",
1348 "-- parameter %d: %lld\n",
1356 fprintf(d->
trace,
"-- parameter %d: %d\n",
1398 if (t->
nrow == 0 && rc == SQLITE_ROW) {
1405 int nalloc = t->
nalloc * 2 + need + 1;
1410 t->
rc = SQLITE_NOMEM;
1419 for (i = 0; i < ncol; i++) {
1420 p = (
char *) sqlite3_column_name(t->
stmt, i);
1422 char *q =
xmalloc(strlen(p) + 1);
1439 }
else if (t->
ncol != ncol) {
1440 t->
errmsg = sqlite3_mprintf(
"drvgettable() called with two or" 1441 " more incompatible queries");
1442 t->
rc = SQLITE_ERROR;
1446 if (rc == SQLITE_ROW) {
1447 for (i = 0; i < ncol; i++) {
1448 int coltype = sqlite3_column_type(t->
stmt, i);
1451 if (coltype == SQLITE_BLOB) {
1452 int k, nbytes = sqlite3_column_bytes(t->
stmt, i);
1454 unsigned const char *bp;
1456 bp = sqlite3_column_blob(t->
stmt, i);
1464 for (k = 0; k < nbytes; k++) {
1465 *qp++ =
xdigits[(bp[k] >> 4)];
1466 *qp++ =
xdigits[(bp[k] & 0xF)];
1471 }
else if (coltype == SQLITE_FLOAT) {
1472 struct lconv *lc = 0;
1473 double val = sqlite3_column_double(t->
stmt, i);
1481 snprintf(buffer,
sizeof (buffer),
"%.15g", val);
1483 if (lc && lc->decimal_point && lc->decimal_point[0] &&
1484 lc->decimal_point[0] !=
'.') {
1485 p = strchr(buffer, lc->decimal_point[0]);
1495 }
else if (coltype != SQLITE_NULL) {
1496 p =
xstrdup((
char *) sqlite3_column_text(t->
stmt, i));
1510 int *ncolp,
char **errp,
int nparam,
BINDPARM *p)
1513 int rc = SQLITE_OK, keep = sql == NULL;
1515 const char *sqlleft = 0;
1516 int nretry = 0, haveerr = 0;
1519 return SQLITE_ERROR;
1533 tres.rc = SQLITE_OK;
1534 tres.resarr =
xmalloc(
sizeof (
char *) * tres.nalloc);
1538 return SQLITE_NOMEM;
1543 if (tres.stmt == NULL) {
1544 return SQLITE_NOMEM;
1548 while (sql && *sql && (rc == SQLITE_OK ||
1549 (rc == SQLITE_SCHEMA && (++nretry) < 2))) {
1553 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 1555 rc = sqlite3_prepare_v2(d->
sqlite, sql, -1, &tres.stmt, &sqlleft);
1558 rc = sqlite3_prepare(d->
sqlite, sql, -1, &tres.stmt, &sqlleft);
1560 if (rc != SQLITE_OK) {
1563 sqlite3_finalize(tres.stmt);
1574 if (sqlite3_bind_parameter_count(tres.stmt) != nparam) {
1577 sqlite3_mprintf(
"%s",
"parameter marker count incorrect");
1584 ncol = sqlite3_column_count(tres.stmt);
1590 rc = sqlite3_step(tres.stmt);
1591 if (rc == SQLITE_ROW || rc == SQLITE_DONE) {
1597 if (rc != SQLITE_ROW) {
1600 rc = sqlite3_reset(tres.stmt);
1604 rc = sqlite3_finalize(tres.stmt);
1607 if (rc != SQLITE_SCHEMA) {
1610 while (sql &&
ISSPACE(*sql)) {
1614 if (rc == SQLITE_DONE) {
1626 sqlite3_reset(tres.stmt);
1631 sqlite3_finalize(tres.stmt);
1636 }
else if (rc != SQLITE_OK && rc == sqlite3_errcode(d->
sqlite) && errp) {
1637 *errp = sqlite3_mprintf(
"%s", sqlite3_errmsg(d->
sqlite));
1642 tres.resarr[0] = (
char *) (tres.ndata - 1);
1644 if (rc == SQLITE_ABORT) {
1649 sqlite3_free(*errp);
1651 *errp = tres.errmsg;
1653 sqlite3_free(tres.errmsg);
1658 sqlite3_free(tres.errmsg);
1659 if (rc != SQLITE_OK) {
1663 *resp = &tres.resarr[1];
1681 #if defined(__GNUC__) && (__GNUC__ >= 2) 1682 static void setstatd(
DBC *,
int,
char *,
char *, ...)
1683 __attribute__((format (printf, 3, 5)));
1700 count = vsnprintf((
char *) d->
logmsg, sizeof (d->
logmsg), msg, ap);
1721 #if defined(__GNUC__) && (__GNUC__ >= 2) 1722 static void setstat(
STMT *,
int,
char *,
char *, ...)
1723 __attribute__((format (printf, 3, 5)));
1740 count = vsnprintf((
char *) s->
logmsg, sizeof (s->
logmsg), msg, ap);
1764 if (
dbc == SQL_NULL_HDBC) {
1765 return SQL_INVALID_HANDLE;
1768 setstatd(d, -1,
"not supported",
"IM001");
1783 if (
stmt == SQL_NULL_HSTMT) {
1784 return SQL_INVALID_HANDLE;
1787 setstat(s, -1,
"not supported",
"IM001");
1799 if (x && ((
char **) x)[0]) {
1800 xfree(((
char **) x)[0]);
1801 ((
char **) x)[0] = NULL;
1814 setstat(s, -1,
"out of memory", (*s->
ov3) ?
"HY000" :
"S1000");
1827 setstat(s, -1,
"not connected", (*s->
ov3) ?
"HY000" :
"S1000");
1838 #if defined(HAVE_LOCALECONV) || defined(_WIN32) || defined(_WIN64) 1843 struct lconv *lc = 0;
1844 char buf[128], *p, *end;
1848 if (lc && lc->decimal_point && lc->decimal_point[0] &&
1849 lc->decimal_point[0] !=
'.') {
1850 strncpy(buf, data,
sizeof (buf) - 1);
1851 buf[
sizeof (buf) - 1] =
'\0';
1852 p = strchr(buf,
'.');
1854 *p = lc->decimal_point[0];
1860 value = strtod(p, &end);
1861 end = (
char *) data + (end - p);
1870 #define ln_strtod(A,B) strtod(A,B) 1883 int len = strlen(str);
1888 if ((str[0] ==
'\'' && str[end] ==
'\'') ||
1889 (str[0] ==
'"' && str[end] ==
'"') ||
1890 (str[0] ==
'[' && str[end] ==
']')) {
1891 memmove(str, str + 1, end - 1);
1892 str[end - 1] =
'\0';
1913 while ((q = strchr(p,
'_')) != NULL) {
1914 if (q == str || q[-1] !=
'\\') {
1920 while ((q = strchr(p,
'%')) != NULL) {
1921 if (q == str || q[-1] !=
'\\') {
1927 while ((q = strchr(p,
'\\')) != NULL) {
1928 if (q[1] ==
'\\' || q[1] ==
'_' || q[1] ==
'%') {
1929 memmove(q, q + 1, strlen(q));
1957 if (*str ==
'\0' && cp !=
'%') {
1961 while (*pat ==
'%') {
1969 if (cp !=
'_' && cp !=
'\\') {
1993 if (esc && cp ==
'\\' &&
1994 (pat[1] ==
'\\' || pat[1] ==
'%' || pat[1] ==
'_')) {
2023 #if !defined(_WIN32) && !defined(_WIN64) 2025 #ifdef HAVE_NANOSLEEP 2038 #if defined(_WIN32) || defined(_WIN64) 2039 d->
t0 = GetTickCount();
2041 gettimeofday(&tv, NULL);
2042 d->
t0 = tv.tv_sec * 1000 + tv.tv_usec / 1000;
2045 #if defined(_WIN32) || defined(_WIN64) 2046 t1 = GetTickCount();
2048 gettimeofday(&tv, NULL);
2049 t1 = tv.tv_sec * 1000 + tv.tv_usec / 1000;
2054 #if defined(_WIN32) || defined(_WIN64) 2057 #ifdef HAVE_NANOSLEEP 2059 ts.tv_nsec = 10000000;
2061 ret = nanosleep(&ts, &ts);
2062 if (ret < 0 && errno != EINTR) {
2072 select(0, NULL, NULL, NULL, &tv);
2095 int count = 0, step = 0,
max, rc = SQLITE_ERROR;
2097 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME) 2105 while (step <
max) {
2107 rc = sqlite3_exec(x,
"PRAGMA empty_result_callbacks = on;",
2109 if (rc == SQLITE_OK) {
2111 "PRAGMA foreign_keys = on;" :
2112 "PRAGMA foreign_keys = off;",
2115 }
else if (step < 2) {
2117 "PRAGMA full_column_names = off;" :
2118 "PRAGMA full_column_names = on;",
2120 }
else if (step < 3) {
2122 "PRAGMA short_column_names = on;" :
2123 "PRAGMA short_column_names = off;",
2126 if (rc != SQLITE_OK) {
2127 if (rc != SQLITE_BUSY ||
2159 for (i = 1; i <= size; i++) {
2176 mapsqltype(
const char *
typename,
int *nosign,
int ov3,
int nowchar,
2180 int testsign = 0, result;
2183 result = nowchar ? SQL_VARCHAR : SQL_WVARCHAR;
2185 result = SQL_VARCHAR;
2190 q = p =
xmalloc(strlen(
typename) + 1);
2194 strcpy(p,
typename);
2199 if (strncmp(p,
"inter", 5) == 0) {
2200 }
else if (strncmp(p,
"int", 3) == 0 ||
2201 strncmp(p,
"mediumint", 9) == 0) {
2203 result = SQL_INTEGER;
2204 }
else if (strncmp(p,
"numeric", 7) == 0) {
2205 result = SQL_DOUBLE;
2206 }
else if (strncmp(p,
"tinyint", 7) == 0) {
2208 result = SQL_TINYINT;
2209 }
else if (strncmp(p,
"smallint", 8) == 0) {
2211 result = SQL_SMALLINT;
2212 }
else if (strncmp(p,
"float", 5) == 0) {
2213 result = SQL_DOUBLE;
2214 }
else if (strncmp(p,
"double", 6) == 0 ||
2215 strncmp(p,
"real", 4) == 0) {
2216 result = SQL_DOUBLE;
2217 }
else if (strncmp(p,
"timestamp", 9) == 0) {
2218 #ifdef SQL_TYPE_TIMESTAMP 2219 result = ov3 ? SQL_TYPE_TIMESTAMP : SQL_TIMESTAMP;
2221 result = SQL_TIMESTAMP;
2223 }
else if (strncmp(p,
"datetime", 8) == 0) {
2224 #ifdef SQL_TYPE_TIMESTAMP 2225 result = ov3 ? SQL_TYPE_TIMESTAMP : SQL_TIMESTAMP;
2227 result = SQL_TIMESTAMP;
2229 }
else if (strncmp(p,
"time", 4) == 0) {
2230 #ifdef SQL_TYPE_TIME 2231 result = ov3 ? SQL_TYPE_TIME : SQL_TIME;
2235 }
else if (strncmp(p,
"date", 4) == 0) {
2236 #ifdef SQL_TYPE_DATE 2237 result = ov3 ? SQL_TYPE_DATE : SQL_DATE;
2241 #ifdef SQL_LONGVARCHAR 2242 }
else if (strncmp(p,
"text", 4) == 0 ||
2243 strncmp(p,
"memo", 4) == 0 ||
2244 strncmp(p,
"longvarchar", 11) == 0) {
2246 result = nowchar ? SQL_LONGVARCHAR : SQL_WLONGVARCHAR;
2248 result = SQL_LONGVARCHAR;
2251 }
else if (strncmp(p,
"wtext", 5) == 0 ||
2252 strncmp(p,
"wvarchar", 8) == 0 ||
2253 strncmp(p,
"longwvarchar", 12) == 0) {
2254 result = SQL_WLONGVARCHAR;
2258 }
else if (strncmp(p,
"bool", 4) == 0 ||
2259 strncmp(p,
"bit", 3) == 0) {
2263 }
else if (strncmp(p,
"bigint", 6) == 0) {
2265 result = SQL_BIGINT;
2267 }
else if (strncmp(p,
"blob", 4) == 0) {
2268 result = SQL_BINARY;
2269 }
else if (strncmp(p,
"varbinary", 9) == 0) {
2270 result = SQL_VARBINARY;
2271 }
else if (strncmp(p,
"longvarbinary", 13) == 0) {
2272 result = SQL_LONGVARBINARY;
2276 *nosign = strstr(p,
"unsigned") != NULL;
2282 if (dobigint && result == SQL_INTEGER) {
2283 result = SQL_BIGINT;
2300 getmd(
const char *
typename,
int sqltype,
int *mp,
int *dp)
2305 case SQL_INTEGER: m = 10; d = 9;
break;
2306 case SQL_TINYINT: m = 4; d = 3;
break;
2307 case SQL_SMALLINT: m = 6; d = 5;
break;
2308 case SQL_FLOAT: m = 25; d = 24;
break;
2309 case SQL_DOUBLE: m = 54; d = 53;
break;
2310 case SQL_VARCHAR: m = 255; d = 0;
break;
2313 case SQL_WVARCHAR: m = 255; d = 0;
break;
2316 #ifdef SQL_TYPE_DATE 2319 case SQL_DATE: m = 10; d = 0;
break;
2320 #ifdef SQL_TYPE_TIME 2323 case SQL_TIME: m = 8; d = 0;
break;
2324 #ifdef SQL_TYPE_TIMESTAMP 2325 case SQL_TYPE_TIMESTAMP:
2327 case SQL_TIMESTAMP: m = 32; d = 3;
break;
2328 #ifdef SQL_LONGVARCHAR 2329 case SQL_LONGVARCHAR : m = 65536; d = 0;
break;
2332 #ifdef SQL_WLONGVARCHAR 2333 case SQL_WLONGVARCHAR: m = 65536; d = 0;
break;
2337 case SQL_VARBINARY: m = 255; d = 0;
break;
2338 case SQL_LONGVARBINARY: m = 65536; d = 0;
break;
2340 case SQL_BIGINT: m = 20; d = 19;
break;
2343 case SQL_BIT: m = 1; d = 1;
break;
2346 if (m &&
typename) {
2350 if (sscanf(
typename,
"%*[^(](%d,%d %1[)]", &mm, &dd, clbr) == 3) {
2353 }
else if (sscanf(
typename,
"%*[^(](%d %1[)]", &mm, clbr) == 2) {
2354 if (sqltype == SQL_TIMESTAMP) {
2357 #ifdef SQL_TYPE_TIMESTAMP 2358 else if (sqltype == SQL_TYPE_TIMESTAMP) {
2387 if (type == SQL_C_DEFAULT) {
2390 type = (nosign > 0) ? SQL_C_ULONG : SQL_C_LONG;
2393 type = (nosign > 0) ? SQL_C_UTINYINT : SQL_C_TINYINT;
2396 type = (nosign > 0) ? SQL_C_USHORT : SQL_C_SHORT;
2402 type = SQL_C_DOUBLE;
2405 type = SQL_C_TIMESTAMP;
2413 #ifdef SQL_C_TYPE_TIMESTAMP 2414 case SQL_TYPE_TIMESTAMP:
2415 type = SQL_C_TYPE_TIMESTAMP;
2418 #ifdef SQL_C_TYPE_TIME 2420 type = SQL_C_TYPE_TIME;
2423 #ifdef SQL_C_TYPE_DATE 2425 type = SQL_C_TYPE_DATE;
2431 #ifdef SQL_WLONGVARCHAR 2432 case SQL_WLONGVARCHAR:
2434 type = nowchar ? SQL_C_CHAR : SQL_C_WCHAR;
2439 case SQL_LONGVARBINARY:
2440 type = SQL_C_BINARY;
2454 type = nowchar ? SQL_C_CHAR : SQL_C_WCHAR;
2475 while (*sql &&
ISSPACE(*sql)) {
2478 if (*sql && *sql !=
';') {
2480 static const struct {
2502 if (size >= ddlstr[i].len &&
2503 strncasecmp(sql, ddlstr[i].str, ddlstr[i].len) == 0) {
2524 fixupsql(
char *sql,
int sqlLen,
int cte,
int *nparam,
int *isselect,
2527 char *q = sql, *qz = NULL, *p, *inq = NULL, *out;
2528 int np = 0, isddl = -1, size;
2533 if (sqlLen != SQL_NTS) {
2538 memcpy(q, sql, sqlLen);
2542 size = strlen(sql) * 4;
2544 size +=
sizeof (
char *) - 1;
2545 size &= ~(
sizeof (
char *) - 1);
2592 }
while (*qq &&
ISSPACE(*qq));
2593 if (*qq && *qq !=
';') {
2596 *errmsg =
"only one SQL statement allowed";
2611 int ojfn = 0, brc = 0;
2612 char *inq2 = NULL, *end = q + 1, *start;
2614 while (*end &&
ISSPACE(*end)) {
2617 if (*end !=
'd' && *end !=
'D' &&
2618 *end !=
't' && *end !=
'T') {
2623 if (inq2 && *end == *inq2) {
2625 }
else if (inq2 == NULL && *end ==
'{') {
2626 char *nerr = 0, *nsql;
2628 nsql =
fixupsql(end, SQL_NTS, cte, 0, 0, &nerr);
2629 if (nsql && !nerr) {
2635 }
else if (inq2 == NULL && *end ==
'}') {
2639 }
else if (inq2 == NULL && (*end ==
'\'' || *end ==
'"')) {
2641 }
else if (inq2 == NULL && *end ==
'?') {
2647 char *end2 = end - 1;
2650 while (start < end) {
2656 while (start < end) {
2663 while (start < end2 && *start !=
'\'') {
2666 while (end2 > start && *end2 !=
'\'') {
2669 if (*start ==
'\'' && *end2 ==
'\'') {
2670 while (start <= end2) {
2704 if (!incom && p[1] ==
'-') {
2714 if (incom > 0 && p[-1] ==
'*') {
2718 }
else if (!incom && p[1] ==
'*') {
2730 (strncasecmp(p,
"select", 6) == 0 ||
2731 strncasecmp(p,
"pragma", 6) == 0)) {
2733 }
else if (cte && size >= 4 && strncasecmp(p,
"with", 4) == 0) {
2735 }
else if (size >= 7 && strncasecmp(p,
"explain", 7) == 0) {
2759 for (i = 0; i < ncols; i++) {
2760 if (strcmp(cols[i], name) == 0) {
2788 #ifndef FULL_METADATA 2789 int pk, nn, t, r, nrows, ncols;
2790 char **rowp, *flagp, flags[128];
2801 for (i = 1; table[0] && i < s->
dcols; i++) {
2806 if (i >= s->
dcols) {
2807 for (i = 0; i < s->
dcols; i++) {
2811 }
else if (s->
dcols == 1) {
2815 for (i = 0; i < s->
dcols; i++) {
2821 #ifdef SQL_LONGVARCHAR 2828 #ifdef SQL_WLONGVARCHAR 2840 #ifndef FULL_METADATA 2843 if (flagp == NULL) {
2849 memset(flagp, 0,
sizeof (flags[0]) * s->
dcols);
2850 for (i = 0; i < s->
dcols; i++) {
2854 for (i = 0; i < s->
dcols; i++) {
2855 int ret, lastpk = -1, autoinccount = 0;
2864 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", s->
dyncols[i].
table);
2869 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, NULL);
2871 if (ret != SQLITE_OK) {
2874 k =
findcol(rowp, ncols,
"name");
2875 t =
findcol(rowp, ncols,
"type");
2876 pk =
findcol(rowp, ncols,
"pk");
2877 nn =
findcol(rowp, ncols,
"notnull");
2878 if (k < 0 || t < 0) {
2881 for (r = 1; r <= nrows; r++) {
2884 for (m = i; m < s->
dcols; m++) {
2888 char *dotp = strchr(colname,
'.');
2895 strcmp(colname, rowp[r * ncols + k]) == 0 &&
2897 char *
typename = rowp[r * ncols + t];
2908 #ifdef SQL_LONGVARCHAR 2915 #ifdef SQL_WLONGVARCHAR 2926 if (pk >= 0 && strcmp(rowp[r * ncols + pk],
"1") == 0) {
2928 if (++autoinccount > 1) {
2935 if (strlen(
typename) == 7 &&
2936 strncasecmp(
typename,
"integer", 7) == 0) {
2943 if (nn >= 0 && rowp[r * ncols + nn][0] !=
'0') {
2950 sqlite3_free_table(rowp);
2952 for (i = k = 0; i < s->
dcols; i++) {
2953 if (flagp[i] == 0) {
2958 }
else if (flagp[i] != k) {
2966 for (i = 0; i < s->
dcols; i++) {
2973 if (flagp != flags) {
2977 for (i = 1, k = 0; i < s->
dcols; i++) {
2985 for (i = 0; i < s->
dcols; i++) {
3007 int z, a, b, c, d, e, x1;
3010 ijd = jd * 86400000.0 + 0.5;
3011 z = (int) ((ijd + 43200000) / 86400000);
3012 a = (int) ((z - 1867216.25) / 36524.25);
3013 a = z + 1 + a - (a / 4);
3015 c = (int) ((b - 122.1) / 365.25);
3016 d = (36525 * c) / 100;
3017 e = (int) ((b - d) / 30.6001);
3018 x1 = (int) (30.6001 * e);
3019 ds->day = b - d - x1;
3020 ds->month = (e < 14) ? (e - 1) : (e - 13);
3021 ds->year = (ds->month > 2) ? (c - 4716) : (c - 4715);
3039 ijd = jd * 86400000.0 + 0.5;
3040 s = (int)((ijd + 43200000) % 86400000);
3043 *fp = (s % 1000) * 1000000;
3047 ts->hour = s / 3600;
3048 s -= ts->hour * 3600;
3049 ts->minute = s / 60;
3050 ds += s - ts->minute *60;
3051 ts->second = (int) ds;
3064 static const int mdays[] = {
3065 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
3072 mday = mdays[(month - 1) % 12];
3073 if (mday == 28 && year % 4 == 0 &&
3074 (!(year % 100 == 0) || year % 400 == 0)) {
3100 char *p, *q, sepc =
'\0';
3102 ds->year = ds->month = ds->day = 0;
3104 p = strchr(str,
'.');
3128 strncpy(buf, p + 0, 4); buf[4] =
'\0';
3129 ds->year = strtol(buf, NULL, 10);
3130 strncpy(buf, p + 4, 2); buf[2] =
'\0';
3131 ds->month = strtol(buf, NULL, 10);
3132 strncpy(buf, p + 6, 2); buf[2] =
'\0';
3133 ds->day = strtol(buf, NULL, 10);
3141 n = strtol(p, &q, 10);
3153 if (*q ==
'-' || *q ==
'/' || *q ==
'\0' || i == 2) {
3155 case 0: ds->year = n;
break;
3156 case 1: ds->month = n;
break;
3157 case 2: ds->day = n;
break;
3174 ds->month < 1 || ds->month > 12 ||
3175 ds->day < 1 || ds->day >
getmdays(ds->year, ds->month)) {
3186 if (ds->month >= 1 && ds->month <= 12 &&
3187 (ds->day >= 1 || ds->day <=
getmdays(ds->year, ds->month))) {
3213 int i, err = 0, ampm = -1;
3217 ts->hour = ts->minute = ts->second = 0;
3219 p = strchr(str,
'.');
3243 strncpy(buf, p + 0, 2); buf[2] =
'\0';
3244 ts->hour = strtol(buf, NULL, 10);
3245 strncpy(buf, p + 2, 2); buf[2] =
'\0';
3246 ts->minute = strtol(buf, NULL, 10);
3247 strncpy(buf, p + 4, 2); buf[2] =
'\0';
3248 ts->second = strtol(buf, NULL, 10);
3256 n = strtol(p, &q, 10);
3265 if (*q ==
':' || *q ==
'\0' || i == 2) {
3267 case 0: ts->hour = n;
break;
3268 case 1: ts->minute = n;
break;
3269 case 2: ts->second = n;
break;
3285 if ((p[0] ==
'p' || p[0] ==
'P') &&
3286 (p[1] ==
'm' || p[1] ==
'M')) {
3288 }
else if ((p[0] ==
'a' || p[0] ==
'A') &&
3289 (p[1] ==
'm' || p[1] ==
'M')) {
3295 if (ts->hour < 12) {
3298 }
else if (ampm == 0) {
3299 if (ts->hour == 12) {
3306 if (err || ts->hour > 23 || ts->minute > 59 || ts->second > 59) {
3334 int i, m, n, err = 0, ampm = -1;
3336 char *p, *q, in =
'\0', sepc =
'\0';
3338 tss->year = tss->month = tss->day = 0;
3339 tss->hour = tss->minute = tss->second = 0;
3342 p = strchr(str,
'.');
3344 q = strchr(str,
'-');
3349 q = strchr(str,
'/');
3351 q = strchr(str,
':');
3364 tss->year = ds.year;
3365 tss->month = ds.month;
3367 tss->hour = ts.hour;
3368 tss->minute = ts.minute;
3369 tss->second = ts.second;
3389 strncpy(buf, p + 0, 4); buf[4] =
'\0';
3390 tss->year = strtol(buf, NULL, 10);
3391 strncpy(buf, p + 4, 2); buf[2] =
'\0';
3392 tss->month = strtol(buf, NULL, 10);
3393 strncpy(buf, p + 6, 2); buf[2] =
'\0';
3394 tss->day = strtol(buf, NULL, 10);
3395 strncpy(buf, p + 8, 2); buf[2] =
'\0';
3396 tss->hour = strtol(buf, NULL, 10);
3397 strncpy(buf, p + 10, 2); buf[2] =
'\0';
3398 tss->minute = strtol(buf, NULL, 10);
3399 strncpy(buf, p + 12, 2); buf[2] =
'\0';
3400 tss->second = strtol(buf, NULL, 10);
3403 strncpy(buf, p + 14, m);
3409 tss->fraction = strtol(buf, NULL, 10);
3415 while ((m & 7) != 7) {
3417 n = strtol(p, &q, 10);
3457 case 0: tss->year = n;
break;
3458 case 1: tss->month = n;
break;
3459 case 2: tss->day = n;
break;
3474 case 0: tss->hour = n;
break;
3475 case 1: tss->minute = n;
break;
3476 case 2: tss->second = n;
break;
3489 (void) strtol(q + 1, &e, 10);
3490 if (e && *e ==
'-') {
3506 if (p[0] ==
'+' || p[0] ==
'-') {
3522 if ((q[0] ==
'a' || q[0] ==
'A') &&
3523 (q[1] ==
'm' || q[1] ==
'M')) {
3526 }
else if ((q[0] ==
'p' || q[0] ==
'P') &&
3527 (q[1] ==
'm' || q[1] ==
'M')) {
3536 if ((m & 7) > 1 && (m & 8)) {
3542 if (*q !=
'+' && *q !=
'-') {
3545 sign = (*q ==
'+') ? -1 : 1;
3547 n = strtol(p, &q, 10);
3548 if (!q || *q++ !=
':' || !
ISDIGIT(*q)) {
3553 nn = strtol(p, &q, 10);
3554 tss->minute += nn * sign;
3555 if ((SQLSMALLINT) tss->minute < 0) {
3558 }
else if (tss->minute >= 60) {
3562 tss->hour += n * sign;
3563 if ((SQLSMALLINT) tss->hour < 0) {
3566 }
else if (tss->hour >= 24) {
3570 if ((
short) tss->day < 1 || tss->day >= 28) {
3571 int mday, pday, pmon;
3573 mday =
getmdays(tss->year, tss->month);
3574 pmon = tss->month - 1;
3579 if ((SQLSMALLINT) tss->day < 1) {
3582 }
else if (tss->day > mday) {
3586 if ((SQLSMALLINT) tss->month < 1) {
3589 }
else if (tss->month > 12) {
3598 (tss->month < 1 || tss->month > 12 ||
3599 tss->day < 1 || tss->day >
getmdays(tss->year, tss->month))) {
3613 if (!err && (m & 1) == 0) {
3618 tss->year = t.wYear;
3619 tss->month = t.wMonth;
3625 gettimeofday(&tv, NULL);
3626 tm = *localtime(&tv.tv_sec);
3627 tss->year = tm.tm_year + 1900;
3628 tss->month = tm.tm_mon + 1;
3629 tss->day = tm.tm_mday;
3633 if (tss->fraction < 0) {
3638 tss->month < 1 || tss->month > 12 ||
3639 tss->day < 1 || tss->day >
getmdays(tss->year, tss->month) ||
3640 tss->hour > 23 || tss->minute > 59 || tss->second > 59) {
3645 if (tss->hour < 12) {
3648 }
else if (ampm == 0) {
3649 if (tss->hour == 12) {
3654 return ((m & 7) < 1) ? -1 : 0;
3667 return string[0] && strchr(
"Yy123456789Tt",
string[0]) != NULL;
3683 DBC *d = (
DBC *) sqlite3_user_data(ctx);
3688 if (sqlite3_value_type(args[0]) != SQLITE_NULL) {
3689 filename = (
char *) sqlite3_value_text(args[0]);
3694 char *wname = utf_to_wmb(filename, -1);
3697 FILE *f = fopen(filename,
"r");
3704 f = fopen(wname,
"rb");
3706 sqlite3_result_error(ctx,
"out of memory", -1);
3712 if (fseek(f, 0, SEEK_END) == 0) {
3714 if (fseek(f, 0, SEEK_SET) == 0) {
3715 p = sqlite3_malloc(n);
3717 nn = fread(p, 1, n, f);
3719 sqlite3_result_error(ctx,
"read error", -1);
3722 sqlite3_result_blob(ctx, p, n, sqlite3_free);
3725 sqlite3_result_error(ctx,
"out of memory", -1);
3728 sqlite3_result_error(ctx,
"seek error", -1);
3731 sqlite3_result_error(ctx,
"seek error", -1);
3735 sqlite3_result_error(ctx,
"cannot open file", -1);
3738 sqlite3_result_error(ctx,
"no filename given", -1);
3753 DBC *d = (
DBC *) sqlite3_user_data(ctx);
3760 p = (
char *) sqlite3_value_blob(args[0]);
3761 n = sqlite3_value_bytes(args[0]);
3764 if (sqlite3_value_type(args[1]) != SQLITE_NULL) {
3765 filename = (
char *) sqlite3_value_text(args[1]);
3771 char *wname = utf_to_wmb(filename, -1);
3774 FILE *f = fopen(filename,
"w");
3780 f = fopen(wname,
"wb");
3782 sqlite3_result_error(ctx,
"out of memory", -1);
3788 nn = fwrite(p, 1, n, f);
3791 sqlite3_result_error(ctx,
"write error", -1);
3793 sqlite3_result_int(ctx, nn);
3796 sqlite3_result_error(ctx,
"cannot open file", -1);
3799 sqlite3_result_error(ctx,
"no filename given", -1);
3802 sqlite3_result_null(ctx);
3814 #if defined(HAVE_SQLITE3PROFILE) && (HAVE_SQLITE3PROFILE) 3815 dbtrace(
void *arg,
const char *msg, sqlite_uint64 et)
3817 dbtrace(
void *arg,
const char *msg)
3822 if (msg && d->
trace) {
3823 int len = strlen(msg);
3824 #if defined(HAVE_SQLITE3PROFILE) && (HAVE_SQLITE3PROFILE) 3831 if (msg[len - 1] !=
';') {
3834 fprintf(d->
trace,
"%s%s", msg, end);
3835 #if defined(HAVE_SQLITE3PROFILE) && (HAVE_SQLITE3PROFILE) 3836 s = et / 1000000000LL;
3837 f = et % 1000000000LL;
3838 fprintf(d->
trace,
"-- took %lu.%09lu seconds\n", s, f);
3855 if (fn && d->
trace) {
3857 fprintf(d->
trace,
"-- %s: %s\n", fn, sql);
3859 fprintf(d->
trace,
"-- %s\n", fn);
3875 if (rc != SQLITE_OK && d->
trace) {
3876 fprintf(d->
trace,
"-- SQLITE ERROR CODE %d", rc);
3877 fprintf(d->
trace, err ?
": %s\n" :
"\n", err);
3898 char *spflag,
char *ntflag,
char *jmode,
char *busy)
3901 int rc, tmp, busyto = 100000;
3902 #if defined(HAVE_SQLITE3VFS) && (HAVE_SQLITE3VFS) 3903 int flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
3905 const char *vfs_name = NULL;
3910 fprintf(d->
trace,
"-- sqlite3_close (deferred): '%s'\n",
3914 #if defined(HAVE_SQLITE3CLOSEV2) && (HAVE_SQLITE3CLOSEV2) 3915 sqlite3_close_v2(d->
sqlite);
3917 sqlite3_close(d->
sqlite);
3921 #if defined(HAVE_SQLITE3VFS) && (HAVE_SQLITE3VFS) 3923 flags &= ~ SQLITE_OPEN_CREATE;
3925 #if defined(_WIN32) || defined(_WIN64) 3927 char expname[SQL_MAX_MESSAGE_LENGTH * 2];
3930 rc = ExpandEnvironmentStrings(name, expname,
sizeof (expname));
3931 if (rc <=
sizeof (expname)) {
3932 uname = wmb_to_utf(expname, rc - 1);
3934 uname = wmb_to_utf(name, -1);
3938 setstatd(d, rc,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
3943 #if defined(ENABLE_NVFS) && (ENABLE_NVFS) 3944 vfs_name = nvfs_makevfs(uname);
3946 #ifdef SQLITE_OPEN_URI 3947 flags |= SQLITE_OPEN_URI;
3949 rc = sqlite3_open_v2(uname, &d->
sqlite, flags, vfs_name);
3950 #if defined(WINTERFACE) || defined(_WIN32) || defined(_WIN64) 3951 if (uname != name) {
3956 #if defined(_WIN32) || defined(_WIN64) 3961 cname = utf_to_wmb(name, -1);
3963 if (GetFileAttributesA(cname ? cname : name) ==
3964 INVALID_FILE_ATTRIBUTES) {
3966 rc = SQLITE_CANTOPEN;
3967 setstatd(d, rc,
"cannot open database",
3968 (*d->
ov3) ?
"HY000" :
"S1000");
3974 if (d->
nocreat && access(name, 004) < 0) {
3975 rc = SQLITE_CANTOPEN;
3976 setstatd(d, rc,
"cannot open database", (*d->
ov3) ?
"HY000" :
"S1000");
3980 #if defined(_WIN32) || defined(_WIN64) 3982 WCHAR *wname = wmb_to_uc(name, -1);
3986 setstatd(d, rc,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
3989 rc = sqlite3_open16(wname, &d->
sqlite);
3993 rc = sqlite3_open(name, &d->
sqlite);
3995 if (rc != SQLITE_OK) {
3997 setstatd(d, rc,
"connect failed", (*d->
ov3) ?
"HY000" :
"S1000");
3999 sqlite3_close(d->
sqlite);
4004 #if defined(SQLITE_DYNLOAD) || defined(SQLITE_HAS_CODEC) 4012 #if defined(HAVE_SQLITE3PROFILE) && (HAVE_SQLITE3PROFILE) 4021 SQL_CURSOR_FORWARD_ONLY : SQL_CURSOR_STATIC;
4022 tmp = strtol(busy, &endp, 0);
4023 if (endp && *endp ==
'\0' && endp != busy) {
4026 if (busyto < 1 || busyto > 1000000) {
4036 fprintf(d->
trace,
"-- sqlite3_close: '%s'\n",
4040 sqlite3_close(d->
sqlite);
4044 if (!spflag || spflag[0] ==
'\0') {
4047 if (spflag[0] !=
'\0') {
4050 sprintf(syncp,
"PRAGMA synchronous = %8.8s;", spflag);
4051 sqlite3_exec(d->
sqlite, syncp, NULL, NULL, NULL);
4053 if (jmode[0] !=
'\0') {
4056 sprintf(jourp,
"PRAGMA journal_mode = %16.16s;", jmode);
4057 sqlite3_exec(d->
sqlite, jourp, NULL, NULL, NULL);
4060 fprintf(d->
trace,
"-- sqlite3_open: '%s'\n", d->
dbname);
4063 #if defined(_WIN32) || defined(_WIN64) 4065 char pname[MAX_PATH];
4066 HANDLE h = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
4067 FALSE, GetCurrentProcessId());
4071 HMODULE m = NULL, l = LoadLibrary(
"psapi.dll");
4073 typedef BOOL (WINAPI *epmfunc)(HANDLE, HMODULE *, DWORD, LPDWORD);
4074 typedef BOOL (WINAPI *gmbfunc)(HANDLE, HMODULE, LPSTR, DWORD);
4079 epm = (epmfunc) GetProcAddress(l,
"EnumProcessModules");
4080 gmb = (gmbfunc) GetProcAddress(l,
"GetModuleBaseNameA");
4081 if (epm && gmb && epm(h, &m,
sizeof (m), &need)) {
4082 gmb(h, m, pname,
sizeof (pname));
4088 d->xcelqrx = strncasecmp(pname,
"EXCEL", 5) == 0 ||
4089 strncasecmp(pname,
"MSQRY", 5) == 0;
4090 if (d->
trace && d->xcelqrx) {
4092 fprintf(d->
trace,
"-- enabled EXCEL quirks\n");
4097 sqlite3_create_function(d->
sqlite,
"blob_import", 1, SQLITE_UTF8,
4099 sqlite3_create_function(d->
sqlite,
"blob_export", 2, SQLITE_UTF8,
4113 #if defined(HAVE_SQLITE3LOADEXTENSION) && (HAVE_SQLITE3LOADEXTENSION) 4115 char path[SQL_MAX_MESSAGE_LENGTH];
4121 sqlite3_enable_load_extension(d->
sqlite, 1);
4122 #if defined(_WIN32) || defined(_WIN64) 4123 GetModuleFileName(hModule, path,
sizeof (path));
4124 p = strrchr(path,
'\\');
4125 plen = p ? ((p + 1) - path) : 0;
4128 p = strchr(exts,
',');
4130 strncpy(path + plen, exts, p - exts);
4131 path[plen + (p - exts)] =
'\0';
4133 strcpy(path + plen, exts);
4136 char *errmsg = NULL;
4138 #if defined(_WIN32) || defined(_WIN64) 4144 ((q[1] ==
':' && (q[2] ==
'\\' || q[2] ==
'/')) ||
4145 q[0] ==
'\\' || q[0] ==
'/' || q[0] ==
'.'))) {
4149 for (i = 0; q[i] !=
'\0'; i++) {
4154 rc = sqlite3_load_extension(d->
sqlite, q, 0, &errmsg);
4156 rc = sqlite3_load_extension(d->
sqlite, path, 0, &errmsg);
4158 if (rc != SQLITE_OK) {
4159 #if defined(_WIN32) || defined(_WIN64) 4160 char buf[512], msg[512];
4162 LoadString(hModule, IDS_EXTERR, buf,
sizeof (buf));
4163 wsprintf(msg, buf, q, errmsg ?
4164 errmsg :
"no error info available");
4165 LoadString(hModule, IDS_EXTTITLE, buf,
sizeof (buf));
4166 MessageBox(NULL, msg, buf,
4167 MB_ICONEXCLAMATION | MB_OK | MB_TASKMODAL |
4170 fprintf(stderr,
"extension '%s' did not load%s%s\n",
4171 path, errmsg ?
": " :
"", errmsg ? errmsg :
"");
4194 char *
typename = (
char *) sqlite3_column_decltype(s3stmt, col);
4199 int coltype = sqlite3_column_type(s3stmt, col);
4201 if (guessed_types) {
4205 sprintf(guess,
" (guessed from %d)", coltype);
4208 case SQLITE_INTEGER:
typename =
"integer";
break;
4209 case SQLITE_FLOAT:
typename =
"double";
break;
4211 case SQLITE_TEXT:
typename =
"varchar";
break;
4212 case SQLITE_BLOB:
typename =
"blob";
break;
4214 case SQLITE_NULL:
typename =
"null";
break;
4219 fprintf(d->
trace,
"-- column %d type%s: '%s'\n", col + 1,
4226 #ifdef FULL_METADATA 4237 s3stmt_addmeta(sqlite3_stmt *s3stmt,
int col,
DBC *d,
COL *ci)
4239 int nn = 0, pk = 0, ai = 0;
4240 const char *dn = NULL, *tn = NULL, *cn = NULL, *dummy[4];
4242 dn = sqlite3_column_database_name(s3stmt, col);
4243 tn = sqlite3_column_table_name(s3stmt, col);
4244 cn = sqlite3_column_origin_name(s3stmt, col);
4245 dummy[0] = dummy[1] = 0;
4247 sqlite3_table_column_metadata(d->
sqlite, dn, tn, cn,
4251 ci->
autoinc = ai ? SQL_TRUE: SQL_FALSE;
4252 ci->
notnull = nn ? SQL_NO_NULLS : SQL_NULLABLE;
4253 ci->
ispk = pk ? 1 : 0;
4255 fprintf(d->
trace,
"-- column %d %s\n",
4256 col + 1, nn ?
"notnull" :
"nullable");
4258 fprintf(d->
trace,
"-- column %d autoincrement\n", col + 1);
4263 if (ci->
ispk && tn) {
4265 dummy[2] = dummy[3] = 0;
4267 sqlite3_table_column_metadata(d->
sqlite, dn, tn,
"rowid",
4268 dummy + 2, dummy + 3,
4270 if (pk && dummy[0] && dummy[0] == dummy[2]) {
4289 const char *errp = NULL;
4293 setstat(s, -1,
"stale statement", (*s->
ov3) ?
"HY000" :
"S1000");
4296 rc = sqlite3_step(s->
s3stmt);
4297 if (rc == SQLITE_ROW || rc == SQLITE_DONE) {
4299 ncols = sqlite3_column_count(s->
s3stmt);
4304 const char *colname, *
typename;
4305 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME) 4309 for (i = size = 0; i < ncols; i++) {
4310 colname = sqlite3_column_name(s->
s3stmt, i);
4311 size += 3 + 3 * strlen(colname);
4313 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME) 4314 tblname = (
char *) size;
4315 for (i = 0; i < ncols; i++) {
4316 p = (
char *) sqlite3_column_table_name(s->
s3stmt, i);
4317 size += 2 + (p ? strlen(p) : 0);
4320 dyncols =
xmalloc(ncols *
sizeof (
COL) + size);
4325 sqlite3_finalize(s->
s3stmt);
4330 p = (
char *) (dyncols + ncols);
4331 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME) 4334 for (i = 0; i < ncols; i++) {
4337 colname = sqlite3_column_name(s->
s3stmt, i);
4339 fprintf(d->
trace,
"-- column %d name: '%s'\n",
4343 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME) 4344 q = (
char *) sqlite3_column_table_name(s->
s3stmt, i);
4345 strcpy(tblname, q ? q :
"");
4347 fprintf(d->
trace,
"-- table %d name: '%s'\n",
4351 dyncols[i].
table = tblname;
4352 tblname += strlen(tblname) + 1;
4355 dyncols[i].
db = ((
DBC *) (s->
dbc))->dbname;
4357 dyncols[i].
label = p;
4359 q = strchr(colname,
'.');
4361 char *q2 = strchr(q + 1,
'.');
4369 #if !defined(HAVE_SQLITE3COLUMNTABLENAME) || !(HAVE_SQLITE3COLUMNTABLENAME) 4370 dyncols[i].
table = p;
4372 strncpy(p, colname, q - colname);
4373 p[q - colname] =
'\0';
4379 #if !defined(HAVE_SQLITE3COLUMNTABLENAME) || !(HAVE_SQLITE3COLUMNTABLENAME) 4380 dyncols[i].
table =
"";
4389 #ifdef SQL_LONGVARCHAR 4390 dyncols[i].
type = SQL_LONGVARCHAR;
4391 dyncols[i].
size = 65535;
4393 dyncols[i].
type = SQL_VARCHAR;
4394 dyncols[i].
size = 255;
4396 dyncols[i].
index = i;
4397 dyncols[i].
scale = 0;
4398 dyncols[i].
prec = 0;
4400 dyncols[i].
autoinc = SQL_FALSE;
4401 dyncols[i].
notnull = SQL_NULLABLE;
4402 dyncols[i].
ispk = -1;
4404 #ifdef FULL_METADATA 4405 s3stmt_addmeta(s->
s3stmt, i, d, &dyncols[i]);
4419 if (rc == SQLITE_DONE) {
4423 sqlite3_finalize(s->
s3stmt);
4428 rowd =
xmalloc((1 + 2 * ncols) *
sizeof (
char *));
4430 const unsigned char *value;
4432 rowd[0] = (
char *) ((
PTRDIFF_T) (ncols * 2));
4434 for (i = 0; i < ncols; i++) {
4435 int coltype = sqlite3_column_type(s->
s3stmt, i);
4437 rowd[i] = rowd[i + ncols] = NULL;
4438 if (coltype == SQLITE_BLOB) {
4439 int k, nbytes = sqlite3_column_bytes(s->
s3stmt, i);
4441 unsigned const char *bp;
4443 bp = sqlite3_column_blob(s->
s3stmt, i);
4446 rowd[i + ncols] = qp;
4449 for (k = 0; k < nbytes; k++) {
4450 *qp++ =
xdigits[(bp[k] >> 4)];
4451 *qp++ =
xdigits[(bp[k] & 0xF)];
4457 }
else if (coltype == SQLITE_FLOAT) {
4458 struct lconv *lc = 0;
4459 double d = sqlite3_column_double(s->
s3stmt, i);
4460 char *p, buffer[128];
4467 snprintf(buffer,
sizeof (buffer),
"%.15g", d);
4469 if (lc && lc->decimal_point && lc->decimal_point[0] &&
4470 lc->decimal_point[0] !=
'.') {
4471 p = strchr(buffer, lc->decimal_point[0]);
4476 rowd[i + ncols] =
xstrdup(buffer);
4478 }
else if (coltype != SQLITE_NULL) {
4479 value = sqlite3_column_text(s->
s3stmt, i);
4480 rowd[i + ncols] =
xstrdup((
char *) value);
4483 for (i = 0; i < ncols; i++) {
4484 int coltype = sqlite3_column_type(s->
s3stmt, i);
4487 if (coltype == SQLITE_BLOB) {
4488 value = sqlite3_column_blob(s->
s3stmt, i);
4489 }
else if (coltype != SQLITE_NULL) {
4490 value = sqlite3_column_text(s->
s3stmt, i);
4492 if (value && !rowd[i + ncols]) {
4504 if (rc == SQLITE_DONE) {
4506 sqlite3_finalize(s->
s3stmt);
4515 rc = sqlite3_reset(s->
s3stmt);
4517 errp = sqlite3_errmsg(d->
sqlite);
4521 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
4522 errp ? errp :
"unknown error", rc);
4545 sqlite3_reset(s->
s3stmt);
4586 sqlite3_finalize(s->
s3stmt);
4603 sqlite3_stmt *s3stmt = NULL;
4608 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 4615 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 4616 rc = sqlite3_prepare_v2(d->
sqlite, (
char *) s->
query, -1,
4619 rc = sqlite3_prepare(d->
sqlite, (
char *) s->
query, -1,
4622 if (rc != SQLITE_OK) {
4624 sqlite3_finalize(s3stmt);
4628 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
4630 if (rc != SQLITE_OK) {
4633 sqlite3_finalize(s3stmt);
4635 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
4636 sqlite3_errmsg(d->
sqlite), rc);
4639 if (sqlite3_bind_parameter_count(s3stmt) != s->
nparams) {
4641 sqlite3_finalize(s3stmt);
4642 setstat(s, SQLITE_ERROR,
"parameter marker count incorrect",
4643 (*s->
ov3) ?
"HY000" :
"S1000");
4662 SQLDataSources(SQLHENV env, SQLUSMALLINT dir, SQLCHAR *srvname,
4663 SQLSMALLINT buflen1, SQLSMALLINT *lenp1,
4664 SQLCHAR *desc, SQLSMALLINT buflen2, SQLSMALLINT *lenp2)
4666 if (env == SQL_NULL_HENV) {
4667 return SQL_INVALID_HANDLE;
4680 SQLSMALLINT buflen1, SQLSMALLINT *lenp1,
4681 SQLWCHAR *desc, SQLSMALLINT buflen2, SQLSMALLINT *lenp2)
4683 if (env == SQL_NULL_HENV) {
4684 return SQL_INVALID_HANDLE;
4696 SQLDrivers(SQLHENV env, SQLUSMALLINT dir, SQLCHAR *drvdesc,
4697 SQLSMALLINT descmax, SQLSMALLINT *desclenp,
4698 SQLCHAR *drvattr, SQLSMALLINT attrmax, SQLSMALLINT *attrlenp)
4700 if (env == SQL_NULL_HENV) {
4701 return SQL_INVALID_HANDLE;
4714 SQLSMALLINT descmax, SQLSMALLINT *desclenp,
4715 SQLWCHAR *drvattr, SQLSMALLINT attrmax, SQLSMALLINT *attrlenp)
4717 if (env == SQL_NULL_HENV) {
4718 return SQL_INVALID_HANDLE;
4730 SQLBrowseConnect(SQLHDBC
dbc, SQLCHAR *connin, SQLSMALLINT conninLen,
4731 SQLCHAR *connout, SQLSMALLINT connoutMax,
4732 SQLSMALLINT *connoutLen)
4750 SQLWCHAR *connout, SQLSMALLINT connoutMax,
4751 SQLSMALLINT *connoutLen)
4774 int i, dlen, done = 0;
4777 if (
stmt == SQL_NULL_HSTMT) {
4778 return SQL_INVALID_HANDLE;
4783 setstat(s, -1,
"sequence error",
"HY010");
4786 for (i = (s->
pdcount < 0) ? 0 : s->
pdcount; i < s->nparams; i++) {
4791 if (len == SQL_NULL_DATA) {
4794 p->
len = SQL_NULL_DATA;
4796 }
else if (type != SQL_C_CHAR
4798 && type != SQL_C_WCHAR
4800 && type != SQL_C_BINARY) {
4805 case SQL_C_UTINYINT:
4806 case SQL_C_STINYINT:
4810 size =
sizeof (SQLCHAR);
4815 size =
sizeof (SQLSMALLINT);
4820 size =
sizeof (SQLINTEGER);
4825 size =
sizeof (SQLBIGINT);
4829 size =
sizeof (float);
4832 size =
sizeof (double);
4834 #ifdef SQL_C_TYPE_DATE 4835 case SQL_C_TYPE_DATE:
4838 size =
sizeof (DATE_STRUCT);
4840 #ifdef SQL_C_TYPE_DATE 4841 case SQL_C_TYPE_TIME:
4844 size =
sizeof (TIME_STRUCT);
4846 #ifdef SQL_C_TYPE_DATE 4847 case SQL_C_TYPE_TIMESTAMP:
4849 case SQL_C_TIMESTAMP:
4850 size =
sizeof (TIMESTAMP_STRUCT);
4859 memcpy(p->
param, data, size);
4862 }
else if (len == SQL_NTS && (
4865 || type == SQL_C_WCHAR
4871 if (type == SQL_C_WCHAR) {
4878 #if defined(_WIN32) || defined(_WIN64) 4880 dp = wmb_to_utf(data, strlen (data));
4896 strcpy(p->
param, dp);
4902 }
else if (len < 0) {
4903 setstat(s, -1,
"invalid length",
"HY090");
4908 setstat(s, -1,
"no memory for parameter",
"HY013");
4911 memcpy((
char *) p->
param + p->
offs, data, dlen);
4915 if (type == SQL_C_WCHAR) {
4937 *((
char *) p->
param + p->
len) =
'\0';
4939 p->
need = (type == SQL_C_CHAR || type == SQL_C_WCHAR)
4942 *((
char *) p->
param + p->
len) =
'\0';
4943 p->
need = (type == SQL_C_CHAR) ? -1 : 0;
4945 #if defined(_WIN32) || defined(_WIN64) 4946 if (type == SQL_C_CHAR && *s->
oemcp &&
4947 !(p->
stype == SQL_BINARY ||
4948 p->
stype == SQL_VARBINARY ||
4949 p->
stype == SQL_LONGVARBINARY)) {
4950 char *dp = wmb_to_utf(p->
param, p->
len);
4959 p->
len = strlen(dp);
4961 if (p->
type == SQL_C_WCHAR &&
4962 (p->
stype == SQL_VARCHAR ||
4963 p->
stype == SQL_LONGVARCHAR) &&
4964 p->
len == p->
coldef * sizeof (SQLWCHAR)) {
5033 int type, len = 0, needalloc = 0;
5041 #if (defined(_WIN32) || defined(_WIN64)) && defined(WINTERFACE) 5043 if (type == SQL_C_WCHAR && p->
type == SQL_C_DEFAULT) {
5056 if (type == SQL_C_CHAR &&
5057 (p->
stype == SQL_BINARY ||
5058 p->
stype == SQL_VARBINARY ||
5059 p->
stype == SQL_LONGVARBINARY)) {
5060 type = SQL_C_BINARY;
5072 }
else if (*p->
lenp == SQL_DATA_AT_EXEC) {
5076 if (len <= SQL_LEN_DATA_AT_EXEC_OFFSET) {
5077 len = SQL_LEN_DATA_AT_EXEC(len);
5081 setstat(s, -1,
"invalid length",
"HY009");
5098 if (type == SQL_C_WCHAR) {
5099 if (!p->
lenp || *p->
lenp == SQL_NTS) {
5101 }
else if (*p->
lenp >= 0) {
5106 if (type == SQL_C_CHAR) {
5107 if (!p->
lenp || *p->
lenp == SQL_NTS) {
5109 #if defined(_WIN32) || defined(_WIN64) 5112 }
else if (*p->
lenp >= 0) {
5122 if (type == SQL_C_WCHAR) {
5138 if (type == SQL_C_CHAR) {
5143 #if defined(_WIN32) || defined(_WIN64) 5155 #if defined(_WIN32) || defined(_WIN64) 5157 p->
len = strlen(dp);
5176 case SQL_C_UTINYINT:
5178 case SQL_C_STINYINT:
5179 p->
s3type = SQLITE_INTEGER;
5180 p->
s3size =
sizeof (int);
5184 p->
s3type = SQLITE_INTEGER;
5185 p->
s3size =
sizeof (int);
5190 p->
s3type = SQLITE_INTEGER;
5191 p->
s3size =
sizeof (int);
5195 p->
s3type = SQLITE_INTEGER;
5196 p->
s3size =
sizeof (int);
5201 p->
s3type = SQLITE_INTEGER;
5202 p->
s3size =
sizeof (int);
5207 p->
s3type = SQLITE_INTEGER;
5208 p->
s3size =
sizeof (int);
5214 p->
s3type = SQLITE_INTEGER;
5215 p->
s3size =
sizeof (sqlite_int64);
5219 p->
s3type = SQLITE_INTEGER;
5220 p->
s3size =
sizeof (sqlite_int64);
5225 p->
s3type = SQLITE_FLOAT;
5226 p->
s3size =
sizeof (double);
5230 p->
s3type = SQLITE_FLOAT;
5231 p->
s3size =
sizeof (double);
5234 #ifdef SQL_C_TYPE_DATE 5235 case SQL_C_TYPE_DATE:
5239 int a, b, x1, x2, y, m, d;
5241 p->
s3type = SQLITE_FLOAT;
5242 p->
s3size =
sizeof (double);
5243 y = ((DATE_STRUCT *) p->
param)->year;
5244 m = ((DATE_STRUCT *) p->
param)->month;
5245 d = ((DATE_STRUCT *) p->
param)->day;
5251 b = 2 - a + (a / 4);
5252 x1 = 36525 * (y + 4716) / 100;
5253 x2 = 306001 * (m + 1) / 10000;
5254 p->
s3dval = x1 + x2 + d + b - 1524.5;
5257 sprintf(p->
strbuf,
"%04d-%02d-%02d",
5258 ((DATE_STRUCT *) p->
param)->year,
5259 ((DATE_STRUCT *) p->
param)->month,
5260 ((DATE_STRUCT *) p->
param)->day);
5265 #ifdef SQL_C_TYPE_TIME 5266 case SQL_C_TYPE_TIME:
5270 p->
s3type = SQLITE_FLOAT;
5271 p->
s3size =
sizeof (double);
5273 (((TIME_STRUCT *) p->
param)->hour * 3600000.0 +
5274 ((TIME_STRUCT *) p->
param)->minute * 60000.0 +
5275 ((TIME_STRUCT *) p->
param)->second * 1000.0) / 86400000.0;
5278 sprintf(p->
strbuf,
"%02d:%02d:%02d",
5279 ((TIME_STRUCT *) p->
param)->hour,
5280 ((TIME_STRUCT *) p->
param)->minute,
5281 ((TIME_STRUCT *) p->
param)->second);
5286 #ifdef SQL_C_TYPE_TIMESTAMP 5287 case SQL_C_TYPE_TIMESTAMP:
5289 case SQL_C_TIMESTAMP:
5291 int a, b, x1, x2, y, m, d;
5293 p->
s3type = SQLITE_FLOAT;
5294 p->
s3size =
sizeof (double);
5295 y = ((TIMESTAMP_STRUCT *) p->
param)->year;
5296 m = ((TIMESTAMP_STRUCT *) p->
param)->month;
5297 d = ((TIMESTAMP_STRUCT *) p->
param)->day;
5303 b = 2 - a + (a / 4);
5304 x1 = 36525 * (y + 4716) / 100;
5305 x2 = 306001 * (m + 1) / 10000;
5306 p->
s3dval = x1 + x2 + d + b - 1524.5 +
5307 (((TIMESTAMP_STRUCT *) p->
param)->hour * 3600000.0 +
5308 ((TIMESTAMP_STRUCT *) p->
param)->minute * 60000.0 +
5309 ((TIMESTAMP_STRUCT *) p->
param)->second * 1000.0 +
5310 ((TIMESTAMP_STRUCT *) p->
param)->fraction / 1.0E6)
5314 len = (int) ((TIMESTAMP_STRUCT *) p->
param)->fraction;
5321 sprintf(p->
strbuf,
"%04d-%02d-%02d %02d:%02d:00.000",
5322 ((TIMESTAMP_STRUCT *) p->
param)->year,
5323 ((TIMESTAMP_STRUCT *) p->
param)->month,
5324 ((TIMESTAMP_STRUCT *) p->
param)->day,
5325 ((TIMESTAMP_STRUCT *) p->
param)->hour,
5326 ((TIMESTAMP_STRUCT *) p->
param)->minute);
5328 sprintf(p->
strbuf,
"%04d-%02d-%02d %02d:%02d:%02d.000",
5329 ((TIMESTAMP_STRUCT *) p->
param)->year,
5330 ((TIMESTAMP_STRUCT *) p->
param)->month,
5331 ((TIMESTAMP_STRUCT *) p->
param)->day,
5332 ((TIMESTAMP_STRUCT *) p->
param)->hour,
5333 ((TIMESTAMP_STRUCT *) p->
param)->minute,
5334 ((TIMESTAMP_STRUCT *) p->
param)->second);
5336 sprintf(p->
strbuf,
"%04d-%02d-%02d %02d:%02d:%02d.%03d",
5337 ((TIMESTAMP_STRUCT *) p->
param)->year,
5338 ((TIMESTAMP_STRUCT *) p->
param)->month,
5339 ((TIMESTAMP_STRUCT *) p->
param)->day,
5340 ((TIMESTAMP_STRUCT *) p->
param)->hour,
5341 ((TIMESTAMP_STRUCT *) p->
param)->minute,
5342 ((TIMESTAMP_STRUCT *) p->
param)->second,
5351 setstat(s, -1,
"unsupported parameter type",
5352 (*s->
ov3) ?
"07009" :
"S1093");
5375 SQLSMALLINT buftype, SQLSMALLINT ptype, SQLUINTEGER coldef,
5377 SQLPOINTER data, SQLINTEGER buflen,
SQLLEN *len)
5382 if (
stmt == SQL_NULL_HSTMT) {
5383 return SQL_INVALID_HANDLE;
5387 setstat(s, -1,
"invalid parameter", (*s->
ov3) ?
"07009" :
"S1093");
5390 if (!data && !len) {
5391 setstat(s, -1,
"invalid buffer",
"HY003");
5411 int npar =
max(10, pnum + 1);
5421 case SQL_C_STINYINT:
5422 case SQL_C_UTINYINT:
5427 buflen =
sizeof (SQLCHAR);
5432 buflen =
sizeof (SQLSMALLINT);
5437 buflen =
sizeof (SQLINTEGER);
5440 buflen =
sizeof (float);
5443 buflen =
sizeof (double);
5445 case SQL_C_TIMESTAMP:
5446 #ifdef SQL_C_TYPE_TIMESTAMP 5447 case SQL_C_TYPE_TIMESTAMP:
5449 buflen =
sizeof (TIMESTAMP_STRUCT);
5452 #ifdef SQL_C_TYPE_TIME 5453 case SQL_C_TYPE_TIME:
5455 buflen =
sizeof (TIME_STRUCT);
5458 #ifdef SQL_C_TYPE_DATE 5459 case SQL_C_TYPE_DATE:
5461 buflen =
sizeof (DATE_STRUCT);
5463 #ifdef SQL_C_UBIGINT 5465 buflen =
sizeof (SQLBIGINT);
5468 #ifdef SQL_C_SBIGINT 5470 buflen =
sizeof (SQLBIGINT);
5475 buflen =
sizeof (SQLBIGINT);
5514 SQLSMALLINT buftype, SQLSMALLINT ptype,
SQLULEN coldef,
5522 scale, data, buflen, len);
5543 SQLSMALLINT ptype,
SQLULEN lenprec,
5544 SQLSMALLINT scale, SQLPOINTER val,
5551 lenprec, scale, val, 0, lenp);
5571 if (
stmt == SQL_NULL_HSTMT) {
5572 return SQL_INVALID_HANDLE;
5594 if (*p->
lenp == SQL_DATA_AT_EXEC) {
5597 p->
len = SQL_LEN_DATA_AT_EXEC(*p->
lenp);
5599 if (p->
len < 0 && p->
len != SQL_NTS &&
5600 p->
len != SQL_NULL_DATA) {
5601 setstat(s, -1,
"invalid length",
"HY009");
5614 return SQL_NEED_DATA;
5634 if (
stmt == SQL_NULL_HSTMT) {
5635 return SQL_INVALID_HANDLE;
5644 for (i = 0; i < s->
pdcount; i++) {
5649 p->
need = (type == SQL_C_CHAR || type == SQL_C_WCHAR) ? -1 : 0;
5655 *pind = (SQLPOINTER) p->
param0;
5680 SQLULEN *size, SQLSMALLINT *decdigits, SQLSMALLINT *nullable)
5683 SQLRETURN ret = SQL_ERROR;
5686 if (
stmt == SQL_NULL_HSTMT) {
5687 return SQL_INVALID_HANDLE;
5692 setstat(s, -1,
"invalid parameter index",
5693 (*s->
ov3) ?
"HY000" :
"S1000");
5697 #ifdef SQL_LONGVARCHAR 5699 *dtype = s->
nowchar[0] ? SQL_LONGVARCHAR : SQL_WLONGVARCHAR;
5701 *dtype = SQL_LONGVARCHAR;
5705 *dtype = s->
nowchar[0] ? SQL_VARCHAR : SQL_WVARCHAR;
5707 *dtype = SQL_VARCHAR;
5712 #ifdef SQL_LONGVARCHAR 5722 *nullable = SQL_NULLABLE;
5745 SQLSMALLINT sqltype,
SQLULEN coldef,
5746 SQLSMALLINT scale, SQLPOINTER val,
SQLLEN *nval)
5752 type, sqltype, coldef, scale, val,
5753 SQL_SETPARAM_VALUE_MAX, nval);
5779 SQLGetDescField(SQLHDESC handle, SQLSMALLINT recno,
5780 SQLSMALLINT fieldid, SQLPOINTER value,
5781 SQLINTEGER buflen, SQLINTEGER *strlen)
5794 SQLSMALLINT fieldid, SQLPOINTER value,
5795 SQLINTEGER buflen, SQLINTEGER *strlen)
5807 SQLSetDescField(SQLHDESC handle, SQLSMALLINT recno,
5808 SQLSMALLINT fieldid, SQLPOINTER value,
5822 SQLSMALLINT fieldid, SQLPOINTER value,
5835 SQLGetDescRec(SQLHDESC handle, SQLSMALLINT recno,
5836 SQLCHAR *name, SQLSMALLINT buflen,
5837 SQLSMALLINT *strlen, SQLSMALLINT *type,
5838 SQLSMALLINT *subtype,
SQLLEN *len,
5839 SQLSMALLINT *prec, SQLSMALLINT *scale,
5840 SQLSMALLINT *nullable)
5853 SQLWCHAR *name, SQLSMALLINT buflen,
5854 SQLSMALLINT *strlen, SQLSMALLINT *type,
5855 SQLSMALLINT *subtype,
SQLLEN *len,
5856 SQLSMALLINT *prec, SQLSMALLINT *scale,
5857 SQLSMALLINT *nullable)
5869 SQLSMALLINT type, SQLSMALLINT subtype,
5870 SQLLEN len, SQLSMALLINT prec,
5871 SQLSMALLINT scale, SQLPOINTER data,
5890 int ncols3,
int *nret)
5895 if (
stmt == SQL_NULL_HSTMT) {
5896 return SQL_INVALID_HANDLE;
5899 if (s->
dbc == SQL_NULL_HDBC) {
5909 if (colspec3 && *s->
ov3) {
5932 {
"SYSTEM",
"TABLEPRIV",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
5933 {
"SYSTEM",
"TABLEPRIV",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
5934 {
"SYSTEM",
"TABLEPRIV",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
5935 {
"SYSTEM",
"TABLEPRIV",
"GRANTOR",
SCOL_VARCHAR, 50 },
5936 {
"SYSTEM",
"TABLEPRIV",
"GRANTEE",
SCOL_VARCHAR, 50 },
5937 {
"SYSTEM",
"TABLEPRIV",
"PRIVILEGE",
SCOL_VARCHAR, 50 },
5938 {
"SYSTEM",
"TABLEPRIV",
"IS_GRANTABLE",
SCOL_VARCHAR, 50 }
5942 {
"SYSTEM",
"TABLEPRIV",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
5943 {
"SYSTEM",
"TABLEPRIV",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
5944 {
"SYSTEM",
"TABLEPRIV",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
5945 {
"SYSTEM",
"TABLEPRIV",
"GRANTOR",
SCOL_VARCHAR, 50 },
5946 {
"SYSTEM",
"TABLEPRIV",
"GRANTEE",
SCOL_VARCHAR, 50 },
5947 {
"SYSTEM",
"TABLEPRIV",
"PRIVILEGE",
SCOL_VARCHAR, 50 },
5948 {
"SYSTEM",
"TABLEPRIV",
"IS_GRANTABLE",
SCOL_VARCHAR, 50 }
5965 SQLCHAR *cat, SQLSMALLINT catLen,
5966 SQLCHAR *schema, SQLSMALLINT schemaLen,
5967 SQLCHAR *table, SQLSMALLINT tableLen)
5972 int ncols, rc, size, npatt;
5973 char *errp = NULL, *sql, tname[512];
5977 if (ret != SQL_SUCCESS) {
5982 if (cat && (catLen > 0 || catLen == SQL_NTS) && cat[0] ==
'%') {
5986 if (schema && (schemaLen > 0 || schemaLen == SQL_NTS) &&
5988 if ((!cat || catLen == 0 || !cat[0]) &&
5989 (!table || tableLen == 0 || !table[0])) {
5999 if (tableLen == SQL_NTS) {
6000 size =
sizeof (tname) - 1;
6002 size =
min(
sizeof (tname) - 1, tableLen);
6004 strncpy(tname, (
char *) table, size);
6008 #if defined(_WIN32) || defined(_WIN64) 6009 sql = sqlite3_mprintf(
"select %s as 'TABLE_QUALIFIER', " 6010 "%s as 'TABLE_OWNER', " 6011 "tbl_name as 'TABLE_NAME', " 6014 "'SELECT' AS 'PRIVILEGE', " 6015 "NULL as 'IS_GRANTABLE' " 6016 "from sqlite_master where " 6017 "(type = 'table' or type = 'view') " 6018 "and tbl_name %s %Q " 6020 "select %s as 'TABLE_QUALIFIER', " 6021 "%s as 'TABLE_OWNER', " 6022 "tbl_name as 'TABLE_NAME', " 6025 "'UPDATE' AS 'PRIVILEGE', " 6026 "NULL as 'IS_GRANTABLE' " 6027 "from sqlite_master where " 6028 "(type = 'table' or type = 'view') " 6029 "and tbl_name %s %Q " 6031 "select %s as 'TABLE_QUALIFIER', " 6032 "%s as 'TABLE_OWNER', " 6033 "tbl_name as 'TABLE_NAME', " 6036 "'DELETE' AS 'PRIVILEGE', " 6037 "NULL as 'IS_GRANTABLE' " 6038 "from sqlite_master where " 6039 "(type = 'table' or type = 'view') " 6040 "and tbl_name %s %Q " 6042 "select %s as 'TABLE_QUALIFIER', " 6043 "%s as 'TABLE_OWNER', " 6044 "tbl_name as 'TABLE_NAME', " 6047 "'INSERT' AS 'PRIVILEGE', " 6048 "NULL as 'IS_GRANTABLE' " 6049 "from sqlite_master where " 6050 "(type = 'table' or type = 'view') " 6051 "and tbl_name %s %Q " 6053 "select %s as 'TABLE_QUALIFIER', " 6054 "%s as 'TABLE_OWNER', " 6055 "tbl_name as 'TABLE_NAME', " 6058 "'REFERENCES' AS 'PRIVILEGE', " 6059 "NULL as 'IS_GRANTABLE' " 6060 "from sqlite_master where " 6061 "(type = 'table' or type = 'view') " 6062 "and tbl_name %s %Q",
6063 d->xcelqrx ?
"'main'" :
"NULL",
6064 d->xcelqrx ?
"''" :
"NULL",
6065 npatt ?
"like" :
"=", tname,
6066 d->xcelqrx ?
"'main'" :
"NULL",
6067 d->xcelqrx ?
"''" :
"NULL",
6068 npatt ?
"like" :
"=", tname,
6069 d->xcelqrx ?
"'main'" :
"NULL",
6070 d->xcelqrx ?
"''" :
"NULL",
6071 npatt ?
"like" :
"=", tname,
6072 d->xcelqrx ?
"'main'" :
"NULL",
6073 d->xcelqrx ?
"''" :
"NULL",
6074 npatt ?
"like" :
"=", tname,
6075 d->xcelqrx ?
"'main'" :
"NULL",
6076 d->xcelqrx ?
"''" :
"NULL",
6077 npatt ?
"like" :
"=", tname);
6079 sql = sqlite3_mprintf(
"select NULL as 'TABLE_QUALIFIER', " 6080 "NULL as 'TABLE_OWNER', " 6081 "tbl_name as 'TABLE_NAME', " 6084 "'SELECT' AS 'PRIVILEGE', " 6085 "NULL as 'IS_GRANTABLE' " 6086 "from sqlite_master where " 6087 "(type = 'table' or type = 'view') " 6088 "and tbl_name %s %Q " 6090 "select NULL as 'TABLE_QUALIFIER', " 6091 "NULL as 'TABLE_OWNER', " 6092 "tbl_name as 'TABLE_NAME', " 6095 "'UPDATE' AS 'PRIVILEGE', " 6096 "NULL as 'IS_GRANTABLE' " 6097 "from sqlite_master where " 6098 "(type = 'table' or type = 'view') " 6099 "and tbl_name %s %Q " 6101 "select NULL as 'TABLE_QUALIFIER', " 6102 "NULL as 'TABLE_OWNER', " 6103 "tbl_name as 'TABLE_NAME', " 6106 "'DELETE' AS 'PRIVILEGE', " 6107 "NULL as 'IS_GRANTABLE' " 6108 "from sqlite_master where " 6109 "(type = 'table' or type = 'view') " 6110 "and tbl_name %s %Q " 6112 "select NULL as 'TABLE_QUALIFIER', " 6113 "NULL as 'TABLE_OWNER', " 6114 "tbl_name as 'TABLE_NAME', " 6117 "'INSERT' AS 'PRIVILEGE', " 6118 "NULL as 'IS_GRANTABLE' " 6119 "from sqlite_master where " 6120 "(type = 'table' or type = 'view') " 6121 "and tbl_name %s %Q " 6123 "select NULL as 'TABLE_QUALIFIER', " 6124 "NULL as 'TABLE_OWNER', " 6125 "tbl_name as 'TABLE_NAME', " 6128 "'REFERENCES' AS 'PRIVILEGE', " 6129 "NULL as 'IS_GRANTABLE' " 6130 "from sqlite_master where " 6131 "(type = 'table' or type = 'view') " 6132 "and tbl_name %s %Q",
6133 npatt ?
"like" :
"=", tname,
6134 npatt ?
"like" :
"=", tname,
6135 npatt ?
"like" :
"=", tname,
6136 npatt ?
"like" :
"=", tname,
6137 npatt ?
"like" :
"=", tname);
6143 if (ret != SQL_SUCCESS) {
6148 rc = sqlite3_get_table(d->
sqlite, sql, &s->
rows, &s->
nrows, &ncols, &errp);
6150 if (rc == SQLITE_OK) {
6151 if (ncols != s->
ncols) {
6155 s->
rowfree = sqlite3_free_table;
6171 #if !defined(WINTERFACE) || (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC)) 6185 SQLTablePrivileges(SQLHSTMT
stmt,
6186 SQLCHAR *catalog, SQLSMALLINT catalogLen,
6187 SQLCHAR *schema, SQLSMALLINT schemaLen,
6188 SQLCHAR *table, SQLSMALLINT tableLen)
6190 #if defined(_WIN32) || defined(_WIN64) 6191 char *c = NULL, *s = NULL, *t = NULL;
6196 #if defined(_WIN32) || defined(_WIN64) 6203 c = wmb_to_utf_c((
char *) catalog, catalogLen);
6210 s = wmb_to_utf_c((
char *) schema, schemaLen);
6217 t = wmb_to_utf_c((
char *) table, tableLen);
6224 (SQLCHAR *) s, SQL_NTS,
6225 (SQLCHAR *) t, SQL_NTS);
6230 #if defined(_WIN32) || defined(_WIN64) 6243 #if !defined(HAVE_UNIXODBC) || !(HAVE_UNIXODBC) 6259 SQLWCHAR *catalog, SQLSMALLINT catalogLen,
6260 SQLWCHAR *schema, SQLSMALLINT schemaLen,
6261 SQLWCHAR *table, SQLSMALLINT tableLen)
6263 char *c = NULL, *s = NULL, *t = NULL;
6289 (SQLCHAR *) s, SQL_NTS,
6290 (SQLCHAR *) t, SQL_NTS);
6306 {
"SYSTEM",
"COLPRIV",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
6307 {
"SYSTEM",
"COLPRIV",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
6308 {
"SYSTEM",
"COLPRIV",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
6309 {
"SYSTEM",
"COLPRIV",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6316 {
"SYSTEM",
"COLPRIV",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
6317 {
"SYSTEM",
"COLPRIV",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
6318 {
"SYSTEM",
"COLPRIV",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
6319 {
"SYSTEM",
"COLPRIV",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6325 #if !defined(WINTERFACE) || (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC)) 6341 SQLColumnPrivileges(SQLHSTMT
stmt,
6342 SQLCHAR *catalog, SQLSMALLINT catalogLen,
6343 SQLCHAR *schema, SQLSMALLINT schemaLen,
6344 SQLCHAR *table, SQLSMALLINT tableLen,
6345 SQLCHAR *column, SQLSMALLINT columnLen)
6357 #if !defined(HAVE_UNIXODBC) || !(HAVE_UNIXODBC) 6375 SQLWCHAR *catalog, SQLSMALLINT catalogLen,
6376 SQLWCHAR *schema, SQLSMALLINT schemaLen,
6377 SQLWCHAR *table, SQLSMALLINT tableLen,
6378 SQLWCHAR *column, SQLSMALLINT columnLen)
6396 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
6397 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
6398 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
6399 {
"SYSTEM",
"PRIMARYKEY",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6400 {
"SYSTEM",
"PRIMARYKEY",
"KEY_SEQ", SQL_SMALLINT, 50 },
6401 {
"SYSTEM",
"PRIMARYKEY",
"PK_NAME",
SCOL_VARCHAR, 50 }
6405 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
6406 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
6407 {
"SYSTEM",
"PRIMARYKEY",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
6408 {
"SYSTEM",
"PRIMARYKEY",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6409 {
"SYSTEM",
"PRIMARYKEY",
"KEY_SEQ", SQL_SMALLINT, 50 },
6410 {
"SYSTEM",
"PRIMARYKEY",
"PK_NAME",
SCOL_VARCHAR, 50 }
6427 SQLCHAR *cat, SQLSMALLINT catLen,
6428 SQLCHAR *schema, SQLSMALLINT schemaLen,
6429 SQLCHAR *table, SQLSMALLINT tableLen)
6434 int i, asize, ret, nrows, ncols, nrows2 = 0, ncols2 = 0;
6435 int namec = -1, uniquec = -1, namec2 = -1, uniquec2 = -1, offs, seq = 1;
6437 char **rowp = NULL, **rowp2 = NULL, *errp = NULL, *sql, tname[512];
6441 if (sret != SQL_SUCCESS) {
6446 if (!table || table[0] ==
'\0' || table[0] ==
'%') {
6447 setstat(s, -1,
"need table name", (*s->
ov3) ?
"HY000" :
"S1000");
6450 if (tableLen == SQL_NTS) {
6451 size =
sizeof (tname) - 1;
6453 size =
min(
sizeof (tname) - 1, tableLen);
6455 strncpy(tname, (
char *) table, size);
6458 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", tname);
6463 if (sret != SQL_SUCCESS) {
6468 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
6470 if (ret != SQLITE_OK) {
6471 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
6472 errp ? errp :
"unknown error", ret);
6484 if (ncols * nrows > 0) {
6487 namec =
findcol(rowp, ncols,
"name");
6488 uniquec =
findcol(rowp, ncols,
"pk");
6489 typec =
findcol(rowp, ncols,
"type");
6490 if (namec >= 0 && uniquec >= 0 && typec >= 0) {
6491 for (i = 1; i <= nrows; i++) {
6492 if (*rowp[i * ncols + uniquec] !=
'0') {
6499 sql = sqlite3_mprintf(
"PRAGMA index_list(%Q)", tname);
6501 sqlite3_free_table(rowp);
6505 ret = sqlite3_get_table(d->
sqlite, sql, &rowp2, &nrows2, &ncols2,
6508 if (ret != SQLITE_OK) {
6509 sqlite3_free_table(rowp);
6510 sqlite3_free_table(rowp2);
6511 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
6512 errp ? errp :
"unknown error", ret);
6524 if (ncols2 * nrows2 > 0) {
6525 namec2 =
findcol(rowp2, ncols2,
"name");
6526 uniquec2 =
findcol(rowp2, ncols2,
"unique");
6527 if (namec2 >= 0 && uniquec2 >= 0) {
6528 for (i = 1; i <= nrows2; i++) {
6529 int nnrows, nncols, nlen = 0;
6532 if (rowp2[i * ncols2 + namec2]) {
6533 nlen = strlen(rowp2[i * ncols2 + namec2]);
6536 strncmp(rowp2[i * ncols2 + namec2],
6537 "sqlite_autoindex_", 17)) {
6540 if (*rowp2[i * ncols2 + uniquec2] !=
'0') {
6542 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
6543 rowp2[i * ncols2 + namec2]);
6546 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
6547 &nnrows, &nncols, NULL);
6550 if (ret == SQLITE_OK) {
6552 sqlite3_free_table(rowpp);
6559 sqlite3_free_table(rowp);
6560 sqlite3_free_table(rowp2);
6564 size = (size + 1) * asize;
6568 sqlite3_free_table(rowp);
6569 sqlite3_free_table(rowp2);
6572 s->
rows[0] = (
char *) size;
6574 memset(s->
rows, 0, sizeof (
char *) * size);
6578 for (i = 1; i <= nrows; i++) {
6579 if (*rowp[i * ncols + uniquec] !=
'0') {
6582 #if defined(_WIN32) || defined(_WIN64) 6583 s->
rows[offs + 0] =
xstrdup(d->xcelqrx ?
"main" :
"");
6590 s->
rows[offs + 3] =
xstrdup(rowp[i * ncols + namec]);
6591 sprintf(buf,
"%d", seq++);
6598 for (i = 1; i <= nrows2; i++) {
6599 int nnrows, nncols, nlen = 0;
6602 if (rowp2[i * ncols2 + namec2]) {
6603 nlen = strlen(rowp2[i * ncols2 + namec2]);
6606 strncmp(rowp2[i * ncols2 + namec2],
"sqlite_autoindex_", 17)) {
6609 if (*rowp2[i * ncols2 + uniquec2] !=
'0') {
6613 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
6614 rowp2[i * ncols2 + namec2]);
6617 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
6618 &nnrows, &nncols, NULL);
6621 if (ret != SQLITE_OK) {
6624 for (k = 0; nnrows && k < nncols; k++) {
6625 if (strcmp(rowpp[k],
"name") == 0) {
6628 for (m = 1; m <= nnrows; m++) {
6629 int roffs = offs + (m - 1) * s->
ncols;
6631 #
if defined(_WIN32) || defined(_WIN64)
6632 s->
rows[roffs + 0] =
6633 xstrdup(d->xcelqrx ?
"main" :
"");
6640 s->
rows[roffs + 3] =
6641 xstrdup(rowpp[m * nncols + k]);
6642 s->
rows[roffs + 5] =
6643 xstrdup(rowp2[i * ncols2 + namec2]);
6645 }
else if (strcmp(rowpp[k],
"seqno") == 0) {
6648 for (m = 1; m <= nnrows; m++) {
6649 int roffs = offs + (m - 1) * s->
ncols;
6653 sscanf(rowpp[m * nncols + k],
"%d", &pos);
6654 sprintf(buf,
"%d", pos + 1);
6659 offs += nnrows * s->
ncols;
6660 sqlite3_free_table(rowpp);
6664 sqlite3_free_table(rowp);
6665 sqlite3_free_table(rowp2);
6683 SQLPrimaryKeys(SQLHSTMT
stmt,
6684 SQLCHAR *cat, SQLSMALLINT catLen,
6685 SQLCHAR *schema, SQLSMALLINT schemaLen,
6686 SQLCHAR *table, SQLSMALLINT tableLen)
6688 #if defined(_WIN32) || defined(_WIN64) 6689 char *c = NULL, *s = NULL, *t = NULL;
6694 #if defined(_WIN32) || defined(_WIN64) 6701 c = wmb_to_utf_c((
char *) cat, catLen);
6708 s = wmb_to_utf_c((
char *) schema, schemaLen);
6715 t = wmb_to_utf_c((
char *) table, tableLen);
6722 (SQLCHAR *) s, SQL_NTS, (SQLCHAR *) t, SQL_NTS);
6727 #if defined(_WIN32) || defined(_WIN64) 6755 SQLWCHAR *cat, SQLSMALLINT catLen,
6756 SQLWCHAR *schema, SQLSMALLINT schemaLen,
6757 SQLWCHAR *table, SQLSMALLINT tableLen)
6759 char *c = NULL, *s = NULL, *t = NULL;
6785 (SQLCHAR *) s, SQL_NTS, (SQLCHAR *) t, SQL_NTS);
6800 {
"SYSTEM",
"COLUMN",
"SCOPE", SQL_SMALLINT, 1 },
6801 {
"SYSTEM",
"COLUMN",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6802 {
"SYSTEM",
"COLUMN",
"DATA_TYPE", SQL_SMALLINT, 50 },
6804 {
"SYSTEM",
"COLUMN",
"PRECISION", SQL_INTEGER, 50 },
6805 {
"SYSTEM",
"COLUMN",
"LENGTH", SQL_INTEGER, 50 },
6806 {
"SYSTEM",
"COLUMN",
"DECIMAL_DIGITS", SQL_INTEGER, 50 },
6807 {
"SYSTEM",
"COLUMN",
"PSEUDO_COLUMN", SQL_SMALLINT, 1 },
6808 {
"SYSTEM",
"COLUMN",
"NULLABLE", SQL_SMALLINT, 1 }
6812 {
"SYSTEM",
"COLUMN",
"SCOPE", SQL_SMALLINT, 1 },
6813 {
"SYSTEM",
"COLUMN",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
6814 {
"SYSTEM",
"COLUMN",
"DATA_TYPE", SQL_SMALLINT, 50 },
6816 {
"SYSTEM",
"COLUMN",
"COLUMN_SIZE", SQL_INTEGER, 50 },
6817 {
"SYSTEM",
"COLUMN",
"BUFFER_LENGTH", SQL_INTEGER, 50 },
6818 {
"SYSTEM",
"COLUMN",
"DECIMAL_DIGITS", SQL_INTEGER, 50 },
6819 {
"SYSTEM",
"COLUMN",
"PSEUDO_COLUMN", SQL_SMALLINT, 1 },
6820 {
"SYSTEM",
"COLUMN",
"NULLABLE", SQL_SMALLINT, 1 }
6840 SQLCHAR *cat, SQLSMALLINT catLen,
6841 SQLCHAR *schema, SQLSMALLINT schemaLen,
6842 SQLCHAR *table, SQLSMALLINT tableLen,
6843 SQLUSMALLINT scope, SQLUSMALLINT nullable)
6848 int i, asize, ret, nrows, ncols, nnnrows, nnncols, offs;
6850 int namec = -1, uniquec = -1, namecc = -1, typecc = -1;
6851 int notnullcc = -1, mkrowid = 0;
6852 char *errp = NULL, *sql, tname[512];
6853 char **rowp = NULL, **rowppp = NULL;
6857 if (sret != SQL_SUCCESS) {
6862 if (!table || table[0] ==
'\0' || table[0] ==
'%') {
6863 setstat(s, -1,
"need table name", (*s->
ov3) ?
"HY000" :
"S1000");
6866 if (tableLen == SQL_NTS) {
6867 size =
sizeof (tname) - 1;
6869 size =
min(
sizeof (tname) - 1, tableLen);
6871 strncpy(tname, (
char *) table, size);
6874 if (
id != SQL_BEST_ROWID) {
6877 sql = sqlite3_mprintf(
"PRAGMA index_list(%Q)", tname);
6882 if (sret != SQL_SUCCESS) {
6887 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
6889 if (ret != SQLITE_OK) {
6891 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
6892 errp ? errp :
"unknown error", ret);
6904 if (ncols * nrows <= 0) {
6905 goto nodata_but_rowid;
6907 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", tname);
6912 ret = sqlite3_get_table(d->
sqlite, sql, &rowppp, &nnnrows, &nnncols,
6915 if (ret != SQLITE_OK) {
6916 sqlite3_free_table(rowp);
6923 namec =
findcol(rowp, ncols,
"name");
6924 uniquec =
findcol(rowp, ncols,
"unique");
6925 if (namec < 0 || uniquec < 0) {
6926 goto nodata_but_rowid;
6928 namecc =
findcol(rowppp, nnncols,
"name");
6929 typecc =
findcol(rowppp, nnncols,
"type");
6930 notnullcc =
findcol(rowppp, nnncols,
"notnull");
6931 for (i = 1; i <= nrows; i++) {
6933 char **rowpp = NULL;
6935 if (*rowp[i * ncols + uniquec] !=
'0') {
6937 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
6938 rowp[i * ncols + namec]);
6941 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
6942 &nnrows, &nncols, NULL);
6945 if (ret == SQLITE_OK) {
6947 sqlite3_free_table(rowpp);
6957 size = (size + 1) * asize;
6961 sqlite3_free_table(rowp);
6962 sqlite3_free_table(rowppp);
6965 s->
rows[0] = (
char *) size;
6967 memset(s->
rows, 0, sizeof (
char *) * size);
6974 for (i = 1; i <= nrows; i++) {
6976 char **rowpp = NULL;
6978 if (*rowp[i * ncols + uniquec] !=
'0') {
6982 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
6983 rowp[i * ncols + namec]);
6986 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
6987 &nnrows, &nncols, NULL);
6990 if (ret != SQLITE_OK) {
6993 for (k = 0; nnrows && k < nncols; k++) {
6994 if (strcmp(rowpp[k],
"name") == 0) {
6997 for (m = 1; m <= nnrows; m++) {
6998 int roffs = (offs + m) * s->
ncols;
7000 s->
rows[roffs + 0] =
7002 s->
rows[roffs + 1] =
xstrdup(rowpp[m * nncols + k]);
7004 s->
rows[roffs + 7] =
7006 if (namecc >= 0 && typecc >= 0) {
7009 for (ii = 1; ii <= nnnrows; ii++) {
7010 if (strcmp(rowppp[ii * nnncols + namecc],
7011 rowpp[m * nncols + k]) == 0) {
7012 char *typen = rowppp[ii * nnncols + typecc];
7013 int sqltype, mm, dd, isnullable = 0;
7020 getmd(typen, sqltype, &mm, &dd);
7021 #ifdef SQL_LONGVARCHAR 7022 if (sqltype == SQL_VARCHAR && mm > 255) {
7023 sqltype = SQL_LONGVARCHAR;
7027 #ifdef SQL_WLONGVARCHAR 7028 if (sqltype == SQL_WVARCHAR && mm > 255) {
7029 sqltype = SQL_WLONGVARCHAR;
7033 if (sqltype == SQL_VARBINARY && mm > 255) {
7034 sqltype = SQL_LONGVARBINARY;
7036 sprintf(buf,
"%d", sqltype);
7038 sprintf(buf,
"%d", mm);
7040 sprintf(buf,
"%d", dd);
7042 if (notnullcc >= 0) {
7044 rowppp[ii * nnncols + notnullcc];
7046 isnullable = inp[0] !=
'0';
7048 sprintf(buf,
"%d", isnullable);
7057 sqlite3_free_table(rowpp);
7060 if (nullable == SQL_NO_NULLS) {
7061 for (i = 1; i < s->
nrows; i++) {
7062 if (s->
rows[i * s->
ncols + 8][0] ==
'0') {
7065 for (m = 0; m < s->
ncols; m++) {
7068 size = s->
ncols *
sizeof (
char *) * (s->
nrows - i1);
7074 s->
ncols * sizeof (
char *));
7082 sqlite3_free_table(rowp);
7083 sqlite3_free_table(rowppp);
7084 if (s->
nrows == 0) {
7116 SQLSpecialColumns(SQLHSTMT
stmt, SQLUSMALLINT
id,
7117 SQLCHAR *cat, SQLSMALLINT catLen,
7118 SQLCHAR *schema, SQLSMALLINT schemaLen,
7119 SQLCHAR *table, SQLSMALLINT tableLen,
7120 SQLUSMALLINT scope, SQLUSMALLINT nullable)
7122 #if defined(_WIN32) || defined(_WIN64) 7123 char *c = NULL, *s = NULL, *t = NULL;
7128 #if defined(_WIN32) || defined(_WIN64) 7131 table, tableLen, scope, nullable);
7135 c = wmb_to_utf_c((
char *) cat, catLen);
7142 s = wmb_to_utf_c((
char *) schema, schemaLen);
7149 t = wmb_to_utf_c((
char *) table, tableLen);
7156 (SQLCHAR *) s, SQL_NTS, (SQLCHAR *) t, SQL_NTS,
7160 table, tableLen, scope, nullable);
7162 #if defined(_WIN32) || defined(_WIN64) 7193 SQLWCHAR *cat, SQLSMALLINT catLen,
7194 SQLWCHAR *schema, SQLSMALLINT schemaLen,
7195 SQLWCHAR *table, SQLSMALLINT tableLen,
7196 SQLUSMALLINT scope, SQLUSMALLINT nullable)
7198 char *c = NULL, *s = NULL, *t = NULL;
7224 (SQLCHAR *) s, SQL_NTS, (SQLCHAR *) t, SQL_NTS,
7240 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
7241 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_OWNER",
SCOL_VARCHAR, 50 },
7242 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_NAME",
SCOL_VARCHAR, 255 },
7243 {
"SYSTEM",
"FOREIGNKEY",
"PKCOLUMN_NAME",
SCOL_VARCHAR, 255 },
7244 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
7245 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_OWNER",
SCOL_VARCHAR, 50 },
7246 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_NAME",
SCOL_VARCHAR, 255 },
7247 {
"SYSTEM",
"FOREIGNKEY",
"FKCOLUMN_NAME",
SCOL_VARCHAR, 255 },
7248 {
"SYSTEM",
"FOREIGNKEY",
"KEY_SEQ", SQL_SMALLINT, 5 },
7249 {
"SYSTEM",
"FOREIGNKEY",
"UPDATE_RULE", SQL_SMALLINT, 5 },
7250 {
"SYSTEM",
"FOREIGNKEY",
"DELETE_RULE", SQL_SMALLINT, 5 },
7251 {
"SYSTEM",
"FOREIGNKEY",
"FK_NAME",
SCOL_VARCHAR, 255 },
7252 {
"SYSTEM",
"FOREIGNKEY",
"PK_NAME",
SCOL_VARCHAR, 255 },
7253 {
"SYSTEM",
"FOREIGNKEY",
"DEFERRABILITY", SQL_SMALLINT, 5 }
7257 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_CAT",
SCOL_VARCHAR, 50 },
7258 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_SCHEM",
SCOL_VARCHAR, 50 },
7259 {
"SYSTEM",
"FOREIGNKEY",
"PKTABLE_NAME",
SCOL_VARCHAR, 255 },
7260 {
"SYSTEM",
"FOREIGNKEY",
"PKCOLUMN_NAME",
SCOL_VARCHAR, 255 },
7261 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_CAT",
SCOL_VARCHAR, 50 },
7262 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_SCHEM",
SCOL_VARCHAR, 50 },
7263 {
"SYSTEM",
"FOREIGNKEY",
"FKTABLE_NAME",
SCOL_VARCHAR, 255 },
7264 {
"SYSTEM",
"FOREIGNKEY",
"FKCOLUMN_NAME",
SCOL_VARCHAR, 255 },
7265 {
"SYSTEM",
"FOREIGNKEY",
"KEY_SEQ", SQL_SMALLINT, 5 },
7266 {
"SYSTEM",
"FOREIGNKEY",
"UPDATE_RULE", SQL_SMALLINT, 5 },
7267 {
"SYSTEM",
"FOREIGNKEY",
"DELETE_RULE", SQL_SMALLINT, 5 },
7268 {
"SYSTEM",
"FOREIGNKEY",
"FK_NAME",
SCOL_VARCHAR, 255 },
7269 {
"SYSTEM",
"FOREIGNKEY",
"PK_NAME",
SCOL_VARCHAR, 255 },
7270 {
"SYSTEM",
"FOREIGNKEY",
"DEFERRABILITY", SQL_SMALLINT, 5 }
7293 SQLCHAR *PKcatalog, SQLSMALLINT PKcatalogLen,
7294 SQLCHAR *PKschema, SQLSMALLINT PKschemaLen,
7295 SQLCHAR *PKtable, SQLSMALLINT PKtableLen,
7296 SQLCHAR *FKcatalog, SQLSMALLINT FKcatalogLen,
7297 SQLCHAR *FKschema, SQLSMALLINT FKschemaLen,
7298 SQLCHAR *FKtable, SQLSMALLINT FKtableLen)
7303 int i, asize, ret, nrows, ncols, offs, namec, seqc, fromc, toc;
7306 char **rowp, *errp = NULL, *sql, pname[512], fname[512];
7310 if (sret != SQL_SUCCESS) {
7315 if (sret != SQL_SUCCESS) {
7319 if ((!PKtable || PKtable[0] ==
'\0' || PKtable[0] ==
'%') &&
7320 (!FKtable || FKtable[0] ==
'\0' || FKtable[0] ==
'%')) {
7321 setstat(s, -1,
"need table name", (*s->
ov3) ?
"HY000" :
"S1000");
7326 if (PKtableLen == SQL_NTS) {
7327 size =
sizeof (pname) - 1;
7329 size =
min(
sizeof (pname) - 1, PKtableLen);
7331 strncpy(pname, (
char *) PKtable, size);
7337 if (FKtableLen == SQL_NTS) {
7338 size =
sizeof (fname) - 1;
7340 size =
min(
sizeof (fname) - 1, FKtableLen);
7342 strncpy(fname, (
char *) FKtable, size);
7345 if (fname[0] !=
'\0') {
7349 sql = sqlite3_mprintf(
"PRAGMA foreign_key_list(%Q)", fname);
7352 ret = sqlite3_get_table(d->
sqlite, sql, &rowp,
7353 &nrows, &ncols, &errp);
7356 if (ret != SQLITE_OK) {
7357 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
7358 errp ? errp :
"unknown error", ret);
7369 if (ncols * nrows <= 0) {
7371 sqlite3_free_table(rowp);
7375 namec =
findcol(rowp, ncols,
"table");
7376 seqc =
findcol(rowp, ncols,
"seq");
7377 fromc =
findcol(rowp, ncols,
"from");
7378 toc =
findcol(rowp, ncols,
"to");
7379 onu =
findcol(rowp, ncols,
"on_update");
7380 ond =
findcol(rowp, ncols,
"on_delete");
7381 if (namec < 0 || seqc < 0 || fromc < 0 || toc < 0) {
7384 plen = strlen(pname);
7385 for (i = 1; i <= nrows; i++) {
7386 char *ptab =
unquote(rowp[i * ncols + namec]);
7389 int len = strlen(ptab);
7391 if (plen != len || strncasecmp(pname, ptab, plen) != 0) {
7401 size = (size + 1) * asize;
7407 s->
rows[0] = (
char *) size;
7409 memset(s->
rows, 0, sizeof (
char *) * size);
7412 for (i = 1; i <= nrows; i++) {
7413 int pos = 0, roffs = (offs + 1) * s->
ncols;
7414 char *ptab = rowp[i * ncols + namec];
7418 int len = strlen(ptab);
7420 if (plen != len || strncasecmp(pname, ptab, plen) != 0) {
7424 #if defined(_WIN32) || defined(_WIN64) 7425 s->
rows[roffs + 0] =
xstrdup(d->xcelqrx ?
"main" :
"");
7432 s->
rows[roffs + 3] =
xstrdup(rowp[i * ncols + toc]);
7436 s->
rows[roffs + 7] =
xstrdup(rowp[i * ncols + fromc]);
7437 sscanf(rowp[i * ncols + seqc],
"%d", &pos);
7438 sprintf(buf,
"%d", pos + 1);
7443 if (strcmp(rowp[i * ncols + onu],
"SET NULL") == 0) {
7445 }
else if (strcmp(rowp[i * ncols + onu],
"SET DEFAULT") == 0) {
7447 }
else if (strcmp(rowp[i * ncols + onu],
"CASCADE") == 0) {
7449 }
else if (strcmp(rowp[i * ncols + onu],
"RESTRICT") == 0) {
7458 if (strcmp(rowp[i * ncols + ond],
"SET NULL") == 0) {
7460 }
else if (strcmp(rowp[i * ncols + ond],
"SET DEFAULT") == 0) {
7462 }
else if (strcmp(rowp[i * ncols + ond],
"CASCADE") == 0) {
7464 }
else if (strcmp(rowp[i * ncols + ond],
"RESTRICT") == 0) {
7470 s->
rows[roffs + 11] = NULL;
7471 s->
rows[roffs + 12] = NULL;
7475 sqlite3_free_table(rowp);
7477 int nnrows, nncols, plen = strlen(pname);
7480 sql =
"select name from sqlite_master where type='table'";
7482 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
7483 if (ret != SQLITE_OK) {
7484 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
7485 errp ? errp :
"unknown error", ret);
7496 if (ncols * nrows <= 0) {
7500 for (i = 1; i <= nrows; i++) {
7508 sql = sqlite3_mprintf(
"PRAGMA foreign_key_list(%Q)", rowp[i]);
7511 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
7512 &nnrows, &nncols, NULL);
7515 if (ret != SQLITE_OK || nncols * nnrows <= 0) {
7516 sqlite3_free_table(rowpp);
7519 namec =
findcol(rowpp, nncols,
"table");
7520 seqc =
findcol(rowpp, nncols,
"seq");
7521 fromc =
findcol(rowpp, nncols,
"from");
7522 toc =
findcol(rowpp, nncols,
"to");
7523 if (namec < 0 || seqc < 0 || fromc < 0 || toc < 0) {
7524 sqlite3_free_table(rowpp);
7527 for (k = 1; k <= nnrows; k++) {
7528 char *ptab =
unquote(rowpp[k * nncols + namec]);
7531 int len = strlen(ptab);
7533 if (len != plen || strncasecmp(pname, ptab, plen) != 0) {
7539 sqlite3_free_table(rowpp);
7545 size = (size + 1) * asize;
7551 s->
rows[0] = (
char *) size;
7553 memset(s->
rows, 0, sizeof (
char *) * size);
7556 for (i = 1; i <= nrows; i++) {
7564 sql = sqlite3_mprintf(
"PRAGMA foreign_key_list(%Q)", rowp[i]);
7567 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
7568 &nnrows, &nncols, NULL);
7571 if (ret != SQLITE_OK || nncols * nnrows <= 0) {
7572 sqlite3_free_table(rowpp);
7575 namec =
findcol(rowpp, nncols,
"table");
7576 seqc =
findcol(rowpp, nncols,
"seq");
7577 fromc =
findcol(rowpp, nncols,
"from");
7578 toc =
findcol(rowpp, nncols,
"to");
7579 onu =
findcol(rowpp, nncols,
"on_update");
7580 ond =
findcol(rowpp, nncols,
"on_delete");
7581 if (namec < 0 || seqc < 0 || fromc < 0 || toc < 0) {
7582 sqlite3_free_table(rowpp);
7585 for (k = 1; k <= nnrows; k++) {
7586 int pos = 0, roffs = (offs + 1) * s->
ncols;
7587 char *ptab =
unquote(rowpp[k * nncols + namec]);
7591 int len = strlen(ptab);
7593 if (len != plen || strncasecmp(pname, ptab, plen) != 0) {
7597 #if defined(_WIN32) || defined(_WIN64) 7598 s->
rows[roffs + 0] =
xstrdup(d->xcelqrx ?
"main" :
"");
7605 s->
rows[roffs + 3] =
xstrdup(rowpp[k * nncols + toc]);
7609 s->
rows[roffs + 7] =
xstrdup(rowpp[k * nncols + fromc]);
7610 sscanf(rowpp[k * nncols + seqc],
"%d", &pos);
7611 sprintf(buf,
"%d", pos + 1);
7616 if (strcmp(rowpp[k * nncols + onu],
"SET NULL") == 0) {
7618 }
else if (strcmp(rowpp[k * nncols + onu],
"SET DEFAULT")
7620 s->
rows[roffs + 9] =
7622 }
else if (strcmp(rowpp[k * nncols + onu],
"CASCADE")
7625 }
else if (strcmp(rowpp[k * nncols + onu],
"RESTRICT")
7629 s->
rows[roffs + 9] =
7636 if (strcmp(rowpp[k * nncols + ond],
"SET NULL") == 0) {
7638 }
else if (strcmp(rowpp[k * nncols + ond],
"SET DEFAULT")
7640 s->
rows[roffs + 10] =
7642 }
else if (strcmp(rowpp[k * nncols + ond],
"CASCADE")
7645 }
else if (strcmp(rowpp[k * nncols + ond],
"RESTRICT")
7649 s->
rows[roffs + 10] =
7653 s->
rows[roffs + 11] = NULL;
7654 s->
rows[roffs + 12] = NULL;
7658 sqlite3_free_table(rowpp);
7660 sqlite3_free_table(rowp);
7685 SQLForeignKeys(SQLHSTMT
stmt,
7686 SQLCHAR *PKcatalog, SQLSMALLINT PKcatalogLen,
7687 SQLCHAR *PKschema, SQLSMALLINT PKschemaLen,
7688 SQLCHAR *PKtable, SQLSMALLINT PKtableLen,
7689 SQLCHAR *FKcatalog, SQLSMALLINT FKcatalogLen,
7690 SQLCHAR *FKschema, SQLSMALLINT FKschemaLen,
7691 SQLCHAR *FKtable, SQLSMALLINT FKtableLen)
7693 #if defined(_WIN32) || defined(_WIN64) 7694 char *pc = NULL, *ps = NULL, *pt = NULL;
7695 char *fc = NULL, *fs = NULL, *ft = NULL;
7700 #if defined(_WIN32) || defined(_WIN64) 7703 PKcatalog, PKcatalogLen,
7704 PKschema, PKschemaLen, PKtable, PKtableLen,
7705 FKcatalog, FKcatalogLen,
7706 FKschema, FKschemaLen,
7707 FKtable, FKtableLen);
7711 pc = wmb_to_utf_c((
char *) PKcatalog, PKcatalogLen);
7718 ps = wmb_to_utf_c((
char *) PKschema, PKschemaLen);
7725 pt = wmb_to_utf_c((
char *) PKtable, PKtableLen);
7732 fc = wmb_to_utf_c((
char *) FKcatalog, FKcatalogLen);
7739 fs = wmb_to_utf_c((
char *) FKschema, FKschemaLen);
7746 ft = wmb_to_utf_c((
char *) FKtable, FKtableLen);
7753 (SQLCHAR *) ps, SQL_NTS, (SQLCHAR *) pt, SQL_NTS,
7754 (SQLCHAR *) fc, SQL_NTS, (SQLCHAR *) fs, SQL_NTS,
7755 (SQLCHAR *) ft, SQL_NTS);
7758 PKcatalog, PKcatalogLen,
7759 PKschema, PKschemaLen, PKtable, PKtableLen,
7760 FKcatalog, FKcatalogLen,
7761 FKschema, FKschemaLen,
7762 FKtable, FKtableLen);
7764 #if defined(_WIN32) || defined(_WIN64) 7801 SQLWCHAR *PKcatalog, SQLSMALLINT PKcatalogLen,
7802 SQLWCHAR *PKschema, SQLSMALLINT PKschemaLen,
7803 SQLWCHAR *PKtable, SQLSMALLINT PKtableLen,
7804 SQLWCHAR *FKcatalog, SQLSMALLINT FKcatalogLen,
7805 SQLWCHAR *FKschema, SQLSMALLINT FKschemaLen,
7806 SQLWCHAR *FKtable, SQLSMALLINT FKtableLen)
7808 char *pc = NULL, *ps = NULL, *pt = NULL;
7809 char *fc = NULL, *fs = NULL, *ft = NULL;
7856 (SQLCHAR *) ps, SQL_NTS, (SQLCHAR *) pt, SQL_NTS,
7857 (SQLCHAR *) fc, SQL_NTS, (SQLCHAR *) fs, SQL_NTS,
7858 (SQLCHAR *) ft, SQL_NTS);
7880 int ret = SQL_SUCCESS, rc, busy_count = 0;
7886 rc = sqlite3_exec(d->
sqlite,
"BEGIN TRANSACTION", NULL, NULL, &errp);
7887 if (rc == SQLITE_BUSY) {
7897 if (rc != SQLITE_OK) {
7898 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
7899 errp ? errp :
"unknown error", rc);
7923 int ret, busy_count = 0;
7924 char *sql, *errp = NULL;
7927 setstatd(d, -1,
"not connected", (*d->
ov3) ?
"HY000" :
"S1000");
7935 sql =
"COMMIT TRANSACTION";
7938 sql =
"ROLLBACK TRANSACTION";
7940 ret = sqlite3_exec(d->
sqlite, sql, NULL, NULL, &errp);
7942 if (ret == SQLITE_BUSY && busy_count < 10) {
7951 if (ret != SQLITE_OK) {
7952 setstatd(d, ret,
"%s", (*d->
ov3) ?
"HY000" :
"S1000",
7953 errp ? errp :
"transaction failed");
7967 setstatd(d, -1,
"invalid completion type", (*d->
ov3) ?
"HY000" :
"S1000");
7980 drvendtran(SQLSMALLINT type, SQLHANDLE handle, SQLSMALLINT comptype)
7985 #if defined(_WIN32) || defined(_WIN64) 7990 case SQL_HANDLE_DBC:
7992 if (handle == SQL_NULL_HDBC) {
7993 return SQL_INVALID_HANDLE;
7999 case SQL_HANDLE_ENV:
8000 if (handle == SQL_NULL_HENV) {
8001 return SQL_INVALID_HANDLE;
8003 #if defined(_WIN32) || defined(_WIN64) 8004 env = (
ENV *) handle;
8006 return SQL_INVALID_HANDLE;
8008 EnterCriticalSection(&env->cs);
8010 dbc = ((
ENV *) handle)->dbcs;
8015 if (ret != SQL_SUCCESS) {
8020 #if defined(_WIN32) || defined(_WIN64) 8021 LeaveCriticalSection(&env->cs);
8023 return fail ? SQL_ERROR : SQL_SUCCESS;
8025 return SQL_INVALID_HANDLE;
8037 SQLEndTran(SQLSMALLINT type, SQLHANDLE handle, SQLSMALLINT comptype)
8053 if (
dbc != SQL_NULL_HDBC) {
8056 return drvendtran(SQL_HANDLE_ENV, (SQLHANDLE) env, type);
8082 SQLNativeSql(SQLHSTMT
stmt, SQLCHAR *sqlin, SQLINTEGER sqlinLen,
8083 SQLCHAR *sql, SQLINTEGER sqlMax, SQLINTEGER *sqlLen)
8086 SQLRETURN ret = SQL_SUCCESS;
8089 if (sqlinLen == SQL_NTS) {
8090 sqlinLen = strlen((
char *) sqlin);
8094 strncpy((
char *) sql, (
char *) sqlin, sqlMax - 1);
8095 sqlin[sqlMax - 1] =
'\0';
8096 outLen =
min(sqlMax - 1, sqlinLen);
8104 if (sql && outLen < sqlinLen) {
8106 ret = SQL_SUCCESS_WITH_INFO;
8127 SQLWCHAR *sql, SQLINTEGER sqlMax, SQLINTEGER *sqlLen)
8130 SQLRETURN ret = SQL_SUCCESS;
8133 if (sqlinLen == SQL_NTS) {
8139 sqlin[sqlMax - 1] = 0;
8140 outLen =
min(sqlMax - 1, sqlinLen);
8148 if (sql && outLen < sqlinLen) {
8150 ret = SQL_SUCCESS_WITH_INFO;
8162 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_QUALIFIER",
SCOL_VARCHAR, 50 },
8163 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_OWNER",
SCOL_VARCHAR, 50 },
8164 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_NAME",
SCOL_VARCHAR, 255 },
8165 {
"SYSTEM",
"PROCEDURE",
"NUM_INPUT_PARAMS", SQL_SMALLINT, 5 },
8166 {
"SYSTEM",
"PROCEDURE",
"NUM_OUTPUT_PARAMS", SQL_SMALLINT, 5 },
8167 {
"SYSTEM",
"PROCEDURE",
"NUM_RESULT_SETS", SQL_SMALLINT, 5 },
8168 {
"SYSTEM",
"PROCEDURE",
"REMARKS",
SCOL_VARCHAR, 255 },
8169 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_TYPE", SQL_SMALLINT, 5 }
8173 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_CAT",
SCOL_VARCHAR, 50 },
8174 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_SCHEM",
SCOL_VARCHAR, 50 },
8175 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_NAME",
SCOL_VARCHAR, 255 },
8176 {
"SYSTEM",
"PROCEDURE",
"NUM_INPUT_PARAMS", SQL_SMALLINT, 5 },
8177 {
"SYSTEM",
"PROCEDURE",
"NUM_OUTPUT_PARAMS", SQL_SMALLINT, 5 },
8178 {
"SYSTEM",
"PROCEDURE",
"NUM_RESULT_SETS", SQL_SMALLINT, 5 },
8179 {
"SYSTEM",
"PROCEDURE",
"REMARKS",
SCOL_VARCHAR, 255 },
8180 {
"SYSTEM",
"PROCEDURE",
"PROCEDURE_TYPE", SQL_SMALLINT, 5 }
8197 SQLProcedures(SQLHSTMT
stmt,
8198 SQLCHAR *catalog, SQLSMALLINT catalogLen,
8199 SQLCHAR *schema, SQLSMALLINT schemaLen,
8200 SQLCHAR *proc, SQLSMALLINT procLen)
8227 SQLWCHAR *catalog, SQLSMALLINT catalogLen,
8228 SQLWCHAR *schema, SQLSMALLINT schemaLen,
8229 SQLWCHAR *proc, SQLSMALLINT procLen)
8246 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_QUALIFIER",
SCOL_VARCHAR, 50 },
8247 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_OWNER",
SCOL_VARCHAR, 50 },
8248 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_NAME",
SCOL_VARCHAR, 255 },
8249 {
"SYSTEM",
"PROCCOL",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
8250 {
"SYSTEM",
"PROCCOL",
"COLUMN_TYPE", SQL_SMALLINT, 5 },
8251 {
"SYSTEM",
"PROCCOL",
"DATA_TYPE", SQL_SMALLINT, 5 },
8252 {
"SYSTEM",
"PROCCOL",
"TYPE_NAME",
SCOL_VARCHAR, 50 },
8253 {
"SYSTEM",
"PROCCOL",
"PRECISION", SQL_INTEGER, 10 },
8254 {
"SYSTEM",
"PROCCOL",
"LENGTH", SQL_INTEGER, 10 },
8255 {
"SYSTEM",
"PROCCOL",
"SCALE", SQL_SMALLINT, 5 },
8256 {
"SYSTEM",
"PROCCOL",
"RADIX", SQL_SMALLINT, 5 },
8257 {
"SYSTEM",
"PROCCOL",
"NULLABLE", SQL_SMALLINT, 5 },
8259 {
"SYSTEM",
"PROCCOL",
"COLUMN_DEF",
SCOL_VARCHAR, 50 },
8260 {
"SYSTEM",
"PROCCOL",
"SQL_DATA_TYPE", SQL_SMALLINT, 5 },
8261 {
"SYSTEM",
"PROCCOL",
"SQL_DATETIME_SUB", SQL_SMALLINT, 5 },
8262 {
"SYSTEM",
"PROCCOL",
"CHAR_OCTET_LENGTH", SQL_SMALLINT, 5 },
8263 {
"SYSTEM",
"PROCCOL",
"ORDINAL_POSITION", SQL_SMALLINT, 5 },
8264 {
"SYSTEM",
"PROCCOL",
"IS_NULLABLE",
SCOL_VARCHAR, 50 }
8268 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_CAT",
SCOL_VARCHAR, 50 },
8269 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_SCHEM",
SCOL_VARCHAR, 50 },
8270 {
"SYSTEM",
"PROCCOL",
"PROCEDURE_NAME",
SCOL_VARCHAR, 255 },
8271 {
"SYSTEM",
"PROCCOL",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
8272 {
"SYSTEM",
"PROCCOL",
"COLUMN_TYPE", SQL_SMALLINT, 5 },
8273 {
"SYSTEM",
"PROCCOL",
"DATA_TYPE", SQL_SMALLINT, 5 },
8274 {
"SYSTEM",
"PROCCOL",
"TYPE_NAME",
SCOL_VARCHAR, 50 },
8275 {
"SYSTEM",
"PROCCOL",
"COLUMN_SIZE", SQL_INTEGER, 10 },
8276 {
"SYSTEM",
"PROCCOL",
"BUFFER_LENGTH", SQL_INTEGER, 10 },
8277 {
"SYSTEM",
"PROCCOL",
"DECIMAL_DIGITS", SQL_SMALLINT, 5 },
8278 {
"SYSTEM",
"PROCCOL",
"NUM_PREC_RADIX", SQL_SMALLINT, 5 },
8279 {
"SYSTEM",
"PROCCOL",
"NULLABLE", SQL_SMALLINT, 5 },
8281 {
"SYSTEM",
"PROCCOL",
"COLUMN_DEF",
SCOL_VARCHAR, 50 },
8282 {
"SYSTEM",
"PROCCOL",
"SQL_DATA_TYPE", SQL_SMALLINT, 5 },
8283 {
"SYSTEM",
"PROCCOL",
"SQL_DATETIME_SUB", SQL_SMALLINT, 5 },
8284 {
"SYSTEM",
"PROCCOL",
"CHAR_OCTET_LENGTH", SQL_SMALLINT, 5 },
8285 {
"SYSTEM",
"PROCCOL",
"ORDINAL_POSITION", SQL_SMALLINT, 5 },
8286 {
"SYSTEM",
"PROCCOL",
"IS_NULLABLE",
SCOL_VARCHAR, 50 }
8305 SQLProcedureColumns(SQLHSTMT
stmt,
8306 SQLCHAR *catalog, SQLSMALLINT catalogLen,
8307 SQLCHAR *schema, SQLSMALLINT schemaLen,
8308 SQLCHAR *proc, SQLSMALLINT procLen,
8309 SQLCHAR *column, SQLSMALLINT columnLen)
8339 SQLWCHAR *catalog, SQLSMALLINT catalogLen,
8340 SQLWCHAR *schema, SQLSMALLINT schemaLen,
8341 SQLWCHAR *proc, SQLSMALLINT procLen,
8342 SQLWCHAR *column, SQLSMALLINT columnLen)
8366 SQLINTEGER len, SQLINTEGER *lenp)
8369 SQLRETURN ret = SQL_ERROR;
8371 if (env == SQL_NULL_HENV) {
8372 return SQL_INVALID_HANDLE;
8376 return SQL_INVALID_HANDLE;
8378 #if defined(_WIN32) || defined(_WIN64) 8379 EnterCriticalSection(&e->cs);
8382 case SQL_ATTR_CONNECTION_POOLING:
8384 *((SQLINTEGER *) val) = e->
pool ?
8385 SQL_CP_ONE_PER_DRIVER : SQL_CP_OFF;
8388 *lenp =
sizeof (SQLINTEGER);
8392 case SQL_ATTR_CP_MATCH:
8393 *((SQLINTEGER *) val) = SQL_CP_RELAXED_MATCH;
8395 *lenp =
sizeof (SQLINTEGER);
8399 case SQL_ATTR_OUTPUT_NTS:
8401 *((SQLINTEGER *) val) = SQL_TRUE;
8404 *lenp =
sizeof (SQLINTEGER);
8408 case SQL_ATTR_ODBC_VERSION:
8410 *((SQLINTEGER *) val) = e->
ov3 ? SQL_OV_ODBC3 : SQL_OV_ODBC2;
8413 *lenp =
sizeof (SQLINTEGER);
8418 #if defined(_WIN32) || defined(_WIN64) 8419 LeaveCriticalSection(&e->cs);
8437 SQLRETURN ret = SQL_ERROR;
8439 if (env == SQL_NULL_HENV) {
8440 return SQL_INVALID_HANDLE;
8444 return SQL_INVALID_HANDLE;
8446 #if defined(_WIN32) || defined(_WIN64) 8447 EnterCriticalSection(&e->cs);
8450 case SQL_ATTR_CONNECTION_POOLING:
8451 if (val == (SQLPOINTER) SQL_CP_ONE_PER_DRIVER) {
8454 }
else if (val == (SQLPOINTER) SQL_CP_OFF) {
8459 case SQL_ATTR_CP_MATCH:
8462 case SQL_ATTR_OUTPUT_NTS:
8463 if (val == (SQLPOINTER) SQL_TRUE) {
8467 case SQL_ATTR_ODBC_VERSION:
8471 if (val == (SQLPOINTER) SQL_OV_ODBC2) {
8474 }
else if (val == (SQLPOINTER) SQL_OV_ODBC3) {
8480 #if defined(_WIN32) || defined(_WIN64) 8481 LeaveCriticalSection(&e->cs);
8501 SQLCHAR *sqlstate, SQLINTEGER *nativeerr, SQLCHAR *msg,
8502 SQLSMALLINT buflen, SQLSMALLINT *msglen)
8507 char *logmsg, *sqlst;
8508 SQLRETURN ret = SQL_ERROR;
8510 if (handle == SQL_NULL_HANDLE) {
8511 return SQL_INVALID_HANDLE;
8516 if (msg && buflen > 0) {
8526 case SQL_HANDLE_ENV:
8527 case SQL_HANDLE_DESC:
8529 case SQL_HANDLE_DBC:
8532 logmsg = (
char *) d->
logmsg;
8536 case SQL_HANDLE_STMT:
8538 s = (
STMT *) handle;
8539 logmsg = (
char *) s->
logmsg;
8544 return SQL_INVALID_HANDLE;
8553 len = strlen(logmsg);
8559 *nativeerr = naterr;
8562 strcpy((
char *) sqlstate, sqlst);
8567 if (len >= buflen) {
8568 if (msg && buflen > 0) {
8569 strncpy((
char *) msg, logmsg, buflen);
8570 msg[buflen - 1] =
'\0';
8574 strcpy((
char *) msg, logmsg);
8580 case SQL_HANDLE_DBC:
8583 case SQL_HANDLE_STMT:
8590 #if !defined(WINTERFACE) || (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC)) 8605 SQLGetDiagRec(SQLSMALLINT htype, SQLHANDLE handle, SQLSMALLINT recno,
8606 SQLCHAR *sqlstate, SQLINTEGER *nativeerr, SQLCHAR *msg,
8607 SQLSMALLINT buflen, SQLSMALLINT *msglen)
8610 nativeerr, msg, buflen, msglen);
8614 #if !defined(HAVE_UNIXODBC) || !(HAVE_UNIXODBC) 8632 SQLWCHAR *sqlstate, SQLINTEGER *nativeerr, SQLWCHAR *msg,
8633 SQLSMALLINT buflen, SQLSMALLINT *msglen)
8639 ret =
drvgetdiagrec(htype, handle, recno, (SQLCHAR *) state,
8640 nativeerr, (SQLCHAR *) msg, buflen, &len);
8641 if (ret == SQL_SUCCESS) {
8644 6 *
sizeof (SQLWCHAR));
8653 buflen /=
sizeof (SQLWCHAR);
8673 len *=
sizeof (SQLWCHAR);
8678 }
else if (ret == SQL_NO_DATA) {
8710 SQLSMALLINT
id, SQLPOINTER info,
8711 SQLSMALLINT buflen, SQLSMALLINT *stringlen)
8715 int len, naterr,
strbuf = 1;
8716 char *logmsg, *sqlst, *clrmsg = NULL;
8717 SQLRETURN ret = SQL_ERROR;
8719 if (handle == SQL_NULL_HANDLE) {
8720 return SQL_INVALID_HANDLE;
8726 case SQL_HANDLE_ENV:
8727 case SQL_HANDLE_DESC:
8729 case SQL_HANDLE_DBC:
8732 logmsg = (
char *) d->
logmsg;
8736 case SQL_HANDLE_STMT:
8738 s = (
STMT *) handle;
8740 logmsg = (
char *) s->
logmsg;
8745 return SQL_INVALID_HANDLE;
8749 case SQL_IS_POINTER:
8750 case SQL_IS_UINTEGER:
8751 case SQL_IS_INTEGER:
8752 case SQL_IS_USMALLINT:
8753 case SQL_IS_SMALLINT:
8766 case SQL_DIAG_CLASS_ORIGIN:
8767 logmsg =
"ISO 9075";
8768 if (sqlst[0] ==
'I' && sqlst[1] ==
'M') {
8769 logmsg =
"ODBC 3.0";
8772 case SQL_DIAG_SUBCLASS_ORIGIN:
8773 logmsg =
"ISO 9075";
8774 if (sqlst[0] ==
'I' && sqlst[1] ==
'M') {
8775 logmsg =
"ODBC 3.0";
8776 }
else if (sqlst[0] ==
'H' && sqlst[1] ==
'Y') {
8777 logmsg =
"ODBC 3.0";
8778 }
else if (sqlst[0] ==
'2' || sqlst[0] ==
'0' || sqlst[0] ==
'4') {
8779 logmsg =
"ODBC 3.0";
8782 case SQL_DIAG_CONNECTION_NAME:
8783 case SQL_DIAG_SERVER_NAME:
8784 logmsg = d->
dsn ? d->
dsn :
"No DSN";
8786 case SQL_DIAG_SQLSTATE:
8789 case SQL_DIAG_MESSAGE_TEXT:
8794 case SQL_DIAG_NUMBER:
8797 case SQL_DIAG_NATIVE:
8798 len = strlen(logmsg);
8804 *((SQLINTEGER *) info) = naterr;
8808 case SQL_DIAG_DYNAMIC_FUNCTION:
8811 case SQL_DIAG_CURSOR_ROW_COUNT:
8812 if (htype == SQL_HANDLE_STMT) {
8820 case SQL_DIAG_ROW_COUNT:
8821 if (htype == SQL_HANDLE_STMT) {
8832 if (info && buflen > 0) {
8833 ((
char *) info)[0] =
'\0';
8835 len = strlen(logmsg);
8844 if (len >= buflen) {
8845 if (info && buflen > 0) {
8847 *stringlen = buflen - 1;
8849 strncpy((
char *) info, logmsg, buflen);
8850 ((
char *) info)[buflen - 1] =
'\0';
8853 strcpy((
char *) info, logmsg);
8862 case SQL_HANDLE_DBC:
8865 case SQL_HANDLE_STMT:
8886 SQLGetDiagField(SQLSMALLINT htype, SQLHANDLE handle, SQLSMALLINT recno,
8887 SQLSMALLINT
id, SQLPOINTER info,
8888 SQLSMALLINT buflen, SQLSMALLINT *stringlen)
8890 return drvgetdiagfield(htype, handle, recno,
id, info, buflen, stringlen);
8909 SQLSMALLINT
id, SQLPOINTER info,
8910 SQLSMALLINT buflen, SQLSMALLINT *stringlen)
8916 if (ret == SQL_SUCCESS) {
8919 case SQL_DIAG_CLASS_ORIGIN:
8920 case SQL_DIAG_SUBCLASS_ORIGIN:
8921 case SQL_DIAG_CONNECTION_NAME:
8922 case SQL_DIAG_SERVER_NAME:
8923 case SQL_DIAG_SQLSTATE:
8924 case SQL_DIAG_MESSAGE_TEXT:
8925 case SQL_DIAG_DYNAMIC_FUNCTION:
8932 buflen /=
sizeof (SQLWCHAR);
8940 len *=
sizeof (SQLWCHAR);
8948 ((SQLWCHAR *) info)[0] = 0;
8954 case SQL_DIAG_CLASS_ORIGIN:
8955 case SQL_DIAG_SUBCLASS_ORIGIN:
8956 case SQL_DIAG_CONNECTION_NAME:
8957 case SQL_DIAG_SERVER_NAME:
8958 case SQL_DIAG_SQLSTATE:
8959 case SQL_DIAG_MESSAGE_TEXT:
8960 case SQL_DIAG_DYNAMIC_FUNCTION:
8961 len *=
sizeof (SQLWCHAR);
8985 SQLINTEGER bufmax, SQLINTEGER *buflen)
8996 uval = (SQLPOINTER) dummybuf;
8999 case SQL_QUERY_TIMEOUT:
9003 case SQL_ATTR_CURSOR_TYPE:
9007 case SQL_ATTR_CURSOR_SCROLLABLE:
9008 *uval = (s->
curtype != SQL_CURSOR_FORWARD_ONLY) ?
9009 SQL_SCROLLABLE : SQL_NONSCROLLABLE;
9012 #ifdef SQL_ATTR_CURSOR_SENSITIVITY 9013 case SQL_ATTR_CURSOR_SENSITIVITY:
9014 *uval = SQL_UNSPECIFIED;
9018 case SQL_ATTR_ROW_NUMBER:
9023 *uval = (s->
rowp < 0) ? SQL_ROW_NUMBER_UNKNOWN : (s->
rowp + 1);
9027 case SQL_ATTR_ASYNC_ENABLE:
9028 *uval = SQL_ASYNC_ENABLE_OFF;
9031 case SQL_CONCURRENCY:
9032 *uval = SQL_CONCUR_LOCK;
9035 case SQL_ATTR_RETRIEVE_DATA:
9039 case SQL_ROWSET_SIZE:
9040 case SQL_ATTR_ROW_ARRAY_SIZE:
9045 case SQL_ATTR_IMP_ROW_DESC:
9046 case SQL_ATTR_APP_ROW_DESC:
9047 case SQL_ATTR_IMP_PARAM_DESC:
9048 case SQL_ATTR_APP_PARAM_DESC:
9049 *((SQLHDESC *) uval) = (SQLHDESC)
DEAD_MAGIC;
9050 *buflen =
sizeof (SQLHDESC);
9052 case SQL_ATTR_ROW_STATUS_PTR:
9054 *buflen =
sizeof (SQLUSMALLINT *);
9056 case SQL_ATTR_ROWS_FETCHED_PTR:
9060 case SQL_ATTR_USE_BOOKMARKS: {
9063 *(SQLUINTEGER *) uval = s->
bkmrk;
9064 *buflen = sizeof (SQLUINTEGER);
9067 case SQL_ATTR_FETCH_BOOKMARK_PTR:
9068 *(SQLPOINTER *) uval = s->
bkmrkptr;
9069 *buflen = sizeof (SQLPOINTER);
9071 case SQL_ATTR_PARAM_BIND_OFFSET_PTR:
9075 case SQL_ATTR_PARAM_BIND_TYPE:
9079 case SQL_ATTR_PARAM_OPERATION_PTR:
9080 *((SQLUSMALLINT **) uval) = s->
parm_oper;
9081 *buflen =
sizeof (SQLUSMALLINT *);
9083 case SQL_ATTR_PARAM_STATUS_PTR:
9085 *buflen =
sizeof (SQLUSMALLINT *);
9087 case SQL_ATTR_PARAMS_PROCESSED_PTR:
9091 case SQL_ATTR_PARAMSET_SIZE:
9095 case SQL_ATTR_ROW_BIND_TYPE:
9099 case SQL_ATTR_ROW_BIND_OFFSET_PTR:
9103 case SQL_ATTR_MAX_ROWS:
9107 case SQL_ATTR_MAX_LENGTH:
9108 *((
SQLULEN *) uval) = 1000000000;
9111 #ifdef SQL_ATTR_METADATA_ID 9112 case SQL_ATTR_METADATA_ID:
9113 *((
SQLULEN *) uval) = SQL_FALSE;
9121 #if (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC)) || !defined(WINTERFACE) 9133 SQLGetStmtAttr(SQLHSTMT
stmt, SQLINTEGER attr, SQLPOINTER val,
9134 SQLINTEGER bufmax, SQLINTEGER *buflen)
9158 SQLINTEGER bufmax, SQLINTEGER *buflen)
9183 #if defined(SQL_BIGINT) && defined(__WORDSIZE) && (__WORDSIZE == 64) 9186 uval = (SQLBIGINT) val;
9193 case SQL_ATTR_CURSOR_TYPE:
9194 if (val == (SQLPOINTER) SQL_CURSOR_FORWARD_ONLY) {
9195 s->
curtype = SQL_CURSOR_FORWARD_ONLY;
9197 s->
curtype = SQL_CURSOR_STATIC;
9199 if (val != (SQLPOINTER) SQL_CURSOR_FORWARD_ONLY &&
9200 val != (SQLPOINTER) SQL_CURSOR_STATIC) {
9204 case SQL_ATTR_CURSOR_SCROLLABLE:
9205 if (val == (SQLPOINTER) SQL_NONSCROLLABLE) {
9206 s->
curtype = SQL_CURSOR_FORWARD_ONLY;
9208 s->
curtype = SQL_CURSOR_STATIC;
9211 case SQL_ATTR_ASYNC_ENABLE:
9212 if (val != (SQLPOINTER) SQL_ASYNC_ENABLE_OFF) {
9214 setstat(s, -1,
"option value changed",
"01S02");
9215 return SQL_SUCCESS_WITH_INFO;
9218 case SQL_CONCURRENCY:
9219 if (val != (SQLPOINTER) SQL_CONCUR_LOCK) {
9223 #ifdef SQL_ATTR_CURSOR_SENSITIVITY 9224 case SQL_ATTR_CURSOR_SENSITIVITY:
9225 if (val != (SQLPOINTER) SQL_UNSPECIFIED) {
9230 case SQL_ATTR_QUERY_TIMEOUT:
9232 case SQL_ATTR_RETRIEVE_DATA:
9233 if (val != (SQLPOINTER) SQL_RD_ON &&
9234 val != (SQLPOINTER) SQL_RD_OFF) {
9239 case SQL_ROWSET_SIZE:
9240 case SQL_ATTR_ROW_ARRAY_SIZE:
9242 setstat(s, -1,
"invalid rowset size",
"HY000");
9248 rst =
xmalloc(
sizeof (SQLUSMALLINT) * uval);
9260 case SQL_ATTR_ROW_STATUS_PTR:
9263 case SQL_ATTR_ROWS_FETCHED_PTR:
9266 case SQL_ATTR_PARAM_BIND_OFFSET_PTR:
9269 case SQL_ATTR_PARAM_BIND_TYPE:
9272 case SQL_ATTR_PARAM_OPERATION_PTR:
9275 case SQL_ATTR_PARAM_STATUS_PTR:
9278 case SQL_ATTR_PARAMS_PROCESSED_PTR:
9281 case SQL_ATTR_PARAMSET_SIZE:
9288 case SQL_ATTR_ROW_BIND_TYPE:
9291 case SQL_ATTR_ROW_BIND_OFFSET_PTR:
9294 case SQL_ATTR_USE_BOOKMARKS:
9295 if (val != (SQLPOINTER) SQL_UB_OFF &&
9296 val != (SQLPOINTER) SQL_UB_ON &&
9297 val != (SQLPOINTER) SQL_UB_VARIABLE) {
9300 if (*s->
ov3 && val == (SQLPOINTER) SQL_UB_VARIABLE) {
9301 s->
bkmrk = SQL_UB_VARIABLE;
9304 if (val == (SQLPOINTER) SQL_UB_VARIABLE) {
9305 s->
bkmrk = SQL_UB_ON;
9308 s->
bkmrk = (val == (SQLPOINTER) SQL_UB_ON) ? SQL_UB_ON : SQL_UB_OFF;
9310 case SQL_ATTR_FETCH_BOOKMARK_PTR:
9313 case SQL_ATTR_MAX_ROWS:
9316 case SQL_ATTR_MAX_LENGTH:
9317 if (val != (SQLPOINTER) 1000000000) {
9321 #ifdef SQL_ATTR_METADATA_ID 9322 case SQL_ATTR_METADATA_ID:
9323 if (val != (SQLPOINTER) SQL_FALSE) {
9332 #if (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC)) || !defined(WINTERFACE) 9343 SQLSetStmtAttr(SQLHSTMT
stmt, SQLINTEGER attr, SQLPOINTER val,
9390 SQLUINTEGER *ret = (SQLUINTEGER *) param;
9393 case SQL_QUERY_TIMEOUT:
9396 case SQL_CURSOR_TYPE:
9399 case SQL_ROW_NUMBER:
9404 *ret = (s->
rowp < 0) ? SQL_ROW_NUMBER_UNKNOWN : (s->
rowp + 1);
9407 case SQL_ASYNC_ENABLE:
9408 *ret = SQL_ASYNC_ENABLE_OFF;
9410 case SQL_CONCURRENCY:
9411 *ret = SQL_CONCUR_LOCK;
9413 case SQL_ATTR_RETRIEVE_DATA:
9416 case SQL_ROWSET_SIZE:
9417 case SQL_ATTR_ROW_ARRAY_SIZE:
9420 case SQL_ATTR_MAX_ROWS:
9423 case SQL_ATTR_MAX_LENGTH:
9484 case SQL_CURSOR_TYPE:
9485 if (param == SQL_CURSOR_FORWARD_ONLY) {
9488 s->
curtype = SQL_CURSOR_STATIC;
9490 if (param != SQL_CURSOR_FORWARD_ONLY &&
9491 param != SQL_CURSOR_STATIC) {
9495 case SQL_ASYNC_ENABLE:
9496 if (param != SQL_ASYNC_ENABLE_OFF) {
9500 case SQL_CONCURRENCY:
9501 if (param != SQL_CONCUR_LOCK) {
9505 case SQL_QUERY_TIMEOUT:
9507 case SQL_RETRIEVE_DATA:
9508 if (param != SQL_RD_ON && param != SQL_RD_OFF) {
9510 setstat(s, -1,
"option value changed",
"01S02");
9511 return SQL_SUCCESS_WITH_INFO;
9515 case SQL_ROWSET_SIZE:
9516 case SQL_ATTR_ROW_ARRAY_SIZE:
9518 setstat(s, -1,
"invalid rowset size",
"HY000");
9524 rst =
xmalloc(
sizeof (SQLUSMALLINT) * param);
9536 case SQL_ATTR_MAX_ROWS:
9539 case SQL_ATTR_MAX_LENGTH:
9540 if (param != 1000000000) {
9603 setstat(s, -1,
"unbound columns", (*s->
ov3) ?
"HY000" :
"S1000");
9606 for (i = 0; i < s->
ncols; i++) {
9609 if (b->
type == SQL_UNKNOWN_TYPE || !b->
valp) {
9638 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
9639 dp = (SQLPOINTER) ((
char *) b->valp + s->
bind_type * rsi);
9641 dp = (SQLPOINTER) ((
char *) b->valp + b->max * rsi);
9644 dp = (SQLPOINTER) ((
char *) dp + *s->
bind_offs);
9648 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
9658 setstat(s, -1,
"unbound column in positional update",
9659 (*s->
ov3) ?
"HY000" :
"S1000");
9662 if (*lp == SQL_NULL_DATA) {
9663 sqlite3_bind_null(
stmt, si);
9665 fprintf(d->
trace,
"-- parameter %d: NULL\n", si);
9671 case SQL_C_UTINYINT:
9673 case SQL_C_STINYINT:
9674 sqlite3_bind_int(
stmt, si, *(SQLCHAR *) dp);
9676 fprintf(d->
trace,
"-- parameter %d: %d\n", si, *(SQLCHAR *) dp);
9682 sqlite3_bind_int(
stmt, si, (*(SQLCHAR *) dp) ? 1 : 0);
9684 fprintf(d->
trace,
"-- parameter %d: %d\n", si,
9685 (*(SQLCHAR *) dp) ? 1 : 0);
9691 sqlite3_bind_int(
stmt, si, *(SQLUSMALLINT *) dp);
9693 fprintf(d->
trace,
"-- parameter %d: %d\n", si,
9694 *(SQLUSMALLINT *) dp);
9700 sqlite3_bind_int(
stmt, si, *(SQLSMALLINT *) dp);
9702 fprintf(d->
trace,
"-- parameter %d: %d\n", si,
9703 *(SQLSMALLINT *) dp);
9708 sqlite3_bind_int(
stmt, si, *(SQLUINTEGER *) dp);
9710 fprintf(d->
trace,
"-- parameter %d: %ld\n", si,
9711 (
long) *(SQLUINTEGER *) dp);
9717 sqlite3_bind_int(
stmt, si, *(SQLINTEGER *) dp);
9719 fprintf(d->
trace,
"-- parameter %d: %ld\n", si,
9720 (
long) *(SQLINTEGER *) dp);
9727 sqlite3_bind_int64(
stmt, si, *(SQLBIGINT *) dp);
9731 "-- parameter %d: %I64d\n",
9733 "-- parameter %d: %lld\n",
9735 si, (sqlite_int64) *(SQLBIGINT *) dp);
9741 sqlite3_bind_double(
stmt, si, *(
float *) dp);
9743 fprintf(d->
trace,
"-- parameter %d: %g\n", si,
9749 sqlite3_bind_double(
stmt, si, *(
double *) dp);
9751 fprintf(d->
trace,
"-- parameter %d: %g\n", si,
9757 sqlite3_bind_blob(
stmt, si, (
char *) dp, *lp, SQLITE_STATIC);
9759 fprintf(d->
trace,
"-- parameter %d: [BLOB]\n", si);
9769 sqlite3_bind_text(
stmt, si, cp, -1, SQLITE_TRANSIENT);
9771 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si, cp);
9778 #if defined(_WIN32) || defined(_WIN64) 9780 cp = wmb_to_utf((
char *) dp, *lp);
9784 sqlite3_bind_text(
stmt, si, cp, -1, SQLITE_TRANSIENT);
9786 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si, cp);
9793 if (*lp == SQL_NTS) {
9794 sqlite3_bind_text(
stmt, si, (
char *) dp, -1,
9797 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si,
9802 sqlite3_bind_text(
stmt, si, (
char *) dp, *lp,
9805 fprintf(d->
trace,
"-- parameter %d: '%*s'\n", si,
9806 (
int) *lp, (
char *) dp);
9812 #ifdef SQL_C_TYPE_DATE 9813 case SQL_C_TYPE_DATE:
9817 int a, b, x1, x2, y, m, dd;
9820 y = ((DATE_STRUCT *) dp)->year;
9821 m = ((DATE_STRUCT *) dp)->month;
9822 dd = ((DATE_STRUCT *) dp)->day;
9828 b = 2 - a + (a / 4);
9829 x1 = 36525 * (y + 4716) / 100;
9830 x2 = 306001 * (m + 1) / 10000;
9831 v = x1 + x2 + dd + b - 1524.5;
9832 sqlite3_bind_double(
stmt, si, v);
9834 fprintf(d->
trace,
"-- parameter %d: %g\n", si, v);
9838 sprintf(
strbuf,
"%04d-%02d-%02d",
9839 ((DATE_STRUCT *) dp)->year,
9840 ((DATE_STRUCT *) dp)->month,
9841 ((DATE_STRUCT *) dp)->day);
9842 sqlite3_bind_text(
stmt, si,
strbuf, -1, SQLITE_TRANSIENT);
9844 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si,
strbuf);
9849 #ifdef SQL_C_TYPE_TIME 9850 case SQL_C_TYPE_TIME:
9857 (((TIME_STRUCT *) dp)->hour * 3600000.0 +
9858 ((TIME_STRUCT *) dp)->minute * 60000.0 +
9859 ((TIME_STRUCT *) dp)->second * 1000.0) / 86400000.0;
9860 sqlite3_bind_double(
stmt, si, v);
9862 fprintf(d->
trace,
"-- parameter %d: %g\n", si, v);
9866 sprintf(
strbuf,
"%02d:%02d:%02d",
9867 ((TIME_STRUCT *) dp)->hour,
9868 ((TIME_STRUCT *) dp)->minute,
9869 ((TIME_STRUCT *) dp)->second);
9870 sqlite3_bind_text(
stmt, si,
strbuf, -1, SQLITE_TRANSIENT);
9872 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si,
strbuf);
9877 #ifdef SQL_C_TYPE_TIMESTAMP 9878 case SQL_C_TYPE_TIMESTAMP:
9880 case SQL_C_TIMESTAMP:
9882 int a, b, x1, x2, y, m, dd;
9885 y = ((TIMESTAMP_STRUCT *) dp)->year;
9886 m = ((TIMESTAMP_STRUCT *) dp)->month;
9887 dd = ((TIMESTAMP_STRUCT *) dp)->day;
9893 b = 2 - a + (a / 4);
9894 x1 = 36525 * (y + 4716) / 100;
9895 x2 = 306001 * (m + 1) / 10000;
9896 v = x1 + x2 + dd + b - 1524.5 +
9897 (((TIMESTAMP_STRUCT *) dp)->hour * 3600000.0 +
9898 ((TIMESTAMP_STRUCT *) dp)->minute * 60000.0 +
9899 ((TIMESTAMP_STRUCT *) dp)->second * 1000.0 +
9900 ((TIMESTAMP_STRUCT *) dp)->fraction / 1.0E6)
9902 sqlite3_bind_double(
stmt, si, v);
9904 fprintf(d->
trace,
"-- parameter %d: %g\n", si, v);
9910 frac = (int) ((TIMESTAMP_STRUCT *) dp)->fraction;
9916 if (c->prec && c->prec <= 16) {
9917 sprintf(
strbuf,
"%04d-%02d-%02d %02d:%02d:00.000",
9918 ((TIMESTAMP_STRUCT *) dp)->year,
9919 ((TIMESTAMP_STRUCT *) dp)->month,
9920 ((TIMESTAMP_STRUCT *) dp)->day,
9921 ((TIMESTAMP_STRUCT *) dp)->hour,
9922 ((TIMESTAMP_STRUCT *) dp)->minute);
9923 }
else if (c->prec && c->prec <= 19) {
9924 sprintf(
strbuf,
"%04d-%02d-%02d %02d:%02d:%02d.000",
9925 ((TIMESTAMP_STRUCT *) dp)->year,
9926 ((TIMESTAMP_STRUCT *) dp)->month,
9927 ((TIMESTAMP_STRUCT *) dp)->day,
9928 ((TIMESTAMP_STRUCT *) dp)->hour,
9929 ((TIMESTAMP_STRUCT *) dp)->minute,
9930 ((TIMESTAMP_STRUCT *) dp)->second);
9932 sprintf(
strbuf,
"%04d-%02d-%02d %02d:%02d:%02d.%03d",
9933 ((TIMESTAMP_STRUCT *) dp)->year,
9934 ((TIMESTAMP_STRUCT *) dp)->month,
9935 ((TIMESTAMP_STRUCT *) dp)->day,
9936 ((TIMESTAMP_STRUCT *) dp)->hour,
9937 ((TIMESTAMP_STRUCT *) dp)->minute,
9938 ((TIMESTAMP_STRUCT *) dp)->second,
9941 sqlite3_bind_text(
stmt, si,
strbuf, -1, SQLITE_TRANSIENT);
9943 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si,
strbuf);
9949 setstat(s, -1,
"unsupported column type in positional update",
9950 (*s->
ov3) ?
"HY000" :
"S1000");
9976 setstat(s, -1,
"row out of range", (*s->
ov3) ?
"HY107" :
"S1107");
9981 if (*data == NULL) {
9982 sqlite3_bind_null(
stmt, si);
9984 fprintf(d->
trace,
"-- parameter %d: NULL\n", si);
9988 sqlite3_bind_text(
stmt, si, *data, -1, SQLITE_STATIC);
9990 fprintf(d->
trace,
"-- parameter %d: '%s'\n", si, *data);
10007 int i, withinfo = 0;
10008 SQLRETURN ret = SQL_SUCCESS;
10017 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10020 dp = (SQLPOINTER) ((
char *) b->
valp + b->
max * rsi);
10023 dp = (SQLPOINTER) ((
char *) dp + *s->
bind_offs);
10027 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10030 lp = b->
lenp + rsi;
10037 int rowp = s->
rowp;
10043 if (!SQL_SUCCEEDED(ret)) {
10047 if (ret != SQL_SUCCESS) {
10049 #ifdef SQL_ROW_SUCCESS_WITH_INFO 10055 if (SQL_SUCCEEDED(ret)) {
10056 ret = withinfo ? SQL_SUCCESS_WITH_INFO : SQL_SUCCESS;
10075 int rowp, i, k, rc, nretry = 0;
10078 sqlite3_stmt *s3stmt = NULL;
10081 if (lock != SQL_LOCK_NO_CHANGE) {
10082 setstat(s, -1,
"unsupported locking mode",
10083 (*s->
ov3) ?
"HY000" :
"S1000");
10087 setstat(s, -1,
"incompatible statement",
10088 (*s->
ov3) ?
"HY000" :
"S1000");
10091 if (op == SQL_ADD) {
10093 setstat(s, -1,
"incompatible rowset",
10094 (*s->
ov3) ?
"HY000" :
"S1000");
10101 if (ret != SQL_SUCCESS) {
10104 sql =
dsappend(sql,
"INSERT INTO ");
10110 for (i = 0; i < s->
ncols; i++) {
10111 sql =
dsappend(sql, (i > 0) ?
"," :
"(");
10115 for (i = 0; i < s->
ncols; i++) {
10116 sql =
dsappend(sql, (i > 0) ?
",?" :
"(?");
10123 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10130 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10131 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10137 if (rc != SQLITE_OK) {
10139 sqlite3_finalize(s3stmt);
10143 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10146 if (rc != SQLITE_OK) {
10148 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10149 sqlite3_errmsg(d->
sqlite), rc);
10152 sqlite3_finalize(s3stmt);
10158 if (ret != SQL_SUCCESS) {
10160 sqlite3_finalize(s3stmt);
10165 rc = sqlite3_step(s3stmt);
10166 if (rc != SQLITE_DONE) {
10169 sqlite3_finalize(s3stmt);
10170 if (sqlite3_changes(d->
sqlite) > 0 && row <= s->rowset_size) {
10178 return SQL_SUCCESS;
10179 }
else if (op == SQL_UPDATE || op == SQL_DELETE) {
10181 setstat(s, -1,
"incompatible rowset",
10182 (*s->
ov3) ?
"HY000" :
"S1000");
10189 if (!SQL_SUCCEEDED(ret)) {
10199 if (op != SQL_POSITION && op != SQL_REFRESH &&
10200 op != SQL_DELETE && op != SQL_UPDATE) {
10203 if (op == SQL_POSITION) {
10204 rowp = s->
rowp + row - 1;
10205 if (!s->
rows || row == 0 || rowp < -1 || rowp >= s->
nrows) {
10207 setstat(s, -1,
"row out of range", (*s->
ov3) ?
"HY107" :
"S1107");
10211 }
else if (op == SQL_REFRESH) {
10219 if (!SQL_SUCCEEDED(ret)) {
10226 }
else if (op == SQL_DELETE) {
10227 sql =
dsappend(sql,
"DELETE FROM ");
10233 for (i = k = 0; i < s->
ncols; i++) {
10237 sql =
dsappend(sql, (k > 0) ?
" AND " :
" WHERE ");
10246 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10253 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10254 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10260 if (rc != SQLITE_OK) {
10262 sqlite3_finalize(s3stmt);
10266 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10269 if (rc != SQLITE_OK) {
10271 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10272 sqlite3_errmsg(d->
sqlite), rc);
10275 sqlite3_finalize(s3stmt);
10284 if (ret != SQL_SUCCESS) {
10286 sqlite3_finalize(s3stmt);
10291 rc = sqlite3_step(s3stmt);
10292 if (rc != SQLITE_DONE) {
10295 sqlite3_finalize(s3stmt);
10296 if (sqlite3_changes(d->
sqlite) > 0) {
10304 return SQL_SUCCESS;
10305 }
else if (op == SQL_UPDATE) {
10307 if (ret != SQL_SUCCESS) {
10316 for (i = 0; i < s->
ncols; i++) {
10317 sql =
dsappend(sql, (i > 0) ?
", " :
" SET ");
10321 for (i = k = 0; i < s->
ncols; i++) {
10325 sql =
dsappend(sql, (k > 0) ?
" AND " :
" WHERE ");
10334 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10341 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10342 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10348 if (rc != SQLITE_OK) {
10350 sqlite3_finalize(s3stmt);
10354 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10357 if (rc != SQLITE_OK) {
10359 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10360 sqlite3_errmsg(d->
sqlite), rc);
10363 sqlite3_finalize(s3stmt);
10369 if (ret != SQL_SUCCESS) {
10371 sqlite3_finalize(s3stmt);
10381 if (ret != SQL_SUCCESS) {
10383 sqlite3_finalize(s3stmt);
10388 rc = sqlite3_step(s3stmt);
10389 if (rc != SQLITE_DONE) {
10392 sqlite3_finalize(s3stmt);
10393 if (sqlite3_changes(d->
sqlite) > 0) {
10401 return SQL_SUCCESS;
10403 return SQL_SUCCESS;
10438 int row, i, k, rc, nretry = 0;
10441 sqlite3_stmt *s3stmt = NULL;
10445 setstat(s, -1,
"incompatible statement",
10446 (*s->
ov3) ?
"HY000" :
"S1000");
10449 if (op == SQL_ADD) {
10451 setstat(s, -1,
"incompatible rowset",
10452 (*s->
ov3) ?
"HY000" :
"S1000");
10456 if (ret != SQL_SUCCESS) {
10459 sql =
dsappend(sql,
"INSERT INTO ");
10465 for (i = 0; i < s->
ncols; i++) {
10466 sql =
dsappend(sql, (i > 0) ?
"," :
"(");
10470 for (i = 0; i < s->
ncols; i++) {
10471 sql =
dsappend(sql, (i > 0) ?
",?" :
"(?");
10478 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10485 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10486 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10492 if (rc != SQLITE_OK) {
10494 sqlite3_finalize(s3stmt);
10498 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10501 if (rc != SQLITE_OK) {
10502 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10503 sqlite3_errmsg(d->
sqlite), rc);
10506 sqlite3_finalize(s3stmt);
10513 if (ret != SQL_SUCCESS) {
10522 sqlite3_finalize(s3stmt);
10527 rc = sqlite3_step(s3stmt);
10528 if (rc != SQLITE_DONE) {
10529 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10530 sqlite3_errmsg(d->
sqlite), rc);
10534 if (sqlite3_changes(d->
sqlite) > 0) {
10542 if (s->
bkmrk == SQL_UB_VARIABLE &&
10547 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10555 val = (SQLPOINTER) ((
char *) val + *s->
bind_offs);
10557 *(sqlite_int64 *) val = sqlite3_last_insert_rowid(d->
sqlite);
10561 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10570 *ival =
sizeof (sqlite_int64);
10574 sqlite3_reset(s3stmt);
10577 sqlite3_finalize(s3stmt);
10578 return SQL_SUCCESS;
10579 }
else if (op == SQL_DELETE_BY_BOOKMARK) {
10581 s->
bkmrk != SQL_UB_VARIABLE ||
10584 setstat(s, -1,
"incompatible rowset",
10585 (*s->
ov3) ?
"HY000" :
"S1000");
10588 sql =
dsappend(sql,
"DELETE FROM ");
10601 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10608 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10609 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10615 if (rc != SQLITE_OK) {
10617 sqlite3_finalize(s3stmt);
10621 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10624 if (rc != SQLITE_OK) {
10625 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10626 sqlite3_errmsg(d->
sqlite), rc);
10629 sqlite3_finalize(s3stmt);
10635 sqlite_int64 rowid;
10637 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10645 val = (SQLPOINTER) ((
char *) val + *s->
bind_offs);
10650 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10659 if (*ival !=
sizeof (sqlite_int64)) {
10663 rowid = *(sqlite_int64 *) val;
10664 sqlite3_bind_int64(s3stmt, 1, rowid);
10668 "-- parameter 1: %I64d\n",
10670 "-- parameter 1: %lld\n",
10675 rc = sqlite3_step(s3stmt);
10676 if (rc != SQLITE_DONE) {
10677 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10678 sqlite3_errmsg(d->
sqlite), rc);
10686 sqlite3_finalize(s3stmt);
10689 if (sqlite3_changes(d->
sqlite) > 0) {
10698 sqlite3_reset(s3stmt);
10701 sqlite3_finalize(s3stmt);
10702 return SQL_SUCCESS;
10703 }
else if (op == SQL_UPDATE_BY_BOOKMARK) {
10705 s->
bkmrk != SQL_UB_VARIABLE ||
10708 setstat(s, -1,
"incompatible rowset",
10709 (*s->
ov3) ?
"HY000" :
"S1000");
10713 if (ret != SQL_SUCCESS) {
10722 for (i = 0, k = 0; i < s->
ncols; i++) {
10726 sql =
dsappend(sql, (k > 0) ?
", " :
" SET ");
10738 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10745 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 10746 rc = sqlite3_prepare_v2(d->
sqlite,
dsval(sql), -1,
10752 if (rc != SQLITE_OK) {
10754 sqlite3_finalize(s3stmt);
10758 }
while (rc == SQLITE_SCHEMA && (++nretry) < 2);
10761 if (rc != SQLITE_OK) {
10762 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10763 sqlite3_errmsg(d->
sqlite), rc);
10766 sqlite3_finalize(s3stmt);
10772 sqlite_int64 rowid;
10774 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10782 val = (SQLPOINTER) ((
char *) val + *s->
bind_offs);
10787 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
10796 if (*ival !=
sizeof (sqlite_int64)) {
10805 if (ret != SQL_SUCCESS) {
10814 sqlite3_finalize(s3stmt);
10819 rowid = *(sqlite_int64 *) val;
10820 sqlite3_bind_int64(s3stmt, k, rowid);
10824 "-- parameter %d: %I64d\n",
10826 "-- parameter %d: %lld\n",
10831 rc = sqlite3_step(s3stmt);
10832 if (rc != SQLITE_DONE) {
10833 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
10834 sqlite3_errmsg(d->
sqlite), rc);
10838 if (sqlite3_changes(d->
sqlite) > 0) {
10847 sqlite3_reset(s3stmt);
10850 sqlite3_finalize(s3stmt);
10851 return SQL_SUCCESS;
10853 setstat(s, -1,
"unsupported operation", (*s->
ov3) ?
"HY000" :
"S1000");
10882 SQLUSMALLINT rowset)
10892 #define strmak(dst, src, max, lenp) { \ 10893 int len = strlen(src); \ 10894 int cnt = min(len + 1, max); \ 10895 strncpy(dst, src, cnt); \ 10896 *lenp = (cnt > len) ? len : cnt; \ 10911 SQLSMALLINT *valLen)
10916 #if defined(_WIN32) || defined(_WIN64) 10917 char pathbuf[301], *drvname;
10919 static char drvname[] =
"sqlite3odbc.so";
10922 if (
dbc == SQL_NULL_HDBC) {
10923 return SQL_INVALID_HANDLE;
10934 valMax =
sizeof (dummyc) - 1;
10937 case SQL_MAX_USER_NAME_LEN:
10938 *((SQLSMALLINT *) val) = 16;
10939 *valLen =
sizeof (SQLSMALLINT);
10941 case SQL_USER_NAME:
10942 strmak(val,
"", valMax, valLen);
10944 case SQL_DRIVER_ODBC_VER:
10946 strmak(val, (*d->
ov3) ?
"03.00" :
"02.50", valMax, valLen);
10948 strmak(val,
"03.00", valMax, valLen);
10951 case SQL_ACTIVE_CONNECTIONS:
10952 case SQL_ACTIVE_STATEMENTS:
10953 *((SQLSMALLINT *) val) = 0;
10954 *valLen =
sizeof (SQLSMALLINT);
10956 #ifdef SQL_ASYNC_MODE 10957 case SQL_ASYNC_MODE:
10958 *((SQLUINTEGER *) val) = SQL_AM_NONE;
10959 *valLen =
sizeof (SQLUINTEGER);
10962 #ifdef SQL_CREATE_TABLE 10963 case SQL_CREATE_TABLE:
10964 *((SQLUINTEGER *) val) = SQL_CT_CREATE_TABLE |
10965 SQL_CT_COLUMN_DEFAULT |
10966 SQL_CT_COLUMN_CONSTRAINT |
10967 SQL_CT_CONSTRAINT_NON_DEFERRABLE;
10968 *valLen =
sizeof (SQLUINTEGER);
10971 #ifdef SQL_CREATE_VIEW 10972 case SQL_CREATE_VIEW:
10973 *((SQLUINTEGER *) val) = SQL_CV_CREATE_VIEW;
10974 *valLen =
sizeof (SQLUINTEGER);
10977 #ifdef SQL_DDL_INDEX 10978 case SQL_DDL_INDEX:
10979 *((SQLUINTEGER *) val) = SQL_DI_CREATE_INDEX | SQL_DI_DROP_INDEX;
10980 *valLen =
sizeof (SQLUINTEGER);
10983 #ifdef SQL_DROP_TABLE 10984 case SQL_DROP_TABLE:
10985 *((SQLUINTEGER *) val) = SQL_DT_DROP_TABLE;
10986 *valLen =
sizeof (SQLUINTEGER);
10989 #ifdef SQL_DROP_VIEW 10990 case SQL_DROP_VIEW:
10991 *((SQLUINTEGER *) val) = SQL_DV_DROP_VIEW;
10992 *valLen =
sizeof (SQLUINTEGER);
10995 #ifdef SQL_INDEX_KEYWORDS 10996 case SQL_INDEX_KEYWORDS:
10997 *((SQLUINTEGER *) val) = SQL_IK_ALL;
10998 *valLen =
sizeof (SQLUINTEGER);
11001 case SQL_DATA_SOURCE_NAME:
11004 case SQL_DRIVER_NAME:
11005 #if defined(_WIN32) || defined(_WIN64) 11006 GetModuleFileName(hModule, pathbuf,
sizeof (pathbuf));
11007 drvname = strrchr(pathbuf,
'\\');
11008 if (drvname == NULL) {
11009 drvname = strrchr(pathbuf,
'/');
11011 if (drvname == NULL) {
11017 strmak(val, drvname, valMax, valLen);
11019 case SQL_DRIVER_VER:
11022 case SQL_FETCH_DIRECTION:
11023 *((SQLUINTEGER *) val) = SQL_FD_FETCH_NEXT | SQL_FD_FETCH_FIRST |
11024 SQL_FD_FETCH_LAST | SQL_FD_FETCH_PRIOR | SQL_FD_FETCH_ABSOLUTE;
11025 *valLen =
sizeof (SQLUINTEGER);
11028 strmak(val, (*d->
ov3) ?
"03.00" :
"02.50", valMax, valLen);
11030 case SQL_ODBC_SAG_CLI_CONFORMANCE:
11031 *((SQLSMALLINT *) val) = SQL_OSCC_NOT_COMPLIANT;
11032 *valLen =
sizeof (SQLSMALLINT);
11034 case SQL_STANDARD_CLI_CONFORMANCE:
11035 *((SQLUINTEGER *) val) = SQL_SCC_XOPEN_CLI_VERSION1;
11036 *valLen =
sizeof (SQLUINTEGER);
11038 case SQL_SQL_CONFORMANCE:
11039 *((SQLUINTEGER *) val) = SQL_SC_SQL92_ENTRY;
11040 *valLen =
sizeof (SQLUINTEGER);
11042 case SQL_SERVER_NAME:
11043 case SQL_DATABASE_NAME:
11046 case SQL_SEARCH_PATTERN_ESCAPE:
11047 strmak(val,
"\\", valMax, valLen);
11049 case SQL_ODBC_SQL_CONFORMANCE:
11050 *((SQLSMALLINT *) val) = SQL_OSC_MINIMUM;
11051 *valLen =
sizeof (SQLSMALLINT);
11053 case SQL_ODBC_API_CONFORMANCE:
11054 *((SQLSMALLINT *) val) = SQL_OAC_LEVEL1;
11055 *valLen =
sizeof (SQLSMALLINT);
11057 case SQL_DBMS_NAME:
11058 strmak(val,
"SQLite", valMax, valLen);
11061 strmak(val, SQLITE_VERSION, valMax, valLen);
11063 case SQL_COLUMN_ALIAS:
11064 case SQL_NEED_LONG_DATA_LEN:
11065 strmak(val,
"Y", valMax, valLen);
11067 case SQL_ROW_UPDATES:
11068 case SQL_ACCESSIBLE_PROCEDURES:
11069 case SQL_PROCEDURES:
11070 case SQL_EXPRESSIONS_IN_ORDERBY:
11071 case SQL_ODBC_SQL_OPT_IEF:
11072 case SQL_LIKE_ESCAPE_CLAUSE:
11073 case SQL_ORDER_BY_COLUMNS_IN_SELECT:
11074 case SQL_OUTER_JOINS:
11075 case SQL_ACCESSIBLE_TABLES:
11076 case SQL_MULT_RESULT_SETS:
11077 case SQL_MULTIPLE_ACTIVE_TXN:
11078 case SQL_MAX_ROW_SIZE_INCLUDES_LONG:
11079 strmak(val,
"N", valMax, valLen);
11081 #ifdef SQL_CATALOG_NAME 11082 case SQL_CATALOG_NAME:
11083 #if defined(_WIN32) || defined(_WIN64) 11084 strmak(val, d->xcelqrx ?
"Y" :
"N", valMax, valLen);
11086 strmak(val,
"N", valMax, valLen);
11090 case SQL_DATA_SOURCE_READ_ONLY:
11091 strmak(val,
"N", valMax, valLen);
11093 #ifdef SQL_OJ_CAPABILITIES 11094 case SQL_OJ_CAPABILITIES:
11095 *((SQLUINTEGER *) val) = 0;
11096 *valLen =
sizeof (SQLUINTEGER);
11099 #ifdef SQL_MAX_IDENTIFIER_LEN 11100 case SQL_MAX_IDENTIFIER_LEN:
11101 *((SQLUSMALLINT *) val) = 255;
11102 *valLen =
sizeof (SQLUSMALLINT);
11105 case SQL_CONCAT_NULL_BEHAVIOR:
11106 *((SQLSMALLINT *) val) = SQL_CB_NULL;
11107 *valLen =
sizeof (SQLSMALLINT);
11109 case SQL_CURSOR_COMMIT_BEHAVIOR:
11110 case SQL_CURSOR_ROLLBACK_BEHAVIOR:
11111 *((SQLSMALLINT *) val) = SQL_CB_PRESERVE;
11112 *valLen =
sizeof (SQLSMALLINT);
11114 #ifdef SQL_CURSOR_SENSITIVITY 11115 case SQL_CURSOR_SENSITIVITY:
11116 *((SQLUINTEGER *) val) = SQL_UNSPECIFIED;
11117 *valLen =
sizeof (SQLUINTEGER);
11120 case SQL_DEFAULT_TXN_ISOLATION:
11121 *((SQLUINTEGER *) val) = SQL_TXN_SERIALIZABLE;
11122 *valLen =
sizeof (SQLUINTEGER);
11124 #ifdef SQL_DESCRIBE_PARAMETER 11125 case SQL_DESCRIBE_PARAMETER:
11126 strmak(val,
"Y", valMax, valLen);
11129 case SQL_TXN_ISOLATION_OPTION:
11130 *((SQLUINTEGER *) val) = SQL_TXN_SERIALIZABLE;
11131 *valLen =
sizeof (SQLUINTEGER);
11133 case SQL_IDENTIFIER_CASE:
11134 *((SQLSMALLINT *) val) = SQL_IC_SENSITIVE;
11135 *valLen =
sizeof (SQLSMALLINT);
11137 case SQL_IDENTIFIER_QUOTE_CHAR:
11138 strmak(val,
"\"", valMax, valLen);
11140 case SQL_MAX_TABLE_NAME_LEN:
11141 case SQL_MAX_COLUMN_NAME_LEN:
11142 *((SQLSMALLINT *) val) = 255;
11143 *valLen =
sizeof (SQLSMALLINT);
11145 case SQL_MAX_CURSOR_NAME_LEN:
11146 *((SQLSMALLINT *) val) = 255;
11147 *valLen =
sizeof (SQLSMALLINT);
11149 case SQL_MAX_PROCEDURE_NAME_LEN:
11150 *((SQLSMALLINT *) val) = 0;
11152 case SQL_MAX_QUALIFIER_NAME_LEN:
11153 case SQL_MAX_OWNER_NAME_LEN:
11154 *((SQLSMALLINT *) val) = 255;
11156 case SQL_OWNER_TERM:
11157 strmak(val,
"", valMax, valLen);
11159 case SQL_PROCEDURE_TERM:
11160 strmak(val,
"PROCEDURE", valMax, valLen);
11162 case SQL_QUALIFIER_NAME_SEPARATOR:
11163 strmak(val,
".", valMax, valLen);
11165 case SQL_QUALIFIER_TERM:
11166 #if defined(_WIN32) || defined(_WIN64) 11167 strmak(val, d->xcelqrx ?
"catalog" :
"", valMax, valLen);
11169 strmak(val,
"", valMax, valLen);
11172 case SQL_QUALIFIER_USAGE:
11173 #if defined(_WIN32) || defined(_WIN64) 11174 *((SQLUINTEGER *) val) = d->xcelqrx ?
11175 (SQL_CU_DML_STATEMENTS | SQL_CU_INDEX_DEFINITION |
11176 SQL_CU_TABLE_DEFINITION) : 0;
11178 *((SQLUINTEGER *) val) = 0;
11180 *valLen =
sizeof (SQLUINTEGER);
11182 case SQL_SCROLL_CONCURRENCY:
11183 *((SQLUINTEGER *) val) = SQL_SCCO_LOCK;
11184 *valLen =
sizeof (SQLUINTEGER);
11186 case SQL_SCROLL_OPTIONS:
11187 *((SQLUINTEGER *) val) = SQL_SO_STATIC | SQL_SO_FORWARD_ONLY;
11188 *valLen =
sizeof (SQLUINTEGER);
11190 case SQL_TABLE_TERM:
11191 strmak(val,
"TABLE", valMax, valLen);
11193 case SQL_TXN_CAPABLE:
11194 *((SQLSMALLINT *) val) = SQL_TC_ALL;
11195 *valLen =
sizeof (SQLSMALLINT);
11197 case SQL_CONVERT_FUNCTIONS:
11198 *((SQLUINTEGER *) val) = 0;
11199 *valLen =
sizeof (SQLUINTEGER);
11201 case SQL_SYSTEM_FUNCTIONS:
11202 case SQL_NUMERIC_FUNCTIONS:
11203 case SQL_STRING_FUNCTIONS:
11204 case SQL_TIMEDATE_FUNCTIONS:
11205 *((SQLUINTEGER *) val) = 0;
11206 *valLen =
sizeof (SQLUINTEGER);
11208 case SQL_CONVERT_BIGINT:
11209 case SQL_CONVERT_BIT:
11210 case SQL_CONVERT_CHAR:
11211 case SQL_CONVERT_DATE:
11212 case SQL_CONVERT_DECIMAL:
11213 case SQL_CONVERT_DOUBLE:
11214 case SQL_CONVERT_FLOAT:
11215 case SQL_CONVERT_INTEGER:
11216 case SQL_CONVERT_LONGVARCHAR:
11217 case SQL_CONVERT_NUMERIC:
11218 case SQL_CONVERT_REAL:
11219 case SQL_CONVERT_SMALLINT:
11220 case SQL_CONVERT_TIME:
11221 case SQL_CONVERT_TIMESTAMP:
11222 case SQL_CONVERT_TINYINT:
11223 case SQL_CONVERT_VARCHAR:
11224 *((SQLUINTEGER *) val) =
11225 SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL |
11226 SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT | SQL_CVT_REAL |
11227 SQL_CVT_DOUBLE | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR |
11228 SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_BIGINT |
11229 SQL_CVT_DATE | SQL_CVT_TIME | SQL_CVT_TIMESTAMP;
11230 *valLen =
sizeof (SQLUINTEGER);
11232 case SQL_CONVERT_BINARY:
11233 case SQL_CONVERT_VARBINARY:
11234 case SQL_CONVERT_LONGVARBINARY:
11235 *((SQLUINTEGER *) val) = 0;
11236 *valLen =
sizeof (SQLUINTEGER);
11238 case SQL_POSITIONED_STATEMENTS:
11239 *((SQLUINTEGER *) val) = 0;
11240 *valLen =
sizeof (SQLUINTEGER);
11242 case SQL_LOCK_TYPES:
11243 *((SQLUINTEGER *) val) = SQL_LCK_NO_CHANGE;
11244 *valLen =
sizeof (SQLUINTEGER);
11246 case SQL_BOOKMARK_PERSISTENCE:
11247 *((SQLUINTEGER *) val) = SQL_BP_SCROLL;
11248 *valLen =
sizeof (SQLUINTEGER);
11251 *((SQLUINTEGER *) val) = SQL_U_UNION | SQL_U_UNION_ALL;
11252 *valLen =
sizeof (SQLUINTEGER);
11254 case SQL_OWNER_USAGE:
11255 case SQL_SUBQUERIES:
11256 case SQL_TIMEDATE_ADD_INTERVALS:
11257 case SQL_TIMEDATE_DIFF_INTERVALS:
11258 *((SQLUINTEGER *) val) = 0;
11259 *valLen =
sizeof (SQLUINTEGER);
11261 case SQL_QUOTED_IDENTIFIER_CASE:
11262 *((SQLUSMALLINT *) val) = SQL_IC_SENSITIVE;
11263 *valLen =
sizeof (SQLUSMALLINT);
11265 case SQL_POS_OPERATIONS:
11266 *((SQLUINTEGER *) val) = SQL_POS_POSITION | SQL_POS_UPDATE |
11267 SQL_POS_DELETE | SQL_POS_ADD | SQL_POS_REFRESH;
11268 *valLen =
sizeof (SQLUINTEGER);
11270 case SQL_ALTER_TABLE:
11271 *((SQLUINTEGER *) val) = 0;
11272 *valLen =
sizeof (SQLUINTEGER);
11274 case SQL_CORRELATION_NAME:
11275 *((SQLSMALLINT *) val) = SQL_CN_DIFFERENT;
11276 *valLen =
sizeof (SQLSMALLINT);
11278 case SQL_NON_NULLABLE_COLUMNS:
11279 *((SQLSMALLINT *) val) = SQL_NNC_NON_NULL;
11280 *valLen =
sizeof (SQLSMALLINT);
11282 case SQL_NULL_COLLATION:
11283 *((SQLSMALLINT *) val) = SQL_NC_START;
11284 *valLen =
sizeof (SQLSMALLINT);
11286 case SQL_MAX_COLUMNS_IN_GROUP_BY:
11287 case SQL_MAX_COLUMNS_IN_ORDER_BY:
11288 case SQL_MAX_COLUMNS_IN_SELECT:
11289 case SQL_MAX_COLUMNS_IN_TABLE:
11290 case SQL_MAX_ROW_SIZE:
11291 case SQL_MAX_TABLES_IN_SELECT:
11292 *((SQLSMALLINT *) val) = 0;
11293 *valLen =
sizeof (SQLSMALLINT);
11295 case SQL_MAX_BINARY_LITERAL_LEN:
11296 case SQL_MAX_CHAR_LITERAL_LEN:
11297 *((SQLUINTEGER *) val) = 0;
11298 *valLen =
sizeof (SQLUINTEGER);
11300 case SQL_MAX_COLUMNS_IN_INDEX:
11301 *((SQLSMALLINT *) val) = 0;
11302 *valLen =
sizeof (SQLSMALLINT);
11304 case SQL_MAX_INDEX_SIZE:
11305 *((SQLUINTEGER *) val) = 0;
11306 *valLen =
sizeof (SQLUINTEGER);
11308 #ifdef SQL_MAX_IDENTIFIER_LENGTH 11309 case SQL_MAX_IDENTIFIER_LENGTH:
11310 *((SQLUINTEGER *) val) = 255;
11311 *valLen =
sizeof (SQLUINTEGER);
11314 case SQL_MAX_STATEMENT_LEN:
11315 *((SQLUINTEGER *) val) = 16384;
11316 *valLen =
sizeof (SQLUINTEGER);
11318 case SQL_QUALIFIER_LOCATION:
11319 *((SQLSMALLINT *) val) = SQL_QL_START;
11320 *valLen =
sizeof (SQLSMALLINT);
11322 case SQL_GETDATA_EXTENSIONS:
11323 *((SQLUINTEGER *) val) =
11324 SQL_GD_ANY_COLUMN | SQL_GD_ANY_ORDER | SQL_GD_BOUND;
11325 *valLen =
sizeof (SQLUINTEGER);
11327 case SQL_STATIC_SENSITIVITY:
11328 *((SQLUINTEGER *) val) = 0;
11329 *valLen =
sizeof (SQLUINTEGER);
11331 case SQL_FILE_USAGE:
11332 #if defined(_WIN32) || defined(_WIN64) 11333 *((SQLSMALLINT *) val) =
11334 d->xcelqrx ? SQL_FILE_CATALOG : SQL_FILE_NOT_SUPPORTED;
11336 *((SQLSMALLINT *) val) = SQL_FILE_NOT_SUPPORTED;
11338 *valLen =
sizeof (SQLSMALLINT);
11341 *((SQLSMALLINT *) val) = SQL_GB_GROUP_BY_EQUALS_SELECT;
11342 *valLen =
sizeof (SQLSMALLINT);
11345 strmak(val,
"CREATE,SELECT,DROP,DELETE,UPDATE,INSERT," 11346 "INTO,VALUES,TABLE,INDEX,FROM,SET,WHERE,AND,CURRENT,OF",
11349 case SQL_SPECIAL_CHARACTERS:
11350 #ifdef SQL_COLLATION_SEQ 11351 case SQL_COLLATION_SEQ:
11353 strmak(val,
"", valMax, valLen);
11355 case SQL_BATCH_SUPPORT:
11356 case SQL_BATCH_ROW_COUNT:
11357 case SQL_PARAM_ARRAY_ROW_COUNTS:
11358 *((SQLUINTEGER *) val) = 0;
11359 *valLen =
sizeof (SQLUINTEGER);
11361 case SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1:
11362 *((SQLUINTEGER *) val) = SQL_CA1_NEXT | SQL_CA1_BOOKMARK;
11363 *valLen =
sizeof (SQLUINTEGER);
11365 case SQL_STATIC_CURSOR_ATTRIBUTES1:
11366 *((SQLUINTEGER *) val) = SQL_CA1_NEXT | SQL_CA1_ABSOLUTE |
11367 SQL_CA1_RELATIVE | SQL_CA1_BOOKMARK | SQL_CA1_POS_POSITION |
11368 SQL_CA1_POS_DELETE | SQL_CA1_POS_UPDATE | SQL_CA1_POS_REFRESH |
11369 SQL_CA1_LOCK_NO_CHANGE | SQL_CA1_BULK_ADD |
11370 SQL_CA1_BULK_UPDATE_BY_BOOKMARK | SQL_CA1_BULK_DELETE_BY_BOOKMARK;
11371 *valLen =
sizeof (SQLUINTEGER);
11373 case SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2:
11374 case SQL_STATIC_CURSOR_ATTRIBUTES2:
11375 *((SQLUINTEGER *) val) = SQL_CA2_READ_ONLY_CONCURRENCY |
11376 SQL_CA2_LOCK_CONCURRENCY;
11377 *valLen =
sizeof (SQLUINTEGER);
11379 case SQL_KEYSET_CURSOR_ATTRIBUTES1:
11380 case SQL_KEYSET_CURSOR_ATTRIBUTES2:
11381 case SQL_DYNAMIC_CURSOR_ATTRIBUTES1:
11382 case SQL_DYNAMIC_CURSOR_ATTRIBUTES2:
11383 *((SQLUINTEGER *) val) = 0;
11384 *valLen =
sizeof (SQLUINTEGER);
11386 case SQL_ODBC_INTERFACE_CONFORMANCE:
11387 *((SQLUINTEGER *) val) = SQL_OIC_CORE;
11388 *valLen =
sizeof (SQLUINTEGER);
11391 setstatd(d, -1,
"unsupported info option %d",
11392 (*d->
ov3) ?
"HYC00" :
"S1C00", type);
11395 return SQL_SUCCESS;
11398 #if (defined(HAVE_UNIXODBC) && (HAVE_UNIXODBC)) || !defined(WINTERFACE) 11410 SQLGetInfo(SQLHDBC
dbc, SQLUSMALLINT type, SQLPOINTER val, SQLSMALLINT valMax,
11411 SQLSMALLINT *valLen)
11435 SQLSMALLINT *valLen)
11438 SQLSMALLINT len = 0;
11443 if (ret == SQL_SUCCESS) {
11444 SQLWCHAR *v = NULL;
11447 case SQL_USER_NAME:
11448 case SQL_DRIVER_ODBC_VER:
11449 case SQL_DATA_SOURCE_NAME:
11450 case SQL_DRIVER_NAME:
11451 case SQL_DRIVER_VER:
11453 case SQL_SERVER_NAME:
11454 case SQL_DATABASE_NAME:
11455 case SQL_SEARCH_PATTERN_ESCAPE:
11456 case SQL_DBMS_NAME:
11458 case SQL_NEED_LONG_DATA_LEN:
11459 case SQL_ROW_UPDATES:
11460 case SQL_ACCESSIBLE_PROCEDURES:
11461 case SQL_PROCEDURES:
11462 case SQL_EXPRESSIONS_IN_ORDERBY:
11463 case SQL_ODBC_SQL_OPT_IEF:
11464 case SQL_LIKE_ESCAPE_CLAUSE:
11465 case SQL_ORDER_BY_COLUMNS_IN_SELECT:
11466 case SQL_OUTER_JOINS:
11467 case SQL_COLUMN_ALIAS:
11468 case SQL_ACCESSIBLE_TABLES:
11469 case SQL_MULT_RESULT_SETS:
11470 case SQL_MULTIPLE_ACTIVE_TXN:
11471 case SQL_MAX_ROW_SIZE_INCLUDES_LONG:
11472 case SQL_DATA_SOURCE_READ_ONLY:
11473 #ifdef SQL_DESCRIBE_PARAMETER 11474 case SQL_DESCRIBE_PARAMETER:
11476 case SQL_IDENTIFIER_QUOTE_CHAR:
11477 case SQL_OWNER_TERM:
11478 case SQL_PROCEDURE_TERM:
11479 case SQL_QUALIFIER_NAME_SEPARATOR:
11480 case SQL_QUALIFIER_TERM:
11481 case SQL_TABLE_TERM:
11483 case SQL_SPECIAL_CHARACTERS:
11484 #ifdef SQL_CATALOG_NAME 11485 case SQL_CATALOG_NAME:
11487 #ifdef SQL_COLLATION_SEQ 11488 case SQL_COLLATION_SEQ:
11494 int vmax = valMax /
sizeof (SQLWCHAR);
11504 len *=
sizeof (SQLWCHAR);
11511 if (valMax >=
sizeof (SQLWCHAR)) {
11512 *((SQLWCHAR *)val) = 0;
11516 len *=
sizeof (SQLWCHAR);
11538 SQLUSMALLINT *flags)
11541 SQLUSMALLINT exists[100];
11543 if (
dbc == SQL_NULL_HDBC) {
11544 return SQL_INVALID_HANDLE;
11547 exists[i] = SQL_FALSE;
11549 exists[SQL_API_SQLALLOCCONNECT] = SQL_TRUE;
11550 exists[SQL_API_SQLFETCH] = SQL_TRUE;
11551 exists[SQL_API_SQLALLOCENV] = SQL_TRUE;
11552 exists[SQL_API_SQLFREECONNECT] = SQL_TRUE;
11553 exists[SQL_API_SQLALLOCSTMT] = SQL_TRUE;
11554 exists[SQL_API_SQLFREEENV] = SQL_TRUE;
11555 exists[SQL_API_SQLBINDCOL] = SQL_TRUE;
11556 exists[SQL_API_SQLFREESTMT] = SQL_TRUE;
11557 exists[SQL_API_SQLCANCEL] = SQL_TRUE;
11558 exists[SQL_API_SQLGETCURSORNAME] = SQL_TRUE;
11559 exists[SQL_API_SQLCOLATTRIBUTES] = SQL_TRUE;
11560 exists[SQL_API_SQLNUMRESULTCOLS] = SQL_TRUE;
11561 exists[SQL_API_SQLCONNECT] = SQL_TRUE;
11562 exists[SQL_API_SQLPREPARE] = SQL_TRUE;
11563 exists[SQL_API_SQLDESCRIBECOL] = SQL_TRUE;
11564 exists[SQL_API_SQLROWCOUNT] = SQL_TRUE;
11565 exists[SQL_API_SQLDISCONNECT] = SQL_TRUE;
11566 exists[SQL_API_SQLSETCURSORNAME] = SQL_FALSE;
11567 exists[SQL_API_SQLERROR] = SQL_TRUE;
11568 exists[SQL_API_SQLSETPARAM] = SQL_TRUE;
11569 exists[SQL_API_SQLEXECDIRECT] = SQL_TRUE;
11570 exists[SQL_API_SQLTRANSACT] = SQL_TRUE;
11571 exists[SQL_API_SQLBULKOPERATIONS] = SQL_TRUE;
11572 exists[SQL_API_SQLEXECUTE] = SQL_TRUE;
11573 exists[SQL_API_SQLBINDPARAMETER] = SQL_TRUE;
11574 exists[SQL_API_SQLGETTYPEINFO] = SQL_TRUE;
11575 exists[SQL_API_SQLCOLUMNS] = SQL_TRUE;
11576 exists[SQL_API_SQLPARAMDATA] = SQL_TRUE;
11577 exists[SQL_API_SQLDRIVERCONNECT] = SQL_TRUE;
11578 exists[SQL_API_SQLPUTDATA] = SQL_TRUE;
11579 exists[SQL_API_SQLGETCONNECTOPTION] = SQL_TRUE;
11580 exists[SQL_API_SQLSETCONNECTOPTION] = SQL_TRUE;
11581 exists[SQL_API_SQLGETDATA] = SQL_TRUE;
11582 exists[SQL_API_SQLSETSTMTOPTION] = SQL_TRUE;
11583 exists[SQL_API_SQLGETFUNCTIONS] = SQL_TRUE;
11584 exists[SQL_API_SQLSPECIALCOLUMNS] = SQL_TRUE;
11585 exists[SQL_API_SQLGETINFO] = SQL_TRUE;
11586 exists[SQL_API_SQLSTATISTICS] = SQL_TRUE;
11587 exists[SQL_API_SQLGETSTMTOPTION] = SQL_TRUE;
11588 exists[SQL_API_SQLTABLES] = SQL_TRUE;
11589 exists[SQL_API_SQLBROWSECONNECT] = SQL_FALSE;
11590 exists[SQL_API_SQLNUMPARAMS] = SQL_TRUE;
11591 exists[SQL_API_SQLCOLUMNPRIVILEGES] = SQL_FALSE;
11592 exists[SQL_API_SQLPARAMOPTIONS] = SQL_FALSE;
11593 exists[SQL_API_SQLDATASOURCES] = SQL_TRUE;
11594 exists[SQL_API_SQLPRIMARYKEYS] = SQL_TRUE;
11595 exists[SQL_API_SQLDESCRIBEPARAM] = SQL_TRUE;
11596 exists[SQL_API_SQLPROCEDURECOLUMNS] = SQL_TRUE;
11597 exists[SQL_API_SQLDRIVERS] = SQL_FALSE;
11598 exists[SQL_API_SQLPROCEDURES] = SQL_TRUE;
11599 exists[SQL_API_SQLEXTENDEDFETCH] = SQL_TRUE;
11600 exists[SQL_API_SQLSETPOS] = SQL_TRUE;
11601 exists[SQL_API_SQLFOREIGNKEYS] = SQL_TRUE;
11602 exists[SQL_API_SQLSETSCROLLOPTIONS] = SQL_TRUE;
11603 exists[SQL_API_SQLMORERESULTS] = SQL_TRUE;
11604 exists[SQL_API_SQLTABLEPRIVILEGES] = SQL_TRUE;
11605 exists[SQL_API_SQLNATIVESQL] = SQL_TRUE;
11606 if (func == SQL_API_ALL_FUNCTIONS) {
11607 memcpy(flags, exists,
sizeof (exists));
11608 }
else if (func == SQL_API_ODBC3_ALL_FUNCTIONS) {
11610 #define SET_EXISTS(x) \ 11611 flags[(x) >> 4] |= (1 << ((x) & 0xF)) 11612 #define CLR_EXISTS(x) \ 11613 flags[(x) >> 4] &= ~(1 << ((x) & 0xF)) 11616 sizeof (SQLUSMALLINT) * SQL_API_ODBC3_ALL_FUNCTIONS_SIZE);
11619 flags[i >> 4] |= (1 << (i & 0xF));
11632 #if !defined(HAVE_UNIXODBC) || !(HAVE_UNIXODBC) 11645 *flags = exists[func];
11648 case SQL_API_SQLALLOCHANDLE:
11649 case SQL_API_SQLFREEHANDLE:
11650 case SQL_API_SQLGETSTMTATTR:
11651 case SQL_API_SQLSETSTMTATTR:
11652 case SQL_API_SQLGETCONNECTATTR:
11653 case SQL_API_SQLSETCONNECTATTR:
11654 case SQL_API_SQLGETENVATTR:
11655 case SQL_API_SQLSETENVATTR:
11656 case SQL_API_SQLCLOSECURSOR:
11657 case SQL_API_SQLBINDPARAM:
11658 #if !defined(HAVE_UNIXODBC) || !(HAVE_UNIXODBC) 11664 case SQL_API_SQLGETDIAGREC:
11666 case SQL_API_SQLGETDIAGFIELD:
11667 case SQL_API_SQLFETCHSCROLL:
11668 case SQL_API_SQLENDTRAN:
11672 *flags = SQL_FALSE;
11676 return SQL_SUCCESS;
11691 return SQL_INVALID_HANDLE;
11695 *env = SQL_NULL_HENV;
11701 #if defined(_WIN32) || defined(_WIN64) 11702 InitializeCriticalSection(&e->cs);
11704 #if defined(ENABLE_NVFS) && (ENABLE_NVFS) 11709 *env = (SQLHENV) e;
11710 return SQL_SUCCESS;
11736 if (env == SQL_NULL_HENV) {
11737 return SQL_INVALID_HANDLE;
11741 return SQL_SUCCESS;
11743 #if defined(_WIN32) || defined(_WIN64) 11744 EnterCriticalSection(&e->cs);
11747 #if defined(_WIN32) || defined(_WIN64) 11748 LeaveCriticalSection(&e->cs);
11753 #if defined(_WIN32) || defined(_WIN64) 11754 LeaveCriticalSection(&e->cs);
11755 DeleteCriticalSection(&e->cs);
11758 return SQL_SUCCESS;
11785 const char *verstr;
11786 int maj = 0,
min = 0, lev = 0;
11793 *
dbc = SQL_NULL_HDBC;
11796 memset(d, 0,
sizeof (
DBC));
11797 d->
curtype = SQL_CURSOR_STATIC;
11799 verstr = sqlite3_libversion();
11800 sscanf(verstr,
"%d.%d.%d", &maj, &
min, &lev);
11803 #if defined(_WIN32) || defined(_WIN64) 11805 EnterCriticalSection(&e->cs);
11825 #if defined(_WIN32) || defined(_WIN64) 11826 InitializeCriticalSection(&d->cs);
11829 LeaveCriticalSection(&e->cs);
11835 *
dbc = (SQLHDBC) d;
11837 return SQL_SUCCESS;
11864 SQLRETURN ret = SQL_ERROR;
11866 if (
dbc == SQL_NULL_HDBC) {
11867 return SQL_INVALID_HANDLE;
11871 return SQL_INVALID_HANDLE;
11875 #if defined(_WIN32) || defined(_WIN64) 11876 EnterCriticalSection(&e->cs);
11883 setstatd(d, -1,
"not disconnected", (*d->
ov3) ?
"HY000" :
"S1000");
11915 #if defined(_WIN32) || defined(_WIN64) 11917 LeaveCriticalSection(&d->cs);
11918 DeleteCriticalSection(&d->cs);
11923 #if defined(_WIN32) || defined(_WIN64) 11925 LeaveCriticalSection(&e->cs);
11955 SQLINTEGER bufmax, SQLINTEGER *buflen)
11960 if (
dbc == SQL_NULL_HDBC) {
11961 return SQL_INVALID_HANDLE;
11965 val = (SQLPOINTER) &dummy;
11971 case SQL_ATTR_CONNECTION_DEAD:
11972 *((SQLINTEGER *) val) = d->
sqlite ? SQL_CD_FALSE : SQL_CD_TRUE;
11973 *buflen =
sizeof (SQLINTEGER);
11975 case SQL_ATTR_ACCESS_MODE:
11976 *((SQLINTEGER *) val) = SQL_MODE_READ_WRITE;
11977 *buflen =
sizeof (SQLINTEGER);
11979 case SQL_ATTR_AUTOCOMMIT:
11980 *((SQLINTEGER *) val) =
11981 d->
autocommit ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF;
11982 *buflen =
sizeof (SQLINTEGER);
11984 case SQL_ATTR_LOGIN_TIMEOUT:
11985 *((SQLINTEGER *) val) = 100;
11986 *buflen =
sizeof (SQLINTEGER);
11988 case SQL_ATTR_ODBC_CURSORS:
11989 *((SQLINTEGER *) val) = SQL_CUR_USE_DRIVER;
11990 *buflen =
sizeof (SQLINTEGER);
11992 case SQL_ATTR_PACKET_SIZE:
11993 *((SQLINTEGER *) val) = 16384;
11994 *buflen =
sizeof (SQLINTEGER);
11996 case SQL_ATTR_TXN_ISOLATION:
11997 *((SQLINTEGER *) val) = SQL_TXN_SERIALIZABLE;
11998 *buflen =
sizeof (SQLINTEGER);
12000 case SQL_ATTR_TRACEFILE:
12001 case SQL_ATTR_TRANSLATE_LIB:
12002 *((SQLCHAR *) val) = 0;
12005 case SQL_ATTR_CURRENT_CATALOG:
12006 #if defined(_WIN32) || defined(_WIN64) 12008 if ((bufmax > 4) && (val != (SQLPOINTER) &dummy)) {
12009 strcpy((
char *) val,
"main");
12015 *((SQLCHAR *) val) = 0;
12018 case SQL_ATTR_TRACE:
12019 case SQL_ATTR_QUIET_MODE:
12020 case SQL_ATTR_TRANSLATE_OPTION:
12021 case SQL_ATTR_KEYSET_SIZE:
12022 case SQL_ATTR_QUERY_TIMEOUT:
12023 *((SQLINTEGER *) val) = 0;
12024 *buflen =
sizeof (SQLINTEGER);
12026 case SQL_ATTR_PARAM_BIND_TYPE:
12027 *((
SQLULEN *) val) = SQL_PARAM_BIND_BY_COLUMN;
12028 *buflen =
sizeof (SQLUINTEGER);
12030 case SQL_ATTR_ROW_BIND_TYPE:
12031 *((
SQLULEN *) val) = SQL_BIND_BY_COLUMN;
12034 case SQL_ATTR_USE_BOOKMARKS:
12035 *((SQLINTEGER *) val) = SQL_UB_OFF;
12036 *buflen =
sizeof (SQLINTEGER);
12038 case SQL_ATTR_ASYNC_ENABLE:
12039 *((SQLINTEGER *) val) = SQL_ASYNC_ENABLE_OFF;
12040 *buflen =
sizeof (SQLINTEGER);
12042 case SQL_ATTR_NOSCAN:
12043 *((SQLINTEGER *) val) = SQL_NOSCAN_ON;
12044 *buflen =
sizeof (SQLINTEGER);
12046 case SQL_ATTR_CONCURRENCY:
12047 *((SQLINTEGER *) val) = SQL_CONCUR_LOCK;
12048 *buflen =
sizeof (SQLINTEGER);
12050 #ifdef SQL_ATTR_CURSOR_SENSITIVITY 12051 case SQL_ATTR_CURSOR_SENSITIVITY:
12052 *((SQLINTEGER *) val) = SQL_UNSPECIFIED;
12053 *buflen =
sizeof (SQLINTEGER);
12056 case SQL_ATTR_SIMULATE_CURSOR:
12057 *((SQLINTEGER *) val) = SQL_SC_NON_UNIQUE;
12058 *buflen =
sizeof (SQLINTEGER);
12060 case SQL_ATTR_MAX_ROWS:
12061 *((SQLINTEGER *) val) = 0;
12062 *buflen =
sizeof (SQLINTEGER);
12063 case SQL_ATTR_MAX_LENGTH:
12064 *((SQLINTEGER *) val) = 1000000000;
12065 *buflen =
sizeof (SQLINTEGER);
12067 case SQL_ATTR_CURSOR_TYPE:
12068 *((SQLINTEGER *) val) = d->
curtype;
12069 *buflen =
sizeof (SQLINTEGER);
12071 case SQL_ATTR_RETRIEVE_DATA:
12072 *((SQLINTEGER *) val) = SQL_RD_ON;
12073 *buflen =
sizeof (SQLINTEGER);
12075 #ifdef SQL_ATTR_METADATA_ID 12076 case SQL_ATTR_METADATA_ID:
12077 *((
SQLULEN *) val) = SQL_FALSE;
12078 return SQL_SUCCESS;
12081 *((SQLINTEGER *) val) = 0;
12082 *buflen =
sizeof (SQLINTEGER);
12083 setstatd(d, -1,
"unsupported connect attribute %d",
12084 (*d->
ov3) ?
"HYC00" :
"S1C00", (
int) attr);
12087 return SQL_SUCCESS;
12102 SQLGetConnectAttr(SQLHDBC
dbc, SQLINTEGER attr, SQLPOINTER val,
12103 SQLINTEGER bufmax, SQLINTEGER *buflen)
12127 SQLINTEGER bufmax, SQLINTEGER *buflen)
12130 SQLINTEGER len = 0;
12134 if (ret == SQL_SUCCESS) {
12135 SQLWCHAR *v = NULL;
12138 case SQL_ATTR_TRACEFILE:
12139 case SQL_ATTR_CURRENT_CATALOG:
12140 case SQL_ATTR_TRANSLATE_LIB:
12145 int vmax = bufmax /
sizeof (SQLWCHAR);
12155 len *=
sizeof (SQLWCHAR);
12162 if (bufmax >=
sizeof (SQLWCHAR)) {
12163 *((SQLWCHAR *)val) = 0;
12167 len *=
sizeof (SQLWCHAR);
12195 if (
dbc == SQL_NULL_HDBC) {
12196 return SQL_INVALID_HANDLE;
12200 case SQL_AUTOCOMMIT:
12201 d->
autocommit = val == (SQLPOINTER) SQL_AUTOCOMMIT_ON;
12203 return endtran(d, SQL_COMMIT, 1);
12208 return SQL_SUCCESS;
12209 #ifdef SQL_ATTR_METADATA_ID 12210 case SQL_ATTR_METADATA_ID:
12211 if (val == (SQLPOINTER) SQL_FALSE) {
12217 setstatd(d, -1,
"option value changed",
"01S02");
12218 return SQL_SUCCESS_WITH_INFO;
12220 return SQL_SUCCESS;
12234 SQLSetConnectAttr(SQLHDBC
dbc, SQLINTEGER attr, SQLPOINTER val,
12283 if (
dbc == SQL_NULL_HDBC) {
12284 return SQL_INVALID_HANDLE;
12288 param = (SQLPOINTER) &dummy;
12291 case SQL_ACCESS_MODE:
12292 *((SQLINTEGER *) param) = SQL_MODE_READ_WRITE;
12294 case SQL_AUTOCOMMIT:
12295 *((SQLINTEGER *) param) =
12296 d->
autocommit ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF;
12298 case SQL_LOGIN_TIMEOUT:
12299 *((SQLINTEGER *) param) = 100;
12301 case SQL_ODBC_CURSORS:
12302 *((SQLINTEGER *) param) = SQL_CUR_USE_DRIVER;
12304 case SQL_PACKET_SIZE:
12305 *((SQLINTEGER *) param) = 16384;
12307 case SQL_TXN_ISOLATION:
12308 *((SQLINTEGER *) param) = SQL_TXN_SERIALIZABLE;
12310 case SQL_OPT_TRACE:
12311 case SQL_OPT_TRACEFILE:
12312 case SQL_QUIET_MODE:
12313 case SQL_TRANSLATE_DLL:
12314 case SQL_TRANSLATE_OPTION:
12315 case SQL_KEYSET_SIZE:
12316 case SQL_QUERY_TIMEOUT:
12317 case SQL_BIND_TYPE:
12318 case SQL_CURRENT_QUALIFIER:
12319 *((SQLINTEGER *) param) = 0;
12321 case SQL_USE_BOOKMARKS:
12322 *((SQLINTEGER *) param) = SQL_UB_OFF;
12324 case SQL_ASYNC_ENABLE:
12325 *((SQLINTEGER *) param) = SQL_ASYNC_ENABLE_OFF;
12328 *((SQLINTEGER *) param) = SQL_NOSCAN_ON;
12330 case SQL_CONCURRENCY:
12331 *((SQLINTEGER *) param) = SQL_CONCUR_LOCK;
12333 case SQL_SIMULATE_CURSOR:
12334 *((SQLINTEGER *) param) = SQL_SC_NON_UNIQUE;
12337 *((SQLINTEGER *) param) = 0;
12339 case SQL_ROWSET_SIZE:
12340 case SQL_MAX_LENGTH:
12341 *((SQLINTEGER *) param) = 1000000000;
12343 case SQL_CURSOR_TYPE:
12344 *((SQLINTEGER *) param) = d->
curtype;
12346 case SQL_RETRIEVE_DATA:
12347 *((SQLINTEGER *) param) = SQL_RD_ON;
12350 *((SQLINTEGER *) param) = 0;
12351 setstatd(d, -1,
"unsupported connect option %d",
12352 (*d->
ov3) ?
"HYC00" :
"S1C00", opt);
12355 return SQL_SUCCESS;
12368 SQLGetConnectOption(SQLHDBC
dbc, SQLUSMALLINT opt, SQLPOINTER param)
12395 if (SQL_SUCCEEDED(ret)) {
12397 case SQL_OPT_TRACEFILE:
12398 case SQL_CURRENT_QUALIFIER:
12399 case SQL_TRANSLATE_DLL:
12401 *(SQLWCHAR *) param = 0;
12424 if (
dbc == SQL_NULL_HDBC) {
12425 return SQL_INVALID_HANDLE;
12429 case SQL_AUTOCOMMIT:
12432 return endtran(d, SQL_COMMIT, 1);
12438 setstatd(d, -1,
"option value changed",
"01S02");
12439 return SQL_SUCCESS_WITH_INFO;
12441 return SQL_SUCCESS;
12454 SQLSetConnectOption(SQLHDBC
dbc, SQLUSMALLINT opt,
SQLULEN param)
12486 #if defined(WITHOUT_DRIVERMGR) || (!defined(_WIN32) && !defined(_WIN64)) 12501 char *str = dsn, *start;
12502 int len = strlen(attr);
12505 while (*str && *str ==
';') {
12509 if ((str = strchr(str,
'=')) == NULL) {
12512 if (str - start == len && strncasecmp(start, attr, len) == 0) {
12514 while (*str && *str !=
';') {
12517 len =
min(outLen - 1, str - start);
12518 strncpy(out, start, len);
12522 while (*str && *str !=
';') {
12543 int pwdLen,
int isu)
12548 char buf[SQL_MAX_MESSAGE_LENGTH * 6], dbname[SQL_MAX_MESSAGE_LENGTH];
12549 char busy[SQL_MAX_MESSAGE_LENGTH / 4], tracef[SQL_MAX_MESSAGE_LENGTH];
12550 char loadext[SQL_MAX_MESSAGE_LENGTH];
12551 char sflag[32], spflag[32], ntflag[32], nwflag[32], biflag[32];
12552 char snflag[32], lnflag[32], ncflag[32], fkflag[32], jmode[32];
12554 #if defined(_WIN32) || defined(_WIN64) 12558 if (
dbc == SQL_NULL_HDBC) {
12559 return SQL_INVALID_HANDLE;
12563 return SQL_INVALID_HANDLE;
12565 if (d->
sqlite != NULL) {
12566 setstatd(d, -1,
"connection already established",
"08002");
12570 if (dsnLen == SQL_NTS) {
12571 len =
sizeof (buf) - 1;
12573 len =
min(
sizeof (buf) - 1, dsnLen);
12576 strncpy(buf, (
char *) dsn, len);
12579 if (buf[0] ==
'\0') {
12580 setstatd(d, -1,
"invalid DSN", (*d->
ov3) ?
"HY090" :
"S1090");
12583 #if defined(_WIN32) || defined(_WIN64) 12589 char *cdsn = utf_to_wmb(buf, len);
12592 setstatd(d, -1,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
12601 #ifdef WITHOUT_DRIVERMGR 12602 getdsnattr(buf,
"database", dbname,
sizeof (dbname));
12603 if (dbname[0] ==
'\0') {
12604 strncpy(dbname, buf,
sizeof (dbname));
12605 dbname[
sizeof (dbname) - 1] =
'\0';
12607 getdsnattr(buf,
"timeout", busy,
sizeof (busy));
12609 getdsnattr(buf,
"stepapi", sflag,
sizeof (sflag));
12611 getdsnattr(buf,
"syncpragma", spflag,
sizeof (spflag));
12613 getdsnattr(buf,
"notxn", ntflag,
sizeof (ntflag));
12615 getdsnattr(buf,
"nowchar", nwflag,
sizeof (nwflag));
12617 getdsnattr(buf,
"shortnames", snflag,
sizeof (snflag));
12619 getdsnattr(buf,
"longnames", lnflag,
sizeof (lnflag));
12621 getdsnattr(buf,
"nocreat", ncflag,
sizeof (ncflag));
12623 getdsnattr(buf,
"fksupport", fkflag,
sizeof (fkflag));
12625 getdsnattr(buf,
"loadext", loadext,
sizeof (loadext));
12627 getdsnattr(buf,
"journalmode", jmode,
sizeof (jmode));
12629 getdsnattr(buf,
"jdconv", jdflag,
sizeof (jdflag));
12630 #if defined(_WIN32) || defined(_WIN64) 12632 getdsnattr(buf,
"oemcp", oemcp,
sizeof (oemcp));
12635 getdsnattr(buf,
"bigint", biflag,
sizeof (biflag));
12637 SQLGetPrivateProfileString(buf,
"timeout",
"100000",
12639 SQLGetPrivateProfileString(buf,
"database",
"",
12640 dbname,
sizeof (dbname),
ODBC_INI);
12641 #if defined(_WIN32) || defined(_WIN64) 12645 SQLGetPrivateProfileString(buf,
"stepapi",
"",
12647 SQLGetPrivateProfileString(buf,
"syncpragma",
"NORMAL",
12648 spflag,
sizeof (spflag),
ODBC_INI);
12649 SQLGetPrivateProfileString(buf,
"notxn",
"",
12650 ntflag,
sizeof (ntflag),
ODBC_INI);
12651 SQLGetPrivateProfileString(buf,
"nowchar",
"",
12652 nwflag,
sizeof (nwflag),
ODBC_INI);
12653 SQLGetPrivateProfileString(buf,
"shortnames",
"",
12654 snflag,
sizeof (snflag),
ODBC_INI);
12655 SQLGetPrivateProfileString(buf,
"longnames",
"",
12656 lnflag,
sizeof (lnflag),
ODBC_INI);
12657 SQLGetPrivateProfileString(buf,
"nocreat",
"",
12658 ncflag,
sizeof (ncflag),
ODBC_INI);
12659 SQLGetPrivateProfileString(buf,
"fksupport",
"",
12660 fkflag,
sizeof (fkflag),
ODBC_INI);
12661 SQLGetPrivateProfileString(buf,
"loadext",
"",
12662 loadext,
sizeof (loadext),
ODBC_INI);
12663 SQLGetPrivateProfileString(buf,
"journalmode",
"",
12665 SQLGetPrivateProfileString(buf,
"jdconv",
"",
12666 jdflag,
sizeof (jdflag),
ODBC_INI);
12667 #if defined(_WIN32) || defined(_WIN64) 12668 SQLGetPrivateProfileString(buf,
"oemcp",
"1",
12671 SQLGetPrivateProfileString(buf,
"bigint",
"",
12672 biflag,
sizeof (biflag),
ODBC_INI);
12675 #ifdef WITHOUT_DRIVERMGR 12676 getdsnattr(buf,
"tracefile", tracef,
sizeof (tracef));
12678 SQLGetPrivateProfileString(buf,
"tracefile",
"",
12679 tracef,
sizeof (tracef),
ODBC_INI);
12681 if (tracef[0] !=
'\0') {
12682 d->
trace = fopen(tracef,
"a");
12690 #if defined(_WIN32) || defined(_WIN64) 12699 d->
pwdLen = (pwdLen == SQL_NTS) ? strlen(d->
pwd) : pwdLen;
12701 ret =
dbopen(d, dbname, isu, (
char *) dsn, sflag, spflag, ntflag,
12703 if (ret == SQL_SUCCESS) {
12723 SQLConnect(SQLHDBC
dbc, SQLCHAR *dsn, SQLSMALLINT dsnLen,
12724 SQLCHAR *uid, SQLSMALLINT uidLen,
12725 SQLCHAR *pwd, SQLSMALLINT pwdLen)
12730 ret =
drvconnect(
dbc, dsn, dsnLen, (
char *) pwd, pwdLen, 0);
12751 SQLWCHAR *uid, SQLSMALLINT uidLen,
12752 SQLWCHAR *pwd, SQLSMALLINT pwdLen)
12764 setstatd(d, -1,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
12774 setstatd(d, -1,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
12779 ret =
drvconnect(
dbc, (SQLCHAR *) dsna, SQL_NTS, pwda, SQL_NTS, 1);
12800 if (
dbc == SQL_NULL_HDBC) {
12801 return SQL_INVALID_HANDLE;
12805 return SQL_INVALID_HANDLE;
12808 setstatd(d, -1,
"incomplete transaction",
"25000");
12816 fprintf(d->
trace,
"-- sqlite3_close: '%s'\n",
12820 rc = sqlite3_close(d->
sqlite);
12821 if (rc == SQLITE_BUSY) {
12822 setstatd(d, -1,
"unfinished statements",
"25000");
12829 return SQL_SUCCESS;
12849 #if defined(WITHOUT_DRIVERMGR) || (!defined(_WIN32) && !defined(_WIN64)) 12866 SQLCHAR *connIn, SQLSMALLINT connInLen,
12867 SQLCHAR *connOut, SQLSMALLINT connOutMax,
12868 SQLSMALLINT *connOutLen, SQLUSMALLINT drvcompl)
12873 char buf[SQL_MAX_MESSAGE_LENGTH * 8], dbname[SQL_MAX_MESSAGE_LENGTH];
12874 char dsn[SQL_MAX_MESSAGE_LENGTH], busy[SQL_MAX_MESSAGE_LENGTH / 4];
12875 char tracef[SQL_MAX_MESSAGE_LENGTH], loadext[SQL_MAX_MESSAGE_LENGTH];
12876 char pwd[SQL_MAX_MESSAGE_LENGTH];
12877 char sflag[32], spflag[32], ntflag[32], snflag[32], lnflag[32];
12878 char ncflag[32], nwflag[32], fkflag[32], jmode[32], biflag[32];
12881 if (
dbc == SQL_NULL_HDBC) {
12882 return SQL_INVALID_HANDLE;
12884 if (drvcompl != SQL_DRIVER_COMPLETE &&
12885 drvcompl != SQL_DRIVER_COMPLETE_REQUIRED &&
12886 drvcompl != SQL_DRIVER_PROMPT &&
12887 drvcompl != SQL_DRIVER_NOPROMPT) {
12888 return SQL_NO_DATA;
12892 setstatd(d, -1,
"connection already established",
"08002");
12896 if (connInLen == SQL_NTS) {
12897 len =
sizeof (buf) - 1;
12899 len =
min(connInLen,
sizeof (buf) - 1);
12901 if (connIn != NULL) {
12902 strncpy(buf, (
char *) connIn, len);
12906 setstatd(d, -1,
"invalid connect attributes",
12907 (*d->
ov3) ?
"HY090" :
"S1090");
12914 if (!dsn[0] && !strchr(buf,
';') && !strchr(buf,
'=')) {
12915 strncpy(dsn, buf,
sizeof (dsn) - 1);
12916 dsn[
sizeof (dsn) - 1] =
'\0';
12920 getdsnattr(buf,
"timeout", busy,
sizeof (busy));
12921 #ifndef WITHOUT_DRIVERMGR 12922 if (dsn[0] && !busy[0]) {
12923 SQLGetPrivateProfileString(dsn,
"timeout",
"100000",
12928 getdsnattr(buf,
"database", dbname,
sizeof (dbname));
12929 #ifndef WITHOUT_DRIVERMGR 12930 if (dsn[0] && !dbname[0]) {
12931 SQLGetPrivateProfileString(dsn,
"database",
"",
12932 dbname,
sizeof (dbname),
ODBC_INI);
12936 getdsnattr(buf,
"stepapi", sflag,
sizeof (sflag));
12937 #ifndef WITHOUT_DRIVERMGR 12938 if (dsn[0] && !sflag[0]) {
12939 SQLGetPrivateProfileString(dsn,
"stepapi",
"",
12944 getdsnattr(buf,
"syncpragma", spflag,
sizeof (spflag));
12945 #ifndef WITHOUT_DRIVERMGR 12946 if (dsn[0] && !spflag[0]) {
12947 SQLGetPrivateProfileString(dsn,
"syncpragma",
"NORMAL",
12948 spflag,
sizeof (spflag),
ODBC_INI);
12952 getdsnattr(buf,
"notxn", ntflag,
sizeof (ntflag));
12953 #ifndef WITHOUT_DRIVERMGR 12954 if (dsn[0] && !ntflag[0]) {
12955 SQLGetPrivateProfileString(dsn,
"notxn",
"",
12956 ntflag,
sizeof (ntflag),
ODBC_INI);
12960 getdsnattr(buf,
"shortnames", snflag,
sizeof (snflag));
12961 #ifndef WITHOUT_DRIVERMGR 12962 if (dsn[0] && !snflag[0]) {
12963 SQLGetPrivateProfileString(dsn,
"shortnames",
"",
12964 snflag,
sizeof (snflag),
ODBC_INI);
12968 getdsnattr(buf,
"longnames", lnflag,
sizeof (lnflag));
12969 #ifndef WITHOUT_DRIVERMGR 12970 if (dsn[0] && !lnflag[0]) {
12971 SQLGetPrivateProfileString(dsn,
"longnames",
"",
12972 lnflag,
sizeof (lnflag),
ODBC_INI);
12976 getdsnattr(buf,
"nocreat", ncflag,
sizeof (ncflag));
12977 #ifndef WITHOUT_DRIVERMGR 12978 if (dsn[0] && !ncflag[0]) {
12979 SQLGetPrivateProfileString(dsn,
"nocreat",
"",
12980 ncflag,
sizeof (ncflag),
ODBC_INI);
12984 getdsnattr(buf,
"nowchar", nwflag,
sizeof (nwflag));
12985 #ifndef WITHOUT_DRIVERMGR 12986 if (dsn[0] && !nwflag[0]) {
12987 SQLGetPrivateProfileString(dsn,
"nowchar",
"",
12988 nwflag,
sizeof (nwflag),
ODBC_INI);
12992 getdsnattr(buf,
"fksupport", fkflag,
sizeof (fkflag));
12993 #ifndef WITHOUT_DRIVERMGR 12994 if (dsn[0] && !fkflag[0]) {
12995 SQLGetPrivateProfileString(dsn,
"fksupport",
"",
12996 fkflag,
sizeof (fkflag),
ODBC_INI);
13000 getdsnattr(buf,
"loadext", loadext,
sizeof (loadext));
13001 #ifndef WITHOUT_DRIVERMGR 13002 if (dsn[0] && !loadext[0]) {
13003 SQLGetPrivateProfileString(dsn,
"loadext",
"",
13004 loadext,
sizeof (loadext),
ODBC_INI);
13008 getdsnattr(buf,
"journalmode", jmode,
sizeof (jmode));
13009 #ifndef WITHOUT_DRIVERMGR 13010 if (dsn[0] && !jmode[0]) {
13011 SQLGetPrivateProfileString(dsn,
"journalmode",
"",
13016 getdsnattr(buf,
"bigint", biflag,
sizeof (biflag));
13017 #ifndef WITHOUT_DRIVERMGR 13018 if (dsn[0] && !biflag[0]) {
13019 SQLGetPrivateProfileString(dsn,
"bigint",
"",
13020 biflag,
sizeof (biflag),
ODBC_INI);
13024 getdsnattr(buf,
"jdconv", jdflag,
sizeof (jdflag));
13025 #ifndef WITHOUT_DRIVERMGR 13026 if (dsn[0] && !jdflag[0]) {
13027 SQLGetPrivateProfileString(dsn,
"jdconv",
"",
13028 jdflag,
sizeof (jdflag),
ODBC_INI);
13033 #ifndef WITHOUT_DRIVERMGR 13034 if (dsn[0] && !pwd[0]) {
13035 SQLGetPrivateProfileString(dsn,
"pwd",
"",
13040 if (!dbname[0] && !dsn[0]) {
13041 strcpy(dsn,
"SQLite");
13042 strncpy(dbname, buf,
sizeof (dbname));
13043 dbname[
sizeof (dbname) - 1] =
'\0';
13046 getdsnattr(buf,
"tracefile", tracef,
sizeof (tracef));
13047 #ifndef WITHOUT_DRIVERMGR 13048 if (dsn[0] && !tracef[0]) {
13049 SQLGetPrivateProfileString(dsn,
"tracefile",
"",
13050 tracef,
sizeof (tracef),
ODBC_INI);
13053 if (connOut || connOutLen) {
13057 count = snprintf(buf,
sizeof (buf),
13058 "DSN=%s;Database=%s;StepAPI=%s;Timeout=%s;" 13059 "SyncPragma=%s;NoTXN=%s;ShortNames=%s;LongNames=%s;" 13060 "NoCreat=%s;NoWCHAR=%s;FKSupport=%s;Tracefile=%s;" 13061 "JournalMode=%s;LoadExt=%s;BigInt=%s;JDConv=%s;" 13063 dsn, dbname, sflag, busy, spflag, ntflag,
13064 snflag, lnflag, ncflag, nwflag, fkflag, tracef,
13065 jmode, loadext, biflag, jdflag, pwd);
13067 buf[
sizeof (buf) - 1] =
'\0';
13069 len =
min(connOutMax - 1, strlen(buf));
13071 strncpy((
char *) connOut, buf, len);
13072 connOut[len] =
'\0';
13078 if (tracef[0] !=
'\0') {
13079 d->
trace = fopen(tracef,
"a");
13089 d->
pwdLen = strlen(pwd);
13091 ret =
dbopen(d, dbname, 0, dsn, sflag, spflag, ntflag, jmode, busy);
13092 memset(pwd, 0,
sizeof (pwd));
13093 if (ret == SQL_SUCCESS) {
13112 if (
stmt == SQL_NULL_HSTMT) {
13113 return SQL_INVALID_HANDLE;
13148 return SQL_SUCCESS;
13164 if (
dbc == SQL_NULL_HDBC) {
13165 return SQL_INVALID_HANDLE;
13169 return SQL_INVALID_HANDLE;
13173 *
stmt = SQL_NULL_HSTMT;
13176 *
stmt = (SQLHSTMT) s;
13177 memset(s, 0,
sizeof (
STMT));
13180 s->
bkmrk = SQL_UB_OFF;
13201 sprintf((
char *) s->
cursorname,
"CUR_%I64X", (SQLUBIGINT) *
stmt);
13216 return SQL_SUCCESS;
13248 SQLRETURN ret = SQL_SUCCESS;
13251 if (
stmt == SQL_NULL_HSTMT) {
13252 return SQL_INVALID_HANDLE;
13258 case SQL_RESET_PARAMS:
13273 setstat(s, -1,
"unsupported option", (*s->
ov3) ?
"HYC00" :
"S1C00");
13303 if (
stmt != SQL_NULL_HSTMT) {
13305 #if defined(_WIN32) || defined(_WIN64) 13307 if (d->
magic ==
DBC_MAGIC && d->owner != GetCurrentThreadId() &&
13310 sqlite3_interrupt(d->
sqlite);
13311 return SQL_SUCCESS;
13316 sqlite3_interrupt(d->
sqlite);
13338 if (
stmt == SQL_NULL_HSTMT) {
13339 return SQL_INVALID_HANDLE;
13342 if (lenp && !cursor) {
13344 return SQL_SUCCESS;
13348 strncpy((
char *) cursor, (
char *) s->
cursorname, buflen - 1);
13349 cursor[buflen - 1] =
'\0';
13355 return SQL_SUCCESS;
13369 SQLGetCursorName(SQLHSTMT
stmt, SQLCHAR *cursor, SQLSMALLINT buflen,
13373 #if defined(_WIN32) || defined(_WIN64) 13374 SQLSMALLINT len = 0;
13378 #if defined(_WIN32) || defined(_WIN64) 13384 if (ret == SQL_SUCCESS) {
13388 c = utf_to_wmb((
char *) cursor, len);
13396 strncpy((
char *) cursor, c, buflen - 1);
13397 cursor[buflen - 1] = 0;
13402 *lenp =
min(len, buflen - 1);
13430 SQLSMALLINT len = 0;
13434 if (ret == SQL_SUCCESS) {
13435 SQLWCHAR *c = NULL;
13447 cursor[buflen - 1] = 0;
13452 *lenp =
min(len, buflen - 1);
13474 if (
stmt == SQL_NULL_HSTMT) {
13475 return SQL_INVALID_HANDLE;
13479 !((cursor[0] >=
'A' && cursor[0] <=
'Z') ||
13480 (cursor[0] >=
'a' && cursor[0] <=
'z'))) {
13481 setstat(s, -1,
"invalid cursor name", (*s->
ov3) ?
"HYC00" :
"S1C00");
13484 if (len == SQL_NTS) {
13489 strncpy((
char *) s->
cursorname, (
char *) cursor, len);
13491 return SQL_SUCCESS;
13504 SQLSetCursorName(SQLHSTMT
stmt, SQLCHAR *cursor, SQLSMALLINT len)
13506 #if defined(_WIN32) || defined(_WIN64) 13512 #if defined(_WIN32) || defined(_WIN64) 13518 c = wmb_to_utf_c((
char *) cursor, len);
13528 #if defined(_WIN32) || defined(_WIN64) 13596 case SQL_HANDLE_ENV:
13598 if (ret == SQL_SUCCESS) {
13599 ENV *e = (
ENV *) *output;
13606 case SQL_HANDLE_DBC:
13608 case SQL_HANDLE_STMT:
13610 ret =
drvallocstmt((SQLHDBC) input, (SQLHSTMT *) output);
13628 case SQL_HANDLE_ENV:
13630 case SQL_HANDLE_DBC:
13632 case SQL_HANDLE_STMT:
13649 for (i = 0; i < s->
dcols; i++) {
13740 for (i = s->
nbindcols; i < ncols; i++) {
13741 bindcols[i].
type = SQL_UNKNOWN_TYPE;
13742 bindcols[i].
max = 0;
13743 bindcols[i].
lenp = NULL;
13744 bindcols[i].
valp = NULL;
13745 bindcols[i].
index = i;
13746 bindcols[i].
offs = 0;
13751 }
else if (ncols > 0) {
13759 return SQL_SUCCESS;
13777 SQLPOINTER val, SQLINTEGER len,
SQLLEN *lenp,
int partial)
13779 char **data, valdummy[16];
13781 SQLINTEGER *ilenp = NULL;
13784 SQLRETURN sret = SQL_NO_DATA;
13790 if (((SQLINTEGER *) lenp) + 1 == (SQLINTEGER *) val) {
13791 ilenp = (SQLINTEGER *) lenp;
13794 if (col >= s->
ncols) {
13795 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009" :
"S1002");
13799 return SQL_SUCCESS;
13802 *lenp = SQL_NULL_DATA;
13806 *lenp = SQL_NULL_DATA;
13811 #if (defined(_WIN32) || defined(_WIN64)) && defined(WINTERFACE) 13813 if (type == SQL_C_WCHAR && otype == SQL_C_DEFAULT) {
13820 val = (SQLPOINTER) valdummy;
13822 if (*data == NULL) {
13823 *lenp = SQL_NULL_DATA;
13825 case SQL_C_UTINYINT:
13826 case SQL_C_TINYINT:
13827 case SQL_C_STINYINT:
13831 *((SQLCHAR *) val) = 0;
13836 *((SQLSMALLINT *) val) = 0;
13841 *((SQLINTEGER *) val) = 0;
13844 case SQL_C_SBIGINT:
13845 case SQL_C_UBIGINT:
13846 *((SQLBIGINT *) val) = 0;
13850 *((
float *) val) = 0;
13853 *((
double *) val) = 0;
13858 *((SQLCHAR *) val) =
'\0';
13861 #ifdef WCHARSUPPORT 13864 *((SQLWCHAR *) val) =
'\0';
13868 #ifdef SQL_C_TYPE_DATE 13869 case SQL_C_TYPE_DATE:
13872 memset((DATE_STRUCT *) val, 0,
sizeof (DATE_STRUCT));
13874 #ifdef SQL_C_TYPE_TIME 13875 case SQL_C_TYPE_TIME:
13878 memset((TIME_STRUCT *) val, 0,
sizeof (TIME_STRUCT));
13880 #ifdef SQL_C_TYPE_TIMESTAMP 13881 case SQL_C_TYPE_TIMESTAMP:
13883 case SQL_C_TIMESTAMP:
13884 memset((TIMESTAMP_STRUCT *) val, 0,
sizeof (TIMESTAMP_STRUCT));
13891 #if defined(_WIN32) || defined(_WIN64) 13898 case SQL_C_UTINYINT:
13899 case SQL_C_TINYINT:
13900 case SQL_C_STINYINT:
13901 *((SQLCHAR *) val) = strtol(*data, &endp, 0);
13902 if (endp && endp == *data) {
13903 *lenp = SQL_NULL_DATA;
13905 *lenp =
sizeof (SQLCHAR);
13910 *((SQLCHAR *) val) =
getbool(*data);
13911 *lenp =
sizeof (SQLCHAR);
13917 *((SQLSMALLINT *) val) = strtol(*data, &endp, 0);
13918 if (endp && endp == *data) {
13919 *lenp = SQL_NULL_DATA;
13921 *lenp =
sizeof (SQLSMALLINT);
13927 *((SQLINTEGER *) val) = strtol(*data, &endp, 0);
13928 if (endp && endp == *data) {
13929 *lenp = SQL_NULL_DATA;
13931 *lenp =
sizeof (SQLINTEGER);
13935 case SQL_C_UBIGINT:
13936 #if defined(_WIN32) || defined(_WIN64) 13937 if (sscanf(*data,
"%I64u%c", (SQLUBIGINT *) val, &endc) != 1) {
13938 *lenp = SQL_NULL_DATA;
13940 *lenp =
sizeof (SQLUBIGINT);
13944 *((SQLUBIGINT *) val) = strtoul(*data, &endp, 0);
13946 *((SQLUBIGINT *) val) = strtoull(*data, &endp, 0);
13948 if (endp && endp == *data) {
13949 *lenp = SQL_NULL_DATA;
13951 *lenp =
sizeof (SQLUBIGINT);
13955 case SQL_C_SBIGINT:
13956 #if defined(_WIN32) || defined(_WIN64) 13957 if (sscanf(*data,
"%I64d%c", (SQLBIGINT *) val, &endc) != 1) {
13958 *lenp = SQL_NULL_DATA;
13960 *lenp =
sizeof (SQLBIGINT);
13964 *((SQLBIGINT *) val) = strtol(*data, &endp, 0);
13966 *((SQLBIGINT *) val) = strtoll(*data, &endp, 0);
13968 if (endp && endp == *data) {
13969 *lenp = SQL_NULL_DATA;
13971 *lenp =
sizeof (SQLBIGINT);
13977 *((
float *) val) =
ln_strtod(*data, &endp);
13978 if (endp && endp == *data) {
13979 *lenp = SQL_NULL_DATA;
13981 *lenp =
sizeof (float);
13985 *((
double *) val) =
ln_strtod(*data, &endp);
13986 if (endp && endp == *data) {
13987 *lenp = SQL_NULL_DATA;
13989 *lenp =
sizeof (double);
13992 case SQL_C_BINARY: {
13993 int dlen, offs = 0;
14017 if (!(dp[0] ==
'x' || dp[0] ==
'X') || dp[1] !=
'\'' ||
14018 dp[dlen - 1] !=
'\'') {
14029 memset(bin, 0, dlen);
14031 for (i = 0; i < dlen; i++) {
14035 if (!*dp || !(x = strchr(
xdigits, *dp))) {
14039 bin[i] = (v >= 16) ? ((v - 6) << 4) : (v << 4);
14041 if (!*dp || !(x = strchr(
xdigits, *dp))) {
14045 setstat(s, -1,
"conversion error",
14046 (*s->
ov3) ?
"HY000" :
"S1000");
14050 bin[i] |= (v >= 16) ? (v - 6) : v;
14055 if (partial && len && s->
bindcols) {
14060 sret = SQL_SUCCESS;
14064 sret = SQL_NO_DATA;
14071 memcpy(val, bin + offs,
min(len, dlen));
14076 *lenp =
min(len, dlen);
14077 if (*lenp == len && *lenp != dlen) {
14078 *lenp = SQL_NO_TOTAL;
14081 if (partial && len && s->
bindcols) {
14082 if (*lenp == SQL_NO_TOTAL) {
14085 setstat(s, -1,
"data right truncated",
"01004");
14089 sret = SQL_SUCCESS_WITH_INFO;
14094 if (*lenp == SQL_NO_TOTAL) {
14096 setstat(s, -1,
"data right truncated",
"01004");
14097 sret = SQL_SUCCESS_WITH_INFO;
14103 #ifdef WCHARSUPPORT 14107 int doz, zlen = len - 1;
14108 int dlen = strlen(*data);
14110 #ifdef WCHARSUPPORT 14111 SQLWCHAR *ucdata = NULL;
14112 SQLCHAR *cdata = (SQLCHAR *) *data;
14115 #if (defined(_WIN32) || defined(_WIN64)) && defined(WINTERFACE) 14118 (s->
cols == statSpec2P || s->
cols == statSpec3P) &&
14119 type == SQL_C_WCHAR) {
14120 if (len > 0 && len <=
sizeof (SQLWCHAR)) {
14121 ((
char *) val)[0] = data[0][0];
14122 memset((
char *) val + 1, 0, len - 1);
14124 sret = SQL_SUCCESS;
14130 #ifdef WCHARSUPPORT 14136 doz =
sizeof (SQLWCHAR);
14142 if (type == SQL_C_WCHAR) {
14147 dlen =
uc_strlen(ucdata) *
sizeof (SQLWCHAR);
14149 #if defined(_WIN32) || defined(_WIN64) 14150 else if (*s->
oemcp && type == SQL_C_CHAR) {
14151 ucdata = (SQLWCHAR *) utf_to_wmb((
char *) cdata, dlen);
14155 cdata = (SQLCHAR *) ucdata;
14156 dlen = strlen((
char *) cdata);
14160 doz = (type == SQL_C_CHAR) ? 1 : 0;
14162 if (partial && len && s->
bindcols) {
14164 #ifdef WCHARSUPPORT 14169 #ifdef WCHARSUPPORT 14170 if (type == SQL_C_WCHAR) {
14171 ((SQLWCHAR *) val)[0] = 0;
14173 ((
char *) val)[0] =
'\0';
14176 ((
char *) val)[0] =
'\0';
14181 sret = SQL_SUCCESS;
14185 sret = SQL_NO_DATA;
14191 if (val && !valnull && len) {
14192 #ifdef WCHARSUPPORT 14193 if (type == SQL_C_WCHAR) {
14194 uc_strncpy(val, ucdata + offs /
sizeof (SQLWCHAR),
14195 (len - doz) /
sizeof (SQLWCHAR));
14197 strncpy(val, (
char *) cdata + offs, len - doz);
14200 strncpy(val, *data + offs, len - doz);
14203 if (valnull || len < 1) {
14206 *lenp =
min(len - doz, dlen);
14207 if (*lenp == len - doz && *lenp != dlen) {
14208 *lenp = SQL_NO_TOTAL;
14209 }
else if (*lenp < zlen) {
14213 if (len && !valnull && doz) {
14214 #ifdef WCHARSUPPORT 14215 if (type == SQL_C_WCHAR) {
14216 ((SQLWCHAR *) val)[zlen /
sizeof (SQLWCHAR)] = 0;
14218 ((
char *) val)[zlen] =
'\0';
14221 ((
char *) val)[zlen] =
'\0';
14224 #ifdef WCHARSUPPORT 14227 if (partial && len && s->
bindcols) {
14228 if (*lenp == SQL_NO_TOTAL) {
14231 setstat(s, -1,
"data right truncated",
"01004");
14235 sret = SQL_SUCCESS_WITH_INFO;
14240 if (*lenp == SQL_NO_TOTAL) {
14242 setstat(s, -1,
"data right truncated",
"01004");
14243 sret = SQL_SUCCESS_WITH_INFO;
14248 #ifdef SQL_C_TYPE_DATE 14249 case SQL_C_TYPE_DATE:
14253 *lenp = SQL_NULL_DATA;
14255 *lenp =
sizeof (DATE_STRUCT);
14258 #ifdef SQL_C_TYPE_TIME 14259 case SQL_C_TYPE_TIME:
14263 *lenp = SQL_NULL_DATA;
14265 *lenp =
sizeof (TIME_STRUCT);
14268 #ifdef SQL_C_TYPE_TIMESTAMP 14269 case SQL_C_TYPE_TIMESTAMP:
14271 case SQL_C_TIMESTAMP:
14273 (TIMESTAMP_STRUCT *) val) < 0) {
14274 *lenp = SQL_NULL_DATA;
14276 *lenp =
sizeof (TIMESTAMP_STRUCT);
14280 ((TIMESTAMP_STRUCT *) val)->fraction = 0;
14283 ((TIMESTAMP_STRUCT *) val)->fraction /= 100000000;
14284 ((TIMESTAMP_STRUCT *) val)->fraction *= 100000000;
14287 ((TIMESTAMP_STRUCT *) val)->fraction /= 10000000;
14288 ((TIMESTAMP_STRUCT *) val)->fraction *= 10000000;
14296 sret = SQL_SUCCESS;
14322 if (
stmt == SQL_NULL_HSTMT) {
14323 return SQL_INVALID_HANDLE;
14327 if (col == 0 && s->
bkmrk == SQL_UB_ON &&
14328 type == SQL_C_BOOKMARK) {
14337 return SQL_SUCCESS;
14338 }
else if (col == 0 && s->
bkmrk == SQL_UB_VARIABLE &&
14339 type == SQL_C_VARBOOKMARK &&
14340 max >= sizeof (sqlite_int64)) {
14349 return SQL_SUCCESS;
14351 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009" :
"S1002");
14358 if (type == SQL_C_DEFAULT) {
14366 sz =
sizeof (SQLINTEGER);
14368 case SQL_C_TINYINT:
14369 case SQL_C_UTINYINT:
14370 case SQL_C_STINYINT:
14371 sz =
sizeof (SQLCHAR);
14376 sz =
sizeof (SQLSMALLINT);
14379 sz =
sizeof (SQLFLOAT);
14382 sz =
sizeof (SQLDOUBLE);
14384 case SQL_C_TIMESTAMP:
14385 sz =
sizeof (SQL_TIMESTAMP_STRUCT);
14388 sz =
sizeof (SQL_TIME_STRUCT);
14391 sz =
sizeof (SQL_DATE_STRUCT);
14395 #ifdef WCHARSUPPORT 14399 #ifdef SQL_C_TYPE_DATE 14400 case SQL_C_TYPE_DATE:
14401 sz =
sizeof (SQL_DATE_STRUCT);
14404 #ifdef SQL_C_TYPE_TIME 14405 case SQL_C_TYPE_TIME:
14406 sz =
sizeof (SQL_TIME_STRUCT);
14409 #ifdef SQL_C_TYPE_TIMESTAMP 14410 case SQL_C_TYPE_TIMESTAMP:
14411 sz =
sizeof (SQL_TIMESTAMP_STRUCT);
14416 sz =
sizeof (SQLCHAR);
14422 case SQL_C_SBIGINT:
14423 case SQL_C_UBIGINT:
14424 sz =
sizeof (SQLBIGINT);
14432 setstat(s, -1,
"invalid type %d",
"HY003", type);
14443 if (sz == 0 &&
max < 0) {
14444 setstat(s, -1,
"invalid length",
"HY090");
14456 return SQL_SUCCESS;
14487 {
"SYSTEM",
"COLUMN",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
14488 {
"SYSTEM",
"COLUMN",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
14489 {
"SYSTEM",
"COLUMN",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
14490 {
"SYSTEM",
"COLUMN",
"TABLE_TYPE",
SCOL_VARCHAR, 50 },
14495 {
"SYSTEM",
"COLUMN",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
14496 {
"SYSTEM",
"COLUMN",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
14497 {
"SYSTEM",
"COLUMN",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
14498 {
"SYSTEM",
"COLUMN",
"TABLE_TYPE",
SCOL_VARCHAR, 50 },
14518 SQLCHAR *cat, SQLSMALLINT catLen,
14519 SQLCHAR *schema, SQLSMALLINT schemaLen,
14520 SQLCHAR *table, SQLSMALLINT tableLen,
14521 SQLCHAR *type, SQLSMALLINT typeLen)
14526 int ncols, asize, rc, size, npatt;
14527 char *errp = NULL, *sql, tname[512];
14528 char *where =
"(type = 'table' or type = 'view')";
14532 if (ret != SQL_SUCCESS) {
14537 if (type && (typeLen > 0 || typeLen == SQL_NTS) && type[0] ==
'%') {
14538 int size = 3 * asize;
14545 memset(s->
rows, 0, sizeof (
char *) * size);
14555 #ifdef MEMORY_DEBUG 14562 return SQL_SUCCESS;
14564 if (cat && (catLen > 0 || catLen == SQL_NTS) && cat[0] ==
'%') {
14568 if (schema && (schemaLen > 0 || schemaLen == SQL_NTS) &&
14569 schema[0] ==
'%') {
14570 if ((!cat || catLen == 0 || !cat[0]) &&
14571 (!table || tableLen == 0 || !table[0])) {
14576 if (type && (typeLen > 0 || typeLen == SQL_NTS) && type[0] !=
'\0') {
14578 int with_view = 0, with_table = 0;
14580 if (typeLen == SQL_NTS) {
14581 strncpy(tmp, (
char *) type,
sizeof (tmp));
14582 tmp[
sizeof (tmp) - 1] =
'\0';
14584 int len =
min(
sizeof (tmp) - 1, typeLen);
14586 strncpy(tmp, (
char *) type, len);
14597 if (t[0] ==
'\'') {
14600 if (strncmp(t,
"table", 5) == 0) {
14602 }
else if (strncmp(t,
"view", 4) == 0) {
14605 t = strchr(t,
',');
14610 if (with_view && with_table) {
14612 }
else if (with_view && !with_table) {
14613 where =
"type = 'view'";
14614 }
else if (!with_view && with_table) {
14615 where =
"type = 'table'";
14617 return SQL_SUCCESS;
14625 if (tableLen == SQL_NTS) {
14626 size =
sizeof (tname) - 1;
14628 size =
min(
sizeof (tname) - 1, tableLen);
14630 strncpy(tname, (
char *) table, size);
14632 tname[size] =
'\0';
14634 #if defined(_WIN32) || defined(_WIN64) 14635 sql = sqlite3_mprintf(
"select %s as 'TABLE_CAT', " 14636 "%s as 'TABLE_SCHEM', " 14637 "tbl_name as 'TABLE_NAME', " 14638 "upper(type) as 'TABLE_TYPE', " 14639 "NULL as 'REMARKS' " 14640 "from sqlite_master where %s " 14641 "and tbl_name %s %Q",
14642 d->xcelqrx ?
"'main'" :
"NULL",
14643 d->xcelqrx ?
"''" :
"NULL",
14645 npatt ?
"like" :
"=", tname);
14647 sql = sqlite3_mprintf(
"select NULL as 'TABLE_QUALIFIER', " 14648 "NULL as 'TABLE_OWNER', " 14649 "tbl_name as 'TABLE_NAME', " 14650 "upper(type) as 'TABLE_TYPE', " 14651 "NULL as 'REMARKS' " 14652 "from sqlite_master where %s " 14653 "and tbl_name %s %Q", where,
14654 npatt ?
"like" :
"=", tname);
14660 if (ret != SQL_SUCCESS) {
14665 rc = sqlite3_get_table(d->
sqlite, sql, &s->
rows, &s->
nrows, &ncols, &errp);
14667 if (rc == SQLITE_OK) {
14668 if (ncols != s->
ncols) {
14672 s->
rowfree = sqlite3_free_table;
14680 sqlite3_free(errp);
14684 return SQL_SUCCESS;
14703 SQLTables(SQLHSTMT
stmt,
14704 SQLCHAR *cat, SQLSMALLINT catLen,
14705 SQLCHAR *schema, SQLSMALLINT schemaLen,
14706 SQLCHAR *table, SQLSMALLINT tableLen,
14707 SQLCHAR *type, SQLSMALLINT typeLen)
14709 #if defined(_WIN32) || defined(_WIN64) 14710 char *c = NULL, *s = NULL, *t = NULL, *y = NULL;
14715 #if defined(_WIN32) || defined(_WIN64) 14718 table, tableLen, type, typeLen);
14722 c = wmb_to_utf_c((
char *) cat, catLen);
14729 s = wmb_to_utf_c((
char *) schema, schemaLen);
14736 t = wmb_to_utf_c((
char *) table, tableLen);
14743 y = wmb_to_utf_c((
char *) type, typeLen);
14749 ret =
drvtables(
stmt, (SQLCHAR *) c, SQL_NTS, (SQLCHAR *) s, SQL_NTS,
14750 (SQLCHAR *) t, SQL_NTS, (SQLCHAR *) y, SQL_NTS);
14753 table, tableLen, type, typeLen);
14755 #if defined(_WIN32) || defined(_WIN64) 14786 SQLWCHAR *cat, SQLSMALLINT catLen,
14787 SQLWCHAR *schema, SQLSMALLINT schemaLen,
14788 SQLWCHAR *table, SQLSMALLINT tableLen,
14789 SQLWCHAR *type, SQLSMALLINT typeLen)
14791 char *c = NULL, *s = NULL, *t = NULL, *y = NULL;
14823 ret =
drvtables(
stmt, (SQLCHAR *) c, SQL_NTS, (SQLCHAR *) s, SQL_NTS,
14824 (SQLCHAR *) t, SQL_NTS, (SQLCHAR *) y, SQL_NTS);
14840 {
"SYSTEM",
"COLUMN",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
14841 {
"SYSTEM",
"COLUMN",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
14842 {
"SYSTEM",
"COLUMN",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
14843 {
"SYSTEM",
"COLUMN",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
14844 {
"SYSTEM",
"COLUMN",
"DATA_TYPE", SQL_SMALLINT, 50 },
14845 {
"SYSTEM",
"COLUMN",
"TYPE_NAME",
SCOL_VARCHAR, 50 },
14846 {
"SYSTEM",
"COLUMN",
"PRECISION", SQL_INTEGER, 50 },
14847 {
"SYSTEM",
"COLUMN",
"LENGTH", SQL_INTEGER, 50 },
14848 {
"SYSTEM",
"COLUMN",
"SCALE", SQL_SMALLINT, 50 },
14849 {
"SYSTEM",
"COLUMN",
"RADIX", SQL_SMALLINT, 50 },
14850 {
"SYSTEM",
"COLUMN",
"NULLABLE", SQL_SMALLINT, 50 },
14852 {
"SYSTEM",
"COLUMN",
"COLUMN_DEF",
SCOL_VARCHAR, 50 },
14853 {
"SYSTEM",
"COLUMN",
"SQL_DATA_TYPE", SQL_SMALLINT, 50 },
14854 {
"SYSTEM",
"COLUMN",
"SQL_DATETIME_SUB", SQL_SMALLINT, 50 },
14855 {
"SYSTEM",
"COLUMN",
"CHAR_OCTET_LENGTH", SQL_SMALLINT, 50 },
14856 {
"SYSTEM",
"COLUMN",
"ORDINAL_POSITION", SQL_SMALLINT, 50 },
14857 {
"SYSTEM",
"COLUMN",
"IS_NULLABLE",
SCOL_VARCHAR, 50 }
14861 {
"SYSTEM",
"COLUMN",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
14862 {
"SYSTEM",
"COLUMN",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
14863 {
"SYSTEM",
"COLUMN",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
14864 {
"SYSTEM",
"COLUMN",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
14865 {
"SYSTEM",
"COLUMN",
"DATA_TYPE", SQL_SMALLINT, 50 },
14866 {
"SYSTEM",
"COLUMN",
"TYPE_NAME",
SCOL_VARCHAR, 50 },
14867 {
"SYSTEM",
"COLUMN",
"COLUMN_SIZE", SQL_INTEGER, 50 },
14868 {
"SYSTEM",
"COLUMN",
"BUFFER_LENGTH", SQL_INTEGER, 50 },
14869 {
"SYSTEM",
"COLUMN",
"DECIMAL_DIGITS", SQL_SMALLINT, 50 },
14870 {
"SYSTEM",
"COLUMN",
"NUM_PREC_RADIX", SQL_SMALLINT, 50 },
14871 {
"SYSTEM",
"COLUMN",
"NULLABLE", SQL_SMALLINT, 50 },
14873 {
"SYSTEM",
"COLUMN",
"COLUMN_DEF",
SCOL_VARCHAR, 50 },
14874 {
"SYSTEM",
"COLUMN",
"SQL_DATA_TYPE", SQL_SMALLINT, 50 },
14875 {
"SYSTEM",
"COLUMN",
"SQL_DATETIME_SUB", SQL_SMALLINT, 50 },
14876 {
"SYSTEM",
"COLUMN",
"CHAR_OCTET_LENGTH", SQL_SMALLINT, 50 },
14877 {
"SYSTEM",
"COLUMN",
"ORDINAL_POSITION", SQL_SMALLINT, 50 },
14878 {
"SYSTEM",
"COLUMN",
"IS_NULLABLE",
SCOL_VARCHAR, 50 }
14897 SQLCHAR *cat, SQLSMALLINT catLen,
14898 SQLCHAR *schema, SQLSMALLINT schemaLen,
14899 SQLCHAR *table, SQLSMALLINT tableLen,
14900 SQLCHAR *col, SQLSMALLINT colLen)
14905 int ret, nrows, ncols, asize, i, k, roffs, namec;
14906 int tnrows, tncols, npatt;
14908 char *errp = NULL, *sql, tname[512], cname[512], **rowp, **trows;
14912 if (sret != SQL_SUCCESS) {
14921 if (tableLen == SQL_NTS) {
14922 size =
sizeof (tname) - 1;
14924 size =
min(
sizeof (tname) - 1, tableLen);
14926 strncpy(tname, (
char *) table, size);
14928 tname[size] =
'\0';
14932 if (colLen == SQL_NTS) {
14933 size =
sizeof (cname) - 1;
14935 size =
min(
sizeof (cname) - 1, colLen);
14937 strncpy(cname, (
char *) col, size);
14939 cname[size] =
'\0';
14940 if (!strcmp(cname,
"%")) {
14943 sql = sqlite3_mprintf(
"select tbl_name from sqlite_master where " 14944 "(type = 'table' or type = 'view') " 14945 "and tbl_name %s %Q", npatt ?
"like" :
"=", tname);
14950 if (sret != SQL_SUCCESS) {
14955 ret = sqlite3_get_table(d->
sqlite, sql, &trows, &tnrows, &tncols, &errp);
14957 if (ret != SQLITE_OK) {
14958 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
14959 errp ? errp :
"unknown error", ret);
14961 sqlite3_free(errp);
14967 sqlite3_free(errp);
14971 if (tncols * tnrows <= 0) {
14972 sqlite3_free_table(trows);
14973 return SQL_SUCCESS;
14976 for (i = 1; i <= tnrows; i++) {
14977 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", trows[i]);
14979 sqlite3_free_table(trows);
14983 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
14985 if (ret != SQLITE_OK) {
14986 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
14987 errp ? errp :
"unknown error", ret);
14989 sqlite3_free(errp);
14992 sqlite3_free_table(trows);
14996 sqlite3_free(errp);
14999 if (ncols * nrows > 0) {
15001 for (k = 0; k < ncols; k++) {
15002 if (strcmp(rowp[k],
"name") == 0) {
15009 for (k = 1; k <= nrows; k++) {
15010 if (
namematch(rowp[k * ncols + namec], cname, 1)) {
15019 sqlite3_free_table(rowp);
15023 sqlite3_free_table(trows);
15024 return SQL_SUCCESS;
15027 size = (size + 1) * asize;
15031 sqlite3_free_table(trows);
15034 s->
rows[0] = (
char *) size;
15036 memset(s->
rows, 0, sizeof (
char *) * size);
15039 for (i = 1; i <= tnrows; i++) {
15040 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", trows[i]);
15042 sqlite3_free_table(trows);
15046 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
15048 if (ret != SQLITE_OK) {
15049 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
15050 errp ? errp :
"unknown error", ret);
15052 sqlite3_free(errp);
15055 sqlite3_free_table(trows);
15059 sqlite3_free(errp);
15062 if (ncols * nrows > 0) {
15063 int m, mr, nr = nrows;
15066 for (k = 0; k < ncols; k++) {
15067 if (strcmp(rowp[k],
"name") == 0) {
15075 for (k = 1; k <= nrows; k++) {
15076 if (
namematch(rowp[k * ncols + namec], cname, 1)) {
15082 for (k = 0; k < nr; k++) {
15083 m = asize * (roffs + k);
15084 #if defined(_WIN32) || defined(_WIN64) 15085 s->
rows[m + 0] =
xstrdup(d->xcelqrx ?
"main" :
"");
15096 for (k = 0; nr && k < ncols; k++) {
15097 if (strcmp(rowp[k],
"cid") == 0) {
15098 for (mr = 0, m = 1; m <= nrows; m++) {
15103 !
namematch(rowp[m * ncols + namec], cname, 1)) {
15106 ir = asize * (roffs + mr);
15107 sscanf(rowp[m * ncols + k],
"%d", &coln);
15108 sprintf(buf,
"%d", coln + 1);
15112 }
else if (k == namec) {
15113 for (mr = 0, m = 1; m <= nrows; m++) {
15117 !
namematch(rowp[m * ncols + namec], cname, 1)) {
15120 ir = asize * (roffs + mr);
15124 }
else if (strcmp(rowp[k],
"notnull") == 0) {
15125 for (mr = 0, m = 1; m <= nrows; m++) {
15129 !
namematch(rowp[m * ncols + namec], cname, 1)) {
15132 ir = asize * (roffs + mr);
15133 if (*rowp[m * ncols + k] !=
'0') {
15139 xstrdup((*rowp[m * ncols + k] !=
'0') ?
15143 }
else if (strcmp(rowp[k],
"dflt_value") == 0) {
15144 for (mr = 0, m = 1; m <= nrows; m++) {
15145 char *dflt =
unquote(rowp[m * ncols + k]);
15149 !
namematch(rowp[m * ncols + namec], cname, 1)) {
15152 ir = asize * (roffs + mr);
15153 s->
rows[ir + 12] =
xstrdup(dflt ? dflt :
"NULL");
15156 }
else if (strcmp(rowp[k],
"type") == 0) {
15157 for (mr = 0, m = 1; m <= nrows; m++) {
15158 char *
typename = rowp[m * ncols + k];
15159 int sqltype, mm, dd, ir;
15163 !
namematch(rowp[m * ncols + namec], cname, 1)) {
15166 ir = asize * (roffs + mr);
15170 getmd(
typename, sqltype, &mm, &dd);
15171 #ifdef SQL_LONGVARCHAR 15172 if (sqltype == SQL_VARCHAR && mm > 255) {
15173 sqltype = SQL_LONGVARCHAR;
15177 #ifdef SQL_WLONGVARCHAR 15178 if (sqltype == SQL_WVARCHAR && mm > 255) {
15179 sqltype = SQL_WLONGVARCHAR;
15183 if (sqltype == SQL_VARBINARY && mm > 255) {
15184 sqltype = SQL_LONGVARBINARY;
15186 sprintf(buf,
"%d", sqltype);
15189 sprintf(buf,
"%d", mm);
15191 sprintf(buf,
"%d", dd);
15199 sqlite3_free_table(rowp);
15201 sqlite3_free_table(trows);
15202 return SQL_SUCCESS;
15221 SQLColumns(SQLHSTMT
stmt,
15222 SQLCHAR *cat, SQLSMALLINT catLen,
15223 SQLCHAR *schema, SQLSMALLINT schemaLen,
15224 SQLCHAR *table, SQLSMALLINT tableLen,
15225 SQLCHAR *col, SQLSMALLINT colLen)
15227 #if defined(_WIN32) || defined(_WIN64) 15228 char *c = NULL, *s = NULL, *t = NULL, *k = NULL;
15233 #if defined(_WIN32) || defined(_WIN64) 15236 table, tableLen, col, colLen);
15240 c = wmb_to_utf_c((
char *) cat, catLen);
15247 s = wmb_to_utf_c((
char *) schema, schemaLen);
15254 t = wmb_to_utf_c((
char *) table, tableLen);
15261 k = wmb_to_utf_c((
char *) col, colLen);
15267 ret =
drvcolumns(
stmt, (SQLCHAR *) c, SQL_NTS, (SQLCHAR *) s, SQL_NTS,
15268 (SQLCHAR *) t, SQL_NTS, (SQLCHAR *) k, SQL_NTS);
15271 table, tableLen, col, colLen);
15273 #if defined(_WIN32) || defined(_WIN64) 15304 SQLWCHAR *cat, SQLSMALLINT catLen,
15305 SQLWCHAR *schema, SQLSMALLINT schemaLen,
15306 SQLWCHAR *table, SQLSMALLINT tableLen,
15307 SQLWCHAR *col, SQLSMALLINT colLen)
15309 char *c = NULL, *s = NULL, *t = NULL, *k = NULL;
15341 ret =
drvcolumns(
stmt, (SQLCHAR *) c, SQL_NTS, (SQLCHAR *) s, SQL_NTS,
15342 (SQLCHAR *) t, SQL_NTS, (SQLCHAR *) k, SQL_NTS);
15360 {
"SYSTEM",
"TYPE",
"DATA_TYPE", SQL_SMALLINT, 2 },
15361 {
"SYSTEM",
"TYPE",
"PRECISION", SQL_INTEGER, 9 },
15362 {
"SYSTEM",
"TYPE",
"LITERAL_PREFIX",
SCOL_VARCHAR, 50 },
15363 {
"SYSTEM",
"TYPE",
"LITERAL_SUFFIX",
SCOL_VARCHAR, 50 },
15364 {
"SYSTEM",
"TYPE",
"CREATE_PARAMS",
SCOL_VARCHAR, 50 },
15365 {
"SYSTEM",
"TYPE",
"NULLABLE", SQL_SMALLINT, 2 },
15366 {
"SYSTEM",
"TYPE",
"CASE_SENSITIVE", SQL_SMALLINT, 2 },
15367 {
"SYSTEM",
"TYPE",
"SEARCHABLE", SQL_SMALLINT, 2 },
15368 {
"SYSTEM",
"TYPE",
"UNSIGNED_ATTRIBUTE", SQL_SMALLINT, 2 },
15369 {
"SYSTEM",
"TYPE",
"MONEY", SQL_SMALLINT, 2 },
15370 {
"SYSTEM",
"TYPE",
"AUTO_INCREMENT", SQL_SMALLINT, 2 },
15371 {
"SYSTEM",
"TYPE",
"LOCAL_TYPE_NAME",
SCOL_VARCHAR, 50 },
15372 {
"SYSTEM",
"TYPE",
"MINIMUM_SCALE", SQL_SMALLINT, 2 },
15373 {
"SYSTEM",
"TYPE",
"MAXIMUM_SCALE", SQL_SMALLINT, 2 }
15378 {
"SYSTEM",
"TYPE",
"DATA_TYPE", SQL_SMALLINT, 2 },
15379 {
"SYSTEM",
"TYPE",
"COLUMN_SIZE", SQL_INTEGER, 9 },
15380 {
"SYSTEM",
"TYPE",
"LITERAL_PREFIX",
SCOL_VARCHAR, 50 },
15381 {
"SYSTEM",
"TYPE",
"LITERAL_SUFFIX",
SCOL_VARCHAR, 50 },
15382 {
"SYSTEM",
"TYPE",
"CREATE_PARAMS",
SCOL_VARCHAR, 50 },
15383 {
"SYSTEM",
"TYPE",
"NULLABLE", SQL_SMALLINT, 2 },
15384 {
"SYSTEM",
"TYPE",
"CASE_SENSITIVE", SQL_SMALLINT, 2 },
15385 {
"SYSTEM",
"TYPE",
"SEARCHABLE", SQL_SMALLINT, 2 },
15386 {
"SYSTEM",
"TYPE",
"UNSIGNED_ATTRIBUTE", SQL_SMALLINT, 2 },
15387 {
"SYSTEM",
"TYPE",
"FIXED_PREC_SCALE", SQL_SMALLINT, 2 },
15388 {
"SYSTEM",
"TYPE",
"AUTO_UNIQUE_VALUE", SQL_SMALLINT, 2 },
15389 {
"SYSTEM",
"TYPE",
"LOCAL_TYPE_NAME",
SCOL_VARCHAR, 50 },
15390 {
"SYSTEM",
"TYPE",
"MINIMUM_SCALE", SQL_SMALLINT, 2 },
15391 {
"SYSTEM",
"TYPE",
"MAXIMUM_SCALE", SQL_SMALLINT, 2 },
15392 {
"SYSTEM",
"TYPE",
"SQL_DATA_TYPE", SQL_SMALLINT, 2 },
15393 {
"SYSTEM",
"TYPE",
"SQL_DATETIME_SUB", SQL_SMALLINT, 2 },
15394 {
"SYSTEM",
"TYPE",
"NUM_PREC_RADIX", SQL_INTEGER, 4 },
15395 {
"SYSTEM",
"TYPE",
"INTERVAL_PRECISION", SQL_SMALLINT, 2 }
15411 int offs = row * asize;
15412 char *tcode, *crpar = NULL, *quote = NULL, *sign =
stringify(SQL_FALSE);
15413 static char tcodes[32 * 32];
15418 tcode = tcodes + tind * 32;
15419 sprintf(tcode,
"%d", type);
15420 s->
rows[offs + 0] =
typename;
15421 s->
rows[offs + 1] = tcode;
15423 s->
rows[offs + 15] = tcode;
15424 s->
rows[offs + 16] =
"0";
15428 #ifdef SQL_LONGVARCHAR 15429 case SQL_LONGVARCHAR:
15431 case SQL_WLONGVARCHAR:
15436 s->
rows[offs + 2] =
"65536";
15442 s->
rows[offs + 2] =
"1";
15451 s->
rows[offs + 2] =
"255";
15457 s->
rows[offs + 2] =
"3";
15460 s->
rows[offs + 2] =
"5";
15463 s->
rows[offs + 2] =
"9";
15467 s->
rows[offs + 2] =
"19";
15471 s->
rows[offs + 2] =
"7";
15474 s->
rows[offs + 2] =
"15";
15476 #ifdef SQL_TYPE_DATE 15477 case SQL_TYPE_DATE:
15480 s->
rows[offs + 2] =
"10";
15484 #ifdef SQL_TYPE_TIME 15485 case SQL_TYPE_TIME:
15488 s->
rows[offs + 2] =
"8";
15492 #ifdef SQL_TYPE_TIMESTAMP 15493 case SQL_TYPE_TIMESTAMP:
15495 case SQL_TIMESTAMP:
15496 s->
rows[offs + 2] =
"32";
15500 case SQL_VARBINARY:
15502 s->
rows[offs + 2] =
"255";
15504 case SQL_LONGVARBINARY:
15506 s->
rows[offs + 2] =
"65536";
15509 s->
rows[offs + 3] = s->
rows[offs + 4] = quote;
15510 s->
rows[offs + 5] = crpar;
15514 s->
rows[offs + 9] = sign;
15517 s->
rows[offs + 12] =
typename;
15521 s->
rows[offs + 13] =
"0";
15522 s->
rows[offs + 14] =
"0";
15524 #ifdef SQL_TYPE_TIMESTAMP 15525 case SQL_TYPE_TIMESTAMP:
15527 case SQL_TIMESTAMP:
15528 s->
rows[offs + 13] =
"0";
15529 s->
rows[offs + 14] =
"3";
15532 s->
rows[offs + 13] = NULL;
15533 s->
rows[offs + 14] = NULL;
15549 char **pa = (
char **) a;
15550 char **pb = (
char **) b;
15553 na = strtol(pa[1], NULL, 0);
15554 nb = strtol(pb[1], NULL, 0);
15574 if (ret != SQL_SUCCESS) {
15578 #ifdef SQL_LONGVARCHAR 15579 s->
nrows = (sqltype == SQL_ALL_TYPES) ? 13 : 1;
15581 s->
nrows = (sqltype == SQL_ALL_TYPES) ? 12 : 1;
15583 if (sqltype == SQL_ALL_TYPES) {
15586 #ifdef SQL_WLONGVARCHAR 15591 if (sqltype == SQL_ALL_TYPES) {
15605 #ifdef MEMORY_DEBUG 15610 memset(s->
rows, 0, sizeof (
char *) * (s->
nrows + 1) * asize);
15611 if (sqltype == SQL_ALL_TYPES) {
15614 mktypeinfo(s, cc++, asize,
"varchar", SQL_VARCHAR, 0);
15615 mktypeinfo(s, cc++, asize,
"tinyint", SQL_TINYINT, 0);
15616 mktypeinfo(s, cc++, asize,
"smallint", SQL_SMALLINT, 0);
15617 mktypeinfo(s, cc++, asize,
"integer", SQL_INTEGER, 0);
15618 mktypeinfo(s, cc++, asize,
"float", SQL_FLOAT, 0);
15619 mktypeinfo(s, cc++, asize,
"double", SQL_DOUBLE, 0);
15620 #ifdef SQL_TYPE_DATE 15622 (*s->
ov3) ? SQL_TYPE_DATE : SQL_DATE, 0);
15624 mktypeinfo(s, cc++, asize,
"date", SQL_DATE, 0);
15626 #ifdef SQL_TYPE_TIME 15628 (*s->
ov3) ? SQL_TYPE_TIME : SQL_TIME, 0);
15630 mktypeinfo(s, cc++, asize,
"time", SQL_TIME, 0);
15632 #ifdef SQL_TYPE_TIMESTAMP 15634 (*s->
ov3) ? SQL_TYPE_TIMESTAMP : SQL_TIMESTAMP, 0);
15636 mktypeinfo(s, cc++, asize,
"timestamp", SQL_TIMESTAMP, 0);
15638 mktypeinfo(s, cc++, asize,
"char", SQL_CHAR, 0);
15639 mktypeinfo(s, cc++, asize,
"numeric", SQL_DOUBLE, 0);
15640 #ifdef SQL_LONGVARCHAR 15641 mktypeinfo(s, cc++, asize,
"text", SQL_LONGVARCHAR, 0);
15642 mktypeinfo(s, cc++, asize,
"longvarchar", SQL_LONGVARCHAR, 0);
15644 mktypeinfo(s, cc++, asize,
"text", SQL_VARCHAR, 0);
15646 mktypeinfo(s, cc++, asize,
"varbinary", SQL_VARBINARY, 0);
15647 mktypeinfo(s, cc++, asize,
"longvarbinary", SQL_LONGVARBINARY, 0);
15649 mktypeinfo(s, cc++, asize,
"bit", SQL_BIT, 0);
15652 mktypeinfo(s, cc++, asize,
"bigint", SQL_BIGINT, 0);
15655 mktypeinfo(s, cc++, asize,
"wvarchar", SQL_WVARCHAR, 0);
15656 mktypeinfo(s, cc++, asize,
"wchar", SQL_WCHAR, 0);
15657 #ifdef SQL_WLONGVARCHAR 15658 mktypeinfo(s, cc++, asize,
"wtext", SQL_WLONGVARCHAR, 0);
15659 mktypeinfo(s, cc++, asize,
"longwvarchar", SQL_WLONGVARCHAR, 0);
15662 qsort(s->
rows + asize, s->
nrows, sizeof (
char *) * asize,
15667 mktypeinfo(s, 1, asize,
"char", SQL_CHAR, 10);
15670 mktypeinfo(s, 1, asize,
"varchar", SQL_VARCHAR, 1);
15673 mktypeinfo(s, 1, asize,
"tinyint", SQL_TINYINT, 2);
15676 mktypeinfo(s, 1, asize,
"smallint", SQL_SMALLINT, 3);
15679 mktypeinfo(s, 1, asize,
"integer", SQL_INTEGER, 4);
15682 mktypeinfo(s, 1, asize,
"float", SQL_FLOAT, 5);
15685 mktypeinfo(s, 1, asize,
"double", SQL_DOUBLE, 6);
15687 #ifdef SQL_TYPE_DATE 15688 case SQL_TYPE_DATE:
15689 mktypeinfo(s, 1, asize,
"date", SQL_TYPE_DATE, 25);
15693 mktypeinfo(s, 1, asize,
"date", SQL_DATE, 7);
15695 #ifdef SQL_TYPE_TIME 15696 case SQL_TYPE_TIME:
15697 mktypeinfo(s, 1, asize,
"time", SQL_TYPE_TIME, 26);
15701 mktypeinfo(s, 1, asize,
"time", SQL_TIME, 8);
15703 #ifdef SQL_TYPE_TIMESTAMP 15704 case SQL_TYPE_TIMESTAMP:
15705 mktypeinfo(s, 1, asize,
"timestamp", SQL_TYPE_TIMESTAMP, 27);
15708 case SQL_TIMESTAMP:
15709 mktypeinfo(s, 1, asize,
"timestamp", SQL_TIMESTAMP, 9);
15711 #ifdef SQL_LONGVARCHAR 15712 case SQL_LONGVARCHAR:
15713 mktypeinfo(s, 1, asize,
"longvarchar", SQL_LONGVARCHAR, 12);
15716 case SQL_VARBINARY:
15717 mktypeinfo(s, 1, asize,
"varbinary", SQL_VARBINARY, 30);
15719 case SQL_LONGVARBINARY:
15720 mktypeinfo(s, 1, asize,
"longvarbinary", SQL_LONGVARBINARY, 31);
15724 mktypeinfo(s, 1, asize,
"bit", SQL_BIT, 29);
15729 mktypeinfo(s, 1, asize,
"bigint", SQL_BIGINT, 28);
15735 mktypeinfo(s, 1, asize,
"wchar", SQL_WCHAR, 18);
15738 #ifdef SQL_WVARCHAR 15740 mktypeinfo(s, 1, asize,
"wvarchar", SQL_WVARCHAR, 19);
15743 #ifdef SQL_WLONGVARCHAR 15744 case SQL_WLONGVARCHAR:
15745 mktypeinfo(s, 1, asize,
"longwvarchar", SQL_WLONGVARCHAR, 20);
15753 return SQL_SUCCESS;
15765 SQLGetTypeInfo(SQLHSTMT
stmt, SQLSMALLINT sqltype)
15801 {
"SYSTEM",
"STATISTICS",
"TABLE_QUALIFIER",
SCOL_VARCHAR, 50 },
15802 {
"SYSTEM",
"STATISTICS",
"TABLE_OWNER",
SCOL_VARCHAR, 50 },
15803 {
"SYSTEM",
"STATISTICS",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
15804 {
"SYSTEM",
"STATISTICS",
"NON_UNIQUE", SQL_SMALLINT, 50 },
15805 {
"SYSTEM",
"STATISTICS",
"INDEX_QUALIFIER",
SCOL_VARCHAR, 255 },
15806 {
"SYSTEM",
"STATISTICS",
"INDEX_NAME",
SCOL_VARCHAR, 255 },
15807 {
"SYSTEM",
"STATISTICS",
"TYPE", SQL_SMALLINT, 50 },
15808 {
"SYSTEM",
"STATISTICS",
"SEQ_IN_INDEX", SQL_SMALLINT, 50 },
15809 {
"SYSTEM",
"STATISTICS",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
15810 {
"SYSTEM",
"STATISTICS",
"COLLATION",
SCOL_CHAR, 1 },
15811 {
"SYSTEM",
"STATISTICS",
"CARDINALITY", SQL_INTEGER, 50 },
15812 {
"SYSTEM",
"STATISTICS",
"PAGES", SQL_INTEGER, 50 },
15813 {
"SYSTEM",
"STATISTICS",
"FILTER_CONDITION",
SCOL_VARCHAR, 255 }
15817 {
"SYSTEM",
"STATISTICS",
"TABLE_CAT",
SCOL_VARCHAR, 50 },
15818 {
"SYSTEM",
"STATISTICS",
"TABLE_SCHEM",
SCOL_VARCHAR, 50 },
15819 {
"SYSTEM",
"STATISTICS",
"TABLE_NAME",
SCOL_VARCHAR, 255 },
15820 {
"SYSTEM",
"STATISTICS",
"NON_UNIQUE", SQL_SMALLINT, 50 },
15821 {
"SYSTEM",
"STATISTICS",
"INDEX_QUALIFIER",
SCOL_VARCHAR, 255 },
15822 {
"SYSTEM",
"STATISTICS",
"INDEX_NAME",
SCOL_VARCHAR, 255 },
15823 {
"SYSTEM",
"STATISTICS",
"TYPE", SQL_SMALLINT, 50 },
15824 {
"SYSTEM",
"STATISTICS",
"ORDINAL_POSITION", SQL_SMALLINT, 50 },
15825 {
"SYSTEM",
"STATISTICS",
"COLUMN_NAME",
SCOL_VARCHAR, 255 },
15826 {
"SYSTEM",
"STATISTICS",
"ASC_OR_DESC",
SCOL_CHAR, 1 },
15827 {
"SYSTEM",
"STATISTICS",
"CARDINALITY", SQL_INTEGER, 50 },
15828 {
"SYSTEM",
"STATISTICS",
"PAGES", SQL_INTEGER, 50 },
15829 {
"SYSTEM",
"STATISTICS",
"FILTER_CONDITION",
SCOL_VARCHAR, 255 }
15848 SQLCHAR *schema, SQLSMALLINT schemaLen,
15849 SQLCHAR *table, SQLSMALLINT tableLen,
15850 SQLUSMALLINT itype, SQLUSMALLINT resv)
15855 int i, asize, ret, nrows, ncols, offs, namec, uniquec, addipk = 0;
15857 char **rowp, *errp = NULL, *sql, tname[512];
15861 if (sret != SQL_SUCCESS) {
15866 if (!table || table[0] ==
'\0' || table[0] ==
'%') {
15867 setstat(s, -1,
"need table name", (*s->
ov3) ?
"HY000" :
"S1000");
15870 if (tableLen == SQL_NTS) {
15871 size =
sizeof (tname) - 1;
15873 size =
min(
sizeof (tname) - 1, tableLen);
15875 strncpy(tname, (
char *) table, size);
15876 tname[size] =
'\0';
15879 if (sret != SQL_SUCCESS) {
15885 if (itype == SQL_INDEX_UNIQUE || itype == SQL_INDEX_ALL) {
15887 ret = SQLITE_ERROR;
15888 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", tname);
15891 ret = sqlite3_get_table(d->
sqlite, sql, &rowp,
15892 &nrows, &ncols, NULL);
15895 if (ret == SQLITE_OK) {
15896 int colid, typec, npk = 0, npkint = 0;
15898 namec =
findcol(rowp, ncols,
"name");
15899 uniquec =
findcol(rowp, ncols,
"pk");
15900 typec =
findcol(rowp, ncols,
"type");
15901 colid =
findcol(rowp, ncols,
"cid");
15902 if (namec < 0 || uniquec < 0 || typec < 0 || colid < 0) {
15905 for (i = 1; i <= nrows; i++) {
15906 if (*rowp[i * ncols + uniquec] !=
'0') {
15908 if (strlen(rowp[i * ncols + typec]) == 7 &&
15909 strncasecmp(rowp[i * ncols + typec],
"integer", 7)
15915 if (npkint == 1 && npk == npkint) {
15920 sqlite3_free_table(rowp);
15922 sql = sqlite3_mprintf(
"PRAGMA index_list(%Q)", tname);
15927 ret = sqlite3_get_table(d->
sqlite, sql, &rowp, &nrows, &ncols, &errp);
15929 if (ret != SQLITE_OK) {
15930 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
15931 errp ? errp :
"unknown error", ret);
15933 sqlite3_free(errp);
15939 sqlite3_free(errp);
15943 namec =
findcol(rowp, ncols,
"name");
15944 uniquec =
findcol(rowp, ncols,
"unique");
15945 if (namec < 0 || uniquec < 0) {
15948 for (i = 1; i <= nrows; i++) {
15949 int nnrows, nncols;
15953 isuniq = *rowp[i * ncols + uniquec] !=
'0';
15954 if (isuniq || itype == SQL_INDEX_ALL) {
15955 ret = SQLITE_ERROR;
15956 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
15957 rowp[i * ncols + namec]);
15960 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
15961 &nnrows, &nncols, NULL);
15964 if (ret == SQLITE_OK) {
15966 sqlite3_free_table(rowpp);
15975 sqlite3_free_table(rowp);
15976 return SQL_SUCCESS;
15979 size = (size + 1) * asize;
15985 s->
rows[0] = (
char *) size;
15987 memset(s->
rows, 0, sizeof (
char *) * size);
15992 int nrows2, ncols2;
15994 sql = sqlite3_mprintf(
"PRAGMA table_info(%Q)", tname);
15997 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
15998 &nrows2, &ncols2, NULL);
16001 if (ret == SQLITE_OK) {
16002 int colid, typec, roffs, namecc, uniquecc;
16004 namecc =
findcol(rowpp, ncols2,
"name");
16005 uniquecc =
findcol(rowpp, ncols2,
"pk");
16006 typec =
findcol(rowpp, ncols2,
"type");
16007 colid =
findcol(rowpp, ncols2,
"cid");
16008 if (namecc < 0 || uniquecc < 0 || typec < 0 || colid < 0) {
16013 for (i = 1; i <= nrows2; i++) {
16014 if (*rowpp[i * ncols2 + uniquecc] !=
'0' &&
16015 strlen(rowpp[i * ncols2 + typec]) == 7 &&
16016 strncasecmp(rowpp[i * ncols2 + typec],
"integer", 7)
16027 #if defined(_WIN32) || defined(_WIN64) 16028 s->
rows[roffs + 0] =
xstrdup(d->xcelqrx ?
"main" :
"");
16036 s->
rows[roffs + 5] =
xstrdup(
"sqlite_autoindex_0");
16039 s->
rows[roffs + 8] =
xstrdup(rowpp[i * ncols2 + namecc]);
16043 sqlite3_free_table(rowpp);
16045 for (i = 1; i <= nrows; i++) {
16046 int nnrows, nncols;
16049 if (*rowp[i * ncols + uniquec] !=
'0' || itype == SQL_INDEX_ALL) {
16052 ret = SQLITE_ERROR;
16053 sql = sqlite3_mprintf(
"PRAGMA index_info(%Q)",
16054 rowp[i * ncols + namec]);
16057 ret = sqlite3_get_table(d->
sqlite, sql, &rowpp,
16058 &nnrows, &nncols, NULL);
16061 if (ret != SQLITE_OK) {
16064 for (k = 0; nnrows && k < nncols; k++) {
16065 if (strcmp(rowpp[k],
"name") == 0) {
16068 for (m = 1; m <= nnrows; m++) {
16069 int roffs = (offs + addipk + m) * s->
ncols;
16072 isuniq = *rowp[i * ncols + uniquec] !=
'0';
16081 s->
rows[roffs + 5] =
xstrdup(rowp[i * ncols + namec]);
16082 s->
rows[roffs + 6] =
16084 s->
rows[roffs + 8] =
xstrdup(rowpp[m * nncols + k]);
16087 }
else if (strcmp(rowpp[k],
"seqno") == 0) {
16090 for (m = 1; m <= nnrows; m++) {
16091 int roffs = (offs + addipk + m) * s->
ncols;
16095 sscanf(rowpp[m * nncols + k],
"%d", &pos);
16096 sprintf(buf,
"%d", pos + 1);
16102 sqlite3_free_table(rowpp);
16105 sqlite3_free_table(rowp);
16106 return SQL_SUCCESS;
16125 SQLStatistics(SQLHSTMT
stmt, SQLCHAR *cat, SQLSMALLINT catLen,
16126 SQLCHAR *schema, SQLSMALLINT schemaLen,
16127 SQLCHAR *table, SQLSMALLINT tableLen,
16128 SQLUSMALLINT itype, SQLUSMALLINT resv)
16130 #if defined(_WIN32) || defined(_WIN64) 16131 char *c = NULL, *s = NULL, *t = NULL;
16136 #if defined(_WIN32) || defined(_WIN64) 16139 table, tableLen, itype, resv);
16143 c = wmb_to_utf_c((
char *) cat, catLen);
16150 s = wmb_to_utf_c((
char *) schema, schemaLen);
16157 t = wmb_to_utf_c((
char *) table, tableLen);
16164 (SQLCHAR *) t, SQL_NTS, itype, resv);
16167 table, tableLen, itype, resv);
16169 #if defined(_WIN32) || defined(_WIN64) 16199 SQLWCHAR *schema, SQLSMALLINT schemaLen,
16200 SQLWCHAR *table, SQLSMALLINT tableLen,
16201 SQLUSMALLINT itype, SQLUSMALLINT resv)
16203 char *c = NULL, *s = NULL, *t = NULL;
16229 (SQLCHAR *) t, SQL_NTS, itype, resv);
16255 SQLRETURN ret = SQL_ERROR;
16258 if (
stmt == SQL_NULL_HSTMT) {
16259 return SQL_INVALID_HANDLE;
16262 if (col == 0 && s->
bkmrk != SQL_UB_OFF) {
16263 if (s->
bkmrk == SQL_UB_ON && type == SQL_C_BOOKMARK) {
16264 *((SQLINTEGER *) val) = s->
rowp;
16266 *lenp =
sizeof (SQLINTEGER);
16270 }
else if (s->
bkmrk == SQL_UB_VARIABLE && type == SQL_C_VARBOOKMARK) {
16272 char **data, *endp = 0;
16277 *((sqlite_int64 *) val) = strtol(*data, &endp, 0);
16279 *((sqlite_int64 *) val) = strtoll(*data, &endp, 0);
16282 *((sqlite_int64 *) val) = s->
rowp;
16285 *lenp =
sizeof (sqlite_int64);
16291 if (col < 1 || col > s->
ncols) {
16292 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009" :
"S1002");
16296 ret =
getrowdata(s, col, type, val, len, lenp, 1);
16312 int ret, i, withinfo = 0;
16316 int bsize =
sizeof (SQLINTEGER);
16321 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
16329 val = (SQLPOINTER) ((
char *) val + *s->
bind_offs);
16332 char **data, *endp = 0;
16337 *(sqlite_int64 *) val = strtol(*data, &endp, 0);
16339 *(sqlite_int64 *) val = strtoll(*data, &endp, 0);
16342 *(sqlite_int64 *) val = s->
rowp;
16344 bsize =
sizeof (sqlite_int64);
16348 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
16349 val = (SQLINTEGER *)
16355 val = (SQLINTEGER *) ((
char *) val + *s->
bind_offs);
16362 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
16382 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
16385 dp = (SQLPOINTER) ((
char *) b->
valp + b->
max * rsi);
16388 dp = (SQLPOINTER) ((
char *) dp + *s->
bind_offs);
16392 if (s->
bind_type != SQL_BIND_BY_COLUMN) {
16395 lp = b->
lenp + rsi;
16403 if (!SQL_SUCCEEDED(ret)) {
16407 if (ret != SQL_SUCCESS) {
16409 #ifdef SQL_ROW_SUCCESS_WITH_INFO 16415 if (SQL_SUCCEEDED(ret)) {
16416 ret = withinfo ? SQL_SUCCESS_WITH_INFO : SQL_SUCCESS;
16433 int i, withinfo = 0;
16436 if (
stmt == SQL_NULL_HSTMT) {
16437 return SQL_INVALID_HANDLE;
16460 setstat(s, -1,
"no result set available",
"24000");
16465 if (s->
curtype == SQL_CURSOR_FORWARD_ONLY && orient != SQL_FETCH_NEXT) {
16466 setstat(s, -1,
"wrong fetch direction",
"01000");
16473 if (((
DBC *) (s->
dbc))->cur_s3stmt == s && s->
s3stmt) {
16477 ret = (i == 0) ? SQL_NO_DATA : SQL_SUCCESS;
16481 if (ret != SQL_SUCCESS) {
16485 if (s->
nrows < 1) {
16489 if (!SQL_SUCCEEDED(ret)) {
16491 }
else if (ret == SQL_SUCCESS_WITH_INFO) {
16495 }
else if (s->
rows) {
16497 case SQL_FETCH_NEXT:
16498 if (s->
nrows < 1) {
16499 return SQL_NO_DATA;
16506 return SQL_NO_DATA;
16509 case SQL_FETCH_PRIOR:
16512 return SQL_NO_DATA;
16515 if (s->
rowp < -1) {
16517 return SQL_NO_DATA;
16520 case SQL_FETCH_FIRST:
16521 if (s->
nrows < 1) {
16522 return SQL_NO_DATA;
16526 case SQL_FETCH_LAST:
16527 if (s->
nrows < 1) {
16528 return SQL_NO_DATA;
16531 if (--s->
rowp < -1) {
16535 case SQL_FETCH_ABSOLUTE:
16538 return SQL_NO_DATA;
16539 }
else if (offset < 0) {
16540 if (0 - offset <= s->nrows) {
16545 return SQL_NO_DATA;
16546 }
else if (offset > s->
nrows) {
16548 return SQL_NO_DATA;
16550 s->
rowp = offset - 1 - 1;
16552 case SQL_FETCH_RELATIVE:
16557 return SQL_NO_DATA;
16561 if (s->
rowp < -1) {
16563 return SQL_NO_DATA;
16567 case SQL_FETCH_BOOKMARK:
16569 if (offset < 0 || offset >= s->
nrows) {
16570 return SQL_NO_DATA;
16572 s->
rowp = offset - 1;
16578 if (s->
bkmrk == SQL_UB_VARIABLE) {
16580 sqlite_int64 bkmrk, rowid;
16582 bkmrk = *(sqlite_int64 *) s->
bkmrkptr;
16583 for (rowp = 0; rowp < s->
nrows; rowp++) {
16584 char **data, *endp = 0;
16589 rowid = strtol(*data, &endp, 0);
16591 rowid = strtoll(*data, &endp, 0);
16593 if (rowid == bkmrk) {
16598 rowp = *(sqlite_int64 *) s->
bkmrkptr;
16603 if (rowp + offset < 0 || rowp + offset >= s->
nrows) {
16604 return SQL_NO_DATA;
16606 s->
rowp = rowp + offset - 1;
16622 if (!SQL_SUCCEEDED(ret)) {
16624 }
else if (ret == SQL_SUCCESS_WITH_INFO) {
16631 if (SQL_SUCCEEDED(ret)) {
16632 return SQL_NO_DATA;
16636 if (SQL_SUCCEEDED(ret)) {
16637 ret = withinfo ? SQL_SUCCESS_WITH_INFO : SQL_SUCCESS;
16704 SQLINTEGER *bkmrkptr;
16707 if (
stmt == SQL_NULL_HSTMT) {
16708 return SQL_INVALID_HANDLE;
16743 if (
stmt == SQL_NULL_HSTMT) {
16744 return SQL_INVALID_HANDLE;
16751 return SQL_SUCCESS;
16767 if (
stmt == SQL_NULL_HSTMT) {
16768 return SQL_INVALID_HANDLE;
16775 return SQL_SUCCESS;
16794 SQLSMALLINT nameMax, SQLSMALLINT *nameLen,
16795 SQLSMALLINT *type,
SQLULEN *size,
16796 SQLSMALLINT *digits, SQLSMALLINT *nullable)
16802 if (
stmt == SQL_NULL_HSTMT) {
16803 return SQL_INVALID_HANDLE;
16807 setstat(s, -1,
"no columns", (*s->
ov3) ?
"07009" :
"S1002");
16810 if (col < 1 || col > s->
ncols) {
16811 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009" :
"S1002");
16814 c = s->
cols + col - 1;
16815 if (name && nameMax > 0) {
16816 strncpy((
char *) name, c->
column, nameMax);
16817 name[nameMax - 1] =
'\0';
16822 *nameLen = strlen((
char *) name);
16824 *nameLen = strlen(c->
column);
16836 *type = SQL_VARCHAR;
16838 #ifdef SQL_LONGVARCHAR 16839 case SQL_WLONGVARCHAR:
16840 *type = SQL_LONGVARCHAR;
16856 return SQL_SUCCESS;
16875 SQLDescribeCol(SQLHSTMT
stmt, SQLUSMALLINT col, SQLCHAR *name,
16876 SQLSMALLINT nameMax, SQLSMALLINT *nameLen,
16877 SQLSMALLINT *type,
SQLULEN *size,
16878 SQLSMALLINT *digits, SQLSMALLINT *nullable)
16880 #if defined(_WIN32) || defined(_WIN64) 16881 SQLSMALLINT len = 0;
16886 #if defined(_WIN32) || defined(_WIN64) 16889 type, size, digits, nullable);
16893 &len, type, size, digits, nullable);
16894 if (ret == SQL_SUCCESS) {
16899 n = (SQLCHAR *) utf_to_wmb((
char *) name, len);
16901 strncpy((
char *) name, (
char *) n, nameMax);
16903 len =
min(nameMax, strlen((
char *) n));
16921 len = strlen(c->
column);
16932 type, size, digits, nullable);
16956 SQLSMALLINT nameMax, SQLSMALLINT *nameLen,
16957 SQLSMALLINT *type,
SQLULEN *size,
16958 SQLSMALLINT *digits, SQLSMALLINT *nullable)
16961 SQLSMALLINT len = 0;
16965 (SQLSMALLINT) (nameMax *
sizeof (SQLWCHAR)),
16966 &len, type, size, digits, nullable);
16967 if (ret == SQL_SUCCESS) {
16970 SQLWCHAR *n = NULL;
16994 len = strlen(c->
column);
17020 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17026 char *valc = (
char *) val;
17028 if (
stmt == SQL_NULL_HSTMT) {
17029 return SQL_INVALID_HANDLE;
17038 if (
id == SQL_COLUMN_COUNT) {
17042 *valLen =
sizeof (int);
17043 return SQL_SUCCESS;
17045 if (
id == SQL_COLUMN_TYPE && col == 0) {
17047 *val2 = SQL_INTEGER;
17049 *valLen =
sizeof (int);
17050 return SQL_SUCCESS;
17052 #ifdef SQL_DESC_OCTET_LENGTH 17053 if (
id == SQL_DESC_OCTET_LENGTH && col == 0) {
17057 *valLen =
sizeof (int);
17058 return SQL_SUCCESS;
17061 if (col < 1 || col > s->
ncols) {
17062 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009":
"S1002");
17065 c = s->
cols + col - 1;
17068 case SQL_COLUMN_LABEL:
17070 if (valc && valMax > 0) {
17071 strncpy(valc, c->
label, valMax);
17072 valc[valMax - 1] =
'\0';
17074 *valLen = strlen(c->
label);
17078 case SQL_COLUMN_NAME:
17079 case SQL_DESC_NAME:
17080 if (valc && valMax > 0) {
17081 strncpy(valc, c->
column, valMax);
17082 valc[valMax - 1] =
'\0';
17084 *valLen = strlen(c->
column);
17086 if (*valLen >= valMax) {
17087 setstat(s, -1,
"data right truncated",
"01004");
17088 return SQL_SUCCESS_WITH_INFO;
17090 return SQL_SUCCESS;
17091 #ifdef SQL_DESC_BASE_COLUMN_NAME 17092 case SQL_DESC_BASE_COLUMN_NAME:
17093 if (strchr(c->
column,
'(') || strchr(c->
column,
')')) {
17094 if (valc && valMax > 0) {
17098 }
else if (valc && valMax > 0) {
17099 strncpy(valc, c->
column, valMax);
17100 valc[valMax - 1] =
'\0';
17101 *valLen = strlen(c->
column);
17105 case SQL_COLUMN_TYPE:
17106 case SQL_DESC_TYPE:
17109 int type = c->
type;
17117 type = SQL_VARCHAR;
17119 #ifdef SQL_LONGVARCHAR 17120 case SQL_WLONGVARCHAR:
17121 type = SQL_LONGVARCHAR;
17135 *valLen =
sizeof (int);
17136 return SQL_SUCCESS;
17137 case SQL_COLUMN_DISPLAY_SIZE:
17141 *valLen =
sizeof (int);
17142 return SQL_SUCCESS;
17143 case SQL_COLUMN_UNSIGNED:
17145 *val2 = c->
nosign ? SQL_TRUE : SQL_FALSE;
17147 *valLen =
sizeof (int);
17148 return SQL_SUCCESS;
17149 case SQL_COLUMN_SCALE:
17150 case SQL_DESC_SCALE:
17154 *valLen =
sizeof (int);
17155 return SQL_SUCCESS;
17156 case SQL_COLUMN_PRECISION:
17157 case SQL_DESC_PRECISION:
17177 #ifdef SQL_TYPE_TIMESTAMP 17178 case SQL_TYPE_TIMESTAMP:
17180 case SQL_TIMESTAMP:
17188 *valLen =
sizeof (int);
17189 return SQL_SUCCESS;
17190 case SQL_COLUMN_MONEY:
17194 *valLen =
sizeof (int);
17195 return SQL_SUCCESS;
17196 case SQL_COLUMN_AUTO_INCREMENT:
17200 *valLen =
sizeof (int);
17201 return SQL_SUCCESS;
17202 case SQL_COLUMN_LENGTH:
17203 case SQL_DESC_LENGTH:
17207 *valLen =
sizeof (int);
17208 return SQL_SUCCESS;
17209 case SQL_COLUMN_NULLABLE:
17210 case SQL_DESC_NULLABLE:
17214 *valLen =
sizeof (int);
17215 return SQL_SUCCESS;
17216 case SQL_COLUMN_SEARCHABLE:
17218 *val2 = SQL_SEARCHABLE;
17220 *valLen =
sizeof (int);
17221 return SQL_SUCCESS;
17222 case SQL_COLUMN_CASE_SENSITIVE:
17226 *valLen =
sizeof (int);
17227 return SQL_SUCCESS;
17228 case SQL_COLUMN_UPDATABLE:
17232 *valLen =
sizeof (int);
17233 return SQL_SUCCESS;
17234 case SQL_DESC_COUNT:
17238 *valLen =
sizeof (int);
17239 return SQL_SUCCESS;
17240 case SQL_COLUMN_TYPE_NAME: {
17244 if (c->
type == SQL_WCHAR ||
17245 c->
type == SQL_WVARCHAR ||
17246 c->
type == SQL_WLONGVARCHAR) {
17248 if (strcasecmp(tn,
"varchar") == 0) {
17254 if (valc && valMax > 0) {
17255 strncpy(valc, tn, valMax);
17256 valc[valMax - 1] =
'\0';
17257 p = strchr(valc,
'(');
17260 while (p > valc &&
ISSPACE(p[-1])) {
17265 *valLen = strlen(valc);
17267 *valLen = strlen(tn);
17268 p = strchr(tn,
'(');
17271 while (p > tn &&
ISSPACE(p[-1])) {
17279 case SQL_COLUMN_OWNER_NAME:
17280 case SQL_COLUMN_QUALIFIER_NAME: {
17283 if (valc && valMax > 0) {
17284 strncpy(valc, z, valMax);
17285 valc[valMax - 1] =
'\0';
17287 *valLen = strlen(z);
17290 case SQL_COLUMN_TABLE_NAME:
17291 #if (SQL_COLUMN_TABLE_NAME != SQL_DESC_TABLE_NAME) 17292 case SQL_DESC_TABLE_NAME:
17294 #ifdef SQL_DESC_BASE_TABLE_NAME 17295 case SQL_DESC_BASE_TABLE_NAME:
17297 if (valc && valMax > 0) {
17298 strncpy(valc, c->
table, valMax);
17299 valc[valMax - 1] =
'\0';
17301 *valLen = strlen(c->
table);
17303 #ifdef SQL_DESC_NUM_PREC_RADIX 17304 case SQL_DESC_NUM_PREC_RADIX:
17310 #ifdef SQL_LONGVARCHAR 17311 case SQL_WLONGVARCHAR:
17316 #ifdef SQL_LONGVARCHAR 17317 case SQL_LONGVARCHAR:
17320 case SQL_VARBINARY:
17321 case SQL_LONGVARBINARY:
17328 *valLen =
sizeof (int);
17329 return SQL_SUCCESS;
17332 setstat(s, -1,
"unsupported column attributes %d",
"HY091",
id);
17350 SQLColAttributes(SQLHSTMT
stmt, SQLUSMALLINT col, SQLUSMALLINT
id,
17351 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17354 #if defined(_WIN32) || defined(_WIN64) 17355 SQLSMALLINT len = 0;
17360 #if defined(_WIN32) || defined(_WIN64) 17366 if (SQL_SUCCEEDED(ret)) {
17370 case SQL_COLUMN_LABEL:
17371 case SQL_COLUMN_NAME:
17372 case SQL_DESC_NAME:
17373 case SQL_COLUMN_TYPE_NAME:
17374 case SQL_COLUMN_OWNER_NAME:
17375 case SQL_COLUMN_QUALIFIER_NAME:
17376 case SQL_COLUMN_TABLE_NAME:
17377 #if (SQL_COLUMN_TABLE_NAME != SQL_DESC_TABLE_NAME) 17378 case SQL_DESC_TABLE_NAME:
17380 #ifdef SQL_DESC_BASE_COLUMN_NAME 17381 case SQL_DESC_BASE_COLUMN_NAME:
17383 #ifdef SQL_DESC_BASE_TABLE_NAME 17384 case SQL_DESC_BASE_TABLE_NAME:
17386 if (val && valMax > 0) {
17389 v = utf_to_wmb((
char *) val, SQL_NTS);
17391 strncpy(val, v, vmax);
17392 len =
min(vmax, strlen(v));
17397 v[vmax - 1] =
'\0';
17433 SQLColAttributesW(SQLHSTMT
stmt, SQLUSMALLINT col, SQLUSMALLINT
id,
17434 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17438 SQLSMALLINT len = 0;
17442 if (SQL_SUCCEEDED(ret)) {
17443 SQLWCHAR *v = NULL;
17446 case SQL_COLUMN_LABEL:
17447 case SQL_COLUMN_NAME:
17448 case SQL_DESC_NAME:
17449 case SQL_COLUMN_TYPE_NAME:
17450 case SQL_COLUMN_OWNER_NAME:
17451 case SQL_COLUMN_QUALIFIER_NAME:
17452 case SQL_COLUMN_TABLE_NAME:
17453 #if (SQL_COLUMN_TABLE_NAME != SQL_DESC_TABLE_NAME) 17454 case SQL_DESC_TABLE_NAME:
17456 #ifdef SQL_DESC_BASE_COLUMN_NAME 17457 case SQL_DESC_BASE_COLUMN_NAME:
17459 #ifdef SQL_DESC_BASE_TABLE_NAME 17460 case SQL_DESC_BASE_TABLE_NAME:
17462 if (val && valMax > 0) {
17463 int vmax = valMax /
sizeof (SQLWCHAR);
17470 len *=
sizeof (SQLWCHAR);
17473 v = (SQLWCHAR *) val;
17474 v[vmax - 1] =
'\0';
17504 drvcolattribute(SQLHSTMT
stmt, SQLUSMALLINT col, SQLUSMALLINT
id,
17505 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17511 char *valc = (
char *) val;
17514 if (
stmt == SQL_NULL_HSTMT) {
17515 return SQL_INVALID_HANDLE;
17521 if (col < 1 || col > s->
ncols) {
17522 setstat(s, -1,
"invalid column", (*s->
ov3) ?
"07009" :
"S1002");
17528 c = s->
cols + col - 1;
17530 case SQL_DESC_COUNT:
17533 case SQL_DESC_CATALOG_NAME:
17534 if (valc && valMax > 0) {
17535 strncpy(valc, c->
db, valMax);
17536 valc[valMax - 1] =
'\0';
17538 *valLen = strlen(c->
db);
17540 if (*valLen >= valMax) {
17541 setstat(s, -1,
"data right truncated",
"01004");
17542 return SQL_SUCCESS_WITH_INFO;
17545 case SQL_COLUMN_LENGTH:
17546 case SQL_DESC_LENGTH:
17549 case SQL_COLUMN_LABEL:
17551 if (valc && valMax > 0) {
17552 strncpy(valc, c->
label, valMax);
17553 valc[valMax - 1] =
'\0';
17555 *valLen = strlen(c->
label);
17559 case SQL_COLUMN_NAME:
17560 case SQL_DESC_NAME:
17561 if (valc && valMax > 0) {
17562 strncpy(valc, c->
column, valMax);
17563 valc[valMax - 1] =
'\0';
17565 *valLen = strlen(c->
column);
17567 case SQL_DESC_SCHEMA_NAME: {
17570 if (valc && valMax > 0) {
17571 strncpy(valc, z, valMax);
17572 valc[valMax - 1] =
'\0';
17574 *valLen = strlen(z);
17577 #ifdef SQL_DESC_BASE_COLUMN_NAME 17578 case SQL_DESC_BASE_COLUMN_NAME:
17579 if (strchr(c->
column,
'(') || strchr(c->
column,
')')) {
17582 }
else if (valc && valMax > 0) {
17583 strncpy(valc, c->
column, valMax);
17584 valc[valMax - 1] =
'\0';
17585 *valLen = strlen(c->
column);
17589 case SQL_DESC_TYPE_NAME: {
17593 if (c->
type == SQL_WCHAR ||
17594 c->
type == SQL_WVARCHAR ||
17595 c->
type == SQL_WLONGVARCHAR) {
17597 if (strcasecmp(tn,
"varchar") == 0) {
17603 if (valc && valMax > 0) {
17604 strncpy(valc, tn, valMax);
17605 valc[valMax - 1] =
'\0';
17606 p = strchr(valc,
'(');
17609 while (p > valc &&
ISSPACE(p[-1])) {
17614 *valLen = strlen(valc);
17616 *valLen = strlen(tn);
17617 p = strchr(tn,
'(');
17620 while (p > tn &&
ISSPACE(p[-1])) {
17628 case SQL_DESC_OCTET_LENGTH:
17631 if (c->
type == SQL_WCHAR ||
17632 c->
type == SQL_WVARCHAR ||
17633 c->
type == SQL_WLONGVARCHAR) {
17635 v *=
sizeof (SQLWCHAR);
17640 #if (SQL_COLUMN_TABLE_NAME != SQL_DESC_TABLE_NAME) 17641 case SQL_COLUMN_TABLE_NAME:
17643 #ifdef SQL_DESC_BASE_TABLE_NAME 17644 case SQL_DESC_BASE_TABLE_NAME:
17646 case SQL_DESC_TABLE_NAME:
17647 if (valc && valMax > 0) {
17648 strncpy(valc, c->
table, valMax);
17649 valc[valMax - 1] =
'\0';
17651 *valLen = strlen(c->
table);
17653 case SQL_DESC_TYPE:
17664 #ifdef SQL_LONGVARCHAR 17665 case SQL_WLONGVARCHAR:
17666 v = SQL_LONGVARCHAR;
17673 case SQL_DESC_CONCISE_TYPE:
17690 case SQL_TIMESTAMP:
17691 v = SQL_C_TIMESTAMP;
17699 #ifdef SQL_C_TYPE_TIMESTAMP 17700 case SQL_TYPE_TIMESTAMP:
17701 v = SQL_C_TYPE_TIMESTAMP;
17704 #ifdef SQL_C_TYPE_TIME 17705 case SQL_TYPE_TIME:
17706 v = SQL_C_TYPE_TIME;
17709 #ifdef SQL_C_TYPE_DATE 17710 case SQL_TYPE_DATE:
17711 v = SQL_C_TYPE_DATE;
17726 v = (s->
nowchar[0] || s->
nowchar[1]) ? SQL_C_CHAR : SQL_C_WCHAR;
17733 case SQL_DESC_UPDATABLE:
17736 case SQL_COLUMN_DISPLAY_SIZE:
17739 case SQL_COLUMN_UNSIGNED:
17740 v = c->
nosign ? SQL_TRUE : SQL_FALSE;
17742 case SQL_COLUMN_SEARCHABLE:
17743 v = SQL_SEARCHABLE;
17745 case SQL_COLUMN_SCALE:
17746 case SQL_DESC_SCALE:
17749 case SQL_COLUMN_PRECISION:
17750 case SQL_DESC_PRECISION:
17769 #ifdef SQL_TYPE_TIMESTAMP 17770 case SQL_TYPE_TIMESTAMP:
17772 case SQL_TIMESTAMP:
17780 case SQL_COLUMN_MONEY:
17783 case SQL_COLUMN_AUTO_INCREMENT:
17786 case SQL_DESC_NULLABLE:
17789 #ifdef SQL_DESC_NUM_PREC_RADIX 17790 case SQL_DESC_NUM_PREC_RADIX:
17795 #ifdef SQL_LONGVARCHAR 17796 case SQL_WLONGVARCHAR:
17801 #ifdef SQL_LONGVARCHAR 17802 case SQL_LONGVARCHAR:
17805 case SQL_VARBINARY:
17806 case SQL_LONGVARBINARY:
17815 setstat(s, -1,
"unsupported column attribute %d",
"HY091",
id);
17821 return SQL_SUCCESS;
17838 SQLColAttribute(SQLHSTMT
stmt, SQLUSMALLINT col, SQLUSMALLINT
id,
17839 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17842 #if defined(_WIN32) || defined(_WIN64) 17843 SQLSMALLINT len = 0;
17848 #if defined(_WIN32) || defined(_WIN64) 17850 ret = drvcolattribute(
stmt, col,
id, val, valMax, valLen,
17851 (SQLPOINTER) val2);
17854 ret = drvcolattribute(
stmt, col,
id, val, valMax, &len,
17855 (SQLPOINTER) val2);
17856 if (SQL_SUCCEEDED(ret)) {
17860 case SQL_DESC_SCHEMA_NAME:
17861 case SQL_DESC_CATALOG_NAME:
17862 case SQL_COLUMN_LABEL:
17863 case SQL_DESC_NAME:
17864 case SQL_DESC_TABLE_NAME:
17865 #ifdef SQL_DESC_BASE_TABLE_NAME 17866 case SQL_DESC_BASE_TABLE_NAME:
17868 #ifdef SQL_DESC_BASE_COLUMN_NAME 17869 case SQL_DESC_BASE_COLUMN_NAME:
17871 case SQL_DESC_TYPE_NAME:
17872 if (val && valMax > 0) {
17875 v = utf_to_wmb((
char *) val, SQL_NTS);
17877 strncpy(val, v, vmax);
17878 len =
min(vmax, strlen(v));
17883 v[vmax - 1] =
'\0';
17898 ret = drvcolattribute(
stmt, col,
id, val, valMax, valLen,
17899 (SQLPOINTER) val2);
17920 SQLColAttributeW(SQLHSTMT
stmt, SQLUSMALLINT col, SQLUSMALLINT
id,
17921 SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen,
17925 SQLSMALLINT len = 0;
17928 ret = drvcolattribute(
stmt, col,
id, val, valMax, &len,
17929 (SQLPOINTER) val2);
17930 if (SQL_SUCCEEDED(ret)) {
17931 SQLWCHAR *v = NULL;
17934 case SQL_DESC_SCHEMA_NAME:
17935 case SQL_DESC_CATALOG_NAME:
17936 case SQL_COLUMN_LABEL:
17937 case SQL_DESC_NAME:
17938 case SQL_DESC_TABLE_NAME:
17939 #ifdef SQL_DESC_BASE_TABLE_NAME 17940 case SQL_DESC_BASE_TABLE_NAME:
17942 #ifdef SQL_DESC_BASE_COLUMN_NAME 17943 case SQL_DESC_BASE_COLUMN_NAME:
17945 case SQL_DESC_TYPE_NAME:
17946 if (val && valMax > 0) {
17947 int vmax = valMax /
sizeof (SQLWCHAR);
17954 len *=
sizeof (SQLWCHAR);
17957 v = (SQLWCHAR *) val;
17958 v[vmax - 1] =
'\0';
17989 drverror(SQLHENV env, SQLHDBC
dbc, SQLHSTMT
stmt,
17990 SQLCHAR *sqlState, SQLINTEGER *nativeErr,
17991 SQLCHAR *errmsg, SQLSMALLINT errmax, SQLSMALLINT *errlen)
17995 SQLSMALLINT dummy2;
17997 if (env == SQL_NULL_HENV &&
17998 dbc == SQL_NULL_HDBC &&
17999 stmt == SQL_NULL_HSTMT) {
18000 return SQL_INVALID_HANDLE;
18003 sqlState[0] =
'\0';
18008 nativeErr = &dummy1;
18027 if (s->
logmsg[0] ==
'\0') {
18032 strcpy((
char *) sqlState, s->
sqlstate);
18033 if (errmax == SQL_NTS) {
18034 strcpy((
char *) errmsg,
"[SQLite]");
18035 strcat((
char *) errmsg, (
char *) s->
logmsg);
18036 *errlen = strlen((
char *) errmsg);
18038 strncpy((
char *) errmsg,
"[SQLite]", errmax);
18039 if (errmax - 8 > 0) {
18040 strncpy((
char *) errmsg + 8, (
char *) s->
logmsg, errmax - 8);
18042 *errlen =
min(strlen((
char *) s->
logmsg) + 8, errmax);
18046 return SQL_SUCCESS;
18057 strcpy((
char *) sqlState, d->
sqlstate);
18058 if (errmax == SQL_NTS) {
18059 strcpy((
char *) errmsg,
"[SQLite]");
18060 strcat((
char *) errmsg, (
char *) d->
logmsg);
18061 *errlen = strlen((
char *) errmsg);
18063 strncpy((
char *) errmsg,
"[SQLite]", errmax);
18064 if (errmax - 8 > 0) {
18065 strncpy((
char *) errmsg + 8, (
char *) d->
logmsg, errmax - 8);
18067 *errlen =
min(strlen((
char *) d->
logmsg) + 8, errmax);
18071 return SQL_SUCCESS;
18074 sqlState[0] =
'\0';
18078 return SQL_NO_DATA;
18096 SQLError(SQLHENV env, SQLHDBC
dbc, SQLHSTMT
stmt,
18097 SQLCHAR *sqlState, SQLINTEGER *nativeErr,
18098 SQLCHAR *errmsg, SQLSMALLINT errmax, SQLSMALLINT *errlen)
18100 return drverror(env,
dbc,
stmt, sqlState, nativeErr,
18101 errmsg, errmax, errlen);
18120 SQLErrorW(SQLHENV env, SQLHDBC
dbc, SQLHSTMT
stmt,
18121 SQLWCHAR *sqlState, SQLINTEGER *nativeErr,
18122 SQLWCHAR *errmsg, SQLSMALLINT errmax, SQLSMALLINT *errlen)
18125 SQLSMALLINT len = 0;
18128 ret = drverror(env,
dbc,
stmt, (SQLCHAR *) state, nativeErr,
18129 (SQLCHAR *) errmsg, errmax, &len);
18130 if (ret == SQL_SUCCESS) {
18133 6 *
sizeof (SQLWCHAR));
18137 SQLWCHAR *e = NULL;
18165 }
else if (ret == SQL_NO_DATA) {
18189 SQLMoreResults(SQLHSTMT
stmt)
18192 if (
stmt == SQL_NULL_HSTMT) {
18193 return SQL_INVALID_HANDLE;
18196 return SQL_NO_DATA;
18210 int ncols = *ncolsp, guessed_types = 0;
18211 SQLRETURN ret = SQL_SUCCESS;
18219 const char *colname, *
typename;
18220 #
if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME)
18224 for (i = size = 0; i < ncols; i++) {
18225 colname = sqlite3_column_name(s3stmt, i);
18226 size += 3 + 3 * strlen(colname);
18228 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME) 18229 tblname = (
char *) size;
18230 for (i = 0; i < ncols; i++) {
18231 p = (
char *) sqlite3_column_table_name(s3stmt, i);
18232 size += 2 + (p ? strlen(p) : 0);
18235 dyncols =
xmalloc(ncols *
sizeof (
COL) + size);
18241 p = (
char *) (dyncols + ncols);
18242 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME) 18245 for (i = 0; i < ncols; i++) {
18248 colname = sqlite3_column_name(s3stmt, i);
18250 fprintf(d->
trace,
"-- column %d name: '%s'\n",
18254 #if defined(HAVE_SQLITE3COLUMNTABLENAME) && (HAVE_SQLITE3COLUMNTABLENAME) 18255 q = (
char *) sqlite3_column_table_name(s3stmt, i);
18256 strcpy(tblname, q ? q :
"");
18258 fprintf(d->
trace,
"-- table %d name: '%s'\n",
18262 dyncols[i].
table = tblname;
18263 tblname += strlen(tblname) + 1;
18266 dyncols[i].
db = ((
DBC *) (s->
dbc))->dbname;
18267 strcpy(p, colname);
18268 dyncols[i].
label = p;
18269 p += strlen(p) + 1;
18270 q = strchr(colname,
'.');
18272 char *q2 = strchr(q + 1,
'.');
18280 #if !defined(HAVE_SQLITE3COLUMNTABLENAME) || !(HAVE_SQLITE3COLUMNTABLENAME) 18281 dyncols[i].
table = p;
18283 strncpy(p, colname, q - colname);
18284 p[q - colname] =
'\0';
18285 p += strlen(p) + 1;
18288 p += strlen(p) + 1;
18290 #if !defined(HAVE_SQLITE3COLUMNTABLENAME) || !(HAVE_SQLITE3COLUMNTABLENAME) 18291 dyncols[i].
table =
"";
18293 strcpy(p, colname);
18295 p += strlen(p) + 1;
18300 #ifdef SQL_LONGVARCHAR 18301 dyncols[i].
type = SQL_LONGVARCHAR;
18302 dyncols[i].
size = 65535;
18304 dyncols[i].
type = SQL_VARCHAR;
18305 dyncols[i].
size = 255;
18307 dyncols[i].
index = i;
18308 dyncols[i].
scale = 0;
18309 dyncols[i].
prec = 0;
18311 dyncols[i].
autoinc = SQL_FALSE;
18312 dyncols[i].
notnull = SQL_NULLABLE;
18313 dyncols[i].
ispk = -1;
18315 #ifdef FULL_METADATA 18316 s3stmt_addmeta(s3stmt, i, d, &dyncols[i]);
18339 drvprepare(SQLHSTMT
stmt, SQLCHAR *query, SQLINTEGER queryLen)
18346 if (
stmt == SQL_NULL_HSTMT) {
18347 return SQL_INVALID_HANDLE;
18350 if (s->
dbc == SQL_NULL_HDBC) {
18361 if (sret != SQL_SUCCESS) {
18370 setstat(s, -1,
"%s", (*s->
ov3) ?
"HY000" :
"S1000", errp);
18378 int ret, ncols, nretry = 0;
18380 sqlite3_stmt *s3stmt = NULL;
18382 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 18389 #if defined(HAVE_SQLITE3PREPAREV2) && (HAVE_SQLITE3PREPAREV2) 18390 ret = sqlite3_prepare_v2(d->
sqlite, (
char *) s->
query, -1,
18393 ret = sqlite3_prepare(d->
sqlite, (
char *) s->
query, -1,
18396 if (ret != SQLITE_OK) {
18398 sqlite3_finalize(s3stmt);
18402 }
while (ret == SQLITE_SCHEMA && (++nretry) < 2);
18404 if (ret != SQLITE_OK) {
18407 sqlite3_finalize(s3stmt);
18409 setstat(s, ret,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
18410 sqlite3_errmsg(d->
sqlite), ret);
18413 if (sqlite3_bind_parameter_count(s3stmt) != s->
nparams) {
18415 sqlite3_finalize(s3stmt);
18416 setstat(s, SQLITE_ERROR,
"parameter marker count incorrect",
18417 (*s->
ov3) ?
"HY000" :
"S1000");
18420 ncols = sqlite3_column_count(s3stmt);
18428 return SQL_SUCCESS;
18444 int rc, i, ncols = 0, nrows = 0, busy_count;
18447 if (
stmt == SQL_NULL_HSTMT) {
18448 return SQL_INVALID_HANDLE;
18451 if (s->
dbc == SQL_NULL_HDBC) {
18460 setstat(s, -1,
"no query prepared", (*s->
ov3) ?
"HY000" :
"S1000");
18465 setstat(s, -1,
"unbound parameters in query",
18466 (*s->
ov3) ?
"HY000" :
"S1000");
18469 for (i = 0; i < s->
nparams; i++) {
18478 if (lenp && *lenp < 0 && *lenp > SQL_LEN_DATA_AT_EXEC_OFFSET &&
18479 *lenp != SQL_NTS && *lenp != SQL_NULL_DATA &&
18480 *lenp != SQL_DATA_AT_EXEC) {
18481 setstat(s, -1,
"invalid length reference",
"HY009");
18484 if (lenp && (*lenp <= SQL_LEN_DATA_AT_EXEC_OFFSET ||
18485 *lenp == SQL_DATA_AT_EXEC)) {
18493 if (ret != SQL_SUCCESS) {
18502 for (i = 0; i < s->
nparams; i++) {
18509 if (p->
need <= 0 &&
18510 p->
lenp && (*p->
lenp <= SQL_LEN_DATA_AT_EXEC_OFFSET ||
18511 *p->
lenp == SQL_DATA_AT_EXEC)) {
18519 for (i = 0; i < s->
nparams; i++) {
18521 if (ret != SQL_SUCCESS) {
18528 s->
curtype == SQL_CURSOR_FORWARD_ONLY &&
18532 if (ret == SQL_SUCCESS) {
18539 if (rc == SQLITE_BUSY) {
18542 sqlite3_free(errp);
18545 for (i = 0; i < s->
nparams; i++) {
18552 if (!p->
lenp || (*p->
lenp > SQL_LEN_DATA_AT_EXEC_OFFSET &&
18553 *p->
lenp != SQL_DATA_AT_EXEC)) {
18562 if (rc != SQLITE_OK) {
18563 setstat(s, rc,
"%s (%d)", (*s->
ov3) ?
"HY000" :
"S1000",
18564 errp ? errp :
"unknown error", rc);
18566 sqlite3_free(errp);
18573 sqlite3_free(errp);
18582 nrows += sqlite3_changes(d->sqlite);
18586 if (s->
ncols != ncols) {
18590 setstat(s, -1,
"broken result set %d/%d",
18591 (*s->
ov3) ?
"HY000" :
"S1000", s->
ncols, ncols);
18603 for (i = 0; i < s->
nparams; i++) {
18614 }
else if (p->
lenp0 && p->
inc > 0) {
18617 if (!p->
lenp || (*p->
lenp > SQL_LEN_DATA_AT_EXEC_OFFSET &&
18618 *p->
lenp != SQL_DATA_AT_EXEC)) {
18627 }
else if (p->
lenp && (*p->
lenp <= SQL_LEN_DATA_AT_EXEC_OFFSET ||
18628 *p->
lenp == SQL_DATA_AT_EXEC)) {
18637 if (ret != SQL_NEED_DATA) {
18638 for (i = 0; i < s->
nparams; i++) {
18645 if (!p->
lenp || (*p->
lenp > SQL_LEN_DATA_AT_EXEC_OFFSET &&
18646 *p->
lenp != SQL_DATA_AT_EXEC)) {
18663 ret == SQL_SUCCESS && nrows == 0) {
18679 SQLPrepare(SQLHSTMT
stmt, SQLCHAR *query, SQLINTEGER queryLen)
18682 #if defined(_WIN32) || defined(_WIN64) 18687 #if defined(_WIN32) || defined(_WIN64) 18689 ret = drvprepare(
stmt, query, queryLen);
18692 q = wmb_to_utf_c((
char *) query, queryLen);
18697 query = (SQLCHAR *) q;
18698 queryLen = SQL_NTS;
18700 ret = drvprepare(
stmt, query, queryLen);
18701 #if defined(_WIN32) || defined(_WIN64) 18721 SQLPrepareW(SQLHSTMT
stmt, SQLWCHAR *query, SQLINTEGER queryLen)
18731 ret = drvprepare(
stmt, (SQLCHAR *) q, SQL_NTS);
18746 SQLExecute(SQLHSTMT
stmt)
18766 SQLExecDirect(SQLHSTMT
stmt, SQLCHAR *query, SQLINTEGER queryLen)
18769 #if defined(_WIN32) || defined(_WIN64) 18774 #if defined(_WIN32) || defined(_WIN64) 18776 ret = drvprepare(
stmt, query, queryLen);
18777 if (ret == SQL_SUCCESS) {
18782 q = wmb_to_utf_c((
char *) query, queryLen);
18787 query = (SQLCHAR *) q;
18788 queryLen = SQL_NTS;
18790 ret = drvprepare(
stmt, query, queryLen);
18791 if (ret == SQL_SUCCESS) {
18794 #if defined(_WIN32) || defined(_WIN64) 18814 SQLExecDirectW(SQLHSTMT
stmt, SQLWCHAR *query, SQLINTEGER queryLen)
18824 ret = drvprepare(
stmt, (SQLCHAR *) q, SQL_NTS);
18826 if (ret == SQL_SUCCESS) {
18836 #if defined(_WIN32) || defined(_WIN64) 18837 #ifndef WITHOUT_DRIVERMGR 18843 #include <windowsx.h> 18844 #include <winuser.h> 18846 #define MAXPATHLEN (259+1) 18847 #define MAXKEYLEN (15+1) 18848 #define MAXDESC (255+1) 18849 #define MAXDSNAME (255+1) 18850 #define MAXTONAME (32+1) 18851 #define MAXDBNAME MAXPATHLEN 18857 #define KEY_DBNAME 2 18859 #define KEY_DRIVER 4 18860 #define KEY_STEPAPI 5 18861 #define KEY_SYNCP 6 18862 #define KEY_NOTXN 7 18863 #define KEY_SHORTNAM 8 18864 #define KEY_LONGNAM 9 18865 #define KEY_NOCREAT 10 18866 #define KEY_NOWCHAR 11 18867 #define KEY_LOADEXT 12 18868 #define KEY_JMODE 13 18869 #define KEY_FKSUPPORT 14 18870 #define KEY_OEMCP 15 18871 #define KEY_BIGINT 16 18872 #define KEY_PASSWD 17 18873 #define KEY_JDCONV 18 18874 #define NUMOFKEYS 19 18878 char attr[MAXPATHLEN*4];
18884 ATTR attr[NUMOFKEYS];
18885 char DSN[MAXDSNAME];
18894 {
"DSN", KEY_DSN },
18895 {
"DESC", KEY_DESC },
18896 {
"Description", KEY_DESC},
18897 {
"Database", KEY_DBNAME },
18898 {
"Timeout", KEY_BUSY },
18899 {
"Driver", KEY_DRIVER },
18900 {
"StepAPI", KEY_STEPAPI },
18901 {
"SyncPragma", KEY_SYNCP },
18902 {
"NoTXN", KEY_NOTXN },
18903 {
"ShortNames", KEY_SHORTNAM },
18904 {
"LongNames", KEY_LONGNAM },
18905 {
"NoCreat", KEY_NOCREAT },
18906 {
"NoWCHAR", KEY_NOWCHAR },
18907 {
"LoadExt", KEY_LOADEXT },
18908 {
"JournalMode", KEY_JMODE },
18909 {
"FKSupport", KEY_FKSUPPORT },
18910 {
"OEMCP", KEY_OEMCP },
18911 {
"BigInt", KEY_BIGINT },
18912 {
"PWD", KEY_PASSWD },
18913 {
"JDConv", KEY_JDCONV },
18924 ParseAttributes(LPCSTR attribs, SETUPDLG *setupdlg)
18926 char *str = (
char *) attribs, *start, key[MAXKEYLEN];
18931 if ((str = strchr(str,
'=')) == NULL) {
18935 nkey = str - start;
18936 if (nkey <
sizeof (key)) {
18939 memcpy(key, start, nkey);
18941 for (i = 0; attrLookup[i].key; i++) {
18942 if (strcasecmp(attrLookup[i].key, key) == 0) {
18943 elem = attrLookup[i].ikey;
18949 while (*str && *str !=
';') {
18953 int end =
min(str - start,
sizeof (setupdlg->attr[elem].attr) - 1);
18955 setupdlg->attr[elem].supplied = TRUE;
18956 memcpy(setupdlg->attr[elem].attr, start, end);
18957 setupdlg->attr[elem].attr[end] =
'\0';
18971 SetDSNAttributes(HWND parent, SETUPDLG *setupdlg)
18973 char *dsn = setupdlg->attr[KEY_DSN].attr;
18975 if (setupdlg->newDSN && strlen(dsn) == 0) {
18978 if (!SQLWriteDSNToIni(dsn, setupdlg->driver)) {
18980 char buf[MAXPATHLEN], msg[MAXPATHLEN];
18982 LoadString(hModule, IDS_BADDSN, buf,
sizeof (buf));
18983 wsprintf(msg, buf, dsn);
18984 LoadString(hModule, IDS_MSGTITLE, buf,
sizeof (buf));
18985 MessageBox(parent, msg, buf,
18986 MB_ICONEXCLAMATION | MB_OK | MB_TASKMODAL |
18991 if (parent || setupdlg->attr[KEY_DESC].supplied) {
18992 SQLWritePrivateProfileString(dsn,
"Description",
18993 setupdlg->attr[KEY_DESC].attr,
18996 if (parent || setupdlg->attr[KEY_DBNAME].supplied) {
18997 SQLWritePrivateProfileString(dsn,
"Database",
18998 setupdlg->attr[KEY_DBNAME].attr,
19001 if (parent || setupdlg->attr[KEY_BUSY].supplied) {
19002 SQLWritePrivateProfileString(dsn,
"Timeout",
19003 setupdlg->attr[KEY_BUSY].attr,
19006 if (parent || setupdlg->attr[KEY_STEPAPI].supplied) {
19007 SQLWritePrivateProfileString(dsn,
"StepAPI",
19008 setupdlg->attr[KEY_STEPAPI].attr,
19011 if (parent || setupdlg->attr[KEY_SYNCP].supplied) {
19012 SQLWritePrivateProfileString(dsn,
"SyncPragma",
19013 setupdlg->attr[KEY_SYNCP].attr,
19016 if (parent || setupdlg->attr[KEY_NOTXN].supplied) {
19017 SQLWritePrivateProfileString(dsn,
"NoTXN",
19018 setupdlg->attr[KEY_NOTXN].attr,
19021 if (parent || setupdlg->attr[KEY_SHORTNAM].supplied) {
19022 SQLWritePrivateProfileString(dsn,
"ShortNames",
19023 setupdlg->attr[KEY_SHORTNAM].attr,
19026 if (parent || setupdlg->attr[KEY_LONGNAM].supplied) {
19027 SQLWritePrivateProfileString(dsn,
"LongNames",
19028 setupdlg->attr[KEY_LONGNAM].attr,
19031 if (parent || setupdlg->attr[KEY_NOCREAT].supplied) {
19032 SQLWritePrivateProfileString(dsn,
"NoCreat",
19033 setupdlg->attr[KEY_NOCREAT].attr,
19036 if (parent || setupdlg->attr[KEY_NOWCHAR].supplied) {
19037 SQLWritePrivateProfileString(dsn,
"NoWCHAR",
19038 setupdlg->attr[KEY_NOWCHAR].attr,
19041 if (parent || setupdlg->attr[KEY_FKSUPPORT].supplied) {
19042 SQLWritePrivateProfileString(dsn,
"FKSupport",
19043 setupdlg->attr[KEY_FKSUPPORT].attr,
19046 if (parent || setupdlg->attr[KEY_OEMCP].supplied) {
19047 SQLWritePrivateProfileString(dsn,
"OEMCP",
19048 setupdlg->attr[KEY_OEMCP].attr,
19051 if (parent || setupdlg->attr[KEY_LOADEXT].supplied) {
19052 SQLWritePrivateProfileString(dsn,
"LoadExt",
19053 setupdlg->attr[KEY_LOADEXT].attr,
19056 if (parent || setupdlg->attr[KEY_BIGINT].supplied) {
19057 SQLWritePrivateProfileString(dsn,
"BigInt",
19058 setupdlg->attr[KEY_BIGINT].attr,
19061 if (parent || setupdlg->attr[KEY_JDCONV].supplied) {
19062 SQLWritePrivateProfileString(dsn,
"JDConv",
19063 setupdlg->attr[KEY_JDCONV].attr,
19066 if (parent || setupdlg->attr[KEY_PASSWD].supplied) {
19067 SQLWritePrivateProfileString(dsn,
"PWD",
19068 setupdlg->attr[KEY_PASSWD].attr,
19071 if (setupdlg->attr[KEY_DSN].supplied &&
19072 strcasecmp(setupdlg->DSN, setupdlg->attr[KEY_DSN].attr)) {
19073 SQLRemoveDSNFromIni(setupdlg->DSN);
19084 GetAttributes(SETUPDLG *setupdlg)
19086 char *dsn = setupdlg->attr[KEY_DSN].attr;
19088 if (!setupdlg->attr[KEY_DESC].supplied) {
19089 SQLGetPrivateProfileString(dsn,
"Description",
"",
19090 setupdlg->attr[KEY_DESC].attr,
19091 sizeof (setupdlg->attr[KEY_DESC].attr),
19094 if (!setupdlg->attr[KEY_DBNAME].supplied) {
19095 SQLGetPrivateProfileString(dsn,
"Database",
"",
19096 setupdlg->attr[KEY_DBNAME].attr,
19097 sizeof (setupdlg->attr[KEY_DBNAME].attr),
19100 if (!setupdlg->attr[KEY_BUSY].supplied) {
19101 SQLGetPrivateProfileString(dsn,
"Timeout",
"100000",
19102 setupdlg->attr[KEY_BUSY].attr,
19103 sizeof (setupdlg->attr[KEY_BUSY].attr),
19106 if (!setupdlg->attr[KEY_STEPAPI].supplied) {
19107 SQLGetPrivateProfileString(dsn,
"StepAPI",
"0",
19108 setupdlg->attr[KEY_STEPAPI].attr,
19109 sizeof (setupdlg->attr[KEY_STEPAPI].attr),
19112 if (!setupdlg->attr[KEY_SYNCP].supplied) {
19113 SQLGetPrivateProfileString(dsn,
"SyncPragma",
"NORMAL",
19114 setupdlg->attr[KEY_SYNCP].attr,
19115 sizeof (setupdlg->attr[KEY_SYNCP].attr),
19118 if (!setupdlg->attr[KEY_NOTXN].supplied) {
19119 SQLGetPrivateProfileString(dsn,
"NoTXN",
"",
19120 setupdlg->attr[KEY_NOTXN].attr,
19121 sizeof (setupdlg->attr[KEY_NOTXN].attr),
19124 if (!setupdlg->attr[KEY_SHORTNAM].supplied) {
19125 SQLGetPrivateProfileString(dsn,
"ShortNames",
"",
19126 setupdlg->attr[KEY_SHORTNAM].attr,
19127 sizeof (setupdlg->attr[KEY_SHORTNAM].attr),
19130 if (!setupdlg->attr[KEY_LONGNAM].supplied) {
19131 SQLGetPrivateProfileString(dsn,
"LongNames",
"",
19132 setupdlg->attr[KEY_LONGNAM].attr,
19133 sizeof (setupdlg->attr[KEY_LONGNAM].attr),
19136 if (!setupdlg->attr[KEY_NOCREAT].supplied) {
19137 SQLGetPrivateProfileString(dsn,
"NoCreat",
"",
19138 setupdlg->attr[KEY_NOCREAT].attr,
19139 sizeof (setupdlg->attr[KEY_NOCREAT].attr),
19142 if (!setupdlg->attr[KEY_NOWCHAR].supplied) {
19143 SQLGetPrivateProfileString(dsn,
"NoWCHAR",
"",
19144 setupdlg->attr[KEY_NOWCHAR].attr,
19145 sizeof (setupdlg->attr[KEY_NOWCHAR].attr),
19148 if (!setupdlg->attr[KEY_FKSUPPORT].supplied) {
19149 SQLGetPrivateProfileString(dsn,
"FKSupport",
"",
19150 setupdlg->attr[KEY_FKSUPPORT].attr,
19151 sizeof (setupdlg->attr[KEY_FKSUPPORT].attr),
19154 if (!setupdlg->attr[KEY_OEMCP].supplied) {
19155 SQLGetPrivateProfileString(dsn,
"OEMCP",
"",
19156 setupdlg->attr[KEY_OEMCP].attr,
19157 sizeof (setupdlg->attr[KEY_OEMCP].attr),
19160 if (!setupdlg->attr[KEY_LOADEXT].supplied) {
19161 SQLGetPrivateProfileString(dsn,
"LoadExt",
"",
19162 setupdlg->attr[KEY_LOADEXT].attr,
19163 sizeof (setupdlg->attr[KEY_LOADEXT].attr),
19166 if (!setupdlg->attr[KEY_JMODE].supplied) {
19167 SQLGetPrivateProfileString(dsn,
"JournalMode",
"",
19168 setupdlg->attr[KEY_JMODE].attr,
19169 sizeof (setupdlg->attr[KEY_JMODE].attr),
19172 if (!setupdlg->attr[KEY_BIGINT].supplied) {
19173 SQLGetPrivateProfileString(dsn,
"BigInt",
"",
19174 setupdlg->attr[KEY_BIGINT].attr,
19175 sizeof (setupdlg->attr[KEY_BIGINT].attr),
19178 if (!setupdlg->attr[KEY_PASSWD].supplied) {
19179 SQLGetPrivateProfileString(dsn,
"PWD",
"",
19180 setupdlg->attr[KEY_PASSWD].attr,
19181 sizeof (setupdlg->attr[KEY_PASSWD].attr),
19184 if (!setupdlg->attr[KEY_JDCONV].supplied) {
19185 SQLGetPrivateProfileString(dsn,
"JDConv",
"",
19186 setupdlg->attr[KEY_JDCONV].attr,
19187 sizeof (setupdlg->attr[KEY_JDCONV].attr),
19198 GetDBFile(HWND hdlg)
19201 SETUPDLG *setupdlg = (SETUPDLG *) GetWindowLongPtr(hdlg, DWLP_USER);
19203 SETUPDLG *setupdlg = (SETUPDLG *) GetWindowLong(hdlg, DWL_USER);
19207 memset(&ofn, 0,
sizeof (ofn));
19208 ofn.lStructSize =
sizeof (ofn);
19209 ofn.hwndOwner = hdlg;
19211 ofn.hInstance = (HINSTANCE) GetWindowLongPtr(hdlg, GWLP_HINSTANCE);
19213 ofn.hInstance = (HINSTANCE) GetWindowLong(hdlg, GWL_HINSTANCE);
19215 ofn.lpstrFile = (LPTSTR) setupdlg->attr[KEY_DBNAME].attr;
19216 ofn.nMaxFile = MAXPATHLEN;
19217 ofn.Flags = OFN_HIDEREADONLY | OFN_PATHMUSTEXIST |
19218 OFN_NOCHANGEDIR | OFN_EXPLORER | OFN_FILEMUSTEXIST;
19219 if (GetOpenFileName(&ofn)) {
19220 SetDlgItemText(hdlg, IDC_DBNAME, setupdlg->attr[KEY_DBNAME].attr);
19221 setupdlg->attr[KEY_DBNAME].supplied = TRUE;
19234 static BOOL CALLBACK
19235 ConfigDlgProc(HWND hdlg, WORD wmsg, WPARAM wparam, LPARAM lparam)
19237 SETUPDLG *setupdlg = NULL;
19241 case WM_INITDIALOG:
19243 SetWindowLongPtr(hdlg, DWLP_USER, lparam);
19245 SetWindowLong(hdlg, DWL_USER, lparam);
19247 setupdlg = (SETUPDLG *) lparam;
19248 GetAttributes(setupdlg);
19249 SetDlgItemText(hdlg, IDC_DSNAME, setupdlg->attr[KEY_DSN].attr);
19250 SetDlgItemText(hdlg, IDC_DESC, setupdlg->attr[KEY_DESC].attr);
19251 SetDlgItemText(hdlg, IDC_DBNAME, setupdlg->attr[KEY_DBNAME].attr);
19252 SetDlgItemText(hdlg, IDC_TONAME, setupdlg->attr[KEY_BUSY].attr);
19253 SetDlgItemText(hdlg, IDC_LOADEXT, setupdlg->attr[KEY_LOADEXT].attr);
19254 SendDlgItemMessage(hdlg, IDC_DSNAME, EM_LIMITTEXT,
19255 (WPARAM) (MAXDSNAME - 1), (LPARAM) 0);
19256 SendDlgItemMessage(hdlg, IDC_DESC, EM_LIMITTEXT,
19257 (WPARAM) (MAXDESC - 1), (LPARAM) 0);
19258 SendDlgItemMessage(hdlg, IDC_DBNAME, EM_LIMITTEXT,
19259 (WPARAM) (MAXDBNAME - 1), (LPARAM) 0);
19260 SendDlgItemMessage(hdlg, IDC_TONAME, EM_LIMITTEXT,
19261 (WPARAM) (MAXTONAME - 1), (LPARAM) 0);
19262 SendDlgItemMessage(hdlg, IDC_LOADEXT, EM_LIMITTEXT,
19263 (WPARAM) (MAXPATHLEN*4 - 1), (LPARAM) 0);
19264 CheckDlgButton(hdlg, IDC_STEPAPI,
19265 getbool(setupdlg->attr[KEY_STEPAPI].attr) ?
19266 BST_CHECKED : BST_UNCHECKED);
19267 CheckDlgButton(hdlg, IDC_NOTXN,
19268 getbool(setupdlg->attr[KEY_NOTXN].attr) ?
19269 BST_CHECKED : BST_UNCHECKED);
19270 CheckDlgButton(hdlg, IDC_SHORTNAM,
19271 getbool(setupdlg->attr[KEY_SHORTNAM].attr) ?
19272 BST_CHECKED : BST_UNCHECKED);
19273 CheckDlgButton(hdlg, IDC_LONGNAM,
19274 getbool(setupdlg->attr[KEY_LONGNAM].attr) ?
19275 BST_CHECKED : BST_UNCHECKED);
19276 CheckDlgButton(hdlg, IDC_NOCREAT,
19277 getbool(setupdlg->attr[KEY_NOCREAT].attr) ?
19278 BST_CHECKED : BST_UNCHECKED);
19279 CheckDlgButton(hdlg, IDC_NOWCHAR,
19280 getbool(setupdlg->attr[KEY_NOWCHAR].attr) ?
19281 BST_CHECKED : BST_UNCHECKED);
19282 CheckDlgButton(hdlg, IDC_FKSUPPORT,
19283 getbool(setupdlg->attr[KEY_FKSUPPORT].attr) ?
19284 BST_CHECKED : BST_UNCHECKED);
19285 CheckDlgButton(hdlg, IDC_OEMCP,
19286 getbool(setupdlg->attr[KEY_OEMCP].attr) ?
19287 BST_CHECKED : BST_UNCHECKED);
19288 CheckDlgButton(hdlg, IDC_BIGINT,
19289 getbool(setupdlg->attr[KEY_BIGINT].attr) ?
19290 BST_CHECKED : BST_UNCHECKED);
19291 CheckDlgButton(hdlg, IDC_JDCONV,
19292 getbool(setupdlg->attr[KEY_JDCONV].attr) ?
19293 BST_CHECKED : BST_UNCHECKED);
19294 SendDlgItemMessage(hdlg, IDC_SYNCP,
19295 CB_LIMITTEXT, (WPARAM) 10, (LPARAM) 0);
19296 SendDlgItemMessage(hdlg, IDC_SYNCP,
19297 CB_ADDSTRING, 0, (LPARAM)
"NORMAL");
19298 SendDlgItemMessage(hdlg, IDC_SYNCP,
19299 CB_ADDSTRING, 0, (LPARAM)
"OFF");
19300 SendDlgItemMessage(hdlg, IDC_SYNCP,
19301 CB_ADDSTRING, 0, (LPARAM)
"FULL");
19302 SendDlgItemMessage(hdlg, IDC_SYNCP,
19303 CB_SELECTSTRING, (WPARAM) -1,
19304 (LPARAM) setupdlg->attr[KEY_SYNCP].attr);
19305 if (setupdlg->defDSN) {
19306 EnableWindow(GetDlgItem(hdlg, IDC_DSNAME), FALSE);
19307 EnableWindow(GetDlgItem(hdlg, IDC_DSNAMETEXT), FALSE);
19311 switch (GET_WM_COMMAND_ID(wparam, lparam)) {
19313 if (GET_WM_COMMAND_CMD(wparam, lparam) == EN_CHANGE) {
19314 char item[MAXDSNAME];
19316 EnableWindow(GetDlgItem(hdlg, IDOK),
19317 GetDlgItemText(hdlg, IDC_DSNAME,
19318 item,
sizeof (item)));
19327 setupdlg = (SETUPDLG *) GetWindowLongPtr(hdlg, DWLP_USER);
19329 setupdlg = (SETUPDLG *) GetWindowLong(hdlg, DWL_USER);
19331 if (!setupdlg->defDSN) {
19332 GetDlgItemText(hdlg, IDC_DSNAME,
19333 setupdlg->attr[KEY_DSN].attr,
19334 sizeof (setupdlg->attr[KEY_DSN].attr));
19336 GetDlgItemText(hdlg, IDC_DESC,
19337 setupdlg->attr[KEY_DESC].attr,
19338 sizeof (setupdlg->attr[KEY_DESC].attr));
19339 GetDlgItemText(hdlg, IDC_DBNAME,
19340 setupdlg->attr[KEY_DBNAME].attr,
19341 sizeof (setupdlg->attr[KEY_DBNAME].attr));
19342 GetDlgItemText(hdlg, IDC_TONAME,
19343 setupdlg->attr[KEY_BUSY].attr,
19344 sizeof (setupdlg->attr[KEY_BUSY].attr));
19345 GetDlgItemText(hdlg, IDC_LOADEXT,
19346 setupdlg->attr[KEY_LOADEXT].attr,
19347 sizeof (setupdlg->attr[KEY_LOADEXT].attr));
19348 index = SendDlgItemMessage(hdlg, IDC_SYNCP,
19349 CB_GETCURSEL, (WPARAM) 0, (LPARAM) 0);
19350 if (index != (WORD) CB_ERR) {
19351 SendDlgItemMessage(hdlg, IDC_SYNCP,
19352 CB_GETLBTEXT, index,
19353 (LPARAM) setupdlg->attr[KEY_SYNCP].attr);
19355 strcpy(setupdlg->attr[KEY_STEPAPI].attr,
19356 (IsDlgButtonChecked(hdlg, IDC_STEPAPI) == BST_CHECKED) ?
19358 strcpy(setupdlg->attr[KEY_NOTXN].attr,
19359 (IsDlgButtonChecked(hdlg, IDC_NOTXN) == BST_CHECKED) ?
19361 strcpy(setupdlg->attr[KEY_SHORTNAM].attr,
19362 (IsDlgButtonChecked(hdlg, IDC_SHORTNAM) == BST_CHECKED) ?
19364 strcpy(setupdlg->attr[KEY_LONGNAM].attr,
19365 (IsDlgButtonChecked(hdlg, IDC_LONGNAM) == BST_CHECKED) ?
19367 strcpy(setupdlg->attr[KEY_NOCREAT].attr,
19368 (IsDlgButtonChecked(hdlg, IDC_NOCREAT) == BST_CHECKED) ?
19370 strcpy(setupdlg->attr[KEY_NOWCHAR].attr,
19371 (IsDlgButtonChecked(hdlg, IDC_NOWCHAR) == BST_CHECKED) ?
19373 strcpy(setupdlg->attr[KEY_FKSUPPORT].attr,
19374 (IsDlgButtonChecked(hdlg, IDC_FKSUPPORT) == BST_CHECKED) ?
19376 strcpy(setupdlg->attr[KEY_OEMCP].attr,
19377 (IsDlgButtonChecked(hdlg, IDC_OEMCP) == BST_CHECKED) ?
19379 strcpy(setupdlg->attr[KEY_BIGINT].attr,
19380 (IsDlgButtonChecked(hdlg, IDC_BIGINT) == BST_CHECKED) ?
19382 strcpy(setupdlg->attr[KEY_JDCONV].attr,
19383 (IsDlgButtonChecked(hdlg, IDC_JDCONV) == BST_CHECKED) ?
19385 SetDSNAttributes(hdlg, setupdlg);
19388 EndDialog(hdlg, wparam);
19406 ConfigDSN(HWND hwnd, WORD request, LPCSTR driver, LPCSTR attribs)
19409 SETUPDLG *setupdlg;
19411 setupdlg = (SETUPDLG *)
xmalloc(
sizeof (SETUPDLG));
19412 if (setupdlg == NULL) {
19415 memset(setupdlg, 0,
sizeof (SETUPDLG));
19417 ParseAttributes(attribs, setupdlg);
19419 if (setupdlg->attr[KEY_DSN].supplied) {
19420 strcpy(setupdlg->DSN, setupdlg->attr[KEY_DSN].attr);
19422 setupdlg->DSN[0] =
'\0';
19424 if (request == ODBC_REMOVE_DSN) {
19425 if (!setupdlg->attr[KEY_DSN].supplied) {
19428 success = SQLRemoveDSNFromIni(setupdlg->attr[KEY_DSN].attr);
19431 setupdlg->parent = hwnd;
19432 setupdlg->driver = driver;
19433 setupdlg->newDSN = request == ODBC_ADD_DSN;
19434 setupdlg->defDSN = strcasecmp(setupdlg->attr[KEY_DSN].attr,
19437 success = DialogBoxParam(hModule, MAKEINTRESOURCE(CONFIGDSN),
19438 hwnd, (DLGPROC) ConfigDlgProc,
19439 (LPARAM) setupdlg) == IDOK;
19440 }
else if (setupdlg->attr[KEY_DSN].supplied) {
19441 success = SetDSNAttributes(hwnd, setupdlg);
19459 static BOOL CALLBACK
19460 DriverConnectProc(HWND hdlg, WORD wmsg, WPARAM wparam, LPARAM lparam)
19462 SETUPDLG *setupdlg;
19466 case WM_INITDIALOG:
19468 SetWindowLongPtr(hdlg, DWLP_USER, lparam);
19470 SetWindowLong(hdlg, DWL_USER, lparam);
19472 setupdlg = (SETUPDLG *) lparam;
19473 SetDlgItemText(hdlg, IDC_DSNAME, setupdlg->attr[KEY_DSN].attr);
19474 SetDlgItemText(hdlg, IDC_DESC, setupdlg->attr[KEY_DESC].attr);
19475 SetDlgItemText(hdlg, IDC_DBNAME, setupdlg->attr[KEY_DBNAME].attr);
19476 SetDlgItemText(hdlg, IDC_TONAME, setupdlg->attr[KEY_BUSY].attr);
19477 SetDlgItemText(hdlg, IDC_LOADEXT, setupdlg->attr[KEY_LOADEXT].attr);
19478 SendDlgItemMessage(hdlg, IDC_DSNAME, EM_LIMITTEXT,
19479 (WPARAM) (MAXDSNAME - 1), (LPARAM) 0);
19480 SendDlgItemMessage(hdlg, IDC_DESC, EM_LIMITTEXT,
19481 (WPARAM) (MAXDESC - 1), (LPARAM) 0);
19482 SendDlgItemMessage(hdlg, IDC_DBNAME, EM_LIMITTEXT,
19483 (WPARAM) (MAXDBNAME - 1), (LPARAM) 0);
19484 SendDlgItemMessage(hdlg, IDC_TONAME, EM_LIMITTEXT,
19485 (WPARAM) (MAXTONAME - 1), (LPARAM) 0);
19486 SendDlgItemMessage(hdlg, IDC_LOADEXT, EM_LIMITTEXT,
19487 (WPARAM) (MAXPATHLEN*4 - 1), (LPARAM) 0);
19488 CheckDlgButton(hdlg, IDC_STEPAPI,
19489 getbool(setupdlg->attr[KEY_STEPAPI].attr) ?
19490 BST_CHECKED : BST_UNCHECKED);
19491 CheckDlgButton(hdlg, IDC_NOTXN,
19492 getbool(setupdlg->attr[KEY_NOTXN].attr) ?
19493 BST_CHECKED : BST_UNCHECKED);
19494 CheckDlgButton(hdlg, IDC_SHORTNAM,
19495 getbool(setupdlg->attr[KEY_SHORTNAM].attr) ?
19496 BST_CHECKED : BST_UNCHECKED);
19497 CheckDlgButton(hdlg, IDC_LONGNAM,
19498 getbool(setupdlg->attr[KEY_LONGNAM].attr) ?
19499 BST_CHECKED : BST_UNCHECKED);
19500 CheckDlgButton(hdlg, IDC_NOCREAT,
19501 getbool(setupdlg->attr[KEY_NOCREAT].attr) ?
19502 BST_CHECKED : BST_UNCHECKED);
19503 CheckDlgButton(hdlg, IDC_NOWCHAR,
19504 getbool(setupdlg->attr[KEY_NOWCHAR].attr) ?
19505 BST_CHECKED : BST_UNCHECKED);
19506 CheckDlgButton(hdlg, IDC_FKSUPPORT,
19507 getbool(setupdlg->attr[KEY_FKSUPPORT].attr) ?
19508 BST_CHECKED : BST_UNCHECKED);
19509 CheckDlgButton(hdlg, IDC_OEMCP,
19510 getbool(setupdlg->attr[KEY_OEMCP].attr) ?
19511 BST_CHECKED : BST_UNCHECKED);
19512 CheckDlgButton(hdlg, IDC_BIGINT,
19513 getbool(setupdlg->attr[KEY_BIGINT].attr) ?
19514 BST_CHECKED : BST_UNCHECKED);
19515 CheckDlgButton(hdlg, IDC_JDCONV,
19516 getbool(setupdlg->attr[KEY_JDCONV].attr) ?
19517 BST_CHECKED : BST_UNCHECKED);
19518 SendDlgItemMessage(hdlg, IDC_SYNCP,
19519 CB_LIMITTEXT, (WPARAM) 10, (LPARAM) 0);
19520 SendDlgItemMessage(hdlg, IDC_SYNCP,
19521 CB_ADDSTRING, 0, (LPARAM)
"NORMAL");
19522 SendDlgItemMessage(hdlg, IDC_SYNCP,
19523 CB_ADDSTRING, 0, (LPARAM)
"OFF");
19524 SendDlgItemMessage(hdlg, IDC_SYNCP,
19525 CB_ADDSTRING, 0, (LPARAM)
"FULL");
19526 SendDlgItemMessage(hdlg, IDC_SYNCP,
19527 CB_SELECTSTRING, (WORD) -1,
19528 (LPARAM) setupdlg->attr[KEY_SYNCP].attr);
19529 if (setupdlg->defDSN) {
19530 EnableWindow(GetDlgItem(hdlg, IDC_DSNAME), FALSE);
19531 EnableWindow(GetDlgItem(hdlg, IDC_DSNAMETEXT), FALSE);
19535 switch (GET_WM_COMMAND_ID(wparam, lparam)) {
19541 setupdlg = (SETUPDLG *) GetWindowLongPtr(hdlg, DWLP_USER);
19543 setupdlg = (SETUPDLG *) GetWindowLong(hdlg, DWL_USER);
19545 GetDlgItemText(hdlg, IDC_DSNAME,
19546 setupdlg->attr[KEY_DSN].attr,
19547 sizeof (setupdlg->attr[KEY_DSN].attr));
19548 GetDlgItemText(hdlg, IDC_DBNAME,
19549 setupdlg->attr[KEY_DBNAME].attr,
19550 sizeof (setupdlg->attr[KEY_DBNAME].attr));
19551 GetDlgItemText(hdlg, IDC_TONAME,
19552 setupdlg->attr[KEY_BUSY].attr,
19553 sizeof (setupdlg->attr[KEY_BUSY].attr));
19554 GetDlgItemText(hdlg, IDC_LOADEXT,
19555 setupdlg->attr[KEY_LOADEXT].attr,
19556 sizeof (setupdlg->attr[KEY_LOADEXT].attr));
19557 index = SendDlgItemMessage(hdlg, IDC_SYNCP,
19558 CB_GETCURSEL, (WPARAM) 0, (LPARAM) 0);
19559 if (index != (WORD) CB_ERR) {
19560 SendDlgItemMessage(hdlg, IDC_SYNCP,
19561 CB_GETLBTEXT, index,
19562 (LPARAM) setupdlg->attr[KEY_SYNCP].attr);
19564 strcpy(setupdlg->attr[KEY_STEPAPI].attr,
19565 (IsDlgButtonChecked(hdlg, IDC_STEPAPI) == BST_CHECKED) ?
19567 strcpy(setupdlg->attr[KEY_NOTXN].attr,
19568 (IsDlgButtonChecked(hdlg, IDC_NOTXN) == BST_CHECKED) ?
19570 strcpy(setupdlg->attr[KEY_SHORTNAM].attr,
19571 (IsDlgButtonChecked(hdlg, IDC_SHORTNAM) == BST_CHECKED) ?
19573 strcpy(setupdlg->attr[KEY_LONGNAM].attr,
19574 (IsDlgButtonChecked(hdlg, IDC_LONGNAM) == BST_CHECKED) ?
19576 strcpy(setupdlg->attr[KEY_NOCREAT].attr,
19577 (IsDlgButtonChecked(hdlg, IDC_NOCREAT) == BST_CHECKED) ?
19579 strcpy(setupdlg->attr[KEY_NOWCHAR].attr,
19580 (IsDlgButtonChecked(hdlg, IDC_NOWCHAR) == BST_CHECKED) ?
19582 strcpy(setupdlg->attr[KEY_FKSUPPORT].attr,
19583 (IsDlgButtonChecked(hdlg, IDC_FKSUPPORT) == BST_CHECKED) ?
19585 strcpy(setupdlg->attr[KEY_OEMCP].attr,
19586 (IsDlgButtonChecked(hdlg, IDC_OEMCP) == BST_CHECKED) ?
19588 strcpy(setupdlg->attr[KEY_BIGINT].attr,
19589 (IsDlgButtonChecked(hdlg, IDC_BIGINT) == BST_CHECKED) ?
19591 strcpy(setupdlg->attr[KEY_JDCONV].attr,
19592 (IsDlgButtonChecked(hdlg, IDC_JDCONV) == BST_CHECKED) ?
19596 EndDialog(hdlg, GET_WM_COMMAND_ID(wparam, lparam) == IDOK);
19618 SQLCHAR *connIn, SQLSMALLINT connInLen,
19619 SQLCHAR *connOut, SQLSMALLINT connOutMax,
19620 SQLSMALLINT *connOutLen, SQLUSMALLINT drvcompl)
19622 BOOL maybeprompt, prompt = FALSE, defaultdsn = FALSE;
19624 SETUPDLG *setupdlg;
19626 char *dsn = NULL, *driver = NULL, *dbname = NULL;
19628 if (
dbc == SQL_NULL_HDBC) {
19629 return SQL_INVALID_HANDLE;
19633 setstatd(d, -1,
"connection already established",
"08002");
19636 setupdlg = (SETUPDLG *)
xmalloc(
sizeof (SETUPDLG));
19637 if (setupdlg == NULL) {
19640 memset(setupdlg, 0,
sizeof (SETUPDLG));
19641 maybeprompt = drvcompl == SQL_DRIVER_COMPLETE ||
19642 drvcompl == SQL_DRIVER_COMPLETE_REQUIRED;
19643 if (connIn == NULL || !connInLen ||
19644 (connInLen == SQL_NTS && !connIn[0])) {
19647 ParseAttributes((LPCSTR) connIn, setupdlg);
19648 if (!setupdlg->attr[KEY_DSN].attr[0] &&
19649 drvcompl == SQL_DRIVER_COMPLETE_REQUIRED) {
19650 strcpy(setupdlg->attr[KEY_DSN].attr,
"DEFAULT");
19653 GetAttributes(setupdlg);
19654 if (drvcompl == SQL_DRIVER_PROMPT ||
19656 !setupdlg->attr[KEY_DBNAME].attr[0])) {
19664 setupdlg->defDSN = setupdlg->attr[KEY_DRIVER].attr[0] !=
'\0';
19665 dlgret = DialogBoxParam(hModule, MAKEINTRESOURCE(DRIVERCONNECT),
19666 hwnd, (DLGPROC) DriverConnectProc,
19667 (LPARAM) setupdlg);
19669 if (!dlgret || dlgret == -1) {
19671 return SQL_NO_DATA;
19674 dsn = setupdlg->attr[KEY_DSN].attr;
19675 driver = setupdlg->attr[KEY_DRIVER].attr;
19676 dbname = setupdlg->attr[KEY_DBNAME].attr;
19677 if (connOut || connOutLen) {
19678 char buf[SQL_MAX_MESSAGE_LENGTH * 8];
19680 char dsn_0 = (dsn && !defaultdsn) ? dsn[0] :
'\0';
19681 char drv_0 = driver ? driver[0] :
'\0';
19684 count = snprintf(buf,
sizeof (buf),
19685 "%s%s%s%s%s%sDatabase=%s;StepAPI=%s;" 19686 "SyncPragma=%s;NoTXN=%s;Timeout=%s;" 19687 "ShortNames=%s;LongNames=%s;" 19688 "NoCreat=%s;NoWCHAR=%s;" 19689 "FKSupport=%s;JournalMode=%s;OEMCP=%s;LoadExt=%s;" 19690 "BigInt=%s;JDConv=%s;PWD=%s",
19691 dsn_0 ?
"DSN=" :
"",
19694 drv_0 ?
"Driver=" :
"",
19695 drv_0 ? driver :
"",
19697 dbname ? dbname :
"",
19698 setupdlg->attr[KEY_STEPAPI].attr,
19699 setupdlg->attr[KEY_SYNCP].attr,
19700 setupdlg->attr[KEY_NOTXN].attr,
19701 setupdlg->attr[KEY_BUSY].attr,
19702 setupdlg->attr[KEY_SHORTNAM].attr,
19703 setupdlg->attr[KEY_LONGNAM].attr,
19704 setupdlg->attr[KEY_NOCREAT].attr,
19705 setupdlg->attr[KEY_NOWCHAR].attr,
19706 setupdlg->attr[KEY_FKSUPPORT].attr,
19707 setupdlg->attr[KEY_JMODE].attr,
19708 setupdlg->attr[KEY_OEMCP].attr,
19709 setupdlg->attr[KEY_LOADEXT].attr,
19710 setupdlg->attr[KEY_BIGINT].attr,
19711 setupdlg->attr[KEY_JDCONV].attr,
19712 setupdlg->attr[KEY_PASSWD].attr);
19714 buf[
sizeof (buf) - 1] =
'\0';
19716 len =
min(connOutMax - 1, strlen(buf));
19718 strncpy((
char *) connOut, buf, len);
19719 connOut[len] =
'\0';
19726 char tracef[SQL_MAX_MESSAGE_LENGTH];
19729 SQLGetPrivateProfileString(setupdlg->attr[KEY_DSN].attr,
19730 "tracefile",
"", tracef,
19732 if (tracef[0] !=
'\0') {
19733 d->
trace = fopen(tracef,
"a");
19744 d->
pwdLen = strlen(setupdlg->attr[KEY_PASSWD].attr);
19745 d->
pwd = (d->
pwdLen > 0) ? setupdlg->attr[KEY_PASSWD].attr : NULL;
19746 ret =
dbopen(d, dbname ? dbname :
"", 0,
19748 setupdlg->attr[KEY_STEPAPI].attr,
19749 setupdlg->attr[KEY_SYNCP].attr,
19750 setupdlg->attr[KEY_NOTXN].attr,
19751 setupdlg->attr[KEY_JMODE].attr,
19752 setupdlg->attr[KEY_BUSY].attr);
19753 if (ret != SQL_SUCCESS) {
19754 if (maybeprompt && !prompt) {
19759 memset(setupdlg->attr[KEY_PASSWD].attr, 0,
19760 sizeof (setupdlg->attr[KEY_PASSWD].attr));
19761 if (ret == SQL_SUCCESS) {
19762 dbloadext(d, setupdlg->attr[KEY_LOADEXT].attr);
19786 SQLDriverConnect(SQLHDBC
dbc, SQLHWND hwnd,
19787 SQLCHAR *connIn, SQLSMALLINT connInLen,
19788 SQLCHAR *connOut, SQLSMALLINT connOutMax,
19789 SQLSMALLINT *connOutLen, SQLUSMALLINT drvcompl)
19795 connOut, connOutMax, connOutLen, drvcompl);
19816 SQLDriverConnectW(SQLHDBC
dbc, SQLHWND hwnd,
19817 SQLWCHAR *connIn, SQLSMALLINT connInLen,
19818 SQLWCHAR *connOut, SQLSMALLINT connOutMax,
19819 SQLSMALLINT *connOutLen, SQLUSMALLINT drvcompl)
19823 SQLSMALLINT len = 0;
19827 #if defined(_WIN32) || defined(_WIN64) 19828 if (connInLen == SQL_NTS) {
19831 ci = uc_to_wmb(connIn, connInLen);
19838 setstatd(d, -1,
"out of memory", (*d->
ov3) ?
"HY000" :
"S1000");
19844 (SQLCHAR *) connOut, connOutMax, &len, drvcompl);
19847 if (ret == SQL_SUCCESS) {
19848 SQLWCHAR *co = NULL;
19852 #if defined(_WIN32) || defined(_WIN64) 19853 co = wmb_to_uc((
char *) connOut, len);
19858 uc_strncpy(connOut, co, connOutMax /
sizeof (SQLWCHAR));
19859 len =
min(connOutMax /
sizeof (SQLWCHAR),
uc_strlen(co));
19880 #if defined(_WIN32) || defined(_WIN64) 19891 LibMain(HANDLE hinst, DWORD reason, LPVOID reserved)
19896 case DLL_PROCESS_ATTACH:
19904 #ifdef SQLITE_DYNLOAD 19907 #ifdef SQLITE_HAS_CODEC 19908 sqlite3_activate_see(SQLITE_ACTIVATION_KEY);
19911 #if defined(ENABLE_NVFS) && (ENABLE_NVFS) 19915 case DLL_THREAD_ATTACH:
19917 case DLL_PROCESS_DETACH:
19919 #ifdef SQLITE_DYNLOAD 19924 case DLL_THREAD_DETACH:
19941 DllMain(HANDLE hinst, DWORD reason, LPVOID reserved)
19943 return LibMain(hinst, reason, reserved);
19946 #ifndef WITHOUT_INSTALLER 19955 InUnError(
char *name)
19960 WORD errlen, errmax =
sizeof (errmsg) - 1;
19966 sqlret = SQLInstallerError(err, &code, errmsg, errmax, &errlen);
19967 if (SQL_SUCCEEDED(sqlret)) {
19968 MessageBox(NULL, errmsg, name,
19969 MB_ICONSTOP | MB_OK | MB_TASKMODAL | MB_SETFOREGROUND);
19973 }
while (sqlret != SQL_NO_DATA);
19984 InUn(
int remove,
char *cmdline)
19986 #ifdef SQLITE_HAS_CODEC 19987 static char *drivername =
"SQLite3 ODBC Driver (SEE)";
19988 static char *dsname =
"SQLite3 SEE Datasource";
19990 static char *drivername =
"SQLite3 ODBC Driver";
19991 static char *dsname =
"SQLite3 Datasource";
19994 char dllbuf[301], path[301], driver[300], attr[300], inst[400];
19995 WORD pathmax =
sizeof (path) - 1, pathlen;
19996 DWORD usecnt, mincnt;
20000 GetModuleFileName(hModule, dllbuf,
sizeof (dllbuf));
20001 p = strrchr(dllbuf,
'\\');
20002 dllname = p ? (p + 1) : dllbuf;
20003 quiet = cmdline && strstr(cmdline,
"quiet");
20004 if (SQLInstallDriverManager(path, pathmax, &pathlen)) {
20005 sprintf(driver,
"%s;Driver=%s;Setup=%s;",
20006 drivername, dllname, dllname);
20016 SQLInstallDriverEx(driver, NULL, path, pathmax, NULL,
20017 ODBC_INSTALL_INQUIRY, &usecnt);
20018 pathlen = strlen(path);
20019 while (pathlen > 0 && path[pathlen - 1] ==
'\\') {
20021 path[pathlen] =
'\0';
20023 sprintf(driver,
"%s;Driver=%s\\%s;Setup=%s\\%s;",
20024 drivername, path, dllname, path, dllname);
20032 sprintf(inst,
"%s\\%s", path, dllname);
20033 if (!
remove && usecnt > 0) {
20035 if (GetFileAttributesA(dllbuf) != INVALID_FILE_ATTRIBUTES &&
20036 CopyFile(dllbuf, inst, 0)) {
20040 sprintf(buf,
"%s replaced.", drivername);
20041 MessageBox(NULL, buf,
"Info",
20042 MB_ICONINFORMATION | MB_OK | MB_TASKMODAL |
20048 mincnt =
remove ? 1 : 0;
20049 while (usecnt != mincnt) {
20050 if (!SQLRemoveDriver(driver, TRUE, &usecnt)) {
20055 if (usecnt && !SQLRemoveDriver(driver, TRUE, &usecnt)) {
20056 InUnError(
"SQLRemoveDriver");
20064 sprintf(buf,
"%s uninstalled.", drivername);
20065 MessageBox(NULL, buf,
"Info",
20066 MB_ICONINFORMATION |MB_OK | MB_TASKMODAL |
20070 sprintf(attr,
"DSN=%s;Database=;", dsname);
20078 SQLConfigDataSource(NULL, ODBC_REMOVE_SYS_DSN, drivername, attr);
20081 if (GetFileAttributesA(dllbuf) == INVALID_FILE_ATTRIBUTES) {
20084 if (strcasecmp(dllbuf, inst) != 0 && !CopyFile(dllbuf, inst, 0)) {
20087 sprintf(buf,
"Copy %s to %s failed.", dllbuf, inst);
20088 MessageBox(NULL, buf,
"CopyFile",
20089 MB_ICONSTOP |MB_OK | MB_TASKMODAL | MB_SETFOREGROUND);
20092 if (!SQLInstallDriverEx(driver, path, path, pathmax, &pathlen,
20093 ODBC_INSTALL_COMPLETE, &usecnt)) {
20094 InUnError(
"SQLInstallDriverEx");
20097 sprintf(attr,
"DSN=%s;Database=;", dsname);
20105 SQLConfigDataSource(NULL, ODBC_REMOVE_SYS_DSN, drivername, attr);
20106 if (!SQLConfigDataSource(NULL, ODBC_ADD_SYS_DSN, drivername, attr)) {
20107 InUnError(
"SQLConfigDataSource");
20113 sprintf(buf,
"%s installed.", drivername);
20114 MessageBox(NULL, buf,
"Info",
20115 MB_ICONINFORMATION | MB_OK | MB_TASKMODAL |
20119 InUnError(
"SQLInstallDriverManager");
20134 install(HWND hwnd, HINSTANCE hinst, LPSTR lpszCmdLine,
int nCmdShow)
20136 InUn(0, lpszCmdLine);
20148 uninstall(HWND hwnd, HINSTANCE hinst, LPSTR lpszCmdLine,
int nCmdShow)
20150 InUn(1, lpszCmdLine);
20155 #ifndef WITHOUT_SHELL 20166 setargv(
int *argcp,
char ***argvp,
char *cmdline,
char *argv0)
20168 char *p, *arg, *argspace, **argv;
20169 int argc, size, inquote, copy, slashes;
20171 size = 2 + (argv0 ? 1 : 0);
20172 for (p = cmdline; *p !=
'\0'; p++) {
20183 argspace = malloc(size *
sizeof (
char *) + strlen(cmdline) + 1);
20184 argv = (
char **) argspace;
20185 argspace += size *
sizeof (
char *);
20189 argv[argc++] = argv0;
20192 for (; argc < size; argc++) {
20193 argv[argc] = arg = argspace;
20204 while (*p ==
'\\') {
20209 if ((slashes & 1) == 0) {
20211 if (inquote && p[1] ==
'"') {
20215 inquote = !inquote;
20225 if (*p ==
'\0' || (!inquote &&
ISSPACE(*p))) {
20235 argspace = arg + 1;
20251 shell(HWND hwnd, HINSTANCE hinst, LPSTR lpszCmdLine,
int nCmdShow)
20253 int argc, needcon = 0;
20255 extern int sqlite3_main(
int,
char **);
20256 static const char *name =
"SQLite3 Shell";
20257 DWORD ftype0, ftype1, ftype2;
20259 ftype0 = GetFileType(GetStdHandle(STD_INPUT_HANDLE));
20260 ftype1 = GetFileType(GetStdHandle(STD_OUTPUT_HANDLE));
20261 ftype2 = GetFileType(GetStdHandle(STD_ERROR_HANDLE));
20262 if (ftype0 != FILE_TYPE_DISK && ftype0 != FILE_TYPE_CHAR &&
20263 ftype0 != FILE_TYPE_PIPE) {
20266 ftype0 = FILE_TYPE_UNKNOWN;
20268 if (ftype1 != FILE_TYPE_DISK && ftype1 != FILE_TYPE_CHAR &&
20269 ftype1 != FILE_TYPE_PIPE) {
20272 ftype1 = FILE_TYPE_UNKNOWN;
20274 if (ftype2 != FILE_TYPE_DISK && ftype2 != FILE_TYPE_CHAR &&
20275 ftype2 != FILE_TYPE_PIPE) {
20278 ftype2 = FILE_TYPE_UNKNOWN;
20282 SetConsoleTitle(name);
20284 if (ftype0 == FILE_TYPE_UNKNOWN) {
20285 freopen(
"CONIN$",
"r", stdin);
20287 if (ftype1 == FILE_TYPE_UNKNOWN) {
20288 freopen(
"CONOUT$",
"w", stdout);
20290 if (ftype2 == FILE_TYPE_UNKNOWN) {
20291 freopen(
"CONOUT$",
"w", stderr);
20293 setargv(&argc, &argv, lpszCmdLine, (
char *) name);
20294 #if defined(ENABLE_NVFS) && (ENABLE_NVFS) 20297 sqlite3_main(argc, argv);
20304 #if defined(HAVE_ODBCINSTEXT_H) && (HAVE_ODBCINSTEXT_H) 20311 #include <odbcinstext.h> 20314 ODBCINSTGetProperties(HODBCINSTPROPERTY prop)
20316 static const char *instYN[] = {
"No",
"Yes", NULL };
20317 static const char *syncPragma[] = {
"NORMAL",
"OFF",
"FULL", NULL };
20318 static const char *jmPragma[] = {
20319 "DELETE",
"PERSIST",
"OFF",
"TRUNCATE",
"MEMORY",
"WAL", NULL
20322 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20323 prop = prop->pNext;
20324 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20325 prop->nPromptType = ODBCINST_PROMPTTYPE_FILENAME;
20326 strncpy(prop->szName,
"Database", INI_MAX_PROPERTY_NAME);
20327 strncpy(prop->szValue,
"", INI_MAX_PROPERTY_VALUE);
20328 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20329 prop = prop->pNext;
20330 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20331 prop->nPromptType = ODBCINST_PROMPTTYPE_TEXTEDIT;
20332 strncpy(prop->szName,
"Timeout", INI_MAX_PROPERTY_NAME);
20333 strncpy(prop->szValue,
"100000", INI_MAX_PROPERTY_VALUE);
20334 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20335 prop = prop->pNext;
20336 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20337 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20338 prop->aPromptData = malloc(
sizeof (instYN));
20339 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20340 strncpy(prop->szName,
"StepAPI", INI_MAX_PROPERTY_NAME);
20341 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20342 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20343 prop = prop->pNext;
20344 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20345 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20346 prop->aPromptData = malloc(
sizeof (instYN));
20347 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20348 strncpy(prop->szName,
"ShortNames", INI_MAX_PROPERTY_NAME);
20349 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20350 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20351 prop = prop->pNext;
20352 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20353 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20354 prop->aPromptData = malloc(
sizeof (instYN));
20355 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20356 strncpy(prop->szName,
"LongNames", INI_MAX_PROPERTY_NAME);
20357 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20358 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20359 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20360 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20361 prop->aPromptData = malloc(
sizeof (instYN));
20362 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20363 strncpy(prop->szName,
"NoCreat", INI_MAX_PROPERTY_NAME);
20364 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20366 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20367 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20368 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20369 prop->aPromptData = malloc(
sizeof (instYN));
20370 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20371 strncpy(prop->szName,
"NoWCHAR", INI_MAX_PROPERTY_NAME);
20372 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20374 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20375 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20376 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20377 prop->aPromptData = malloc(
sizeof (instYN));
20378 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20379 strncpy(prop->szName,
"FKSupport", INI_MAX_PROPERTY_NAME);
20380 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20381 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20382 prop = prop->pNext;
20383 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20384 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20385 prop->aPromptData = malloc(
sizeof (syncPragma));
20386 memcpy(prop->aPromptData, syncPragma, sizeof (syncPragma));
20387 strncpy(prop->szName,
"SyncPragma", INI_MAX_PROPERTY_NAME);
20388 strncpy(prop->szValue,
"NORMAL", INI_MAX_PROPERTY_VALUE);
20389 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20390 prop = prop->pNext;
20391 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20392 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20393 prop->aPromptData = malloc(
sizeof (jmPragma));
20394 memcpy(prop->aPromptData, jmPragma, sizeof (jmPragma));
20395 strncpy(prop->szName,
"JournalMode", INI_MAX_PROPERTY_NAME);
20396 strncpy(prop->szValue,
"DELETE", INI_MAX_PROPERTY_VALUE);
20397 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20398 prop = prop->pNext;
20399 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20400 prop->nPromptType = ODBCINST_PROMPTTYPE_TEXTEDIT;
20401 strncpy(prop->szName,
"LoadExt", INI_MAX_PROPERTY_NAME);
20402 strncpy(prop->szValue,
"", INI_MAX_PROPERTY_VALUE);
20403 prop->pNext = (HODBCINSTPROPERTY) malloc(
sizeof (ODBCINSTPROPERTY));
20404 memset(prop, 0,
sizeof (ODBCINSTPROPERTY));
20405 prop->nPromptType = ODBCINST_PROMPTTYPE_COMBOBOX;
20406 prop->aPromptData = malloc(
sizeof (instYN));
20407 memcpy(prop->aPromptData, instYN, sizeof (instYN));
20408 strncpy(prop->szName,
"BigInt", INI_MAX_PROPERTY_NAME);
20409 strncpy(prop->szValue,
"No", INI_MAX_PROPERTY_VALUE);
20415 #ifdef SQLITE_DYNLOAD 20429 return SQLITE_ERROR;
20438 static sqlite_int64
20456 static const char *
20465 return SQLITE_NULL;
20468 #define DLS_ENT(name, func) \ 20469 { "sqlite3_" #name, offsetof(struct dl_sqlite3_funcs, name), \ 20472 #define DLS_ENT3(name, off, func) \ 20473 { "sqlite3_" #name, offsetof(struct dl_sqlite3_funcs, off), \ 20476 #define DLS_END { NULL, 0, NULL } 20482 } dls_nametab[] = {
20483 DLS_ENT(activate_see, dls_void),
20484 DLS_ENT(bind_blob, dls_error),
20485 DLS_ENT(bind_double, dls_error),
20486 DLS_ENT(bind_int, dls_error),
20487 DLS_ENT(bind_int64, dls_error),
20488 DLS_ENT(bind_null, dls_error),
20489 DLS_ENT(bind_parameter_count, dls_0),
20490 DLS_ENT(bind_text, dls_error),
20492 DLS_ENT(changes, dls_0),
20493 DLS_ENT(close, dls_error),
20494 DLS_ENT(column_blob, dls_null),
20495 DLS_ENT(column_bytes, dls_0),
20496 DLS_ENT(column_count, dls_0),
20497 DLS_ENT(column_database_name, dls_empty),
20498 DLS_ENT(column_decltype, dls_empty),
20499 DLS_ENT(column_double, dls_00),
20500 DLS_ENT(column_name, dls_empty),
20501 DLS_ENT(column_origin_name, dls_null),
20502 DLS_ENT(column_table_name, dls_null),
20503 DLS_ENT(column_text, dls_null),
20504 DLS_ENT(column_type, dls_snull),
20505 DLS_ENT(create_function, dls_error),
20506 DLS_ENT(enable_load_extension, dls_error),
20507 DLS_ENT(errcode, dls_error),
20508 DLS_ENT(errmsg, dls_empty),
20509 DLS_ENT(exec, dls_error),
20510 DLS_ENT(finalize, dls_error),
20511 DLS_ENT(free, free),
20512 DLS_ENT(free_table, dls_void),
20513 DLS_ENT(get_table, dls_error),
20514 DLS_ENT(interrupt, dls_void),
20515 DLS_ENT(key, dls_error),
20516 DLS_ENT(last_insert_rowid, dls_0LL),
20517 DLS_ENT(libversion, dls_empty),
20518 DLS_ENT(load_extension, dls_error),
20519 DLS_ENT(malloc, malloc),
20520 DLS_ENT(mprintf, dls_null),
20521 DLS_ENT(open, dls_error),
20522 DLS_ENT(open16, dls_error),
20523 DLS_ENT(open_v2, dls_error),
20524 DLS_ENT(prepare, dls_error),
20525 DLS_ENT(prepare_v2, dls_error),
20526 DLS_ENT(profile, dls_null),
20527 DLS_ENT(realloc, realloc),
20528 DLS_ENT(rekey, dls_error),
20529 DLS_ENT(reset, dls_error),
20530 DLS_ENT(result_blob, dls_void),
20531 DLS_ENT(result_error, dls_void),
20532 DLS_ENT(result_int, dls_void),
20533 DLS_ENT(result_null, dls_void),
20534 DLS_ENT(step, dls_error),
20535 #if defined(_WIN32) || defined(_WIN64) 20536 DLS_ENT3(strnicmp, xstrnicmp, _strnicmp),
20538 DLS_ENT3(strnicmp, xstrnicmp, strncasecmp),
20540 DLS_ENT(table_column_metadata, dls_error),
20541 DLS_ENT(trace, dls_null),
20542 DLS_ENT(user_data, dls_null),
20543 DLS_ENT(value_blob, dls_null),
20544 DLS_ENT(value_bytes, dls_0),
20545 DLS_ENT(value_text, dls_empty),
20546 DLS_ENT(value_type, dls_snull),
20550 #if defined(_WIN32) || defined(_WIN64) 20552 static HMODULE sqlite3_dll = 0;
20558 static const char *dll_names[] = {
20559 "System.Data.SQLite.dll",
20565 while (dll_names[i]) {
20566 sqlite3_dll = LoadLibrary(dll_names[i]);
20573 while (dls_nametab[i].name) {
20574 void *func = 0, **loc;
20577 func = (
void *) GetProcAddress(sqlite3_dll, dls_nametab[i].name);
20580 func = dls_nametab[i].func;
20582 loc = (
void **) ((
char *) &dls_funcs + dls_nametab[i].offset);
20586 if (!sqlite3_dll) {
20587 char buf[MAXPATHLEN], msg[MAXPATHLEN];
20589 LoadString(hModule, IDS_DRVTITLE, buf,
sizeof (buf));
20590 LoadString(hModule, IDS_DLLERR, msg,
sizeof (msg));
20591 MessageBox(NULL, msg, buf,
20592 MB_ICONEXCLAMATION | MB_OK | MB_TASKMODAL |
20601 FreeLibrary(sqlite3_dll);
20610 static void *libsqlite3_so = 0;
20617 libsqlite3_so = dlopen(
"libsqlite3.so.0", RTLD_NOW | RTLD_GLOBAL);
20619 while (dls_nametab[i].name) {
20620 void *func = 0, **loc;
20622 if (libsqlite3_so) {
20623 func = dlsym(libsqlite3_so, dls_nametab[i].name);
20626 func = dls_nametab[i].func;
20628 loc = (
void **) ((
char *) &dls_funcs + dls_nametab[i].offset);
20632 if (!libsqlite3_so) {
20633 const char errmsg[] =
"SQLite3 shared library not found.\n";
20635 write(2, errmsg,
sizeof (errmsg) - 1);
20642 if (libsqlite3_so) {
20643 dlclose(libsqlite3_so);
sqlite3_stmt * s3stmt
SQLite statement handle or NULL.
SQLULEN paramset_size
SQL_ATTR_PARAMSET_SIZE.
sqlite_int64 s3lival
SQLite3 64bit integer value.
int busyint
Interrupt busy handler from SQLCancel()
static SQLRETURN setupparbuf(STMT *s, BINDPARM *p)
Setup parameter buffer for deferred parameter.
void * parbuf
Buffer for SQL_LEN_DATA_AT_EXEC etc.
SQLRETURN SQL_API SQLSetConnectAttrW(SQLHDBC dbc, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER len)
Set connect attribute of HDBC (UNICODE version).
Internal dynamic string buffer.
SQLRETURN SQL_API SQLSetDescRec(SQLHDESC handle, SQLSMALLINT recno, SQLSMALLINT type, SQLSMALLINT subtype, SQLLEN len, SQLSMALLINT prec, SQLSMALLINT scale, SQLPOINTER data, SQLLEN *strlen, SQLLEN *indicator)
Function not implemented.
SQLRETURN SQL_API SQLRowCount(SQLHSTMT stmt, SQLLEN *nrows)
Return number of affected rows of HSTMT.
static SQLRETURN setposbind(STMT *s, sqlite3_stmt *stmt, int i, int si, int rsi)
Internal handler to setup parameters for positional updates from bound user buffers.
static SQLRETURN nomem(STMT *s)
Report S1000 (out of memory) SQL error given STMT.
static const char lower_chars[]
static int findcol(char **cols, int ncols, char *name)
Find column given name in string array.
int longnames
Don't shorten column names.
int nocreat
Don't auto create database file.
static void freerows(char **rowp)
Free counted array of char pointers.
SQLRETURN SQL_API SQLDisconnect(SQLHDBC dbc)
Disconnect given HDBC.
static void setstatd(DBC *d, int naterr, char *msg, char *st,...)
Set error message and SQL state on DBC.
struct dbc * dbcs
Pointer to first DBC.
void * param0
Parameter buffer, initial value.
int * ov3
True for SQL_OV_ODBC3.
static SQLRETURN freeparams(STMT *s)
Clear out parameter bindings, if any.
int dobigint
Force SQL_BIGINT for INTEGER columns.
SQLCHAR * query
Current query, raw string.
sqlite3 * sqlite
SQLITE database handle.
static SQLRETURN drvgettypeinfo(SQLHSTMT stmt, SQLSMALLINT sqltype)
Internal return data type information.
SQLRETURN SQL_API SQLConnectW(SQLHDBC dbc, SQLWCHAR *dsn, SQLSMALLINT dsnLen, SQLWCHAR *uid, SQLSMALLINT uidLen, SQLWCHAR *pwd, SQLSMALLINT pwdLen)
Connect to SQLite database.
int guessed_types
Flag for drvprepare()/drvexecute()
SQLRETURN SQL_API SQLForeignKeysW(SQLHSTMT stmt, SQLWCHAR *PKcatalog, SQLSMALLINT PKcatalogLen, SQLWCHAR *PKschema, SQLSMALLINT PKschemaLen, SQLWCHAR *PKtable, SQLSMALLINT PKtableLen, SQLWCHAR *FKcatalog, SQLSMALLINT FKcatalogLen, SQLWCHAR *FKschema, SQLSMALLINT FKschemaLen, SQLWCHAR *FKtable, SQLSMALLINT FKtableLen)
Retrieve information about primary/foreign keys (UNICODE version).
static SQLRETURN drvfetchscroll(SQLHSTMT stmt, SQLSMALLINT orient, SQLINTEGER offset)
Internal fetch function for SQLFetchScroll() and SQLExtendedFetch().
SQLRETURN SQL_API SQLParamData(SQLHSTMT stmt, SQLPOINTER *pind)
Retrieve next parameter for sending data to executing query.
static SQLRETURN drvfreeconnect(SQLHDBC dbc)
Internal free connection (HDBC).
SQLCHAR logmsg[1024]
Message for SQLError()
static dstr * dsappend(dstr *dsp, const char *str)
Append string to dynamic string.
static SQLRETURN drvgetcursorname(SQLHSTMT stmt, SQLCHAR *cursor, SQLSMALLINT buflen, SQLSMALLINT *lenp)
Internal function to get cursor name of STMT.
char ** rows
2-dim array, result set
int step_enable
True for sqlite_compile/step/finalize.
SQLRETURN SQL_API SQLColumnsW(SQLHSTMT stmt, SQLWCHAR *cat, SQLSMALLINT catLen, SQLWCHAR *schema, SQLSMALLINT schemaLen, SQLWCHAR *table, SQLSMALLINT tableLen, SQLWCHAR *col, SQLSMALLINT colLen)
Retrieve column information on table (UNICODE version).
static int drvgettable_row(TBLRES *t, int ncol, int rc)
static void blob_import(sqlite3_context *ctx, int nargs, sqlite3_value **args)
SQLite function to import a BLOB from a file.
SQLRETURN SQL_API SQLFetchScroll(SQLHSTMT stmt, SQLSMALLINT orient, SQLLEN offset)
Fetch result row with scrolling.
static void s3bind(DBC *d, sqlite3_stmt *stmt, int nparams, BINDPARM *p)
int ispk
Flag for primary key (> 0)
static SQLRETURN dofetchbind(STMT *s, int rsi)
Internal: fetch and bind from statement's current row.
PTRDIFF_T ndata
index into result array
SQLRETURN SQL_API SQLSetConnectOptionW(SQLHDBC dbc, SQLUSMALLINT opt, SQLULEN param)
Set option on HDBC (UNICODE version).
int intrans
True when transaction started.
int shortnames
Always use short column names.
static SQLRETURN drvgetconnectoption(SQLHDBC dbc, SQLUSMALLINT opt, SQLPOINTER param)
Internal get connect option of HDBC.
static SQLRETURN drvallocconnect(SQLHENV env, SQLHDBC *dbc)
Internal allocate HDBC.
SQLULEN * parm_bind_offs
SQL_ATTR_PARAM_BIND_OFFSET_PTR.
void * s3val
SQLite3 value buffer.
static int str2time(int jdconv, char *str, TIME_STRUCT *ts)
Convert string to ODBC TIME_STRUCT.
Internal structure for bound column (SQLBindCol).
static COL pkeySpec2[]
Columns for result set of SQLPrimaryKeys().
SQLRETURN SQL_API SQLGetInfoW(SQLHDBC dbc, SQLUSMALLINT type, SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen)
Return information about what this ODBC driver supports.
static COL fkeySpec2[]
Columns for result set of SQLForeignKeys().
static void freedyncols(STMT *s)
Free dynamically allocated column descriptions of STMT.
int nrows
Number of result rows.
static int mapsqltype(const char *typename, int *nosign, int ov3, int nowchar, int dobigint)
Map SQL field type from string to ODBC integer type code.
SQLRETURN SQL_API SQLCancel(SQLHSTMT stmt)
Cancel HSTMT closing cursor.
static void getmd(const char *typename, int sqltype, int *mp, int *dp)
Get maximum display size and number of digits after decimal point from field type specification...
SQLRETURN SQL_API SQLAllocEnv(SQLHENV *env)
Allocate HENV.
Driver internal structure for database connection (HDBC).
SQLRETURN SQL_API SQLFreeConnect(SQLHDBC dbc)
Free connection (HDBC).
SQLRETURN SQL_API SQLExtendedFetch(SQLHSTMT stmt, SQLUSMALLINT orient, SQLROWOFFSET offset, SQLROWSETSIZE *rowcount, SQLUSMALLINT *rowstatus)
Fetch result row with scrolling and row status.
SQLULEN row_count0
Row count.
int s3ival
SQLite3 integer value.
struct stmt * cur_s3stmt
Current STMT executing sqlite statement.
int need
True when SQL_LEN_DATA_AT_EXEC.
static int checkddl(char *sql)
Check if query is a DDL statement.
static const char digit_chars[]
static SQLRETURN drvgetdiagfield(SQLSMALLINT htype, SQLHANDLE handle, SQLSMALLINT recno, SQLSMALLINT id, SQLPOINTER info, SQLSMALLINT buflen, SQLSMALLINT *stringlen)
Get error record given handle (HDBC or HSTMT).
SQLULEN parm_bind_type
SQL_ATTR_PARAM_BIND_TYPE.
int * ov3
True for SQL_OV_ODBC3.
static SQLRETURN drvfreestmt(SQLHSTMT stmt, SQLUSMALLINT opt)
Internal function to perform certain kinds of free/close on STMT.
SQLULEN * row_count
Row count pointer.
SQLRETURN SQL_API SQLNativeSqlW(SQLHSTMT stmt, SQLWCHAR *sqlin, SQLINTEGER sqlinLen, SQLWCHAR *sql, SQLINTEGER sqlMax, SQLINTEGER *sqlLen)
Translate SQL string (UNICODE version).
static SQLRETURN drvallocenv(SQLHENV *env)
Internal allocate HENV.
static COL procSpec2[]
Columns for result set of SQLProcedures().
char sqlstate[6]
SQL state for SQLError()
static SQLRETURN drvprimarykeys(SQLHSTMT stmt, SQLCHAR *cat, SQLSMALLINT catLen, SQLCHAR *schema, SQLSMALLINT schemaLen, SQLCHAR *table, SQLSMALLINT tableLen)
Internal retrieve information about indexed columns.
int inc
Increment for paramset size > 1.
static int getdsnattr(char *dsn, char *attr, char *out, int outLen)
Handling of SQLConnect() connection attributes for standalone operation without driver manager...
static void s3stmt_end(STMT *s)
Stop running sqlite statement.
SQLRETURN SQL_API SQLSetDescFieldW(SQLHDESC handle, SQLSMALLINT recno, SQLSMALLINT fieldid, SQLPOINTER value, SQLINTEGER buflen)
Function not implemented.
char * column
Column name.
int version
SQLITE version number.
char * dsn
ODBC data source name.
static const char space_chars[]
SQLRETURN SQL_API SQLDescribeColW(SQLHSTMT stmt, SQLUSMALLINT col, SQLWCHAR *name, SQLSMALLINT nameMax, SQLSMALLINT *nameLen, SQLSMALLINT *type, SQLULEN *size, SQLSMALLINT *digits, SQLSMALLINT *nullable)
Describe column information (UNICODE version).
static SQLRETURN drvdisconnect(SQLHDBC dbc)
Internal disconnect given HDBC.
static SQLRETURN drvsetconnectoption(SQLHDBC dbc, SQLUSMALLINT opt, SQLUINTEGER param)
Internal set option on HDBC.
int curtype
Default cursor type.
Driver internal structure representing SQL statement (HSTMT).
SQLRETURN SQL_API SQLGetEnvAttr(SQLHENV env, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER len, SQLINTEGER *lenp)
Get information of HENV.
SQLUINTEGER paramset_nrows
Row count for paramset handling.
static int typeinfosort(const void *a, const void *b)
Helper function to sort type information.
int autocommit
Auto commit state.
SQLCHAR logmsg[1024]
Message for SQLError()
static SQLRETURN drvsetpos(SQLHSTMT stmt, SQLSETPOSIROW row, SQLUSMALLINT op, SQLUSMALLINT lock)
Internal set position on result in HSTMT.
static SQLRETURN drvgetstmtoption(SQLHSTMT stmt, SQLUSMALLINT opt, SQLPOINTER param)
Internal get option of HSTMT.
int isrowid
Flag for ROWID column (> 0)
SQLRETURN SQL_API SQLGetStmtOptionW(SQLHSTMT stmt, SQLUSMALLINT opt, SQLPOINTER param)
Get option of HSTMT (UNICODE version).
int prec
Precision of column.
ENV * env
Pointer to environment.
char buffer[1]
String buffer.
SQLRETURN SQL_API SQLProcedureColumnsW(SQLHSTMT stmt, SQLWCHAR *catalog, SQLSMALLINT catalogLen, SQLWCHAR *schema, SQLSMALLINT schemaLen, SQLWCHAR *proc, SQLSMALLINT procLen, SQLWCHAR *column, SQLSMALLINT columnLen)
Retrieve information about columns in result set of stored procedures (UNICODE version).
static void dbtrace(void *arg, const char *msg, sqlite_uint64 et)
SQLite trace or profile callback.
static void mktypeinfo(STMT *s, int row, int asize, char *typename, int type, int tind)
Internal function to build up data type information as row in result set.
SQLRETURN SQL_API SQLGetConnectOptionW(SQLHDBC dbc, SQLUSMALLINT opt, SQLPOINTER param)
Get connect option of HDBC (UNICODE version).
SQLRETURN SQL_API SQLTransact(SQLHENV env, SQLHDBC dbc, SQLUSMALLINT type)
Commit or rollback transaction.
static void blob_export(sqlite3_context *ctx, int nargs, sqlite3_value **args)
SQLite function to export a BLOB to a file.
static SQLRETURN drvgetinfo(SQLHDBC dbc, SQLUSMALLINT type, SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen)
Internal return information about what this ODBC driver supports.
int nrow
number of rows in result array
static COL procColSpec3[]
static double ln_strtod(const char *data, char **endp)
Internal locale neutral strtod function.
static SQLRETURN drvcolumns(SQLHSTMT stmt, SQLCHAR *cat, SQLSMALLINT catLen, SQLCHAR *schema, SQLSMALLINT schemaLen, SQLCHAR *table, SQLSMALLINT tableLen, SQLCHAR *col, SQLSMALLINT colLen)
Internal retrieve column information on table.
static SQLRETURN drvputdata(SQLHSTMT stmt, SQLPOINTER data, SQLLEN len)
Internal put (partial) parameter data into executing statement.
static int mapdeftype(int type, int stype, int nosign, int nowchar)
Map SQL_C_DEFAULT to proper C type.
static SQLRETURN SQL_API drvforeignkeys(SQLHSTMT stmt, SQLCHAR *PKcatalog, SQLSMALLINT PKcatalogLen, SQLCHAR *PKschema, SQLSMALLINT PKschemaLen, SQLCHAR *PKtable, SQLSMALLINT PKtableLen, SQLCHAR *FKcatalog, SQLSMALLINT FKcatalogLen, SQLCHAR *FKschema, SQLSMALLINT FKschemaLen, SQLCHAR *FKtable, SQLSMALLINT FKtableLen)
Internal retrieve information about primary/foreign keys.
int pool
True for SQL_CP_ONE_PER_DRIVER.
BINDPARM * bindparms
Array of bound parameters.
#define SETSTMTOPTION_LAST_ARG_TYPE
COL * cols
Result column array.
static SQLRETURN noconn(STMT *s)
Report S1000 (not connected) SQL error given STMT.
SQLULEN bind_type
SQL_ATTR_ROW_BIND_TYPE.
SQLRETURN SQL_API SQLPutData(SQLHSTMT stmt, SQLPOINTER data, SQLLEN len)
Put (partial) parameter data into executing statement.
SQLRETURN SQL_API SQLBindParam(SQLHSTMT stmt, SQLUSMALLINT pnum, SQLSMALLINT vtype, SQLSMALLINT ptype, SQLULEN lenprec, SQLSMALLINT scale, SQLPOINTER val, SQLLEN *lenp)
Bind parameter on HSTMT.
SQLRETURN SQL_API SQLCopyDesc(SQLHDESC source, SQLHDESC target)
Function not implemented.
static SQLRETURN mkresultset(HSTMT stmt, COL *colspec, int ncols, COL *colspec3, int ncols3, int *nret)
Setup empty result set from constant column specification.
SQLPOINTER valp
Value buffer.
SQLRETURN SQL_API SQLFreeStmt(SQLHSTMT stmt, SQLUSMALLINT opt)
Free HSTMT.
SQLRETURN SQL_API SQLBulkOperations(SQLHSTMT stmt, SQLSMALLINT oper)
Perform bulk operation on HSTMT.
int ov3
True for SQL_OV_ODBC3.
SQLRETURN SQL_API SQLGetDiagFieldW(SQLSMALLINT htype, SQLHANDLE handle, SQLSMALLINT recno, SQLSMALLINT id, SQLPOINTER info, SQLSMALLINT buflen, SQLSMALLINT *stringlen)
Get error record given handle (HDBC or HSTMT).
static int namematch(char *str, char *pat, int esc)
SQL LIKE string match with optional backslash escape handling.
SQLUSMALLINT * parm_oper
SQL_ATTR_PARAM_OPERATION_PTR.
static SQLWCHAR * uc_strncpy(SQLWCHAR *dest, SQLWCHAR *src, int len)
Copy UNICODE string like strncpy().
static SQLWCHAR * uc_from_utf(unsigned char *str, int len)
Make UNICODE string from UTF8 string.
char * dbname
SQLITE database name.
SQLRETURN SQL_API SQLEndTran(SQLSMALLINT type, SQLHANDLE handle, SQLSMALLINT comptype)
Commit or rollback transaction.
SQLRETURN SQL_API SQLFetch(SQLHSTMT stmt)
Fetch next result row.
static SQLRETURN mkbindcols(STMT *s, int ncols)
Reallocate space for bound columns.
int fksupport
Foreign keys on or off.
SQLRETURN SQL_API SQLSetCursorNameW(SQLHSTMT stmt, SQLWCHAR *cursor, SQLSMALLINT len)
Set cursor name on STMT (UNICODE version).
int s3stmt_needmeta
True to get meta data in s3stmt_step().
int rowprs
Current start row of rowset.
SQLRETURN SQL_API SQLDescribeParam(SQLHSTMT stmt, SQLUSMALLINT pnum, SQLSMALLINT *dtype, SQLULEN *size, SQLSMALLINT *decdigits, SQLSMALLINT *nullable)
Return information about parameter.
static SQLRETURN drvdriverconnect(SQLHDBC dbc, SQLHWND hwnd, SQLCHAR *connIn, SQLSMALLINT connInLen, SQLCHAR *connOut, SQLSMALLINT connOutMax, SQLSMALLINT *connOutLen, SQLUSMALLINT drvcompl)
Internal standalone (w/o driver manager) database connect.
static SQLRETURN drvallocstmt(SQLHDBC dbc, SQLHSTMT *stmt)
Allocate HSTMT given HDBC (driver internal version).
#define strmak(dst, src, max, lenp)
int rc
SQLite return code.
SQLRETURN SQL_API SQLCloseCursor(SQLHSTMT stmt)
Close open cursor.
int s3stmt_rownum
Current row number.
static COL tablePrivSpec2[]
Columns for result set of SQLTablePrivileges().
static SQLRETURN drvtableprivileges(SQLHSTMT stmt, SQLCHAR *cat, SQLSMALLINT catLen, SQLCHAR *schema, SQLSMALLINT schemaLen, SQLCHAR *table, SQLSMALLINT tableLen)
Retrieve privileges on tables and/or views.
int * jdconv
True for julian day conversion.
SQLRETURN SQL_API SQLFreeHandle(SQLSMALLINT type, SQLHANDLE h)
Free a HENV, HDBC, or HSTMT handle.
static SQLRETURN drvsetcursorname(SQLHSTMT stmt, SQLCHAR *cursor, SQLSMALLINT len)
Internal function to set cursor name on STMT.
SQLRETURN SQL_API SQLTablePrivilegesW(SQLHSTMT stmt, SQLWCHAR *catalog, SQLSMALLINT catalogLen, SQLWCHAR *schema, SQLSMALLINT schemaLen, SQLWCHAR *table, SQLSMALLINT tableLen)
Retrieve privileges on tables and/or views (UNICODE version).
SQLUSMALLINT row_status1
Internal status array for 1 row rowsets.
SQLLEN * lenp
Value return, actual size of value buffer.
SQLULEN retr_data
SQL_ATTR_RETRIEVE_DATA.
int longnames
Don't shorten column names.
int index
Index of column in result.
static SQLRETURN chkunbound(STMT *s)
Check for unbound result columns.
static void freep(void *x)
Free memory given pointer to memory pointer.
static void fixupdyncols(STMT *s, DBC *d)
Fixup column information for a running statement.
static char * uc_to_utf(SQLWCHAR *str, int len)
Make UTF8 string from UNICODE string.
static int getmdays(int year, int month)
Return number of month days.
static COL tablePrivSpec3[]
SQLSMALLINT type
ODBC type.
SQLRETURN SQL_API SQLPrimaryKeysW(SQLHSTMT stmt, SQLWCHAR *cat, SQLSMALLINT catLen, SQLWCHAR *schema, SQLSMALLINT schemaLen, SQLWCHAR *table, SQLSMALLINT tableLen)
Retrieve information about indexed columns (UNICODE version).
SQLRETURN SQL_API SQLSpecialColumnsW(SQLHSTMT stmt, SQLUSMALLINT id, SQLWCHAR *cat, SQLSMALLINT catLen, SQLWCHAR *schema, SQLSMALLINT schemaLen, SQLWCHAR *table, SQLSMALLINT tableLen, SQLUSMALLINT scope, SQLUSMALLINT nullable)
Retrieve information about indexed columns (UNICODE version).
static int str2date(int jdconv, char *str, DATE_STRUCT *ds)
Convert string to ODBC DATE_STRUCT.
struct dbc * next
Pointer to next DBC.
static SQLRETURN setposibind(STMT *s, sqlite3_stmt *stmt, int i, int si, int rsi)
Internal handler to setup parameters for positional updates from driver side result set...
static COL colPrivSpec3[]
static SQLRETURN drvtables(SQLHSTMT stmt, SQLCHAR *cat, SQLSMALLINT catLen, SQLCHAR *schema, SQLSMALLINT schemaLen, SQLCHAR *table, SQLSMALLINT tableLen, SQLCHAR *type, SQLSMALLINT typeLen)
Retrieve information on tables and/or views.
static COL statSpec2[]
Columns for result set of SQLStatistics().
int nowchar
Don't try to use WCHAR.
#define HSTMT_UNLOCK(hdbc)
SQLRETURN SQL_API SQLGetCursorNameW(SQLHSTMT stmt, SQLWCHAR *cursor, SQLSMALLINT buflen, SQLSMALLINT *lenp)
Get cursor name of STMT (UNICODE version).
SQLRETURN SQL_API SQLSetStmtOption(SQLHSTMT stmt, SQLUSMALLINT opt, SETSTMTOPTION_LAST_ARG_TYPE param)
Set option on HSTMT.
SQLRETURN SQL_API SQLSetStmtOptionW(SQLHSTMT stmt, SQLUSMALLINT opt, SETSTMTOPTION_LAST_ARG_TYPE param)
Set option on HSTMT (UNICODE version).
double s3dval
SQLite3 float value.
static int drvgettable(STMT *s, const char *sql, char ***resp, int *nrowp, int *ncolp, char **errp, int nparam, BINDPARM *p)
Internal structure for managing driver's sqlite3_get_table() implementation.
int pwdLen
Length of password.
static void unbindcols(STMT *s)
Reset bound columns to unbound state.
static COL scolSpec2[]
Columns for result set of SQLSpecialColumns().
SQLRETURN SQL_API SQLGetConnectAttrW(SQLHDBC dbc, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER bufmax, SQLINTEGER *buflen)
Get connect attribute of HDBC (UNICODE version).
int ncols
Number of result columns.
SQLUSMALLINT * row_status
Row status pointer.
SQLRETURN SQL_API SQLNumResultCols(SQLHSTMT stmt, SQLSMALLINT *ncols)
Return number of columns of result set given HSTMT.
static int busy_handler(void *udata, int count)
Busy callback for SQLite.
static char * uc_to_utf_c(SQLWCHAR *str, int len)
Make UTF8 string from UNICODE string.
SQLCHAR cursorname[32]
Cursor name.
static int str2timestamp(int jdconv, char *str, TIMESTAMP_STRUCT *tss)
Convert string to ODBC TIMESTAMP_STRUCT.
static SQLRETURN starttran(STMT *s)
Start transaction when autocommit off.
static int s3stmt_step(STMT *s)
Do one sqlite statement step gathering one result row.
static COL tableSpec2[]
Columns for result set of SQLTables().
static SQLRETURN drvexecute(SQLHSTMT stmt, int initial)
struct stmt * next
Linkage for STMT list in DBC.
static SQLRETURN drvbulkoperations(SQLHSTMT stmt, SQLSMALLINT op)
Internal perform bulk operation on HSTMT.
SQLRETURN SQL_API SQLSetPos(SQLHSTMT stmt, SQLSETPOSIROW row, SQLUSMALLINT op, SQLUSMALLINT lock)
Set position on result in HSTMT.
#define COLATTRIBUTE_LAST_ARG_TYPE
char * bincache
Cache for blob data.
static SQLRETURN setupdyncols(STMT *s, sqlite3_stmt *s3stmt, int *ncolsp)
static COL procColSpec2[]
Columns for result set of SQLProcedureColumns().
static SQLRETURN drvsetstmtattr(SQLHSTMT stmt, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER buflen)
Internal set option on HSTMT.
SQLINTEGER * bkmrkptr
SQL_ATTR_FETCH_BOOKMARK_PTR.
int notnull
NOT NULL constraint on column.
int timeout
Lock timeout value.
SQLULEN max_rows
SQL_ATTR_MAX_ROWS.
int nalloc
alloc'ed size of result array
static void dbtraceapi(DBC *d, char *fn, const char *sql)
Trace function for SQLite API calls.
SQLRETURN SQL_API SQLDriversW(SQLHENV env, SQLUSMALLINT dir, SQLWCHAR *drvdesc, SQLSMALLINT descmax, SQLSMALLINT *desclenp, SQLWCHAR *drvattr, SQLSMALLINT attrmax, SQLSMALLINT *attrlenp)
Function not implemented.
static int getbool(char *string)
Get boolean flag from string.
SQLRETURN SQL_API SQLGetStmtAttrW(SQLHSTMT stmt, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER bufmax, SQLINTEGER *buflen)
Get option of HSTMT (UNICODE version).
char * label
Column label or NULL.
SQLRETURN SQL_API SQLFreeEnv(SQLHENV env)
Free HENV.
int type
Data type of column.
SQLRETURN SQL_API SQLGetDescRecW(SQLHDESC handle, SQLSMALLINT recno, SQLWCHAR *name, SQLSMALLINT buflen, SQLSMALLINT *strlen, SQLSMALLINT *type, SQLSMALLINT *subtype, SQLLEN *len, SQLSMALLINT *prec, SQLSMALLINT *scale, SQLSMALLINT *nullable)
Function not implemented.
int nowchar[2]
Don't try to use WCHAR.
static const char upper_chars[]
static SQLRETURN setupparam(STMT *s, char *sql, int pnum)
Setup SQLite3 parameter for statement parameter.
int binlen
Length of blob data.
SQLLEN * lenp0
Actual size of parameter buffer, initial value.
int * oemcp
True for Win32 OEM CP translation.
static SQLRETURN drvunimpldbc(HDBC dbc)
Report IM001 (not implemented) SQL error code for HDBC.
SQLUSMALLINT * row_status0
Internal status array.
static void s3stmt_end_if(STMT *s)
Conditionally stop running sqlite statement.
SQLRETURN SQL_API SQLStatisticsW(SQLHSTMT stmt, SQLWCHAR *cat, SQLSMALLINT catLen, SQLWCHAR *schema, SQLSMALLINT schemaLen, SQLWCHAR *table, SQLSMALLINT tableLen, SQLUSMALLINT itype, SQLUSMALLINT resv)
Return statistic information on table indices (UNICODE version).
static int setsqliteopts(sqlite3 *x, DBC *d)
Set SQLite options (PRAGMAs) given SQLite handle.
int nbindcols
Number of entries in bindcols.
int isselect
0 if query is a SELECT statement
SQLLEN * lenp
Actual size of parameter buffer.
SQLRETURN SQL_API SQLGetStmtOption(SQLHSTMT stmt, SQLUSMALLINT opt, SQLPOINTER param)
Get option of HSTMT.
static SQLRETURN drvsetstmtoption(SQLHSTMT stmt, SQLUSMALLINT opt, SQLUINTEGER param)
Internal set option on HSTMT.
char * pwd
Password or NULL.
Driver internal structure for environment (HENV).
static SQLRETURN drvfreeenv(SQLHENV env)
Internal free HENV.
static char * strdup_(const char *str)
Duplicate string using xmalloc().
FILE * trace
sqlite3_trace() file pointer or NULL
Internal structure representing dynamic strings.
static void freeresult(STMT *s, int clrcols)
Free statement's result.
SQLRETURN SQL_API SQLSetStmtAttrW(SQLHSTMT stmt, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER buflen)
Set option on HSTMT (UNICODE version).
static void uc_from_utf_buf(unsigned char *str, int len, SQLWCHAR *uc, int ucLen)
Make UNICODE string from UTF8 string into buffer.
sqlite3_stmt * stmt
SQLite3 statement pointer.
static void uc_free(void *str)
Free converted UTF8 or UNICODE string.
int autoinc
AUTO_INCREMENT column.
SQLRETURN SQL_API SQLSetScrollOptions(SQLHSTMT stmt, SQLUSMALLINT concur, SQLLEN rowkeyset, SQLUSMALLINT rowset)
Function not implemented.
static SQLRETURN endtran(DBC *d, SQLSMALLINT comptype, int force)
Internal commit or rollback transaction.
int oom
True when out of memory.
SQLRETURN SQL_API SQLTablesW(SQLHSTMT stmt, SQLWCHAR *cat, SQLSMALLINT catLen, SQLWCHAR *schema, SQLSMALLINT schemaLen, SQLWCHAR *table, SQLSMALLINT tableLen, SQLWCHAR *type, SQLSMALLINT typeLen)
Retrieve information on tables and/or views.
static SQLRETURN drvsetconnectattr(SQLHDBC dbc, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER len)
Internal set connect attribute of HDBC.
SQLRETURN SQL_API SQLGetFunctions(SQLHDBC dbc, SQLUSMALLINT func, SQLUSMALLINT *flags)
Return information about supported ODBC API functions.
SQLRETURN SQL_API SQLBrowseConnectW(SQLHDBC dbc, SQLWCHAR *connin, SQLSMALLINT conninLen, SQLWCHAR *connout, SQLSMALLINT connoutMax, SQLSMALLINT *connoutLen)
Function not implemented.
static const char * xdigits
long t0
Start time for SQLITE busy handler.
int naterr
Native error code.
SQLRETURN SQL_API SQLGetDiagRecW(SQLSMALLINT htype, SQLHANDLE handle, SQLSMALLINT recno, SQLWCHAR *sqlstate, SQLINTEGER *nativeerr, SQLWCHAR *msg, SQLSMALLINT buflen, SQLSMALLINT *msglen)
Get error message given handle (HENV, HDBC, or HSTMT) (UNICODE version).
char sqlstate[6]
SQL state for SQLError()
int bound
True when SQLBindParameter() called.
static void dbloadext(DBC *d, char *exts)
Load SQLite extension modules, if any.
static BOOL InUn(int remove, char *drivername, char *dllname, char *dll2name, char *dsname)
Driver installer/uninstaller.
void * param
Parameter buffer.
int one_tbl
Flag for single table (> 0)
SQLRETURN SQL_API SQLGetData(SQLHSTMT stmt, SQLUSMALLINT col, SQLSMALLINT type, SQLPOINTER val, SQLLEN len, SQLLEN *lenp)
Retrieve row data after fetch.
void(* rowfree)()
Free function for rows.
static int TOLOWER(int c)
static SQLRETURN drvgetconnectattr(SQLHDBC dbc, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER bufmax, SQLINTEGER *buflen)
Internal get connect attribute of HDBC.
STMT * s
Driver statement pointer.
static COL colSpec2[]
Columns for result set of SQLColumns().
int ncol
number of columns in result array
int scale
from SQLBindParameter()
COL * dyncols
Column array, but malloc()ed.
int dobigint
Force SQL_BIGINT for INTEGER columns.
SQLRETURN SQL_API SQLBindParameter(SQLHSTMT stmt, SQLUSMALLINT pnum, SQLSMALLINT iotype, SQLSMALLINT buftype, SQLSMALLINT ptype, SQLULEN coldef, SQLSMALLINT scale, SQLPOINTER data, SQLLEN buflen, SQLLEN *len)
Bind parameter on HSTMT.
int index
Index of column in result.
int bkmrk
True when bookmarks used.
SQLULEN * parm_proc
SQL_ATTR_PARAMS_PROCESSED_PTR.
SQLULEN * bind_offs
SQL_ATTR_ROW_BIND_OFFSET_PTR.
static SQLRETURN getrowdata(STMT *s, SQLUSMALLINT col, SQLSMALLINT otype, SQLPOINTER val, SQLINTEGER len, SQLLEN *lenp, int partial)
Internal function to retrieve row data, used by SQLFetch() and friends and SQLGetData().
static SQLRETURN setposrefr(STMT *s, int rsi)
Internal handler to refresh user buffers from driver side result set.
static int dserr(dstr *dsp)
Check error on dynamic string.
static SQLRETURN drvconnect(SQLHDBC dbc, SQLCHAR *dsn, SQLSMALLINT dsnLen, char *pwd, int pwdLen, int isu)
Internal connect to SQLite database.
static void convJD2YMD(double jd, DATE_STRUCT *ds)
Convert julian day to year/month/day.
static dstr * dsappendq(dstr *dsp, const char *str)
Append a string double quoted to dynamic string.
SQLRETURN SQL_API SQLSetParam(SQLHSTMT stmt, SQLUSMALLINT par, SQLSMALLINT type, SQLSMALLINT sqltype, SQLULEN coldef, SQLSMALLINT scale, SQLPOINTER val, SQLLEN *nval)
Set information on parameter.
static COL colPrivSpec2[]
Columns for result set of SQLColumnPrivileges().
static SQLRETURN drvunimplstmt(HSTMT stmt)
Report IM001 (not implemented) SQL error code for HSTMT.
SQLRETURN SQL_API SQLSetEnvAttr(SQLHENV env, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER len)
Set information in HENV.
static char * s3stmt_coltype(sqlite3_stmt *s3stmt, int col, DBC *d, int *guessed_types)
Find out column type.
SQLRETURN SQL_API SQLDataSourcesW(SQLHENV env, SQLUSMALLINT dir, SQLWCHAR *srvname, SQLSMALLINT buflen1, SQLSMALLINT *lenp1, SQLWCHAR *desc, SQLSMALLINT buflen2, SQLSMALLINT *lenp2)
Function not implemented.
BINDCOL * bindcols
Array of bound columns.
int rowp
Current result row.
SQLRETURN SQL_API SQLGetDescFieldW(SQLHDESC handle, SQLSMALLINT recno, SQLSMALLINT fieldid, SQLPOINTER value, SQLINTEGER buflen, SQLINTEGER *strlen)
Function not implemented.
int ov3val
True for SQL_OV_ODBC3.
int scale
Scale of column.
static void dsfree(dstr *dsp)
Free dynamic string.
SQLRETURN SQL_API SQLAllocConnect(SQLHENV env, SQLHDBC *dbc)
Allocate HDBC.
static SQLRETURN freestmt(HSTMT stmt)
char * typename
Column type name or NULL.
SQLUSMALLINT * parm_status
SQL_ATTR_PARAMS_STATUS_PTR.
static SQLRETURN s3stmt_start(STMT *s)
Start sqlite statement for execution of SELECT statement.
int jdconv
True for julian day conversion.
int has_rowid
Flag for ROWID (>= 0 or -1)
BINDCOL bkmrkcol
Bookmark bound column.
SQLULEN rowset_size
Size of rowset.
static SQLRETURN drvstatistics(SQLHSTMT stmt, SQLCHAR *cat, SQLSMALLINT catLen, SQLCHAR *schema, SQLSMALLINT schemaLen, SQLCHAR *table, SQLSMALLINT tableLen, SQLUSMALLINT itype, SQLUSMALLINT resv)
Internal return statistic information on table indices.
static SQLRETURN drvcolattributes(SQLHSTMT stmt, SQLUSMALLINT col, SQLUSMALLINT id, SQLPOINTER val, SQLSMALLINT valMax, SQLSMALLINT *valLen, SQLLEN *val2)
Internal retrieve column attributes.
SQLRETURN SQL_API SQLNumParams(SQLHSTMT stmt, SQLSMALLINT *nparam)
Return number of parameters.
char strbuf[64]
String buffer for scalar data.
int oemcp
True for Win32 OEM CP translation.
SQLRETURN SQL_API SQLGetTypeInfoW(SQLHSTMT stmt, SQLSMALLINT sqltype)
Return data type information (UNICODE version).
static SQLRETURN drvendtran(SQLSMALLINT type, SQLHANDLE handle, SQLSMALLINT comptype)
Internal commit or rollback transaction.
char * bincell
Cache for blob data.
int nparams
Number of parameters in query.
static void setstat(STMT *s, int naterr, char *msg, char *st,...)
Set error message and SQL state on statement.
int stype
ODBC and SQL types.
Internal structure for bound parameter (SQLBindParameter).
static void s3stmt_drop(STMT *s)
Drop running sqlite statement in STMT.
int nbindparms
Number bound parameters.
static COL typeSpec2[]
Columns for result set of SQLGetTypeInfo().
SQLRETURN SQL_API SQLBindCol(SQLHSTMT stmt, SQLUSMALLINT col, SQLSMALLINT type, SQLPOINTER val, SQLLEN max, SQLLEN *lenp)
Bind C variable to column of result set.
Internal structure to describe a column in a result set.
char * errmsg
error message or NULL
SQLRETURN SQL_API SQLAllocStmt(SQLHDBC dbc, SQLHSTMT *stmt)
Allocate HSTMT given HDBC.
int has_pk
Flag for primary key (> 0)
static SQLRETURN drvgetstmtattr(SQLHSTMT stmt, SQLINTEGER attr, SQLPOINTER val, SQLINTEGER bufmax, SQLINTEGER *buflen)
Internal get option of HSTMT.
static SQLRETURN dbopen(DBC *d, char *name, int isu, char *dsn, char *sflag, char *spflag, char *ntflag, char *jmode, char *busy)
Open SQLite database file given file name and flags.
static int uc_strlen(SQLWCHAR *str)
Return length of UNICODE string.
int offs
Byte offset for SQLGetData()
SQLULEN paramset_count
Internal for paramset.
int pdcount
SQLParamData() counter.
struct stmt * stmt
STMT list of this DBC.
#define HDBC_UNLOCK(hdbc)
static SQLRETURN drvdescribecol(SQLHSTMT stmt, SQLUSMALLINT col, SQLCHAR *name, SQLSMALLINT nameMax, SQLSMALLINT *nameLen, SQLSMALLINT *type, SQLULEN *size, SQLSMALLINT *digits, SQLSMALLINT *nullable)
Internal describe column information.
static char * unquote(char *str)
Strip quotes from quoted string in-place.
static SQLRETURN drvbindcol(SQLHSTMT stmt, SQLUSMALLINT col, SQLSMALLINT type, SQLPOINTER val, SQLLEN max, SQLLEN *lenp)
Internal bind C variable to column of result set.
SQLRETURN SQL_API SQLAllocHandle(SQLSMALLINT type, SQLHANDLE input, SQLHANDLE *output)
Allocate a HENV, HDBC, or HSTMT handle.
SQLRETURN SQL_API SQLColumnPrivilegesW(SQLHSTMT stmt, SQLWCHAR *catalog, SQLSMALLINT catalogLen, SQLWCHAR *schema, SQLSMALLINT schemaLen, SQLWCHAR *table, SQLSMALLINT tableLen, SQLWCHAR *column, SQLSMALLINT columnLen)
Retrieve privileges on columns (UNICODE version).
static void convJD2HMS(double jd, TIME_STRUCT *ts, int *fp)
Convert julian day to hour/minute/second.
char ** resarr
result array
#define verinfo(maj, min, lev)
int s3stmt_noreset
False when sqlite3_reset() needed.
static void dbtracerc(DBC *d, int rc, char *err)
Trace function for SQLite return codes.
int trans_disable
True for no transaction support.
static SQLRETURN drvspecialcolumns(SQLHSTMT stmt, SQLUSMALLINT id, SQLCHAR *cat, SQLSMALLINT catLen, SQLCHAR *schema, SQLSMALLINT schemaLen, SQLCHAR *table, SQLSMALLINT tableLen, SQLUSMALLINT scope, SQLUSMALLINT nullable)
Internal retrieve information about indexed columns.
static const char * dsval(dstr *dsp)
Return dynamic string's value.
int dcols
Number of entries in dyncols.
static SQLRETURN drvbindparam(SQLHSTMT stmt, SQLUSMALLINT pnum, SQLSMALLINT iotype, SQLSMALLINT buftype, SQLSMALLINT ptype, SQLUINTEGER coldef, SQLSMALLINT scale, SQLPOINTER data, SQLINTEGER buflen, SQLLEN *len)
Internal bind parameter on HSTMT.
SQLRETURN SQL_API SQLProceduresW(SQLHSTMT stmt, SQLWCHAR *catalog, SQLSMALLINT catalogLen, SQLWCHAR *schema, SQLSMALLINT schemaLen, SQLWCHAR *proc, SQLSMALLINT procLen)
Retrieve information about stored procedures (UNICODE version).
static char * fixupsql(char *sql, int sqlLen, int cte, int *nparam, int *isselect, char **errmsg)
Fixup query string with optional parameter markers.
SQLRETURN SQL_API SQLParamOptions(SQLHSTMT stmt, SQLULEN rows, SQLULEN *rowp)
Function not implemented.
int naterr
Native error code.
int len
Offset/length for SQLParamData()/SQLPutData()
static SQLRETURN drvgetdiagrec(SQLSMALLINT htype, SQLHANDLE handle, SQLSMALLINT recno, SQLCHAR *sqlstate, SQLINTEGER *nativeerr, SQLCHAR *msg, SQLSMALLINT buflen, SQLSMALLINT *msglen)
Internal get error message given handle (HENV, HDBC, or HSTMT).
Header file for SQLite3 ODBC driver.
int max
Maximum length of buffer.
static int unescpat(char *str)
Unescape search pattern for e.g.