7 #if defined(HAVE_SQLEXT_H)
18 #define _RPMODBC_INTERNAL
27 if ((_t) || _odbc_debug) fprintf _l
29 #define SPEW(_t, _rc, _odbc) \
30 { if ((_t) || _odbc_debug) \
31 fprintf(stderr, "<-- %s(%p) rc %d\n", __FUNCTION__, (_odbc), \
35 #if !defined(WITH_UNIXODBC)
36 #define SQL_SUCCEEDED(rc) (((rc)&(~1))==0)
37 #define SQL_NO_DATA 100
38 #define SQL_FETCH_NEXT 1
39 #define SQL_FETCH_FIRST 2
40 #define SQL_FETCH_LAST 3
41 #define SQL_FETCH_PRIOR 4
42 #define SQL_FETCH_ABSOLUTE 5
43 #define SQL_FETCH_RELATIVE 6
49 #define SQL_C_DOUBLE 8
52 #define SQL_C_TIMESTAMP 11
54 #define SQL_COLUMN_NAME 1
55 #define SQL_COLUMN_TABLE_NAME 15
56 #define SQL_COLUMN_LABEL 18
59 #define SQL_ROLLBACK 1
64 #if defined(WITH_UNIXODBC)
65 static int Xchkodbc(
ODBC_t odbc,
int ht,
const char * msg,
66 int error,
int printit,
67 const char * func,
const char * fn,
unsigned ln)
77 fprintf(stderr,
"error: %s:%s:%u: %s(%d):\n",
78 func, fn, ln, msg, rc);
81 case SQL_HANDLE_ENV: H = odbc->env;
break;
82 case SQL_HANDLE_DBC: H = odbc->dbc;
break;
83 case SQL_HANDLE_STMT: H = odbc->stmt;
break;
84 case SQL_HANDLE_DESC: H = odbc->desc;
break;
85 default: H = NULL;
break;
92 unsigned char state[7];
93 unsigned char text[256];
95 ret = SQLGetDiagRec(H->ht, H->hp, ++i, state, &native, text,
98 fprintf(stderr,
"\t%s:%ld:%ld:%s\n",
99 state, (
long)i, (
long)native, text);
100 }
while (ret == SQL_SUCCESS);
107 #define CHECK(_o, _t, _m, _rc) \
108 Xchkodbc(_o, _t, _m, _rc, 1, __FUNCTION__, __FILE__, __LINE__)
110 #define CHECK(_o, _t, _m, _rc) (-1)
119 xx =
CHECK(odbc, H->ht,
"SQLFreeHandle",
120 SQLFreeHandle(H->ht, H->hp));
139 case SQL_HANDLE_ENV: PH = NULL;
break;
140 case SQL_HANDLE_DBC: PH = odbc->env;
break;
141 case SQL_HANDLE_STMT: PH = odbc->dbc;
break;
142 case SQL_HANDLE_DESC: PH = odbc->dbc;
break;
143 default: PH = NULL;
break;
145 parent = (PH ? PH->hp : NULL);
147 xx =
CHECK(odbc, H->ht,
"SQLAllocHandle",
148 SQLAllocHandle(H->ht, parent, &H->hp));
155 typedef struct key_s {
161 #define _ENTRY(_t, _v) { _t, SQL_ATTR_##_v, #_v, }
163 #if defined(WITH_UNIXODBC)
165 _ENTRY(8+1, APP_PARAM_DESC),
166 _ENTRY(8+1, APP_ROW_DESC),
167 _ENTRY(8+1, IMP_PARAM_DESC),
168 _ENTRY(8+1, IMP_ROW_DESC),
178 _ENTRY( 8, ENABLE_AUTO_IPD),
179 _ENTRY(8+8, FETCH_BOOKMARK_PTR),
185 _ENTRY(8+8, PARAM_BIND_OFFSET_PTR),
186 _ENTRY( 8, PARAM_BIND_TYPE),
187 _ENTRY(8+2, PARAM_OPERATION_PTR),
188 _ENTRY(8+2, PARAM_STATUS_PTR),
189 _ENTRY(8+8, PARAMS_PROCESSED_PTR),
190 _ENTRY( 8, PARAMSET_SIZE),
191 _ENTRY( 8, QUERY_TIMEOUT),
192 _ENTRY( 8, RETRIEVE_DATA),
193 _ENTRY( 8, ROW_ARRAY_SIZE),
194 _ENTRY(8+8, ROW_BIND_OFFSET_PTR),
195 _ENTRY( 8, ROW_BIND_TYPE),
197 _ENTRY(8+2, ROW_OPERATION_PTR),
198 _ENTRY(8+2, ROW_STATUS_PTR),
199 _ENTRY(8+8, ROWS_FETCHED_PTR),
200 _ENTRY( 8, SIMULATE_CURSOR),
201 _ENTRY( 8, USE_BOOKMARKS),
211 FILE * fp = (_fp ? _fp : stderr);
216 int _attr = SQL_ATTRS[
i].
v;
219 unsigned short * _uhp;
220 unsigned long * _ulp;
228 switch (SQL_ATTRS[i].t) {
235 fprintf(fp,
"\t%s:\t0x%lx\n", SQL_ATTRS[i].n, _ul);
240 fprintf(fp,
"\t%s:\t%p\n", SQL_ATTRS[i].n, _p);
245 fprintf(fp,
"\t%s:\t*(%p) = 0x%hx\n", SQL_ATTRS[i].n, _uhp, *_uhp);
250 fprintf(fp,
"\t%s:\t*(%p) = 0x%lx\n", SQL_ATTRS[i].n, _ulp, *_ulp);
260 SQLHANDLE * stmt = odbc->stmt->hp;
263 rc =
CHECK(odbc, SQL_HANDLE_STMT,
"SQLGetStmtAttr",
264 SQLGetStmtAttr(stmt, _attr, _bp, _nb, nsp));
271 SQLHANDLE * stmt = odbc->stmt->hp;
274 rc =
CHECK(odbc, SQL_HANDLE_STMT,
"SQLSetStmtAttr",
275 SQLSetStmtAttr(stmt, _attr, _bp, ns));
280 #define _ENTRY(_t, _v) { _t, SQL_##_v, #_v, }
282 #if defined(WITH_UNIXODBC)
284 _ENTRY( 0, FETCH_DIRECTION),
286 _ENTRY( 1, ACCESSIBLE_PROCEDURES),
287 _ENTRY( 1, ACCESSIBLE_TABLES),
303 _ENTRY(256, COLLATION_SEQ),
317 _ENTRY( 2, CURSOR_COMMIT_BEHAVIOR),
318 _ENTRY( 2, CURSOR_ROLLBACK_BEHAVIOR),
319 _ENTRY( 4, CURSOR_SENSITIVITY),
320 _ENTRY(256, DATA_SOURCE_NAME),
321 _ENTRY( 1, DATA_SOURCE_READ_ONLY),
327 _ENTRY( 4, DEFAULT_TXN_ISOLATION),
328 _ENTRY( 1, DESCRIBE_PARAMETER),
351 _ENTRY( 4, GETDATA_EXTENSIONS),
353 _ENTRY( 2, IDENTIFIER_CASE),
354 _ENTRY( 2, IDENTIFIER_QUOTE_CHAR),
366 _ENTRY( 2, MAX_CATALOG_NAME_LEN),
367 _ENTRY( 2, MAXIMUM_CATALOG_NAME_LENGTH),
369 _ENTRY( 2, MAX_COLUMN_NAME_LEN),
370 _ENTRY( -2, MAXIMUM_COLUMN_NAME_LENGTH),
371 _ENTRY( 2, MAX_COLUMNS_IN_GROUP_BY),
372 _ENTRY( -2, MAXIMUM_COLUMNS_IN_GROUP_BY),
373 _ENTRY( 2, MAX_COLUMNS_IN_INDEX),
374 _ENTRY( -2, MAXIMUM_COLUMNS_IN_INDEX),
375 _ENTRY( 2, MAX_COLUMNS_IN_ORDER_BY),
376 _ENTRY( -2, MAXIMUM_COLUMNS_IN_ORDER_BY),
377 _ENTRY( 2, MAX_COLUMNS_IN_SELECT),
378 _ENTRY( -2, MAXIMUM_COLUMNS_IN_SELECT),
379 _ENTRY( 2, MAX_COLUMNS_IN_TABLE),
380 _ENTRY( 2, MAX_CONCURRENT_ACTIVITIES),
381 _ENTRY( -2, MAXIMUM_CONCURRENT_ACTIVITIES),
382 _ENTRY( 2, MAX_CURSOR_NAME_LEN),
383 _ENTRY( -2, MAXIMUM_CURSOR_NAME_LENGTH),
384 _ENTRY( 2, MAX_DRIVER_CONNECTIONS),
385 _ENTRY( -2, MAXIMUM_DRIVER_CONNECTIONS),
386 _ENTRY( 2, MAX_IDENTIFIER_LEN),
387 _ENTRY( -2, MAXIMUM_IDENTIFIER_LENGTH),
388 _ENTRY( 2, MAX_INDEX_SIZE),
389 _ENTRY( -2, MAXIMUM_INDEX_SIZE),
392 _ENTRY( -4, MAXIMUM_ROW_SIZE),
394 _ENTRY( 2, MAX_SCHEMA_NAME_LEN),
395 _ENTRY( -2, MAXIMUM_SCHEMA_NAME_LENGTH),
396 _ENTRY( 4, MAX_STATEMENT_LEN),
397 _ENTRY( -4, MAXIMUM_STATEMENT_LENGTH),
398 _ENTRY( 2, MAX_TABLE_NAME_LEN),
399 _ENTRY( 2, MAX_TABLES_IN_SELECT),
400 _ENTRY( -2, MAXIMUM_TABLES_IN_SELECT),
401 _ENTRY( 2, MAX_USER_NAME_LEN),
402 _ENTRY( -2, MAXIMUM_USER_NAME_LENGTH),
407 _ENTRY( 2, NULL_COLLATION),
411 _ENTRY( 4, OJ_CAPABILITIES),
412 _ENTRY( -4, OUTER_JOIN_CAPABILITIES),
413 _ENTRY( 1, ORDER_BY_COLUMNS_IN_SELECT),
424 _ENTRY( 4, SCROLL_CONCURRENCY),
425 _ENTRY(256, SEARCH_PATTERN_ESCAPE),
427 _ENTRY(256, SPECIAL_CHARACTERS),
451 _ENTRY( -2, TRANSACTION_CAPABLE),
452 _ENTRY( 4, TXN_ISOLATION_OPTION),
453 _ENTRY( -4, TRANSACTION_ISOLATION_OPTION),
456 _ENTRY(256, XOPEN_CLI_YEAR),
466 FILE * fp = (_fp ? _fp : stderr);
471 int _type = SQL_INFOS[
i].
v;
483 switch (SQL_INFOS[i].t) {
488 rc =
odbcGetInfo(odbc, _type, &_c,
sizeof(_c), &ns);
490 fprintf(fp,
"\t%s:\t%c\n", SQL_INFOS[i].n, _c);
493 rc =
odbcGetInfo(odbc, _type, &_uh,
sizeof(_uh), &ns);
495 fprintf(fp,
"\t%s:\t0x%hx\n", SQL_INFOS[i].n, _uh);
498 rc =
odbcGetInfo(odbc, _type, &_ui,
sizeof(_ui), &ns);
500 fprintf(fp,
"\t%s:\t0x%x\n", SQL_INFOS[i].n, _ui);
503 rc =
odbcGetInfo(odbc, _type, &_s,
sizeof(_s), &ns);
505 fprintf(fp,
"\t%s:\t%s\n", SQL_INFOS[i].n, _s);
515 SQLHANDLE * dbc = odbc->dbc->hp;
518 rc =
CHECK(odbc, SQL_HANDLE_DBC,
"SQLGetInfo",
519 SQLGetInfo(dbc, _type, _bp, _nb, nsp));
524 #define _ENTRY(_t, _v) { _t, SQL_ATTR_##_v, #_v, }
526 #if defined(WITH_UNIXODBC)
528 _ENTRY( 4, CONNECTION_POOLING),
533 _ENTRY( 0, UNIXODBC_SYSPATH),
534 _ENTRY( 0, UNIXODBC_VERSION),
535 _ENTRY( 0, UNIXODBC_ENVATTR),
543 FILE * fp = (_fp ? _fp : stderr);
548 int _type = SQL_EATTRS[
i].
v;
554 switch (SQL_EATTRS[i].t) {
561 fprintf(fp,
"\t%s:\t0x%x\n", SQL_EATTRS[i].n, _ui);
571 SQLHANDLE * env = odbc->env->hp;
574 rc =
CHECK(odbc, SQL_HANDLE_ENV,
"SQLGetEnvAttr",
575 SQLGetEnvAttr(env, _type, _bp, _nb, nsp));
581 SQLHANDLE * env = odbc->env->hp;
584 rc =
CHECK(odbc, SQL_HANDLE_ENV,
"SQLSetEnvAttr",
585 SQLSetEnvAttr(env, _type, _bp, ns));
590 #define _ENTRY(_t, _v) { _t, SQL_COLUMN_##_v, #_v, }
592 #if defined(WITH_UNIXODBC)
605 _ENTRY( 4, AUTO_INCREMENT),
606 _ENTRY( 4, CASE_SENSITIVE),
611 _ENTRY(256, QUALIFIER_NAME),
622 FILE * fp = (_fp ? _fp : stderr);
627 int _type = SQL_CATTRS[
i].
v;
629 size_t nb =
sizeof(
b);;
636 switch (SQL_CATTRS[i].t) {
643 fprintf(fp,
"\t%s:\tgot %lx %p[%hu] = \"%s\"\n", SQL_CATTRS[i].n, got, b, ns, b);
648 fprintf(fp,
"\t%s:\t0x%lx\n", SQL_CATTRS[i].n, got);
652 fprintf(fp,
"\t%s:\t%s\n", SQL_CATTRS[i].n, b);
661 unsigned short ColumnNumber,
662 unsigned short FieldIdentifier,
663 void * CharacterAttributePtr,
665 short * StringLengthPtr,
666 long * NumericAttributePtr)
668 SQLHANDLE * stmt = odbc->stmt->hp;
672 rc =
CHECK(odbc, SQL_HANDLE_STMT,
"SQLColAttribute",
673 SQLColAttribute(stmt,
676 CharacterAttributePtr,
679 NumericAttributePtr));
689 SQLHANDLE * stmt = odbc->stmt->hp;
693 rc =
CHECK(odbc, SQL_HANDLE_STMT,
"SQLCloseCursor",
694 SQLCloseCursor(stmt));
702 SQLHANDLE * stmt = odbc->stmt->hp;
705 short nb =
sizeof(
b);
712 rc =
CHECK(odbc, SQL_HANDLE_STMT,
"SQLGetCursorName",
713 SQLGetCursorName(stmt, (SQLCHAR *)b, nb, &ns));
723 SQLHANDLE * stmt = odbc->stmt->hp;
729 rc =
CHECK(odbc, SQL_HANDLE_STMT,
"SQLSetCursorName",
730 SQLSetCursorName(stmt, (SQLCHAR *)s, (SQLSMALLINT)ns));
740 SQLHANDLE * dbc = odbc->dbc->hp;
745 rc =
CHECK(odbc, SQL_HANDLE_DBC,
"SQLEndTran",
746 SQLEndTran(SQL_HANDLE_DBC, dbc, _completion));
766 const char *
db = NULL;
772 DBG(0, (stderr,
"--> %s(%p,%s)\n", __FUNCTION__, odbc, uri));
777 const char * dbpath = NULL;
778 int ut =
urlPath(uri, &dbpath);
789 DBG(0, (stderr,
"\tdb: %s\n", db));
790 DBG(0, (stderr,
"\t u: %s\n", u->
user));
793 if (odbc->dbc == NULL)
794 odbc->dbc =
hAlloc(odbc, SQL_HANDLE_DBC);
797 rc =
CHECK(odbc, SQL_HANDLE_DBC,
"SQLConnect",
799 (SQLCHAR *) db, SQL_NTS,
800 (SQLCHAR *) u->
user, SQL_NTS,
816 SQLHANDLE * dbc = odbc->dbc->hp;
820 rc =
CHECK(odbc, SQL_HANDLE_DBC,
"SQLDisconnect",
823 odbc->desc =
hFree(odbc, odbc->desc);
824 odbc->stmt =
hFree(odbc, odbc->stmt);
825 odbc->dbc =
hFree(odbc, odbc->dbc);
833 FILE * fp = (_fp ? _fp : stderr);
834 SQLHANDLE * env = odbc->env->hp;
838 unsigned char dsn[256];
839 unsigned char desc[256];
849 SQLDataSources(env, direction,
850 dsn,
sizeof(dsn), &dsn_ret,
851 desc,
sizeof(desc), &desc_ret)))))
854 fprintf(fp,
"\t%s - %s\n", dsn, desc);
856 if (ret == SQL_SUCCESS_WITH_INFO) fprintf(fp,
"\tdata truncation\n");
866 FILE * fp = (_fp ? _fp : stderr);
870 SQLHANDLE * env = odbc->env->hp;
871 unsigned char driver[256];
872 unsigned char attr[256];
882 SQLDrivers(env, direction,
883 driver,
sizeof(driver), &driver_ret,
884 attr,
sizeof(attr), &attr_ret)))))
887 fprintf(fp,
"\t%s - %s\n", driver, attr);
889 if (xx == SQL_SUCCESS_WITH_INFO) fprintf(fp,
"\tdata truncation\n");
899 SQLHANDLE * stmt = odbc->stmt->hp;
904 rc =
CHECK(odbc, SQL_HANDLE_STMT,
"SQLRowCount",
905 SQLRowCount(stmt, &rows));
914 SQLHANDLE * stmt = odbc->stmt->hp;
919 rc =
CHECK(odbc, SQL_HANDLE_STMT,
"SQLNumResultCols",
920 SQLNumResultCols(stmt, &columns));
929 SQLHANDLE * stmt = odbc->stmt->hp;
933 rc =
CHECK(odbc, SQL_HANDLE_STMT,
"SQLCancel",
935 odbc->stmt =
hFree(odbc, odbc->stmt);
943 SQLHANDLE * stmt = odbc->stmt->hp;
947 rc =
CHECK(odbc, SQL_HANDLE_STMT,
"SQLFetch",
956 SQLHANDLE * stmt = odbc->stmt->hp;
960 rc =
CHECK(odbc, SQL_HANDLE_STMT,
"SQLFetch",
961 SQLFetchScroll(stmt, FetchOrientation, FetchOffset));
968 unsigned short Col_or_Param_Num,
970 void * TargetValuePtr,
972 long * StrLen_or_IndPtr)
974 SQLHANDLE * stmt = odbc->stmt->hp;
978 rc =
CHECK(odbc, SQL_HANDLE_STMT,
"SQLGetData",
992 FILE * fp = (_fp ? _fp : stderr);
993 SQLHANDLE * stmt = odbc->stmt->hp;
996 size_t nb =
sizeof(
b);
1003 DBG(0, (stderr,
"--> %s(%p,%p)\n", __FUNCTION__, odbc, fp));
1012 for (i = 0; i < odbc->ncols; i++) {
1021 nw =
snprintf(b, nb,
" Column %d", i+1);
1030 fprintf(fp,
"Row %d\n", ++odbc->nrows);
1031 for (i = 0; i < odbc->ncols; i++) {
1036 if (got == 0) strcpy(b,
"NULL");
1037 fprintf(fp,
" %20s : %s\n", av[i], b);
1045 odbc->stmt =
hFree(odbc, odbc->stmt);
1059 if (odbc->stmt == NULL)
1060 odbc->stmt =
hAlloc(odbc, SQL_HANDLE_STMT);
1061 stmt = odbc->stmt->hp;
1063 rc =
CHECK(odbc, SQL_HANDLE_STMT,
"SQLTables",
1067 (SQLCHAR *) tblname, SQL_NTS,
1079 if (odbc->stmt == NULL)
1080 odbc->stmt =
hAlloc(odbc, SQL_HANDLE_STMT);
1081 stmt = odbc->stmt->hp;
1083 rc =
CHECK(odbc, SQL_HANDLE_STMT,
"SQLColumns",
1087 (SQLCHAR *) tblname, SQL_NTS,
1088 (SQLCHAR *) colname, SQL_NTS));
1099 if (odbc->stmt == NULL)
1100 odbc->stmt =
hAlloc(odbc, SQL_HANDLE_STMT);
1101 stmt = odbc->stmt->hp;
1103 rc =
CHECK(odbc, SQL_HANDLE_STMT,
"SQLStatistics",
1107 (SQLCHAR *) tblname, SQL_NTS,
1119 DBG(0, (stderr,
"--> %s(%p,%s,%u)\n", __FUNCTION__, odbc, s, (
unsigned)ns));
1124 if (odbc->stmt == NULL)
1125 odbc->stmt =
hAlloc(odbc, SQL_HANDLE_STMT);
1126 stmt = odbc->stmt->hp;
1128 rc =
CHECK(odbc, SQL_HANDLE_STMT,
"SQLExecDirect",
1129 SQLExecDirect(stmt, (SQLCHAR *) s, (SQLINTEGER) ns));
1140 DBG(0, (stderr,
"--> %s(%p,%s,%u)\n", __FUNCTION__, odbc, s, (
unsigned)ns));
1146 odbc->stmt =
hFree(odbc, odbc->stmt);
1148 if (odbc->stmt == NULL)
1149 odbc->stmt =
hAlloc(odbc, SQL_HANDLE_STMT);
1150 stmt = odbc->stmt->hp;
1152 rc =
CHECK(odbc, SQL_HANDLE_STMT,
"SQLPrepare",
1153 SQLPrepare(stmt, (SQLCHAR *) s, (SQLINTEGER) ns));
1160 void * TargetValuePtr,
long BufferLength,
long * StrLen_or_Ind)
1162 SQLHANDLE * stmt = odbc->stmt->hp;
1163 int rc =
CHECK(odbc, SQL_HANDLE_STMT,
"SQLBindCol",
1178 SQLHANDLE * stmt = odbc->stmt->hp;
1179 int rc =
CHECK(odbc, SQL_HANDLE_STMT,
"SQLBindParameter",
1180 SQLBindParameter(stmt,
1181 param->ParameterNumber,
1182 param->InputOutputType,
1184 param->ParameterType,
1186 param->DecimalDigits,
1187 param->ParameterValuePtr,
1188 param->BufferLength,
1189 param->StrLen_or_IndPtr));
1198 SQLHANDLE * stmt = odbc->stmt->hp;
1199 int rc =
CHECK(odbc, SQL_HANDLE_STMT,
"SQLExecute",
1215 odbc->desc =
hFree(odbc, odbc->desc);
1216 odbc->stmt =
hFree(odbc, odbc->stmt);
1217 odbc->dbc =
hFree(odbc, odbc->dbc);
1218 odbc->env =
hFree(odbc, odbc->env);
1220 odbc->db =
_free(odbc->db);
1221 odbc->u =
urlFree(odbc->u, __FUNCTION__);
1222 odbc->fn =
_free(odbc->fn);
1234 if (_odbcPool == NULL) {
1240 memset(((
char *)odbc)+
sizeof(odbc->_item), 0,
sizeof(*odbc)-
sizeof(odbc->_item));
1244 static char *
_odbc_uri =
"mysql://luser:jasnl@localhost/test";
1254 odbc->flags =
flags;
1256 {
const char * dbpath = NULL;
1257 int ut =
urlPath(fn, &dbpath);
1263 odbc->u =
urlLink(u, __FUNCTION__);
1266 odbc->env =
hAlloc(odbc, SQL_HANDLE_ENV);
1267 #if defined(WITH_UNIXODBC)
1268 xx =
odbcSetEnvAttr(odbc, SQL_ATTR_ODBC_VERSION, (
void*)SQL_OV_ODBC3, 0);
int odbcColAttribute(ODBC_t odbc, unsigned short ColumnNumber, unsigned short FieldIdentifier, void *CharacterAttributePtr, short BufferLength, short *StringLengthPtr, long *NumericAttributePtr)
int odbcStatistics(ODBC_t odbc, const char *tblname)
ODBC_t odbcLink(ODBC_t odbc)
Reference a odbc wrapper instance.
int odbcGetStmtAttr(ODBC_t odbc, int _attr, void *_bp, int _nb, int *nsp)
const char const char size_t len
char * xstrdup(const char *str)
int odbcExecute(ODBC_t odbc)
int odbcSetEnvAttr(ODBC_t odbc, int _type, void *_bp, int ns)
ODBC_t odbcNew(const char *fn, int flags)
Create and load a odbc wrapper.
#define SQL_SUCCEEDED(rc)
int odbcCancel(ODBC_t odbc)
int odbcCloseCursor(ODBC_t odbc)
static size_t nSQL_EATTRS
static int odbcDumpInfo(ODBC_t odbc, void *_fp)
int odbcPrepare(ODBC_t odbc, const char *s, size_t ns)
int odbcNCols(ODBC_t odbc)
int odbcGetData(ODBC_t odbc, unsigned short Col_or_Param_Num, short TargetType, void *TargetValuePtr, long BufferLength, long *StrLen_or_IndPtr)
int odbcListDrivers(ODBC_t odbc, void *_fp)
static void * hAlloc(ODBC_t odbc, int ht)
static void odbcFini(void *_odbc)
int odbcRollback(ODBC_t odbc)
static int odbcDumpEnvAttr(ODBC_t odbc, void *_fp)
Yet Another syslog(3) API clone.
rpmioItem rpmioGetPool(rpmioPool pool, size_t size)
Get unused item from pool, or alloc a new item.
int odbcNRows(ODBC_t odbc)
ARGV_t argvFree(ARGV_t argv)
Destroy an argv array.
int odbcGetInfo(ODBC_t odbc, int _type, void *_bp, int _nb, short *nsp)
int odbcPrint(ODBC_t odbc, void *_fp)
static ODBC_t odbcGetPool(rpmioPool pool)
int argvAdd(ARGV_t *argvp, ARGstr_t val)
Add a string to an argv array.
int odbcFetch(ODBC_t odbc)
#define CHECK(_o, _t, _m, _rc)
char * rpmExpand(const char *arg,...)
Return (malloc'ed) concatenated macro expansion(s).
const char const bson int mongo_write_concern int flags
int odbcBindParameter(ODBC_t odbc, _PARAM_t param)
int odbcSetStmtAttr(ODBC_t odbc, int _attr, void *_bp, int ns)
int odbcTables(ODBC_t odbc, const char *tblname)
int odbcBindCol(ODBC_t odbc, unsigned short ColumnNumber, short TargetType, void *TargetValuePtr, long BufferLength, long *StrLen_or_Ind)
int urlSplit(const char *url, urlinfo *uret)
Parse URL string into a control structure.
int odbcFetchScroll(ODBC_t odbc, short FetchOrientation, long FetchOffset)
urltype urlPath(const char *url, const char **pathp)
Return path component of URL.
static int snprintf(char *buf, int nb, const char *fmt,...)
rpmioPool rpmioNewPool(const char *name, size_t size, int limit, int flags, char *(*dbg)(void *item), void(*init)(void *item), void(*fini)(void *item))
Create a memory pool.
#define SPEW(_t, _rc, _odbc)
const char * odbcGetCursorName(ODBC_t odbc)
int odbcEndTran(ODBC_t odbc, int _rollback)
static void * _free(const void *p)
Wrapper to free(3), hides const compilation noise, permit NULL, return NULL.
int odbcCommit(ODBC_t odbc)
static size_t nSQL_CATTRS
int odbcGetEnvAttr(ODBC_t odbc, int _type, void *_bp, int _nb, int *nsp)
int odbcDisconnect(ODBC_t odbc)
int odbcListDataSources(ODBC_t odbc, void *_fp)
int odbcConnect(ODBC_t odbc, const char *uri)
static int odbcDumpColAttrs(ODBC_t odbc, int colx, void *_fp)
static char * columns[30]
int odbcExecDirect(ODBC_t odbc, const char *s, size_t ns)
static int odbcDumpStmt(ODBC_t odbc, void *_fp)
urlinfo urlFree(urlinfo u, const char *msg)
Dereference a URL control structure instance.
static void * hFree(ODBC_t odbc, HNDL_t H)
int odbcColumns(ODBC_t odbc, const char *tblname, const char *colname)
int odbcSetCursorName(ODBC_t odbc, const char *s, size_t ns)
struct _PARAM_s * _PARAM_t
urlinfo urlLink(urlinfo u, const char *msg)
Reference a URL control structure instance.