Class: GDBM
Overview
Summary
Ruby extension for GNU dbm (gdbm) – a simple database engine for storing key-value pairs on disk.
Description
GNU dbm is a library for simple databases. A database is a file that stores key-value pairs. Gdbm allows the user to store, retrieve, and delete data by key. It furthermore allows a non-sorted traversal of all key-value pairs. A gdbm database thus provides the same functionality as a hash. As with objects of the Hash class, elements can be accessed with []
. Furthermore, GDBM mixes in the Enumerable module, thus providing convenient methods such as #find, #collect, #map, etc.
A process is allowed to open several different databases at the same time. A process can open a database as a “reader” or a “writer”. Whereas a reader has only read-access to the database, a writer has read- and write-access. A database can be accessed either by any number of readers or by exactly one writer at the same time.
Examples
-
Opening/creating a database, and filling it with some entries:
require 'gdbm' gdbm = GDBM.new("fruitstore.db") gdbm["ananas"] = "3" gdbm["banana"] = "8" gdbm["cranberry"] = "4909" gdbm.close
-
Reading out a database:
require 'gdbm' gdbm = GDBM.new("fruitstore.db") gdbm.each_pair do |key, value| print "#{key}: #{value}\n" end gdbm.close
produces
banana: 8 ananas: 3 cranberry: 4909
Links
Constant Summary collapse
- READER =
open database as a reader
flag for #new and #open
- WRITER =
open database as a writer
flag for #new and #open
- WRCREAT =
open database as a writer; if the database does not exist, create a new one
flag for #new and #open
- NEWDB =
open database as a writer; overwrite any existing databases
flag for #new and #open
- FAST =
flag for #new and #open. this flag is obsolete for gdbm >= 1.8
INT2FIX(GDBM_FAST)
- SYNC =
flag for #new and #open. only for gdbm >= 1.8
INT2FIX(GDBM_SYNC)
- NOLOCK =
flag for #new and #open
INT2FIX(GDBM_NOLOCK)
- VERSION =
version of the gdbm library
rb_str_new2(gdbm_version)
Class Method Summary collapse
-
.open ⇒ Object
If called without a block, this is synonymous to GDBM::new.
Instance Method Summary collapse
-
#[](key) ⇒ Object
Retrieves the value corresponding to key.
-
#[]= ⇒ Object
Associates the value value with the specified key.
-
#cachesize=(size) ⇒ Object
Sets the size of the internal bucket cache to size.
-
#clear ⇒ Object
Removes all the key-value pairs within gdbm.
-
#close ⇒ nil
Closes the associated database file.
-
#closed? ⇒ Boolean
Returns true if the associated database file has been closed.
-
#delete(key) ⇒ nil
Removes the key-value-pair with the specified key from this database and returns the corresponding value.
-
#delete_if ⇒ Object
Deletes every key-value pair from gdbm for which block evaluates to true.
-
#each_pair {|key, value| ... } ⇒ Object
Executes block for each key in the database, passing the key and the correspoding value as a parameter.
-
#each_key {|key| ... } ⇒ Object
Executes block for each key in the database, passing the key as a parameter.
-
#each_pair {|key, value| ... } ⇒ Object
Executes block for each key in the database, passing the key and the correspoding value as a parameter.
-
#each_value {|value| ... } ⇒ Object
Executes block for each key in the database, passing the corresponding value as a parameter.
-
#empty? ⇒ Boolean
Returns true if the database is empty.
-
#fastmode=(boolean) ⇒ Boolean
Turns the database’s fast mode on or off.
-
#fetch(key[, default]) ⇒ Object
Retrieves the value corresponding to key.
-
#has_key? ⇒ Boolean
Returns true if the given key k exists within the database.
-
#has_value? ⇒ Boolean
Returns true if the given value v exists within the database.
-
#include? ⇒ Boolean
Returns true if the given key k exists within the database.
-
#index ⇒ Object
:nodoc:.
-
#new(filename, mode = 0666, flags = nil) ⇒ Object
constructor
Creates a new GDBM instance by opening a gdbm file named filename.
-
#invert ⇒ Hash
Returns a hash created by using gdbm’s values as keys, and the keys as values.
-
#key(value) ⇒ Object
Returns the key for a given value.
-
#key? ⇒ Boolean
Returns true if the given key k exists within the database.
-
#keys ⇒ Array
Returns an array of all keys of this database.
-
#length ⇒ Object
Returns the number of key-value pairs in this database.
-
#member? ⇒ Boolean
Returns true if the given key k exists within the database.
-
#reject {|key, value| ... } ⇒ Hash
Returns a hash copy of gdbm where all key-value pairs from gdbm for which block evaluates to true are removed.
-
#reject! ⇒ Object
Deletes every key-value pair from gdbm for which block evaluates to true.
-
#reorganize ⇒ Object
Reorganizes the database file.
-
#replace(other) ⇒ Object
Replaces the content of gdbm with the key-value pairs of other.
-
#select {|key, value| ... } ⇒ Array
Returns a new array of all key-value pairs of the database for which block evaluates to true.
-
#shift ⇒ nil
Removes a key-value-pair from this database and returns it as a two-item array [ key, value ].
-
#size ⇒ Object
Returns the number of key-value pairs in this database.
-
#store ⇒ Object
Associates the value value with the specified key.
-
#sync ⇒ Object
Unless the gdbm object has been opened with the SYNC flag, it is not guarenteed that database modification operations are immediately applied to the database file.
-
#syncmode=(boolean) ⇒ Boolean
Turns the database’s synchronization mode on or off.
-
#to_a ⇒ Array
Returns an array of all key-value pairs contained in the database.
-
#to_hash ⇒ Hash
Returns a hash of all key-value pairs contained in the database.
-
#update(other) ⇒ Object
Adds the key-value pairs of other to gdbm, overwriting entries with duplicate keys with those from other.
-
#value? ⇒ Boolean
Returns true if the given value v exists within the database.
-
#values ⇒ Array
Returns an array of all values of this database.
-
#values_at(key, ...) ⇒ Array
Returns an array of the values associated with each specified key.
Constructor Details
#new(filename, mode = 0666, flags = nil) ⇒ Object
Creates a new GDBM instance by opening a gdbm file named filename. If the file does not exist, a new file with file mode mode will be created. flags may be one of the following:
-
READER - open as a reader
-
WRITER - open as a writer
-
WRCREAT - open as a writer; if the database does not exist, create a new one
-
NEWDB - open as a writer; overwrite any existing databases
The values WRITER, WRCREAT and NEWDB may be combined with the following values by bitwise or:
-
SYNC - cause all database operations to be synchronized to the disk
-
NOLOCK - do not lock the database file
If no flags are specified, the GDBM object will try to open the database file as a writer and will create it if it does not already exist (cf. flag WRCREAT
). If this fails (for instance, if another process has already opened the database as a reader), it will try to open the database file as a reader (cf. flag READER
).
190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 |
# File 'gdbm.c', line 190
static VALUE
fgdbm_initialize(int argc, VALUE *argv, VALUE obj)
{
VALUE file, vmode, vflags;
GDBM_FILE dbm;
struct dbmdata *dbmp;
int mode, flags = 0;
if (rb_scan_args(argc, argv, "12", &file, &vmode, &vflags) == 1) {
mode = 0666; /* default value */
}
else if (NIL_P(vmode)) {
mode = -1; /* return nil if DB does not exist */
}
else {
mode = NUM2INT(vmode);
}
if (!NIL_P(vflags))
flags = NUM2INT(vflags);
SafeStringValue(file);
#ifdef GDBM_CLOEXEC
/* GDBM_CLOEXEC is available since gdbm 1.10. */
flags |= GDBM_CLOEXEC;
#endif
if (flags & RUBY_GDBM_RW_BIT) {
flags &= ~RUBY_GDBM_RW_BIT;
dbm = gdbm_open(RSTRING_PTR(file), MY_BLOCK_SIZE,
flags, mode, MY_FATAL_FUNC);
}
else {
dbm = 0;
if (mode >= 0)
dbm = gdbm_open(RSTRING_PTR(file), MY_BLOCK_SIZE,
GDBM_WRCREAT|flags, mode, MY_FATAL_FUNC);
if (!dbm)
dbm = gdbm_open(RSTRING_PTR(file), MY_BLOCK_SIZE,
GDBM_WRITER|flags, 0, MY_FATAL_FUNC);
if (!dbm)
dbm = gdbm_open(RSTRING_PTR(file), MY_BLOCK_SIZE,
GDBM_READER|flags, 0, MY_FATAL_FUNC);
}
if (dbm) {
rb_fd_fix_cloexec(gdbm_fdesc(dbm));
}
if (!dbm) {
if (mode == -1) return Qnil;
if (gdbm_errno == GDBM_FILE_OPEN_ERROR ||
gdbm_errno == GDBM_CANT_BE_READER ||
gdbm_errno == GDBM_CANT_BE_WRITER)
rb_sys_fail_str(file);
else
rb_raise(rb_eGDBMError, "%s", gdbm_strerror(gdbm_errno));
}
dbmp = ALLOC(struct dbmdata);
free_dbm(DATA_PTR(obj));
DATA_PTR(obj) = dbmp;
dbmp->di_dbm = dbm;
dbmp->di_size = -1;
return obj;
}
|
Class Method Details
.open(filename, mode = 0666, flags = nil) ⇒ Object .open(filename, mode = 0666, flags = nil) {|gdbm| ... } ⇒ Object
If called without a block, this is synonymous to GDBM::new. If a block is given, the new GDBM instance will be passed to the block as a parameter, and the corresponding database file will be closed after the execution of the block code has been finished.
Example for an open call with a block:
require 'gdbm'
GDBM.open("fruitstore.db") do |gdbm|
gdbm.each_pair do |key, value|
print "#{key}: #{value}\n"
end
end
279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 |
# File 'gdbm.c', line 279
static VALUE
fgdbm_s_open(int argc, VALUE *argv, VALUE klass)
{
VALUE obj = Data_Wrap_Struct(klass, 0, free_dbm, 0);
if (NIL_P(fgdbm_initialize(argc, argv, obj))) {
return Qnil;
}
if (rb_block_given_p()) {
return rb_ensure(rb_yield, obj, fgdbm_close, obj);
}
return obj;
}
|
Instance Method Details
#[](key) ⇒ Object
Retrieves the value corresponding to key.
393 394 395 396 397 |
# File 'gdbm.c', line 393
static VALUE
fgdbm_aref(VALUE obj, VALUE keystr)
{
return rb_gdbm_fetch3(obj, keystr);
}
|
#[]=(key) ⇒ Object #store(key, value) ⇒ Object
Associates the value value with the specified key.
699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 |
# File 'gdbm.c', line 699
static VALUE
fgdbm_store(VALUE obj, VALUE keystr, VALUE valstr)
{
datum key, val;
struct dbmdata *dbmp;
GDBM_FILE dbm;
rb_gdbm_modify(obj);
StringValue(keystr);
StringValue(valstr);
key.dptr = RSTRING_PTR(keystr);
key.dsize = RSTRING_LENINT(keystr);
val.dptr = RSTRING_PTR(valstr);
val.dsize = RSTRING_LENINT(valstr);
GetDBM2(obj, dbmp, dbm);
dbmp->di_size = -1;
if (gdbm_store(dbm, key, val, GDBM_REPLACE)) {
if (errno == EPERM) rb_sys_fail(0);
rb_raise(rb_eGDBMError, "%s", gdbm_strerror(gdbm_errno));
}
return valstr;
}
|
#cachesize=(size) ⇒ Object
Sets the size of the internal bucket cache to size.
1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 |
# File 'gdbm.c', line 1088
static VALUE
fgdbm_set_cachesize(VALUE obj, VALUE val)
{
struct dbmdata *dbmp;
GDBM_FILE dbm;
int optval;
GetDBM2(obj, dbmp, dbm);
optval = FIX2INT(val);
if (gdbm_setopt(dbm, GDBM_CACHESIZE, &optval, sizeof(optval)) == -1) {
rb_raise(rb_eGDBMError, "%s", gdbm_strerror(gdbm_errno));
}
return val;
}
|
#clear ⇒ Object
Removes all the key-value pairs within gdbm.
630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 |
# File 'gdbm.c', line 630
static VALUE
fgdbm_clear(VALUE obj)
{
datum key, nextkey;
struct dbmdata *dbmp;
GDBM_FILE dbm;
rb_gdbm_modify(obj);
GetDBM2(obj, dbmp, dbm);
dbmp->di_size = -1;
#if 0
while (key = gdbm_firstkey(dbm), key.dptr) {
if (gdbm_delete(dbm, key)) {
free(key.dptr);
rb_raise(rb_eGDBMError, "%s", gdbm_strerror(gdbm_errno));
}
free(key.dptr);
}
#else
while (key = gdbm_firstkey(dbm), key.dptr) {
for (; key.dptr; key = nextkey) {
nextkey = gdbm_nextkey(dbm, key);
if (gdbm_delete(dbm, key)) {
free(key.dptr);
if (nextkey.dptr) free(nextkey.dptr);
rb_raise(rb_eGDBMError, "%s", gdbm_strerror(gdbm_errno));
}
free(key.dptr);
}
}
#endif
dbmp->di_size = 0;
return obj;
}
|
#close ⇒ nil
Closes the associated database file.
129 130 131 132 133 134 135 136 137 138 139 |
# File 'gdbm.c', line 129
static VALUE
fgdbm_close(VALUE obj)
{
struct dbmdata *dbmp;
GetDBM(obj, dbmp);
gdbm_close(dbmp->di_dbm);
dbmp->di_dbm = 0;
return Qnil;
}
|
#closed? ⇒ Boolean
Returns true if the associated database file has been closed.
147 148 149 150 151 152 153 154 155 156 157 158 159 |
# File 'gdbm.c', line 147
static VALUE
fgdbm_closed(VALUE obj)
{
struct dbmdata *dbmp;
Data_Get_Struct(obj, struct dbmdata, dbmp);
if (dbmp == 0)
return Qtrue;
if (dbmp->di_dbm == 0)
return Qtrue;
return Qfalse;
}
|
#delete(key) ⇒ nil
Removes the key-value-pair with the specified key from this database and returns the corresponding value. Returns nil if the database is empty.
549 550 551 552 553 554 555 556 557 |
# File 'gdbm.c', line 549
static VALUE
fgdbm_delete(VALUE obj, VALUE keystr)
{
VALUE valstr;
valstr = fgdbm_fetch(obj, keystr, Qnil);
rb_gdbm_delete(obj, keystr);
return valstr;
}
|
#delete_if {|key, value| ... } ⇒ Object #reject! {|key, value| ... } ⇒ Object
Deletes every key-value pair from gdbm for which block evaluates to true.
590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 |
# File 'gdbm.c', line 590
static VALUE
fgdbm_delete_if(VALUE obj)
{
struct dbmdata *dbmp;
GDBM_FILE dbm;
VALUE keystr, valstr;
VALUE ret, ary = rb_ary_tmp_new(0);
int i, status = 0, n;
rb_gdbm_modify(obj);
GetDBM2(obj, dbmp, dbm);
n = dbmp->di_size;
dbmp->di_size = -1;
for (keystr = rb_gdbm_firstkey(dbm); RTEST(keystr);
keystr = rb_gdbm_nextkey(dbm, keystr)) {
OBJ_FREEZE(keystr);
valstr = rb_gdbm_fetch2(dbm, keystr);
ret = rb_protect(rb_yield, rb_assoc_new(rb_str_dup(keystr), valstr), &status);
if (status != 0) break;
if (RTEST(ret)) rb_ary_push(ary, keystr);
GetDBM2(obj, dbmp, dbm);
}
for (i = 0; i < RARRAY_LEN(ary); i++)
rb_gdbm_delete(obj, RARRAY_PTR(ary)[i]);
if (status) rb_jump_tag(status);
if (n > 0) dbmp->di_size = n - (int)RARRAY_LEN(ary);
rb_ary_clear(ary);
return obj;
}
|
#each_pair {|key, value| ... } ⇒ Object
Executes block for each key in the database, passing the key and the correspoding value as a parameter.
883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 |
# File 'gdbm.c', line 883
static VALUE
fgdbm_each_pair(VALUE obj)
{
GDBM_FILE dbm;
struct dbmdata *dbmp;
VALUE keystr;
RETURN_ENUMERATOR(obj, 0, 0);
GetDBM2(obj, dbmp, dbm);
for (keystr = rb_gdbm_firstkey(dbm); RTEST(keystr);
keystr = rb_gdbm_nextkey(dbm, keystr)) {
rb_yield(rb_assoc_new(keystr, rb_gdbm_fetch2(dbm, keystr)));
GetDBM2(obj, dbmp, dbm);
}
return obj;
}
|
#each_key {|key| ... } ⇒ Object
Executes block for each key in the database, passing the key as a parameter.
857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 |
# File 'gdbm.c', line 857
static VALUE
fgdbm_each_key(VALUE obj)
{
struct dbmdata *dbmp;
GDBM_FILE dbm;
VALUE keystr;
RETURN_ENUMERATOR(obj, 0, 0);
GetDBM2(obj, dbmp, dbm);
for (keystr = rb_gdbm_firstkey(dbm); RTEST(keystr);
keystr = rb_gdbm_nextkey(dbm, keystr)) {
rb_yield(keystr);
GetDBM2(obj, dbmp, dbm);
}
return obj;
}
|
#each_pair {|key, value| ... } ⇒ Object
Executes block for each key in the database, passing the key and the correspoding value as a parameter.
883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 |
# File 'gdbm.c', line 883
static VALUE
fgdbm_each_pair(VALUE obj)
{
GDBM_FILE dbm;
struct dbmdata *dbmp;
VALUE keystr;
RETURN_ENUMERATOR(obj, 0, 0);
GetDBM2(obj, dbmp, dbm);
for (keystr = rb_gdbm_firstkey(dbm); RTEST(keystr);
keystr = rb_gdbm_nextkey(dbm, keystr)) {
rb_yield(rb_assoc_new(keystr, rb_gdbm_fetch2(dbm, keystr)));
GetDBM2(obj, dbmp, dbm);
}
return obj;
}
|
#each_value {|value| ... } ⇒ Object
Executes block for each key in the database, passing the corresponding value as a parameter.
831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 |
# File 'gdbm.c', line 831
static VALUE
fgdbm_each_value(VALUE obj)
{
struct dbmdata *dbmp;
GDBM_FILE dbm;
VALUE keystr;
RETURN_ENUMERATOR(obj, 0, 0);
GetDBM2(obj, dbmp, dbm);
for (keystr = rb_gdbm_firstkey(dbm); RTEST(keystr);
keystr = rb_gdbm_nextkey(dbm, keystr)) {
rb_yield(rb_gdbm_fetch2(dbm, keystr));
GetDBM2(obj, dbmp, dbm);
}
return obj;
}
|
#empty? ⇒ Boolean
Returns true if the database is empty.
801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 |
# File 'gdbm.c', line 801
static VALUE
fgdbm_empty_p(VALUE obj)
{
datum key;
struct dbmdata *dbmp;
GDBM_FILE dbm;
GetDBM(obj, dbmp);
if (dbmp->di_size < 0) {
dbm = dbmp->di_dbm;
key = gdbm_firstkey(dbm);
if (key.dptr) {
free(key.dptr);
return Qfalse;
}
return Qtrue;
}
if (dbmp->di_size == 0) return Qtrue;
return Qfalse;
}
|
#fastmode=(boolean) ⇒ Boolean
Turns the database’s fast mode on or off. If fast mode is turned on, gdbm does not wait for writes to be flushed to the disk before continuing.
This option is obsolete for gdbm >= 1.8 since fast mode is turned on by default. See also: #syncmode=
1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 |
# File 'gdbm.c', line 1113
static VALUE
fgdbm_set_fastmode(VALUE obj, VALUE val)
{
struct dbmdata *dbmp;
GDBM_FILE dbm;
int optval;
GetDBM2(obj, dbmp, dbm);
optval = 0;
if (RTEST(val))
optval = 1;
if (gdbm_setopt(dbm, GDBM_FASTMODE, &optval, sizeof(optval)) == -1) {
rb_raise(rb_eGDBMError, "%s", gdbm_strerror(gdbm_errno));
}
return val;
}
|
#fetch(key[, default]) ⇒ Object
Retrieves the value corresponding to key. If there is no value associated with key, default will be returned instead.
406 407 408 409 410 411 412 413 414 415 416 417 |
# File 'gdbm.c', line 406
static VALUE
fgdbm_fetch_m(int argc, VALUE *argv, VALUE obj)
{
VALUE keystr, valstr, ifnone;
rb_scan_args(argc, argv, "11", &keystr, &ifnone);
valstr = fgdbm_fetch(obj, keystr, ifnone);
if (argc == 1 && !rb_block_given_p() && NIL_P(valstr))
rb_raise(rb_eIndexError, "key not found");
return valstr;
}
|
#include?(k) ⇒ Boolean #has_key?(k) ⇒ Boolean #member?(k) ⇒ Boolean #key?(k) ⇒ Boolean
Returns true if the given key k exists within the database. Returns false otherwise.
963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 |
# File 'gdbm.c', line 963
static VALUE
fgdbm_has_key(VALUE obj, VALUE keystr)
{
datum key;
struct dbmdata *dbmp;
GDBM_FILE dbm;
long len;
StringValue(keystr);
len = RSTRING_LENINT(keystr);
if (TOO_LONG(len)) return Qfalse;
key.dptr = RSTRING_PTR(keystr);
key.dsize = (int)len;
GetDBM2(obj, dbmp, dbm);
if (gdbm_exists(dbm, key))
return Qtrue;
return Qfalse;
}
|
#has_value?(v) ⇒ Boolean #value?(v) ⇒ Boolean
Returns true if the given value v exists within the database. Returns false otherwise.
991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 |
# File 'gdbm.c', line 991
static VALUE
fgdbm_has_value(VALUE obj, VALUE valstr)
{
struct dbmdata *dbmp;
GDBM_FILE dbm;
VALUE keystr, valstr2;
StringValue(valstr);
GetDBM2(obj, dbmp, dbm);
for (keystr = rb_gdbm_firstkey(dbm); RTEST(keystr);
keystr = rb_gdbm_nextkey(dbm, keystr)) {
valstr2 = rb_gdbm_fetch2(dbm, keystr);
if (!NIL_P(valstr2) &&
(int)RSTRING_LEN(valstr) == (int)RSTRING_LEN(valstr2) &&
memcmp(RSTRING_PTR(valstr), RSTRING_PTR(valstr2),
(int)RSTRING_LEN(valstr)) == 0) {
return Qtrue;
}
}
return Qfalse;
}
|
#include?(k) ⇒ Boolean #has_key?(k) ⇒ Boolean #member?(k) ⇒ Boolean #key?(k) ⇒ Boolean
Returns true if the given key k exists within the database. Returns false otherwise.
963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 |
# File 'gdbm.c', line 963
static VALUE
fgdbm_has_key(VALUE obj, VALUE keystr)
{
datum key;
struct dbmdata *dbmp;
GDBM_FILE dbm;
long len;
StringValue(keystr);
len = RSTRING_LENINT(keystr);
if (TOO_LONG(len)) return Qfalse;
key.dptr = RSTRING_PTR(keystr);
key.dsize = (int)len;
GetDBM2(obj, dbmp, dbm);
if (gdbm_exists(dbm, key))
return Qtrue;
return Qfalse;
}
|
#index ⇒ Object
:nodoc:
450 451 452 453 454 455 |
# File 'gdbm.c', line 450
static VALUE
fgdbm_index(VALUE obj, VALUE value)
{
rb_warn("GDBM#index is deprecated; use GDBM#key");
return fgdbm_key(obj, value);
}
|
#invert ⇒ Hash
Returns a hash created by using gdbm’s values as keys, and the keys as values.
674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 |
# File 'gdbm.c', line 674
static VALUE
fgdbm_invert(VALUE obj)
{
struct dbmdata *dbmp;
GDBM_FILE dbm;
VALUE keystr, valstr;
VALUE hash = rb_hash_new();
GetDBM2(obj, dbmp, dbm);
for (keystr = rb_gdbm_firstkey(dbm); RTEST(keystr);
keystr = rb_gdbm_nextkey(dbm, keystr)) {
valstr = rb_gdbm_fetch2(dbm, keystr);
rb_hash_aset(hash, valstr, keystr);
}
return hash;
}
|
#key(value) ⇒ Object
Returns the key for a given value. If several keys may map to the same value, the key that is found first will be returned.
426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 |
# File 'gdbm.c', line 426
static VALUE
fgdbm_key(VALUE obj, VALUE valstr)
{
struct dbmdata *dbmp;
GDBM_FILE dbm;
VALUE keystr, valstr2;
StringValue(valstr);
GetDBM2(obj, dbmp, dbm);
for (keystr = rb_gdbm_firstkey(dbm); RTEST(keystr);
keystr = rb_gdbm_nextkey(dbm, keystr)) {
valstr2 = rb_gdbm_fetch2(dbm, keystr);
if (!NIL_P(valstr2) &&
(int)RSTRING_LEN(valstr) == (int)RSTRING_LEN(valstr2) &&
memcmp(RSTRING_PTR(valstr), RSTRING_PTR(valstr2),
(int)RSTRING_LEN(valstr)) == 0) {
return keystr;
}
}
return Qnil;
}
|
#include?(k) ⇒ Boolean #has_key?(k) ⇒ Boolean #member?(k) ⇒ Boolean #key?(k) ⇒ Boolean
Returns true if the given key k exists within the database. Returns false otherwise.
963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 |
# File 'gdbm.c', line 963
static VALUE
fgdbm_has_key(VALUE obj, VALUE keystr)
{
datum key;
struct dbmdata *dbmp;
GDBM_FILE dbm;
long len;
StringValue(keystr);
len = RSTRING_LENINT(keystr);
if (TOO_LONG(len)) return Qfalse;
key.dptr = RSTRING_PTR(keystr);
key.dsize = (int)len;
GetDBM2(obj, dbmp, dbm);
if (gdbm_exists(dbm, key))
return Qtrue;
return Qfalse;
}
|
#keys ⇒ Array
Returns an array of all keys of this database.
909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 |
# File 'gdbm.c', line 909
static VALUE
fgdbm_keys(VALUE obj)
{
struct dbmdata *dbmp;
GDBM_FILE dbm;
VALUE keystr, ary;
GetDBM2(obj, dbmp, dbm);
ary = rb_ary_new();
for (keystr = rb_gdbm_firstkey(dbm); RTEST(keystr);
keystr = rb_gdbm_nextkey(dbm, keystr)) {
rb_ary_push(ary, keystr);
}
return ary;
}
|
#length ⇒ Fixnum #size ⇒ Fixnum
Returns the number of key-value pairs in this database.
774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 |
# File 'gdbm.c', line 774
static VALUE
fgdbm_length(VALUE obj)
{
datum key, nextkey;
struct dbmdata *dbmp;
GDBM_FILE dbm;
int i = 0;
GetDBM2(obj, dbmp, dbm);
if (dbmp->di_size > 0) return INT2FIX(dbmp->di_size);
for (key = gdbm_firstkey(dbm); key.dptr; key = nextkey) {
nextkey = gdbm_nextkey(dbm, key);
free(key.dptr);
i++;
}
dbmp->di_size = i;
return INT2FIX(i);
}
|
#include?(k) ⇒ Boolean #has_key?(k) ⇒ Boolean #member?(k) ⇒ Boolean #key?(k) ⇒ Boolean
Returns true if the given key k exists within the database. Returns false otherwise.
963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 |
# File 'gdbm.c', line 963
static VALUE
fgdbm_has_key(VALUE obj, VALUE keystr)
{
datum key;
struct dbmdata *dbmp;
GDBM_FILE dbm;
long len;
StringValue(keystr);
len = RSTRING_LENINT(keystr);
if (TOO_LONG(len)) return Qfalse;
key.dptr = RSTRING_PTR(keystr);
key.dsize = (int)len;
GetDBM2(obj, dbmp, dbm);
if (gdbm_exists(dbm, key))
return Qtrue;
return Qfalse;
}
|
#reject {|key, value| ... } ⇒ Hash
Returns a hash copy of gdbm where all key-value pairs from gdbm for which block evaluates to true are removed. See also: #delete_if
1198 1199 1200 1201 1202 |
# File 'gdbm.c', line 1198
static VALUE
fgdbm_reject(VALUE obj)
{
return rb_hash_delete_if(fgdbm_to_hash(obj));
}
|
#delete_if {|key, value| ... } ⇒ Object #reject! {|key, value| ... } ⇒ Object
Deletes every key-value pair from gdbm for which block evaluates to true.
590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 |
# File 'gdbm.c', line 590
static VALUE
fgdbm_delete_if(VALUE obj)
{
struct dbmdata *dbmp;
GDBM_FILE dbm;
VALUE keystr, valstr;
VALUE ret, ary = rb_ary_tmp_new(0);
int i, status = 0, n;
rb_gdbm_modify(obj);
GetDBM2(obj, dbmp, dbm);
n = dbmp->di_size;
dbmp->di_size = -1;
for (keystr = rb_gdbm_firstkey(dbm); RTEST(keystr);
keystr = rb_gdbm_nextkey(dbm, keystr)) {
OBJ_FREEZE(keystr);
valstr = rb_gdbm_fetch2(dbm, keystr);
ret = rb_protect(rb_yield, rb_assoc_new(rb_str_dup(keystr), valstr), &status);
if (status != 0) break;
if (RTEST(ret)) rb_ary_push(ary, keystr);
GetDBM2(obj, dbmp, dbm);
}
for (i = 0; i < RARRAY_LEN(ary); i++)
rb_gdbm_delete(obj, RARRAY_PTR(ary)[i]);
if (status) rb_jump_tag(status);
if (n > 0) dbmp->di_size = n - (int)RARRAY_LEN(ary);
rb_ary_clear(ary);
return obj;
}
|
#reorganize ⇒ Object
Reorganizes the database file. This operation removes reserved space of elements that have already been deleted. It is only useful after a lot of deletions in the database.
1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 |
# File 'gdbm.c', line 1047
static VALUE
fgdbm_reorganize(VALUE obj)
{
struct dbmdata *dbmp;
GDBM_FILE dbm;
rb_gdbm_modify(obj);
GetDBM2(obj, dbmp, dbm);
gdbm_reorganize(dbm);
rb_fd_fix_cloexec(gdbm_fdesc(dbm));
return obj;
}
|
#replace(other) ⇒ Object
Replaces the content of gdbm with the key-value pairs of other. other must have an each_pair method.
759 760 761 762 763 764 765 |
# File 'gdbm.c', line 759
static VALUE
fgdbm_replace(VALUE obj, VALUE other)
{
fgdbm_clear(obj);
rb_block_call(other, rb_intern("each_pair"), 0, 0, update_i, obj);
return obj;
}
|
#select {|key, value| ... } ⇒ Array
Returns a new array of all key-value pairs of the database for which block evaluates to true.
464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 |
# File 'gdbm.c', line 464
static VALUE
fgdbm_select(VALUE obj)
{
VALUE new = rb_ary_new();
GDBM_FILE dbm;
struct dbmdata *dbmp;
VALUE keystr;
GetDBM2(obj, dbmp, dbm);
for (keystr = rb_gdbm_firstkey(dbm); RTEST(keystr);
keystr = rb_gdbm_nextkey(dbm, keystr)) {
VALUE assoc = rb_assoc_new(keystr, rb_gdbm_fetch2(dbm, keystr));
VALUE v = rb_yield(assoc);
if (RTEST(v)) {
rb_ary_push(new, assoc);
}
GetDBM2(obj, dbmp, dbm);
}
return new;
}
|
#shift ⇒ nil
Removes a key-value-pair from this database and returns it as a two-item array [ key, value ]. Returns nil if the database is empty.
566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 |
# File 'gdbm.c', line 566
static VALUE
fgdbm_shift(VALUE obj)
{
struct dbmdata *dbmp;
GDBM_FILE dbm;
VALUE keystr, valstr;
rb_gdbm_modify(obj);
GetDBM2(obj, dbmp, dbm);
keystr = rb_gdbm_firstkey(dbm);
if (NIL_P(keystr)) return Qnil;
valstr = rb_gdbm_fetch2(dbm, keystr);
rb_gdbm_delete(obj, keystr);
return rb_assoc_new(keystr, valstr);
}
|
#length ⇒ Fixnum #size ⇒ Fixnum
Returns the number of key-value pairs in this database.
774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 |
# File 'gdbm.c', line 774
static VALUE
fgdbm_length(VALUE obj)
{
datum key, nextkey;
struct dbmdata *dbmp;
GDBM_FILE dbm;
int i = 0;
GetDBM2(obj, dbmp, dbm);
if (dbmp->di_size > 0) return INT2FIX(dbmp->di_size);
for (key = gdbm_firstkey(dbm); key.dptr; key = nextkey) {
nextkey = gdbm_nextkey(dbm, key);
free(key.dptr);
i++;
}
dbmp->di_size = i;
return INT2FIX(i);
}
|
#[]=(key) ⇒ Object #store(key, value) ⇒ Object
Associates the value value with the specified key.
699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 |
# File 'gdbm.c', line 699
static VALUE
fgdbm_store(VALUE obj, VALUE keystr, VALUE valstr)
{
datum key, val;
struct dbmdata *dbmp;
GDBM_FILE dbm;
rb_gdbm_modify(obj);
StringValue(keystr);
StringValue(valstr);
key.dptr = RSTRING_PTR(keystr);
key.dsize = RSTRING_LENINT(keystr);
val.dptr = RSTRING_PTR(valstr);
val.dsize = RSTRING_LENINT(valstr);
GetDBM2(obj, dbmp, dbm);
dbmp->di_size = -1;
if (gdbm_store(dbm, key, val, GDBM_REPLACE)) {
if (errno == EPERM) rb_sys_fail(0);
rb_raise(rb_eGDBMError, "%s", gdbm_strerror(gdbm_errno));
}
return valstr;
}
|
#sync ⇒ Object
Unless the gdbm object has been opened with the SYNC flag, it is not guarenteed that database modification operations are immediately applied to the database file. This method ensures that all recent modifications to the database are written to the file. Blocks until all writing operations to the disk have been finished.
1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 |
# File 'gdbm.c', line 1070
static VALUE
fgdbm_sync(VALUE obj)
{
struct dbmdata *dbmp;
GDBM_FILE dbm;
rb_gdbm_modify(obj);
GetDBM2(obj, dbmp, dbm);
gdbm_sync(dbm);
return obj;
}
|
#syncmode=(boolean) ⇒ Boolean
Turns the database’s synchronization mode on or off. If the synchronization mode is turned on, the database’s in-memory state will be synchronized to disk after every database modification operation. If the synchronization mode is turned off, GDBM does not wait for writes to be flushed to the disk before continuing.
This option is only available for gdbm >= 1.8 where syncmode is turned off by default. See also: #fastmode=
1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 |
# File 'gdbm.c', line 1144
static VALUE
fgdbm_set_syncmode(VALUE obj, VALUE val)
{
#if !defined(GDBM_SYNCMODE)
fgdbm_set_fastmode(obj, RTEST(val) ? Qfalse : Qtrue);
return val;
#else
struct dbmdata *dbmp;
GDBM_FILE dbm;
int optval;
GetDBM2(obj, dbmp, dbm);
optval = 0;
if (RTEST(val))
optval = 1;
if (gdbm_setopt(dbm, GDBM_FASTMODE, &optval, sizeof(optval)) == -1) {
rb_raise(rb_eGDBMError, "%s", gdbm_strerror(gdbm_errno));
}
return val;
#endif
}
|
#to_a ⇒ Array
Returns an array of all key-value pairs contained in the database.
1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 |
# File 'gdbm.c', line 1021
static VALUE
fgdbm_to_a(VALUE obj)
{
struct dbmdata *dbmp;
GDBM_FILE dbm;
VALUE keystr, ary;
GetDBM2(obj, dbmp, dbm);
ary = rb_ary_new();
for (keystr = rb_gdbm_firstkey(dbm); RTEST(keystr);
keystr = rb_gdbm_nextkey(dbm, keystr)) {
rb_ary_push(ary, rb_assoc_new(keystr, rb_gdbm_fetch2(dbm, keystr)));
}
return ary;
}
|
#to_hash ⇒ Hash
Returns a hash of all key-value pairs contained in the database.
1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 |
# File 'gdbm.c', line 1173
static VALUE
fgdbm_to_hash(VALUE obj)
{
struct dbmdata *dbmp;
GDBM_FILE dbm;
VALUE keystr, hash;
GetDBM2(obj, dbmp, dbm);
hash = rb_hash_new();
for (keystr = rb_gdbm_firstkey(dbm); RTEST(keystr);
keystr = rb_gdbm_nextkey(dbm, keystr)) {
rb_hash_aset(hash, keystr, rb_gdbm_fetch2(dbm, keystr));
}
return hash;
}
|
#update(other) ⇒ Object
Adds the key-value pairs of other to gdbm, overwriting entries with duplicate keys with those from other. other must have an each_pair method.
745 746 747 748 749 750 |
# File 'gdbm.c', line 745
static VALUE
fgdbm_update(VALUE obj, VALUE other)
{
rb_block_call(other, rb_intern("each_pair"), 0, 0, update_i, obj);
return obj;
}
|
#has_value?(v) ⇒ Boolean #value?(v) ⇒ Boolean
Returns true if the given value v exists within the database. Returns false otherwise.
991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 |
# File 'gdbm.c', line 991
static VALUE
fgdbm_has_value(VALUE obj, VALUE valstr)
{
struct dbmdata *dbmp;
GDBM_FILE dbm;
VALUE keystr, valstr2;
StringValue(valstr);
GetDBM2(obj, dbmp, dbm);
for (keystr = rb_gdbm_firstkey(dbm); RTEST(keystr);
keystr = rb_gdbm_nextkey(dbm, keystr)) {
valstr2 = rb_gdbm_fetch2(dbm, keystr);
if (!NIL_P(valstr2) &&
(int)RSTRING_LEN(valstr) == (int)RSTRING_LEN(valstr2) &&
memcmp(RSTRING_PTR(valstr), RSTRING_PTR(valstr2),
(int)RSTRING_LEN(valstr)) == 0) {
return Qtrue;
}
}
return Qfalse;
}
|
#values ⇒ Array
Returns an array of all values of this database.
933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 |
# File 'gdbm.c', line 933
static VALUE
fgdbm_values(VALUE obj)
{
datum key, nextkey;
struct dbmdata *dbmp;
GDBM_FILE dbm;
VALUE valstr, ary;
GetDBM2(obj, dbmp, dbm);
ary = rb_ary_new();
for (key = gdbm_firstkey(dbm); key.dptr; key = nextkey) {
nextkey = gdbm_nextkey(dbm, key);
valstr = rb_gdbm_fetch(dbm, key);
free(key.dptr);
rb_ary_push(ary, valstr);
}
return ary;
}
|
#values_at(key, ...) ⇒ Array
Returns an array of the values associated with each specified key.
493 494 495 496 497 498 499 500 501 502 503 504 |
# File 'gdbm.c', line 493
static VALUE
fgdbm_values_at(int argc, VALUE *argv, VALUE obj)
{
VALUE new = rb_ary_new2(argc);
int i;
for (i=0; i<argc; i++) {
rb_ary_push(new, rb_gdbm_fetch3(obj, argv[i]));
}
return new;
}
|