40 #define _RPMSQL_INTERNAL
48 #define _RPMDB_INTERNAL
54 #if defined(__QNXNTO__)
58 #if defined(__LCLINT__)
59 #define UINT32_T u_int32_t
61 #define UINT32_T uint32_t
70 #define SQLDBDEBUG(_dbi, _list) \
71 if (((_dbi) && (_dbi)->dbi_debug) || (_sqldb_debug)) fprintf _list
75 typedef struct key_s {
83 static const char *
tblName(uint32_t v,
KEY * tbl,
size_t ntbl)
86 const char *
n =
NULL;
90 for (i = 0; i < ntbl; i++) {
110 sprintf(t,
"0x%x", (
unsigned)flags);
113 for (i = 0; i < 32; i++) {
114 uint32_t mask = (1 <<
i);
120 name =
tblName(mask, tbl, ntbl);
125 if (pre ==
',') *te++ =
'>';
129 #define _DBT_ENTRY(_v) { DB_DBT_##_v, #_v, }
138 #if defined(DB_DBT_READONLY)
149 static size_t keymax = 35;
172 for (i = 0; i < _nu; i++)
177 size_t nb = (_nu < keymax ? _nu : keymax);
178 char *
ellipsis = (_nu < keymax ?
"" :
"...");
179 sprintf(te,
"\t\"%.*s%s\"", (
int)nb, (
char *)_u, ellipsis);
183 case 4:
sprintf(te,
"\t0x%08x", (
unsigned)*(uint32_t *)_u);
break;
196 static char buf[BUFSIZ];
200 te =
stpcpy(te,
"\n\t key: ");
204 te =
stpcpy(te,
"\n\t pkey: ");
208 te =
stpcpy(te,
"\n\t data: ");
212 te =
stpcpy(te,
"\n\t res: ");
219 #define _KEYDATA(_K, _P, _D, _R) fmtKDR(_K, _P, _D, _R)
223 int error,
int printit,
224 const char * func,
const char *
fn,
unsigned ln)
236 sqlite3 * sqlI = (sqlite3 *) sql->I;
237 const char * errmsg = dbi !=
NULL
238 ? sqlite3_errmsg(sqlI)
241 func, fn, ln, msg, rc, errmsg);
247 #define cvtdberr(_dbi, _msg, _error) \
248 Xcvtdberr(_dbi, _msg, _error, _sqldb_debug, __FUNCTION__, __FILE__, __LINE__)
286 #if defined(__LCLINT__)
295 #define SCPDEBUG(_dbi, _list) if (_scp_debug) fprintf _list
305 #define scpUnlink(_scp) \
306 ((SCP_t)rpmioUnlinkPoolItem((rpmioItem)(_scp), __FUNCTION__, __FILE__, __LINE__))
316 #define scpLink(_scp) \
317 ((SCP_t)rpmioLinkPoolItem((rpmioItem)(_scp), __FUNCTION__, __FILE__, __LINE__))
328 #define scpFree(_scp) \
329 ((SCP_t)rpmioFreePoolItem((rpmioItem)(_scp), __FUNCTION__, __FILE__, __LINE__))
338 fprintf(stderr,
"\tscp %p [%d:%d] av %p avlen %p nr [%d:%d] nc %d all %d\n", scp, scp->
ac, scp->
nalloc, scp->
av, scp->
avlen, scp->
rx, scp->
nr, scp->
nc, scp->
all);
348 if (!_scp_debug)
return;
350 fprintf(stderr,
"%s on %s (%p,%p,%p,0x%x)", msg, dbi->dbi_subfile, dbcursor, key, data, flags);
354 fprintf(stderr,
" key 0x%x[%d]", *(
unsigned int *)key->
data, key->
size);
356 fprintf(stderr,
" \"%s\"", (
const char *)key->
data);
359 fprintf(stderr,
" data 0x%x[%d]", *(
unsigned int *)data->
data, data->
size);
362 if (dbcursor !=
NULL)
373 SCPDEBUG(
NULL, (stderr,
"--> %s(%p)\n", __FUNCTION__, scp));
377 for ( ix =0 ; ix < scp->
nkeys ; ix++ ) {
396 SCPDEBUG(
NULL, (stderr,
"--> %s(%p)\n", __FUNCTION__, scp));
403 sqlite3_free_table(scp->
av);
408 for (xx = 0; xx < scp->
ac; xx++)
434 SCPDEBUG(
NULL, (stderr,
"--> %s(%p)\n", __FUNCTION__, scp));
440 sqlite3_free(scp->
cmd);
449 sqlite3_reset(scp->
pStmt));
451 sqlite3_finalize(scp->
pStmt));
465 SCP_t scp = (
SCP_t) _scp;
467 SCPDEBUG(
NULL, (stderr,
"==> %s(%p)\n", __FUNCTION__, scp));
483 if (_scpPool ==
NULL) {
484 _scpPool =
rpmioNewPool(
"scp",
sizeof(*scp), -1, _scp_debug,
489 memset(((
char *)scp)+
sizeof(scp->
_item), 0,
sizeof(*scp)-
sizeof(scp->
_item));
514 int swapped = dbiByteSwapped(dbi);
523 scp->
nc = sqlite3_column_count(scp->
pStmt);
525 if (scp->
nr == 0 && scp->
av !=
NULL)
531 if (!scp->
ac && !need && !scp->
nalloc)
534 if (scp->
ac + need >= scp->
nalloc) {
541 if (scp->
av !=
NULL && scp->
nr == 0) {
542 for (i = 0; i < scp->
nc; i++) {
553 sqlite3_step(scp->
pStmt));
556 SQLDBDEBUG(dbi, (stderr,
"%s(%p,%p): DONE [%d:%d] av %p avlen %p\n", __FUNCTION__, dbi, scp, scp->
ac, scp->
nalloc, scp->
av, scp->
avlen));
561 for (i = 0; i < scp->
nc; i++) {
563 if (scp->
ac + need >= scp->
nalloc) {
572 cname = sqlite3_column_name(scp->
pStmt, i);
573 vtype = sqlite3_column_decltype(scp->
pStmt, i);
576 if (!
strcmp(vtype,
"blob")) {
577 const void * v = sqlite3_column_blob(scp->
pStmt, i);
578 nb = sqlite3_column_bytes(scp->
pStmt, i);
579 SQLDBDEBUG(dbi, (stderr,
"\t%d %s %s %p[%d]\n", i, cname, vtype, v, (
int)nb));
582 scp->
av[scp->
ac] = (
char *) memcpy(t, v, nb);
587 if (!
strcmp(vtype,
"double")) {
588 double v = sqlite3_column_double(scp->
pStmt, i);
590 SQLDBDEBUG(dbi, (stderr,
"\t%d %s %s %g\n", i, cname, vtype, v));
598 if (!
strcmp(vtype,
"int")) {
601 SQLDBDEBUG(dbi, (stderr,
"\t%d %s %s %d\n", i, cname, vtype, (
int) v));
608 if (!
strcmp(vtype,
"int64")) {
609 int64_t v = sqlite3_column_int64(scp->
pStmt, i);
611 SQLDBDEBUG(dbi, (stderr,
"\t%d %s %s %ld\n", i, cname, vtype, (
long)v));
619 if (!
strcmp(vtype,
"text")) {
620 const char * v = (
const char *)sqlite3_column_text(scp->
pStmt, i);
622 SQLDBDEBUG(dbi, (stderr,
"\t%d %s %s \"%s\"\n", i, cname, vtype, v));
634 fprintf(stderr,
"sqlite3_step: BUSY %d\n", rc);
638 sqlite3 * sqlI = (sqlite3 *) sql->I;
639 fprintf(stderr,
"sqlite3_step: ERROR %d -- %s\n", rc, scp->
cmd);
641 sqlite3_errmsg(sqlI), sqlite3_errcode(sqlI));
646 fprintf(stderr,
"sqlite3_step: MISUSE %d\n", rc);
650 fprintf(stderr,
"sqlite3_step: rc %d\n", rc);
656 if (rc == SQLITE_DONE)
668 switch (dbi->dbi_rpmtag) {
672 memcpy(&hnum, key->
data,
sizeof(hnum));
674 rc =
cvtdberr(dbi,
"sqlite3_bind_int",
675 sqlite3_bind_int(scp->
pStmt, pos, hnum));
682 rc =
cvtdberr(dbi,
"sqlite3_bind_blob",
683 sqlite3_bind_blob(scp->
pStmt, pos,
684 key->
data, key->
size, SQLITE_STATIC));
689 memcpy(&i, key->
data,
sizeof(i));
690 rc =
cvtdberr(dbi,
"sqlite3_bind_int",
691 sqlite3_bind_int(scp->
pStmt, pos, (
int) i));
696 memcpy(&i, key->
data,
sizeof(i));
697 rc =
cvtdberr(dbi,
"sqlite3_bind_int",
698 sqlite3_bind_int(scp->
pStmt, pos, (
int) i));
703 memcpy(&i, key->
data,
sizeof(i));
705 rc =
cvtdberr(dbi,
"sqlite3_bind_int",
706 sqlite3_bind_int(scp->
pStmt, pos, i));
711 memcpy(&i, key->
data,
sizeof(i));
713 rc =
cvtdberr(dbi,
"sqlite3_bind_int64",
714 sqlite3_bind_int64(scp->
pStmt, pos, i));
720 rc =
cvtdberr(dbi,
"sqlite3_bind_text",
721 sqlite3_bind_text(scp->
pStmt, pos,
722 key->
data, key->
size, SQLITE_STATIC));
737 rc =
cvtdberr(dbi,
"sqlite3_bind_blob",
738 sqlite3_bind_blob(scp->
pStmt, pos,
739 data->
data, data->
size, SQLITE_STATIC));
746 int (*callback)(
void*,
int,
char**,
char**),
750 sqlite3 * sqlI = (sqlite3 *) sql->I;
751 char * errmsg =
NULL;
753 sqlite3_exec(sqlI, cmd, callback, context, &errmsg));
755 SQLDBDEBUG(dbi, (stderr,
"%s\n<-- %s(%p,%p(%p)) rc %d %s\n", cmd, __FUNCTION__, dbi, callback, context, rc, (errmsg ? errmsg :
"")));
756 errmsg =
_free(errmsg);
768 dbi->dbi_file, time);
774 SQLDBDEBUG(dbi, (stderr,
"<-- %s(%p,%d) rc %d\n", __FUNCTION__, _dbi, time, rc));
782 CREATE TABLE IF NOT EXISTS 'Packages' (\n\
783 key INTEGER UNIQUE PRIMARY KEY NOT NULL,\n\
784 value BLOB NOT NULL\n\
787 CREATE TRIGGER IF NOT EXISTS insert_Packages AFTER INSERT ON 'Packages'\n\
789 INSERT INTO 'Nvra' (key,value) VALUES (\n\
790 new.key, new.rowid );\n\
791 INSERT INTO 'Packagecolor' (key,value) VALUES (\n\
792 new.key, new.rowid );\n\
793 INSERT INTO 'Pubkeys' (key,value) VALUES (\n\
794 new.key, new.rowid );\n\
795 INSERT INTO 'Sha1header' (key,value) VALUES (\n\
796 new.key, new.rowid );\n\
797 INSERT INTO 'Installtid' (key,value) VALUES (\n\
798 new.key, new.rowid );\n\
799 INSERT INTO 'Providename' (key,value) VALUES (\n\
800 new.key, new.rowid );\n\
801 INSERT INTO 'Group' (key,value) VALUES (\n\
802 new.key, new.rowid );\n\
803 INSERT INTO 'Release' (key,value) VALUES (\n\
804 new.key, new.rowid );\n\
805 INSERT INTO 'Version' (key,value) VALUES (\n\
806 new.key, new.rowid );\n\
807 INSERT INTO 'Name' (key,value) VALUES (\n\
808 new.key, new.rowid );\n\
810 CREATE TRIGGER IF NOT EXISTS delete_Packages BEFORE DELETE ON 'Packages'\n\
812 DELETE FROM 'Nvra' WHERE value = old.rowid;\n\
813 DELETE FROM 'Packagecolor' WHERE value = old.rowid;\n\
814 DELETE FROM 'Pubkeys' WHERE value = old.rowid;\n\
815 DELETE FROM 'Sha1header' WHERE value = old.rowid;\n\
816 DELETE FROM 'Installtid' WHERE value = old.rowid;\n\
817 DELETE FROM 'Providename' WHERE value = old.rowid;\n\
818 DELETE FROM 'Group' WHERE value = old.rowid;\n\
819 DELETE FROM 'Release' WHERE value = old.rowid;\n\
820 DELETE FROM 'Version' WHERE value = old.rowid;\n\
821 DELETE FROM 'Name' WHERE value = old.rowid;\n\
824 CREATE TABLE IF NOT EXISTS 'Seqno' (\n\
829 CREATE TABLE IF NOT EXISTS 'Nvra' (\n\
830 key TEXT NOT NULL,\n\
831 value INTEGER REFERENCES 'Packages'\n\
834 CREATE TABLE IF NOT EXISTS 'Packagecolor' (\n\
835 key INTEGER NOT NULL,\n\
836 value INTEGER REFERENCES 'Packages'\n\
839 CREATE TABLE IF NOT EXISTS 'Pubkeys' (\n\
840 key BLOB NOT NULL,\n\
841 value INTEGER REFERENCES 'Packages'\n\
844 CREATE TABLE IF NOT EXISTS 'Sha1header' (\n\
845 key TEXT NOT NULL,\n\
846 value INTEGER REFERENCES 'Packages'\n\
849 CREATE TABLE IF NOT EXISTS 'Installtid' (\n\
850 key INTEGER NOT NULL,\n\
851 value INTEGER REFERENCES 'Packages'\n\
854 CREATE TABLE IF NOT EXISTS 'Providename' (\n\
855 key TEXT NOT NULL,\n\
856 value INTEGER REFERENCES 'Packages'\n\
859 CREATE TABLE IF NOT EXISTS 'Group' (\n\
860 key TEXT NOT NULL,\n\
861 value INTEGER REFERENCES 'Packages'\n\
864 CREATE TABLE IF NOT EXISTS 'Release' (\n\
865 key TEXT NOT NULL,\n\
866 value INTEGER REFERENCES 'Packages'\n\
869 CREATE TABLE IF NOT EXISTS 'Version' (\n\
870 key TEXT NOT NULL,\n\
871 value INTEGER REFERENCES 'Packages'\n\
874 CREATE TABLE IF NOT EXISTS 'Name' (\n\
875 key TEXT NOT NULL,\n\
876 value INTEGER REFERENCES 'Packages'\n\
898 if (dbi && argc == 1) {
900 dbi->dbi_table_exists = strtoll(argv[0], &end, 10);
901 if (end && *end ==
'\0') rc = 0;
903 SQLDBDEBUG(dbi, (stderr,
"<-- %s(%p,%p[%d],%p) rc %d table_exists %llu\n", __FUNCTION__, _dbi, argv, argc, cols, rc, (
unsigned long long) (dbi ? dbi->dbi_table_exists : 0)));
920 PRAGMA auto_vacuum = 0 | NONE | 1 | FULL | 2 | INCREMENTAL;
921 PRAGMA automatic_index = boolean;
922 PRAGMA cache_size = pages | -kibibytes;
923 PRAGMA case_sensitive_like = boolean;
924 PRAGMA checkpoint_fullfsync = boolean;
925 PRAGMA collation_list;
926 PRAGMA compile_options;
927 PRAGMA count_changes = boolean;
928 PRAGMA database_list;
929 PRAGMA default_cache_size = Number-of-pages;
930 PRAGMA empty_result_callbacks = boolean;
931 PRAGMA encoding =
"UTF-8" |
"UTF-16" |
"UTF-16le" |
"UTF-16be";
932 PRAGMA foreign_key_list(table-
name);
933 PRAGMA foreign_keys = boolean;
934 PRAGMA freelist_count;
935 PRAGMA full_column_names = boolean;
936 PRAGMA fullfsync = boolean;
937 PRAGMA ignore_check_constraints = boolean;
938 PRAGMA incremental_vacuum(
N);
939 PRAGMA index_info(index-
name);
940 PRAGMA index_list(table-
name);
941 PRAGMA integrity_check(integer)
942 PRAGMA database.journal_mode = DELETE | TRUNCATE | PERSIST | MEMORY | WAL | OFF;
943 PRAGMA journal_size_limit =
N;
944 PRAGMA legacy_file_format = boolean;
945 PRAGMA locking_mode = NORMAL | EXCLUSIVE;
946 PRAGMA max_page_count =
N;
948 PRAGMA page_size = bytes;
949 PRAGMA parser_trace = boolean;
950 PRAGMA quick_check(integer);
951 PRAGMA read_uncommitted = boolean;
952 PRAGMA recursive_triggers = boolean;
953 PRAGMA reverse_unordered_selects = boolean;
954 PRAGMA schema_version = integer;
955 PRAGMA user_version = integer;
956 PRAGMA database.secure_delete = boolean;
957 PRAGMA short_column_names = boolean; (deprecated)
958 PRAGMA shrink_memory;
959 PRAGMA synchronous = 0 | OFF | 1 | NORMAL | 2 | FULL;
960 PRAGMA table_info(table-
name);
961 PRAGMA temp_store = 0 | DEFAULT | 1 | FILE | 2 | MEMORY;
962 PRAGMA temp_store_directory =
'directory-name';
963 PRAGMA vdbe_listing = boolean;
964 PRAGMA vdbe_trace = boolean;
965 PRAGMA wal_autocheckpoint=
N;
966 PRAGMA database.wal_checkpoint(PASSIVE | FULL | RESTART);
967 PRAGMA writable_schema = boolean;
970 if (dbi->dbi_tmpdir) {
973 root = (dbi->dbi_root ? dbi->dbi_root : dbi->dbi_rpmdb->db_root);
974 if ((root[0] ==
'/' && root[1] ==
'\0') || dbi->dbi_rpmdb->db_chrootDone)
977 if (
rpmioMkpath(tmpdir, 0755, getuid(), getgid()) == 0) {
978 sprintf(cmd,
" PRAGMA temp_store_directory = '%s';", tmpdir);
981 tmpdir =
_free(tmpdir);
984 if (dbi->dbi_eflags &
DB_EXCL) {
985 sprintf(cmd,
" PRAGMA locking_mode = EXCLUSIVE;");
989 if (dbi->dbi_no_fsync) {
990 static const char _cmd[] =
" PRAGMA synchronous = OFF;";
995 if (dbi->dbi_pagesize > 0) {
996 sprintf(cmd,
" PRAGMA cache_size = %d;", dbi->dbi_cachesize);
999 if (dbi->dbi_cachesize > 0) {
1000 sprintf(cmd,
" PRAGMA page_size = %d;", dbi->dbi_pagesize);
1006 if (!dbi->dbi_table_exists) {
1008 SELECT count(type) FROM 'sqlite_master' WHERE type='table' and name='%s';\n\
1009 ", dbi->dbi_subfile);
1016 if (!dbi->dbi_table_exists) {
1017 const char * valtype =
"INTEGER REFERENCES Packages";
1018 const char * keytype;
1021 switch (dbi->dbi_rpmtag) {
1031 keytype = tagTypes[(kt > 0 && kt < (
int)ntagTypes ? kt : 0)];
1039 CREATE %sTABLE IF NOT EXISTS '%s' (key %s, value %s);\
1041 dbi->dbi_temporary ?
"TEMPORARY " :
"",
1042 dbi->dbi_subfile, keytype, valtype);
1050 SQLDBDEBUG(dbi, (stderr,
"<-- %s(%p) rc %d\n", __FUNCTION__, dbi, rc));
1066 SCP_t scp = (
SCP_t) dbcursor;
1069 SQLDBDEBUG(dbi, (stderr,
"==> sql_cclose(%p)\n", scp));
1079 SQLDBDEBUG(dbi, (stderr,
"<-- %s(%p,%p,0x%x) rc %d\n", __FUNCTION__, dbi, dbcursor, flags, rc));
1099 if (dbi->dbi_temporary && !(dbi->dbi_eflags &
DB_PRIVATE)) {
1100 const char * dbhome =
NULL;
1103 int xx = (dbfname ?
Unlink(dbfname) : 0);
1105 dbfname =
_free(dbfname);
1111 dbi->dbi_db = sql =
NULL;
1118 (
void) db3Free(dbi);
1120 SQLDBDEBUG(dbi, (stderr,
"<-- %s(%p,0x%x) rc %d\n", __FUNCTION__, dbi, flags,
rc));
1136 extern struct _dbiVec sqlitevec;
1139 const char * urlfn =
NULL;
1140 const char * dbhome =
NULL;
1141 const char * dbfname =
NULL;
1148 SQLDBDEBUG(dbi, (stderr,
"==> %s(%p,%s(%u),%p)\n", __FUNCTION__, rpmdb,
tagName(rpmtag), rpmtag, dbip));
1154 if ((dbi = db3New(rpmdb, rpmtag)) ==
NULL)
1158 dbi->dbi_root =
xstrdup(rpmdb->db_root);
1159 dbi->dbi_home =
xstrdup(rpmdb->db_home);
1160 {
const char *
s =
tagName(dbi->dbi_rpmtag);
1162 dbi->dbi_subfile =
xstrdup(s);
1164 dbi->dbi_mode = O_RDWR;
1177 dbfname =
xstrdup(
":memory:");
1187 dbfname, dbi->dbi_subfile, dbi->dbi_mode);
1191 {
const char * _av[] = { __FUNCTION__,
NULL, NULL };
1192 int _flags = RPMSQL_FLAGS_CREATE;
1200 { sqlite3 * sqlI = (sqlite3 *) sql->I;
1201 xx =
cvtdberr(dbi,
"sqlite3_busy_handler",
1205 dbi->dbi_db = (
void *) sql;
1211 if (rc == 0 && dbi->dbi_db !=
NULL && dbip !=
NULL) {
1221 if (dbip) *dbip =
dbi;
1224 urlfn =
_free(urlfn);
1225 dbfname =
_free(dbfname);
1227 SQLDBDEBUG(dbi, (stderr,
"<== %s(%p,%s(%u),%p) rc %d dbi %p\n", __FUNCTION__, rpmdb,
tagName(rpmtag), rpmtag, dbip, rc, (dbip ? *dbip :
NULL)));
1245 SQLDBDEBUG(dbi, (stderr,
"<-- %s(%p,0x%x) rc %d\n", __FUNCTION__, dbi, flags, rc));
1261 SQLDBDEBUG(dbi, (stderr,
"<-- %s(%p,%p,0x%x) rc %d %s\n", __FUNCTION__, dbi, key, flags, rc,
_KEYDATA(key,
NULL,
NULL,
NULL)));
1266 UPDATE SQLITE_SEQUENCE
SET seq = 0 WHERE
name =
'MyTable';
1269 BEGIN EXCLUSIVE TRANSACTION;\n\
1270 REPLACE INTO Seqno VALUES (0,\n\
1271 COALESCE((SELECT value FROM Seqno WHERE key == 0), 0) + 1);\n\
1272 SELECT value FROM Seqno WHERE key == 0;\n\
1273 COMMIT TRANSACTION;\n\
1280 if (dbi && argc == 1) {
1282 dbi->dbi_seqno = strtoll(argv[0], &end, 10);
1283 if (end && *end) rc = 0;
1284 if (end && *end ==
'\0') rc = 0;
1286 SQLDBDEBUG(dbi, (stderr,
"<-- %s(%p,%p[%d],%p) rc %d seqno %llu\n", __FUNCTION__, _dbi, argv, argc, cols, rc, (
unsigned long long) (dbi ? dbi->dbi_seqno : 0)));
1300 if (dbi && seqnop) {
1303 if (!rc) *seqnop = dbi->dbi_seqno;
1305 SQLDBDEBUG(dbi, (stderr,
"<-- %s(%p,%p,0x%x) rc %d seqno %llu\n", __FUNCTION__, dbi, seqnop, flags, rc, (
unsigned long long) (seqnop ? *seqnop : 0xdeadbeef)));
1325 DBC * dbcursor = (
DBC *)scp;
1335 SQLDBDEBUG(dbi, (stderr,
"<== %s(%p,%p,%p,0x%x) rc %d subfile %s\n", __FUNCTION__, dbi, txnid, dbcp, flags, rc, dbi->dbi_subfile));
1354 sqlite3 * sqlI = (sqlite3 *) sql->I;
1355 SCP_t scp =
scpLink(dbcursor);
1358 dbg_keyval(__FUNCTION__, dbi, dbcursor, key, data, flags);
1361 scp->
cmd = sqlite3_mprintf(
"DELETE FROM '%q' WHERE key=? AND value=?;",
1364 rc =
cvtdberr(dbi,
"sqlite3_prepare",
1365 sqlite3_prepare(sqlI, scp->
cmd, (
int)strlen(scp->
cmd),
1367 if (rc)
rpmlog(
RPMLOG_WARNING,
"cdel(%s) prepare %s (%d)\n", dbi->dbi_subfile, sqlite3_errmsg(sqlI), rc);
1370 if (rc)
rpmlog(
RPMLOG_WARNING,
"cdel(%s) bind key %s (%d)\n", dbi->dbi_subfile, sqlite3_errmsg(sqlI), rc);
1371 rc =
cvtdberr(dbi,
"sql_bind_data",
1373 if (rc)
rpmlog(
RPMLOG_WARNING,
"cdel(%s) bind data %s (%d)\n", dbi->dbi_subfile, sqlite3_errmsg(sqlI), rc);
1381 SQLDBDEBUG(dbi, (stderr,
"<-- %s(%p,%p,%p,%p,0x%x) rc %d subfile %s %s\n", __FUNCTION__, dbi, dbcursor, key, data, flags, rc, dbi->dbi_subfile,
_KEYDATA(key,
NULL, data,
NULL)));
1400 sqlite3 * sqlI = (sqlite3 *) sql->I;
1401 SCP_t scp = (
SCP_t)dbcursor;
1406 dbg_keyval(__FUNCTION__, dbi, dbcursor, key, data, flags);
1410 SQLDBDEBUG(dbi, (stderr,
"\tcget(%s) scp %p rc %d flags %d av %p\n",
1411 dbi->dbi_subfile, scp, rc, flags, scp->
av));
1419 if (key->
size == 0) {
1428 switch (dbi->dbi_rpmtag) {
1430 scp->
cmd = sqlite3_mprintf(
"SELECT key FROM '%q' ORDER BY key;",
1434 scp->
cmd = sqlite3_mprintf(
"SELECT key FROM '%q';",
1438 rc =
cvtdberr(dbi,
"sqlite3_prepare",
1439 sqlite3_prepare(sqlI, scp->
cmd,
1440 (
int)strlen(scp->
cmd), &scp->
pStmt,
1442 if (rc)
rpmlog(
RPMLOG_WARNING,
"cget(%s) sequential prepare %s (%d)\n", dbi->dbi_subfile, sqlite3_errmsg(sqlI), rc);
1450 for (ix = 0; ix < scp->
nkeys; ix++) {
1471 scp->
cmd = sqlite3_mprintf(
"SELECT value FROM '%q' WHERE key=?;", dbi->dbi_subfile);
1472 rc =
cvtdberr(dbi,
"sqlite3_prepare",
1473 sqlite3_prepare(sqlI, scp->
cmd, (
int)strlen(scp->
cmd),
1476 if (rc)
rpmlog(
RPMLOG_WARNING,
"cget(%s) prepare %s (%d)\n", dbi->dbi_subfile, sqlite3_errmsg(sqlI), rc);
1482 if ((scp->
rx + 1) > scp->
nkeys )
1491 if (rc)
rpmlog(
RPMLOG_WARNING,
"cget(%s) key bind %s (%d)\n", dbi->dbi_subfile, sqlite3_errmsg(sqlI), rc);
1497 rc =
cvtdberr(dbi,
"sqlite3_reset",
1498 sqlite3_reset(scp->
pStmt));
1504 if (scp->
nr == 0 && scp->
all == 0)
1527 switch (dbi->dbi_rpmtag) {
1543 SQLDBDEBUG(dbi, (stderr,
"\tcget(%s) found key 0x%x (%d)\n", dbi->dbi_subfile,
1545 SQLDBDEBUG(dbi, (stderr,
"\tcget(%s) found data 0x%x (%d)\n", dbi->dbi_subfile,
1550 SQLDBDEBUG(dbi, (stderr,
"\tcget(%s) not found\n", dbi->dbi_subfile));
1553 SQLDBDEBUG(dbi, (stderr,
"<-- %s(%p,%p,%p,%p,0x%x) rc %d subfile %s %s\n", __FUNCTION__, dbi, dbcursor, key, data, flags, rc, dbi->dbi_subfile,
_KEYDATA(key,
NULL, data,
NULL)));
1572 sqlite3 * sqlI = (sqlite3 *) sql->I;
1573 SCP_t scp =
scpLink(dbcursor);
1576 dbg_keyval(
"sql_cput", dbi, dbcursor, key, data, flags);
1579 switch (dbi->dbi_rpmtag) {
1582 scp->
cmd = sqlite3_mprintf(
"INSERT OR REPLACE INTO '%q' VALUES(?, ?);",
1584 rc =
cvtdberr(dbi,
"sqlite3_prepare",
1585 sqlite3_prepare(sqlI, scp->
cmd, (
int)strlen(scp->
cmd),
1589 rc =
cvtdberr(dbi,
"sql_bind_data",
1600 SQLDBDEBUG(dbi, (stderr,
"<-- %s(%p,%p,%p,%p,0x%x) rc %d subfile %s %s\n", __FUNCTION__, dbi, dbcursor, key, data, flags, rc, dbi->dbi_subfile,
_KEYDATA(key,
NULL, data,
NULL)));
1615 SQLDBDEBUG(dbi, (stderr,
"<-- %s(%p) rc %d subfile %s\n", __FUNCTION__, dbi, rc, dbi->dbi_subfile));
1630 int (*callback) (
DB *,
const DBT *,
const DBT *,
DBT *),
1635 SQLDBDEBUG(dbi, (stderr,
"<-- %s(%p,%p,%p,0x%x) rc %d subfile %s\n", __FUNCTION__, dbi, dbisecondary, callback, flags, rc, dbi->dbi_subfile));
1649 int (*callback) (
DB *,
const DBT *,
DBT *,
const DBT *,
int *),
1654 SQLDBDEBUG(dbi, (stderr,
"<-- %s(%p,%p,%p,0x%x) rc %d subfile %s\n", __FUNCTION__, dbi, dbisecondary, callback, flags, rc, dbi->dbi_subfile));
1674 SQLDBDEBUG(dbi, (stderr,
"<-- %s(%p,%p,%p,0x%x) rc %d\n", __FUNCTION__, dbi, curslist, dbcp, flags, rc));
1694 SQLDBDEBUG(dbi, (stderr,
"<-- %s(%p,%p,%p,0x%x) rc %d\n", __FUNCTION__, dbi, dbcursor, dbcp, flags, rc));
1718 SQLDBDEBUG(dbi, (stderr,
"<-- %s(%p,%p,%p,%p,%p,0x%x) rc %d %s\n", __FUNCTION__, dbi, dbcursor, key, pkey, data, flags, rc,
_KEYDATA(key, pkey, data,
NULL)));
1732 unsigned int * countp,
1738 SQLDBDEBUG(dbi, (stderr,
"<-- %s(%p,%p,%p,0x%x) rc %d\n", __FUNCTION__, dbi, dbcursor, countp, flags, rc));
1746 if (dbi && argc == 1) {
1748 dbi->dbi_table_nkeys = strtoll(argv[0], &end, 10);
1749 if (end && *end ==
'\0') rc = 0;
1751 SQLDBDEBUG(dbi, (stderr,
"<-- %s(%p,%p[%d],%p) rc %d table_nkeys %llu\n", __FUNCTION__, _dbi, argv, argc, cols, rc, (
unsigned long long) (dbi ? dbi->dbi_table_nkeys : 0)));
1768 dbi->dbi_table_nkeys = -1;
1770 cmd = sqlite3_mprintf(
" SELECT COUNT('key') FROM '%q';", dbi->dbi_subfile);
1774 if (dbi->dbi_table_nkeys < 0)
1775 dbi->dbi_table_nkeys = 4096;
1777 dbi->dbi_stats =
_free(dbi->dbi_stats);
1780 dbi->dbi_stats = (
void *) _stats;
1783 SQLDBDEBUG(dbi, (stderr,
"<-- %s(%p,0x%x) rc %d subfile %s\n", __FUNCTION__, dbi, flags, rc, dbi->dbi_subfile));
1794 "Sqlite " SQLITE_VERSION,
1795 ((SQLITE_VERSION_NUMBER / (1000 * 1000)) % 1000),
1796 ((SQLITE_VERSION_NUMBER / ( 1000)) % 1000),
1797 ((SQLITE_VERSION_NUMBER ) % 1000),
static SCP_t scpGetPool(rpmioPool pool)
static const char * fmtKDR(const DBT *K, const DBT *P, const DBT *D, const DBT *R)
static int sql_bind_key(dbiIndex dbi, SCP_t scp, int pos, DBT *key)
struct rpmdb_s * rpmdb
Database of headers and tag value indices.
static int sql_join(dbiIndex dbi, DBC **curslist, DBC **dbcp, unsigned int flags)
Return join cursor for list of cursors.
rpmlog(RPMLOG_ERR,"%s\n", buf)
enum urltype_e urltype
Supported URL types.
char * xstrdup(const char *str)
static int sql_ccount(dbiIndex dbi, DBC *dbcursor, unsigned int *countp, unsigned int flags)
Retrieve count of (possible) duplicate items using dbcursor->c_count.
static char *size_t nb
fgets(3) analogue that reads \ continuations.
static void dbg_scp(void *ptr)
static int Xcvtdberr(dbiIndex dbi, const char *msg, int error, int printit, const char *func, const char *fn, unsigned ln)
int rpmioMkpath(const char *path, mode_t mode, uid_t uid, gid_t gid)
Insure that directories in path exist, creating as needed.
static int sql_bind_data(dbiIndex dbi, SCP_t scp, int pos, DBT *data)
static int sql_sync(dbiIndex dbi, unsigned int flags)
Flush pending operations to disk.
unsigned short rpmuint16_t
static void dbg_keyval(const char *msg, dbiIndex dbi, DBC *dbcursor, DBT *key, DBT *data, unsigned int flags)
static int sql_cput(dbiIndex dbi, DBC *dbcursor, DBT *key, DBT *data, unsigned int flags)
Store (key,data) pair using db->put or dbcursor->c_put.
static int sql_initDB(dbiIndex dbi)
Verify the DB is setup.
static void scpFini(void *_scp)
unsigned char rpmuint8_t
Private int typedefs to avoid C99 portability issues.
static int sql_open(rpmdb rpmdb, rpmTag rpmtag, dbiIndex *dbip)
Return handle for an index database.
sprintf(t," (%u)",(unsigned) dig->nbytes)
static int sql_seqno_cb(void *_dbi, int argc, char **argv, char **cols)
rpmsql rpmsqlNew(char **av, uint32_t flags)
Create and load a sql interpreter.
Yet Another syslog(3) API clone.
memset(_r, 0, sizeof(*_r))
static int xisprint(int c)
static int sql_cdel(dbiIndex dbi, DBC *dbcursor, DBT *key, DBT *data, unsigned int flags)
Delete (key,data) pair(s) using db->del or dbcursor->c_del.
void * xcalloc(size_t nmemb, size_t size)
assert(key->size==sizeof(hdrNum))
static SCP_t scpResetKeys(SCP_t scp)
rpmioItem rpmioGetPool(rpmioPool pool, size_t size)
Get unused item from pool, or alloc a new item.
fprintf(stderr,"--> %s(%p,%p,%p) sig %p sigp %p\n", __FUNCTION__, dig, t, rsactx, sig, sigp)
#define SQLDBDEBUG(_dbi, _list)
static int sql_busy_handler(void *_dbi, int time)
#define cvtdberr(_dbi, _msg, _error)
unsigned int tagType(rpmTag tag)
Return tag data type from value.
unsigned long long rpmuint64_t
static int sql_exec(dbiIndex dbi, const char *cmd, int(*callback)(void *, int, char **, char **), void *context)
const char * tagName(rpmTag tag)
Return tag name from value.
static int sql_cget(dbiIndex dbi, DBC *dbcursor, DBT *key, DBT *data, unsigned int flags)
Retrieve (key,data) pair using db->get or dbcursor->c_get.
static int sql_cdup(dbiIndex dbi, DBC *dbcursor, DBC **dbcp, unsigned int flags)
Duplicate a database cursor.
const char * rpmGenPath(const char *urlroot, const char *urlmdir, const char *urlfile)
Merge 3 args into path, any or all of which may be a url.
#define _KEYDATA(_K, _P, _D, _R)
static SCP_t scpNew(void *dbp)
static SCP_t scpReset(SCP_t scp)
static char * fmtDBT(const DBT *K, char *te)
static int sql_cclose(dbiIndex dbi, DBC *dbcursor, unsigned int flags)
Close database cursor.
rpmsql rpmsqlFree(rpmsql sql)
Destroy a sql interpreter.
static int sql_cpget(dbiIndex dbi, DBC *dbcursor, DBT *key, DBT *pkey, DBT *data, unsigned int flags)
Retrieve (key,data) pair using dbcursor->c_pget.
return strcmp(ame->name, bme->name)
static int sql_associate_foreign(dbiIndex dbi, dbiIndex dbisecondary, int(*callback)(DB *, const DBT *, DBT *, const DBT *, int *), unsigned int flags)
Associate secondary database with primary.
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.
static const char * tagTypes[]
char * stpcpy(char *dest, const char *src)
static int sql_copen(dbiIndex dbi, DB_TXN *txnid, DBC **dbcp, unsigned int flags)
Open database cursor.
static const char * fmtBits(uint32_t flags, KEY tbl[], size_t ntbl, char *t)
static int sql_stat(dbiIndex dbi, unsigned int flags)
Save statistics in database handle.
static const char seqno_inc_cmd[]
static const char * tblName(uint32_t v, KEY *tbl, size_t ntbl)
static int sql_byteswapped(dbiIndex dbi)
Is database byte swapped?
static SCP_t scpResetAv(SCP_t scp)
static void
Print copy of spec file, filling in Group/Description/Summary from specspo.
char * buf
Parse (and execute) macro undefinition.
struct _sql_dbcursor_s * SCP_t
int
Save source and expand field into target.
Access RPM indices using Berkeley DB interface(s).
static int sql_close(dbiIndex dbi, unsigned int flags)
Close index database, and destroy database handle.
static void * _free(const void *p)
Wrapper to free(3), hides const compilation noise, permit NULL, return NULL.
static const char _Packages_sql_init[]
#define RPMDBI_PACKAGES
Pseudo-tags used by the rpmdb and rpmgi iterator API's.
static int sql_seqno(dbiIndex dbi, int64_t *seqnop, unsigned int flags)
Return next sequence number.
static int sql_associate(dbiIndex dbi, dbiIndex dbisecondary, int(*callback)(DB *, const DBT *, const DBT *, DBT *), unsigned int flags)
Associate secondary database with primary.
static int sql_step(dbiIndex dbi, SCP_t scp)
struct _dbiIndex * dbiIndex
static int sql_stat_cb(void *_dbi, int argc, char **argv, char **cols)
static int sql_exists(dbiIndex dbi, DBT *key, unsigned int flags)
Return whether key exists in a database.
static int sql_initDB_cb(void *_dbi, int argc, char **argv, char **cols)
#define SCPDEBUG(_dbi, _list)
int Unlink(const char *path)
unlink(2) clone.