Class: LMDB::Cursor

Inherits:
Object
  • Object
show all
Defined in:
ext/lmdb_ext/lmdb_ext.c,
ext/lmdb_ext/lmdb_ext.c

Overview

A Cursor points to records in a database, and is used to iterate through the records in the database.

Cursors are created in the context of a transaction, and should only be used as long as that transaction is active. In other words, after you Transaction#commit or Transaction#abort a transaction, the cursors created while that transaction was active are no longer usable.

To create a cursor, call Database#cursor and pass it a block for that should be performed using the cursor.

Examples:

Typical usage

env = LMDB.new "databasedir"
db = env.database "databasename"
db.cursor do |cursor|
  rl = cursor.last           #=> content of the last record
  r1 = cursor.first          #=> content of the first record
  r2 = cursor.next           #=> content of the second record
  cursor.put "x", "y", current: true
                             #=> replaces the second record with a new value "y"
end

Instance Method Summary collapse

Instance Method Details

#close ⇒ Object

Close a cursor. The cursor must not be used again after this call.



1213
1214
1215
1216
1217
1218
 
# File 'ext/lmdb_ext/lmdb_ext.c', line 1213

static VALUE cursor_close(VALUE self) {
        CURSOR(self, cursor);
        mdb_cursor_close(cursor->cur);
        cursor->cur = 0;
        return Qnil;
}

#count ⇒ Number

Return count of duplicates for current key. This call is only valid on databases that support sorted duplicate data items :dupsort.

Returns:

  • (Number) —

    count of duplicates



1602
1603
1604
1605
1606
1607
 
# File 'ext/lmdb_ext/lmdb_ext.c', line 1602

static VALUE cursor_count(VALUE self) {
        CURSOR(self, cursor);
        size_t count;
        check(mdb_cursor_count(cursor->cur, &count));
        return SIZET2NUM(count);
}

#cursor_db ⇒ Database

Returns the database which this cursor is iterating over.

Returns:

  • (Database) —

    the database which this cursor is iterating over.



1590
1591
1592
1593
 
# File 'ext/lmdb_ext/lmdb_ext.c', line 1590

static VALUE cursor_db(VALUE self) {
        CURSOR(self, cursor);
        return cursor->db;
}

#delete(options) ⇒ Object

Delete current key/data pair. This function deletes the key/data pair to which the cursor refers.

Options Hash (options):

  • :nodupdata (Boolean) —

    Delete all of the data items for the current key. This flag may only be specified if the database was opened with :dupsort.



1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
 
# File 'ext/lmdb_ext/lmdb_ext.c', line 1566

static VALUE cursor_delete(int argc, VALUE *argv, VALUE self) {
    CURSOR(self, cursor);

    VALUE option_hash;
#ifdef RB_SCAN_ARGS_KEYWORDS
    rb_scan_args_kw(RB_SCAN_ARGS_LAST_HASH_KEYWORDS,
                    argc, argv, ":", &option_hash);
#else
    rb_scan_args(argc, argv, ":", &option_hash);
#endif

    int flags = 0;
    if (!NIL_P(option_hash))
        rb_hash_foreach(option_hash, (int (*)(ANYARGS))cursor_delete_flags,
                        (VALUE)&flags);

    check(mdb_cursor_del(cursor->cur, flags));
    return Qnil;
}

#first ⇒ Array?

Position the cursor to the first record in the database, and return its value.

Returns:

  • (Array, nil) —

    The [key, value] pair for the first record, or nil if no record



1294
1295
1296
1297
1298
1299
1300
 
# File 'ext/lmdb_ext/lmdb_ext.c', line 1294

static VALUE cursor_first(VALUE self) {
        CURSOR(self, cursor);
        MDB_val key, value;

        check(mdb_cursor_get(cursor->cur, &key, &value, MDB_FIRST));
        return rb_assoc_new(rb_str_new(key.mv_data, key.mv_size), rb_str_new(value.mv_data, value.mv_size));
}

#get ⇒ Array

Return the value of the record to which the cursor points.

Returns:

  • (Array) —

    The [key, value] pair for the current record.



1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
 
# File 'ext/lmdb_ext/lmdb_ext.c', line 1475

static VALUE cursor_get(VALUE self) {
        CURSOR(self, cursor);

        MDB_val key, value;
        int ret = mdb_cursor_get(cursor->cur, &key, &value, MDB_GET_CURRENT);
        if (ret == MDB_NOTFOUND)
                return Qnil;
        check(ret);
        return rb_assoc_new(rb_str_new(key.mv_data, key.mv_size), rb_str_new(value.mv_data, value.mv_size));
}

