1 #ifndef H_RPMDB_INTERNAL
2 #define H_RPMDB_INTERNAL
8 #include <rpm/rpmtypes.h>
9 #include <rpm/rpmutil.h>
13 typedef struct _dbiIndexItem * dbiIndexItem;
16 * A single element (i.e. inverted list from tag values) of a database.
18 typedef struct _dbiIndexSet * dbiIndexSet;
22 typedef struct _dbiIndex * dbiIndex;
24 /* this will break if sizeof(int) != 4 */
26 * A single item from an index database (i.e. the "data returned").
27 * Note: In rpm-3.0.4 and earlier, this structure was passed by value,
28 * and was identical to the "data saved" structure below.
30 struct _dbiIndexItem {
31 unsigned int hdrNum; /*!< header instance in db */
32 unsigned int tagNum; /*!< tag index in header */
36 * Items retrieved from the index database.
39 struct _dbiIndexItem * recs; /*!< array of records */
40 unsigned int count; /*!< number of records */
44 * Private methods for accessing an index database.
47 int dbv_major; /*!< Berkeley db version major */
48 int dbv_minor; /*!< Berkeley db version minor */
49 int dbv_patch; /*!< Berkeley db version patch */
52 * Return handle for an index database.
53 * @param rpmdb rpm database
54 * @param rpmtag rpm tag
55 * @return 0 on success
57 int (*open) (rpmdb rpmdb, rpmTag rpmtag, dbiIndex * dbip);
60 * Close index database, and destroy database handle.
61 * @param dbi index database handle
62 * @param flags (unused)
63 * @return 0 on success
65 int (*close) (dbiIndex dbi, unsigned int flags);
68 * Flush pending operations to disk.
69 * @param dbi index database handle
70 * @param flags (unused)
71 * @return 0 on success
73 int (*sync) (dbiIndex dbi, unsigned int flags);
76 * Associate secondary database with primary.
77 * @param dbi index database handle
78 * @param dbisecondary secondary index database handle
79 * @param callback create secondary key from primary (NULL if DB_RDONLY)
80 * @param flags DB_CREATE or 0
81 * @return 0 on success
83 int (*associate) (dbiIndex dbi, dbiIndex dbisecondary,
84 int (*callback) (DB *, const DBT *, const DBT *, DBT *),
88 * Return join cursor for list of cursors.
89 * @param dbi index database handle
90 * @param curslist NULL terminated list of database cursors
91 * @retval dbcp address of join database cursor
92 * @param flags DB_JOIN_NOSORT or 0
93 * @return 0 on success
95 int (*join) (dbiIndex dbi, DBC ** curslist, DBC ** dbcp,
99 * Open database cursor.
100 * @param dbi index database handle
101 * @param txnid database transaction handle
102 * @retval dbcp address of new database cursor
103 * @param dbiflags DB_WRITECURSOR or 0
104 * @return 0 on success
106 int (*copen) (dbiIndex dbi, DB_TXN * txnid,
107 DBC ** dbcp, unsigned int dbiflags);
110 * Close database cursor.
111 * @param dbi index database handle
112 * @param dbcursor database cursor
113 * @param flags (unused)
114 * @return 0 on success
116 int (*cclose) (dbiIndex dbi, DBC * dbcursor, unsigned int flags);
119 * Duplicate a database cursor.
120 * @param dbi index database handle
121 * @param dbcursor database cursor
122 * @retval dbcp address of new database cursor
123 * @param flags DB_POSITION for same position, 0 for uninitialized
124 * @return 0 on success
126 int (*cdup) (dbiIndex dbi, DBC * dbcursor, DBC ** dbcp,
130 * Delete (key,data) pair(s) using db->del or dbcursor->c_del.
131 * @param dbi index database handle
132 * @param dbcursor database cursor (NULL will use db->del)
133 * @param key delete key value/length/flags
134 * @param data delete data value/length/flags
135 * @param flags (unused)
136 * @return 0 on success
138 int (*cdel) (dbiIndex dbi, DBC * dbcursor, DBT * key, DBT * data,
142 * Retrieve (key,data) pair using db->get or dbcursor->c_get.
143 * @param dbi index database handle
144 * @param dbcursor database cursor (NULL will use db->get)
145 * @param key retrieve key value/length/flags
146 * @param data retrieve data value/length/flags
147 * @param flags (unused)
148 * @return 0 on success
150 int (*cget) (dbiIndex dbi, DBC * dbcursor, DBT * key, DBT * data,
154 * Retrieve (key,data) pair using dbcursor->c_pget.
155 * @param dbi index database handle
156 * @param dbcursor database cursor
157 * @param key secondary retrieve key value/length/flags
158 * @param pkey primary retrieve key value/length/flags
159 * @param data primary retrieve data value/length/flags
160 * @param flags DB_NEXT, DB_SET, or 0
161 * @return 0 on success
163 int (*cpget) (dbiIndex dbi, DBC * dbcursor,
164 DBT * key, DBT * pkey, DBT * data, unsigned int flags);
167 * Store (key,data) pair using db->put or dbcursor->c_put.
168 * @param dbi index database handle
169 * @param dbcursor database cursor (NULL will use db->put)
170 * @param key store key value/length/flags
171 * @param data store data value/length/flags
172 * @param flags (unused)
173 * @return 0 on success
175 int (*cput) (dbiIndex dbi, DBC * dbcursor, DBT * key, DBT * data,
179 * Retrieve count of (possible) duplicate items using dbcursor->c_count.
180 * @param dbi index database handle
181 * @param dbcursor database cursor
182 * @param countp address of count
183 * @param flags (unused)
184 * @return 0 on success
186 int (*ccount) (dbiIndex dbi, DBC * dbcursor,
187 unsigned int * countp,
191 * Is database byte swapped?
192 * @param dbi index database handle
195 int (*byteswapped) (dbiIndex dbi);
198 * Save statistics in database handle.
199 * @param dbi index database handle
200 * @param flags retrieve statistics that don't require traversal?
201 * @return 0 on success
203 int (*stat) (dbiIndex dbi, unsigned int flags);
207 * Describes an index database (implemented on Berkeley db3 functionality).
210 char * dbi_root; /*!< chroot(2) component of path */
211 char * dbi_home; /*!< directory component of path */
212 char * dbi_file; /*!< file component of path */
214 char * dbi_tmpdir; /*!< temporary directory */
216 int dbi_ecflags; /*!< db_env_create flags */
217 int dbi_cflags; /*!< db_create flags */
218 int dbi_oeflags; /*!< common (db,dbenv}->open flags */
219 int dbi_eflags; /*!< dbenv->open flags */
220 int dbi_oflags; /*!< db->open flags */
221 int dbi_tflags; /*!< dbenv->txn_begin flags */
223 int dbi_type; /*!< db index type */
224 unsigned dbi_mode; /*!< mode to use on open */
225 int dbi_perms; /*!< file permission to use on open */
226 long dbi_shmkey; /*!< shared memory base key */
227 int dbi_api; /*!< Berkeley API type */
229 int dbi_verify_on_close;
230 int dbi_use_dbenv; /*!< use db environment? */
231 int dbi_permit_dups; /*!< permit duplicate entries? */
232 int dbi_no_fsync; /*!< no-op fsync for db */
233 int dbi_no_dbsync; /*!< don't call dbiSync */
234 int dbi_lockdbfd; /*!< do fcntl lock on db fd */
235 int dbi_temporary; /*!< non-persistent */
240 unsigned long dbi_cl_timeout;
241 unsigned long dbi_sv_timeout;
243 /* dbenv parameters */
245 /* XXX db-4.3.14 adds dbenv as 1st arg. */
246 void (*db_errcall) (void * dbenv, const char *db_errpfx, char *buffer);
252 /* mpool sub-system parameters */
253 int dbi_mmapsize; /*!< (10Mb) */
254 int dbi_cachesize; /*!< (128Kb) */
255 /* lock sub-system parameters */
256 unsigned int dbi_lk_max;
257 unsigned int dbi_lk_detect;
259 unsigned char * dbi_lk_conflicts;
260 /* log sub-system parameters */
261 unsigned int dbi_lg_max;
262 unsigned int dbi_lg_bsize;
263 /* transaction sub-system parameters */
264 unsigned int dbi_tx_max;
266 int (*dbi_tx_recover) (DB_ENV *dbenv, DBT *log_rec,
267 DB_LSN *lsnp, int redo, void *info);
269 /* dbinfo parameters */
270 int dbi_pagesize; /*!< (fs blksize) */
271 void * (*dbi_malloc) (size_t nbytes);
272 /* hash access parameters */
273 unsigned int dbi_h_ffactor; /*!< */
274 unsigned int (*dbi_h_hash_fcn) (DB *, const void *bytes,
275 unsigned int length);
276 unsigned int dbi_h_nelem; /*!< */
277 unsigned int dbi_h_flags; /*!< DB_DUP, DB_DUPSORT */
278 int (*dbi_h_dup_compare_fcn) (DB *, const DBT *, const DBT *);
279 /* btree access parameters */
282 int (*dbi_bt_compare_fcn) (DB *, const DBT *, const DBT *);
283 int (*dbi_bt_dup_compare_fcn) (DB *, const DBT *, const DBT *);
284 size_t (*dbi_bt_prefix_fcn) (DB *, const DBT *, const DBT *);
285 /* recno access parameters */
288 unsigned int dbi_re_len;
290 char * dbi_re_source;
291 /* queue access parameters */
292 unsigned int dbi_q_extentsize;
294 rpmdb dbi_rpmdb; /*!< the parent rpm database */
295 rpmTag dbi_rpmtag; /*!< rpm tag used for index */
296 int dbi_jlen; /*!< size of join key */
298 DB * dbi_db; /*!< Berkeley DB * handle */
299 DB_TXN * dbi_txnid; /*!< Bekerley DB_TXN * transaction id */
300 void * dbi_stats; /*!< Berkeley db statistics */
302 const struct _dbiVec * dbi_vec; /*!< private methods */
307 * Describes the collection of index databases used by rpm.
310 char * db_root;/*!< path prefix */
311 char * db_home;/*!< directory path */
313 int db_mode; /*!< open mode */
314 int db_perms; /*!< open permissions */
315 int db_api; /*!< Berkeley API type */
319 int db_chrootDone; /*!< If chroot(2) done, ignore db_root. */
320 void (*db_errcall) (const char *db_errpfx, char *buffer);
322 void * (*db_malloc) (size_t nbytes);
323 void * (*db_realloc) (void * ptr,
325 void (*db_free) (void * ptr);
326 unsigned char * db_bits; /*!< package instance bit mask. */
327 int db_nbits; /*!< no. of bits in mask. */
330 void * db_dbenv; /*!< Berkeley DB_ENV handle. */
331 int db_ndbi; /*!< No. of tag indices. */
332 dbiIndex * _dbi; /*!< Tag indices. */
334 struct rpmop_s db_getops;
335 struct rpmop_s db_putops;
336 struct rpmop_s db_delops;
338 int nrefs; /*!< Reference count. */
341 /* for RPM's internal use only */
346 RPMDB_FLAG_JUSTCHECK = (1 << 0),
347 RPMDB_FLAG_MINIMAL = (1 << 1),
348 RPMDB_FLAG_CHROOT = (1 << 2)
356 * Return new configured index database handle instance.
357 * @param rpmdb rpm database
358 * @param rpmtag rpm tag
359 * @return index database handle
362 dbiIndex db3New(rpmdb rpmdb, rpmTag rpmtag);
365 * Destroy index database handle instance.
366 * @param dbi index database handle
367 * @return NULL always
370 dbiIndex db3Free( dbiIndex dbi);
373 * Format db3 open flags for debugging print.
374 * @param dbflags db open flags
375 * @param print_dbenv_flags format db env flags instead?
376 * @return formatted flags (malloced)
379 char * prDbiOpenFlags(int dbflags, int print_dbenv_flags);
382 * Return handle for an index database.
383 * @param db rpm database
384 * @param rpmtag rpm tag
385 * @param flags (unused)
386 * @return index database handle
389 dbiIndex dbiOpen(rpmdb db, rpmTag rpmtag,
392 /* FIX: vector annotations */
394 * Open a database cursor.
395 * @param dbi index database handle
396 * @param txnid database transaction handle
397 * @retval dbcp returned database cursor
398 * @param flags DB_WRITECURSOR if writing, or 0
399 * @return 0 on success
402 int dbiCopen(dbiIndex dbi, DB_TXN * txnid,
403 DBC ** dbcp, unsigned int flags)
405 return (*dbi->dbi_vec->copen) (dbi, txnid, dbcp, flags);
409 * Close a database cursor.
410 * @param dbi index database handle
411 * @param dbcursor database cursor
412 * @param flags (unused)
413 * @return 0 on success
416 int dbiCclose(dbiIndex dbi, DBC * dbcursor, unsigned int flags)
418 return (*dbi->dbi_vec->cclose) (dbi, dbcursor, flags);
422 * Duplicate a database cursor.
423 * @param dbi index database handle
424 * @param dbcursor database cursor
425 * @retval dbcp address of new database cursor
426 * @param flags DB_POSITION for same position, 0 for uninitialized
427 * @return 0 on success
430 int dbiCdup(dbiIndex dbi, DBC * dbcursor, DBC ** dbcp,
433 return (*dbi->dbi_vec->cdup) (dbi, dbcursor, dbcp, flags);
437 * Delete (key,data) pair(s) from index database.
438 * @param dbi index database handle
439 * @param dbcursor database cursor (NULL will use db->del)
440 * @param key delete key value/length/flags
441 * @param data delete data value/length/flags
442 * @param flags (unused)
443 * @return 0 on success
446 int dbiDel(dbiIndex dbi, DBC * dbcursor, DBT * key, DBT * data,
450 assert(key->data != NULL && key->size > 0);
451 (void) rpmswEnter(&dbi->dbi_rpmdb->db_delops, 0);
452 rc = (dbi->dbi_vec->cdel) (dbi, dbcursor, key, data, flags);
453 (void) rpmswExit(&dbi->dbi_rpmdb->db_delops, data->size);
458 * Retrieve (key,data) pair from index database.
459 * @param dbi index database handle
460 * @param dbcursor database cursor (NULL will use db->get)
461 * @param key retrieve key value/length/flags
462 * @param data retrieve data value/length/flags
463 * @param flags (unused)
464 * @return 0 on success
467 int dbiGet(dbiIndex dbi, DBC * dbcursor, DBT * key, DBT * data,
471 assert((flags == DB_NEXT) || (key->data != NULL && key->size > 0));
472 (void) rpmswEnter(&dbi->dbi_rpmdb->db_getops, 0);
473 rc = (dbi->dbi_vec->cget) (dbi, dbcursor, key, data, flags);
474 (void) rpmswExit(&dbi->dbi_rpmdb->db_getops, data->size);
479 * Retrieve (key,data) pair using dbcursor->c_pget.
480 * @param dbi index database handle
481 * @param dbcursor database cursor (NULL will use db->get)
482 * @param key secondary retrieve key value/length/flags
483 * @param pkey primary retrieve key value/length/flags
484 * @param data primary retrieve data value/length/flags
485 * @param flags DB_NEXT, DB_SET, or 0
486 * @return 0 on success
489 int dbiPget(dbiIndex dbi, DBC * dbcursor,
490 DBT * key, DBT * pkey, DBT * data, unsigned int flags)
493 assert((flags == DB_NEXT) || (key->data != NULL && key->size > 0));
494 (void) rpmswEnter(&dbi->dbi_rpmdb->db_getops, 0);
495 rc = (dbi->dbi_vec->cpget) (dbi, dbcursor, key, pkey, data, flags);
496 (void) rpmswExit(&dbi->dbi_rpmdb->db_getops, (ssize_t) data->size);
501 * Store (key,data) pair in index database.
502 * @param dbi index database handle
503 * @param dbcursor database cursor (NULL will use db->put)
504 * @param key store key value/length/flags
505 * @param data store data value/length/flags
506 * @param flags (unused)
507 * @return 0 on success
510 int dbiPut(dbiIndex dbi, DBC * dbcursor, DBT * key, DBT * data,
514 assert(key->data != NULL && key->size > 0 && data->data != NULL && data->size > 0);
515 (void) rpmswEnter(&dbi->dbi_rpmdb->db_putops, (ssize_t) 0);
516 rc = (dbi->dbi_vec->cput) (dbi, dbcursor, key, data, flags);
517 (void) rpmswExit(&dbi->dbi_rpmdb->db_putops, (ssize_t) data->size);
522 * Retrieve count of (possible) duplicate items.
523 * @param dbi index database handle
524 * @param dbcursor database cursor
525 * @param countp address of count
526 * @param flags (unused)
527 * @return 0 on success
530 int dbiCount(dbiIndex dbi, DBC * dbcursor, unsigned int * countp,
533 return (*dbi->dbi_vec->ccount) (dbi, dbcursor, countp, flags);
537 * Verify (and close) index database.
538 * @param dbi index database handle
539 * @param flags (unused)
540 * @return 0 on success
543 int dbiVerify(dbiIndex dbi, unsigned int flags)
545 dbi->dbi_verify_on_close = 1;
546 return (*dbi->dbi_vec->close) (dbi, flags);
550 * Close index database.
551 * @param dbi index database handle
552 * @param flags (unused)
553 * @return 0 on success
556 int dbiClose(dbiIndex dbi, unsigned int flags)
558 return (*dbi->dbi_vec->close) (dbi, flags);
562 * Flush pending operations to disk.
563 * @param dbi index database handle
564 * @param flags (unused)
565 * @return 0 on success
568 int dbiSync (dbiIndex dbi, unsigned int flags)
570 return (*dbi->dbi_vec->sync) (dbi, flags);
574 * Associate secondary database with primary.
575 * @param dbi index database handle
576 * @param dbisecondary secondary index database handle
577 * @param callback create secondary key from primary (NULL if DB_RDONLY)
578 * @param flags DB_CREATE or 0
579 * @return 0 on success
582 int dbiAssociate(dbiIndex dbi, dbiIndex dbisecondary,
583 int (*callback) (DB *, const DBT *, const DBT *, DBT *),
586 return (*dbi->dbi_vec->associate) (dbi, dbisecondary, callback, flags);
590 * Return join cursor for list of cursors.
591 * @param dbi index database handle
592 * @param curslist NULL terminated list of database cursors
593 * @retval dbcp address of join database cursor
594 * @param flags DB_JOIN_NOSORT or 0
595 * @return 0 on success
598 int dbiJoin(dbiIndex dbi, DBC ** curslist, DBC ** dbcp,
601 return (*dbi->dbi_vec->join) (dbi, curslist, dbcp, flags);
605 * Is database byte swapped?
606 * @param dbi index database handle
607 * @return 0 same order, 1 swapped order
610 int dbiByteSwapped(dbiIndex dbi)
612 if (dbi->dbi_byteswapped == -1)
613 dbi->dbi_byteswapped = (*dbi->dbi_vec->byteswapped) (dbi);
614 return dbi->dbi_byteswapped;
617 * Is database byte swapped?
618 * @param dbi index database handle
619 * @param flags DB_FAST_STAT or 0
620 * @return 0 on success
623 int dbiStat(dbiIndex dbi, unsigned int flags)
625 return (*dbi->dbi_vec->stat) (dbi, flags);
630 * Destroy set of index database items.
631 * @param set set of index database items
632 * @return NULL always
635 dbiIndexSet dbiFreeIndexSet(dbiIndexSet set);
638 * Count items in index database set.
639 * @param set set of index database items
640 * @return number of items
643 unsigned int dbiIndexSetCount(dbiIndexSet set);
646 * Return record offset of header from element in index database set.
647 * @param set set of index database items
648 * @param recno index of item in set
649 * @return record offset of header
652 unsigned int dbiIndexRecordOffset(dbiIndexSet set, int recno);
655 * Return file index from element in index database set.
656 * @param set set of index database items
657 * @param recno index of item in set
661 unsigned int dbiIndexRecordFileNumber(dbiIndexSet set, int recno);
664 * Return database iterator.
665 * @param mi rpm database iterator
666 * @param keyp key data (NULL for sequential access)
667 * @param keylen key data length (0 will use strlen(keyp))
668 * @return 0 on success
670 int rpmdbExtendIterator(rpmdbMatchIterator mi,
671 const void * keyp, size_t keylen);
674 * sort the iterator by (recnum, filenum)
675 * Return database iterator.
676 * @param mi rpm database iterator
678 void rpmdbSortIterator(rpmdbMatchIterator mi);
682 * * Mergesort, same arguments as qsort(2).
685 int mergesort(void *base, size_t nmemb, size_t size,
686 int (*cmp) (const void *, const void *));
688 /* mergesort is defined in stdlib.h on Mac OS X */
689 #endif /* __APPLE__ */