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