#last ⇒ Array?

Position the cursor to the last record in the database, and return its value.

Returns:

  • (Array, nil) —

    The [key, value] pair for the last record, or nil if no record.



1309
1310
1311
1312
1313
1314
1315
 
# File 'ext/lmdb_ext/lmdb_ext.c', line 1309

static VALUE cursor_last(VALUE self) {
        CURSOR(self, cursor);
        MDB_val key, value;

        check(mdb_cursor_get(cursor->cur, &key, &value, MDB_LAST));
        return rb_assoc_new(rb_str_new(key.mv_data, key.mv_size), rb_str_new(value.mv_data, value.mv_size));
}

#next(nodup = nil) ⇒ Array?

Position the cursor to the next record in the database, and return its value.

Parameters:

  • nodup (true, false) (defaults to: nil) —

    If true, skip over duplicate records.

Returns:

  • (Array, nil) —

    The [key, value] pair for the next record, or nil if no next record.



1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
 
# File 'ext/lmdb_ext/lmdb_ext.c', line 1343

static VALUE cursor_next(int argc, VALUE* argv, VALUE self) {
        CURSOR(self, cursor);
        VALUE nodup;
        MDB_val key, value;
        MDB_cursor_op op = MDB_NEXT;

        rb_scan_args(argc, argv, "01", &nodup);

        if (RTEST(nodup))
          op = MDB_NEXT_NODUP;

        int ret = mdb_cursor_get(cursor->cur, &key, &value, op);
        if (ret == MDB_NOTFOUND)
                return Qnil;
        check(ret);
        return rb_assoc_new(rb_str_new(key.mv_data, key.mv_size),
                            rb_str_new(value.mv_data, value.mv_size));
}

#next_range ⇒ Array?

Position the cursor to the next record in the database, and return its value if the record’s key is less than or equal to the specified key, or nil otherwise.

Parameters:

  • key (#to_s) —

    The key to serve as the upper bound

Returns:

  • (Array, nil) —

    The [key, value] pair for the next record, or nil if no next record or the next record is out of the range.



1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
 
# File 'ext/lmdb_ext/lmdb_ext.c', line 1371

static VALUE cursor_next_range(VALUE self, VALUE upper_bound_key) {
        CURSOR(self, cursor);
        MDB_val key, value, ub_key;

        int ret = mdb_cursor_get(cursor->cur, &key, &value, MDB_NEXT);
        if (ret == MDB_NOTFOUND)
                return Qnil;
        check(ret);

        ub_key.mv_size = RSTRING_LEN(upper_bound_key);
        ub_key.mv_data = StringValuePtr(upper_bound_key);

        MDB_txn* txn = mdb_cursor_txn(cursor->cur);
        MDB_dbi dbi = mdb_cursor_dbi(cursor->cur);

        if (mdb_cmp(txn, dbi, &key, &ub_key) <= 0) {
          return rb_assoc_new(rb_str_new(key.mv_data, key.mv_size),
                              rb_str_new(value.mv_data, value.mv_size));
        } else {
          return Qnil;
        }
}

#prev ⇒ Array?

Position the cursor to the previous record in the database, and return its value.

Returns:

  • (Array, nil) —

    The [key, value] pair for the previous record, or nil if no previous record.



1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
 
# File 'ext/lmdb_ext/lmdb_ext.c', line 1324

static VALUE cursor_prev(VALUE self) {
        CURSOR(self, cursor);
        MDB_val key, value;

        int ret = mdb_cursor_get(cursor->cur, &key, &value, MDB_PREV);
        if (ret == MDB_NOTFOUND)
                return Qnil;
        check(ret);
        return rb_assoc_new(rb_str_new(key.mv_data, key.mv_size), rb_str_new(value.mv_data, value.mv_size));
}

#put(key, value, options) ⇒ Object

Store by cursor. This function stores key/data pairs into the database. If the function fails for any reason, the state of the cursor will be unchanged. If the function succeeds and an item is inserted into the database, the cursor is always positioned to refer to the newly inserted item.

Parameters:

  • key —

    The key of the record to set

  • value —

    The value to insert for this key

Options Hash (options):

  • :current (Boolean) —

    Overwrite the data of the key/data pair to which the cursor refers with the specified data item. The key parameter is ignored.

  • :nodupdata (Boolean) —

    Enter the new key/value pair only if it does not already appear in the database. This flag may only be specified if the database was opened with :dupsort. The function will raise an Error if the key/data pair already appears in the database.

  • :nooverwrite (Boolean) —

    Enter the new key/value pair only if the key does not already appear in the database. The function will raise an {Error] if the key already appears in the database, even if the database supports duplicates (:dupsort).

  • :append (Boolean) —

    Append the given key/data pair to the end of the database. No key comparisons are performed. This option allows fast bulk loading when keys are already known to be in the correct order. Loading unsorted keys with this flag will cause data corruption.

  • :appenddup (Boolean) —

    As above, but for sorted dup data.

Returns:

  • nil



1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
 
# File 'ext/lmdb_ext/lmdb_ext.c', line 1523

static VALUE cursor_put(int argc, VALUE* argv, VALUE self) {
    CURSOR(self, cursor);

    VALUE vkey, vval, option_hash;
#ifdef RB_SCAN_ARGS_KEYWORDS
    rb_scan_args_kw(RB_SCAN_ARGS_LAST_HASH_KEYWORDS,
                    argc, argv, "2:", &vkey, &vval, &option_hash);
#else
    rb_scan_args(argc, argv, "2:", &vkey, &vval, &option_hash);
#endif

    int flags = 0;
    if (!NIL_P(option_hash))
        rb_hash_foreach(option_hash, (int (*)(ANYARGS))cursor_put_flags,
                        (VALUE)&flags);

    vkey = StringValue(vkey);
    vval = StringValue(vval);

    MDB_val key, value;
    key.mv_size = RSTRING_LEN(vkey);
    key.mv_data = RSTRING_PTR(vkey);
    value.mv_size = RSTRING_LEN(vval);
    value.mv_data = RSTRING_PTR(vval);

    check(mdb_cursor_put(cursor->cur, &key, &value, flags));
    return Qnil;
}

#set(key, value = nil) ⇒ Array

Set the cursor to a specified key, optionally at the specified value if the database was opened with :dupsort.

Parameters:

  • key (#to_s) —

    The key to which the cursor should be positioned

  • value (nil, #to_s) (defaults to: nil) —

    The optional value (:dupsort only)

Returns:

  • (Array) —

    The [key, value] pair to which the cursor now points.



1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
 
# File 'ext/lmdb_ext/lmdb_ext.c', line 1402

static VALUE cursor_set(int argc, VALUE* argv, VALUE self) {
         CURSOR(self, cursor);
         VALUE vkey, vval;
         MDB_val key, value;
         MDB_cursor_op op = MDB_SET_KEY;
         int ret;

         rb_scan_args(argc, argv, "11", &vkey, &vval);

         /*
           XXX TODO: this was a nasty segfault: the key (and any
           non-nil value) should be asserted to be strings, but then
           if the database is `integerkeys` then perhaps we should
           coerce?
         */

         if (TYPE(vkey) != T_STRING)
           rb_raise(rb_eArgError, "key must be a string");

         key.mv_size = RSTRING_LEN(vkey);
         key.mv_data = StringValuePtr(vkey);

         if (!NIL_P(vval)) {
           if (TYPE(vval) != T_STRING)
             rb_raise(rb_eArgError, "non-nil value must be a string");

           op = MDB_GET_BOTH;
           value.mv_size = RSTRING_LEN(vval);
           value.mv_data = StringValuePtr(vval);
         }

         ret = mdb_cursor_get(cursor->cur, &key, &value, op);

         if (!NIL_P(vval) && ret == MDB_NOTFOUND)
           return Qnil;

         check(ret);

         return rb_assoc_new(rb_str_new(key.mv_data, key.mv_size),
                             rb_str_new(value.mv_data, value.mv_size));
}

#set_range(key) ⇒ Array

Set the cursor at the first key greater than or equal to a specified key.

Parameters:

  • key —

    The key to which the cursor should be positioned

Returns:

  • (Array) —

    The [key, value] pair to which the cursor now points.



1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
 
# File 'ext/lmdb_ext/lmdb_ext.c', line 1450

static VALUE cursor_set_range(VALUE self, VALUE vkey) {
        CURSOR(self, cursor);
        MDB_val key, value;
        int ret;

        key.mv_size = RSTRING_LEN(vkey);
        key.mv_data = StringValuePtr(vkey);

        ret = mdb_cursor_get(cursor->cur, &key, &value, MDB_SET_RANGE);

        /* not sure why we were letting this throw an exception */
        if (ret == MDB_NOTFOUND) return Qnil;

        check(ret);

        return rb_assoc_new(rb_str_new(key.mv_data, key.mv_size),
                            rb_str_new(value.mv_data, value.mv_size));
}