Version 1.1.5
wiredtiger.Cursor Class Reference

Python wrapper around C ::__WT_CURSOR. More...

List of all members.

Public Member Functions

def equals
 equals(self, other) -> int
def next
 next(self) -> int
def prev
 prev(self) -> int
def reset
 reset(self) -> int
def search
 search(self) -> int
def search_near
 search_near(self) -> int
def insert
 insert(self) -> int
def update
 update(self) -> int
def remove
 remove(self) -> int
def close
 close(self, config) -> int
def get_key
 get_key(self) -> object
def get_keys
 get_keys(self) -> (object, ...)
def get_value
 get_value(self) -> object
def get_values
 get_values(self) -> (object, ...)
def set_key
 set_key(self) -> None
def set_value
 set_value(self) -> None
def __iter__
 Cursor objects support iteration, equivalent to calling WT_CURSOR::next until it returns WT_NOTFOUND.
def __init__
 __init__(self) -> Cursor

Public Attributes

 this

Detailed Description

Python wrapper around C ::__WT_CURSOR.


Member Function Documentation

Cursor objects support iteration, equivalent to calling WT_CURSOR::next until it returns WT_NOTFOUND.

def wiredtiger.Cursor.close (   self,
  args 
)

close(self, config) -> int

def wiredtiger.Cursor.equals (   self,
  args 
)

equals(self, other) -> int

Test whether two cursors refer to the same item.

To be equal, both cursors must have the same data source, have valid keys, and the keys must be equal.

        if (cursor->equals(cursor, other)) {
                /* Take some action. */
        }
Parameters:
cursorthe cursor handle
otheranother cursor handle
Returns:
true (non-zero) if both cursors reference the same item, false (zero) otherwise
def wiredtiger.Cursor.get_key (   self)

get_key(self) -> object

Get the key for the current record.

        const char *key;        /* Get the cursor's string key. */
        ret = cursor->get_key(cursor, &key);
        uint64_t recno;         /* Get the cursor's record number key. */
        ret = cursor->get_key(cursor, &recno);
Parameters:
cursorthe cursor handle
Returns:
zero on success and a non-zero error code on failure. See Error Returns for details.
Returns only the first column.

get_keys(self) -> (object, ...)

Get the key for the current record.

        const char *key;        /* Get the cursor's string key. */
        ret = cursor->get_key(cursor, &key);
        uint64_t recno;         /* Get the cursor's record number key. */
        ret = cursor->get_key(cursor, &recno);
Parameters:
cursorthe cursor handle
Returns:
zero on success and a non-zero error code on failure. See Error Returns for details.

get_value(self) -> object

Get the value for the current record.

        const char *value;      /* Get the cursor's string value. */
        ret = cursor->get_value(cursor, &value);
        WT_ITEM value;          /* Get the cursor's raw value. */
        ret = cursor->get_value(cursor, &value);
Parameters:
cursorthe cursor handle
Returns:
zero on success and a non-zero error code on failure. See Error Returns for details.
Returns only the first column.

get_values(self) -> (object, ...)

Get the value for the current record.

        const char *value;      /* Get the cursor's string value. */
        ret = cursor->get_value(cursor, &value);
        WT_ITEM value;          /* Get the cursor's raw value. */
        ret = cursor->get_value(cursor, &value);
Parameters:
cursorthe cursor handle
Returns:
zero on success and a non-zero error code on failure. See Error Returns for details.
def wiredtiger.Cursor.insert (   self,
  args 
)

insert(self) -> int

Insert a record, and optionally overwrite an existing record.

If the cursor was not configured with "append" or "overwrite", both the key and value must be set and the record must not already exist; the record will be inserted.

If the cursor was configured with "overwrite", both the key and value must be set; if the record already exists, the key's value will be updated, otherwise, the record will be inserted.

In a cursor with record number keys was configured with "append", the value must be set; a new record will be appended and the record number set as the cursor key value.

Inserting a new record after the current maximum record in a fixed-length column-store implicitly creates skipped records as records with a value of 0.

        /* Insert a new record. */
        const char *key = "some key";
        const char *value = "some value";
        cursor->set_key(cursor, key);
        cursor->set_value(cursor, value);
        ret = cursor->insert(cursor);
        /* Insert a new record or overwrite an existing record. */
        const char *key = "some key";
        const char *value = "some value";
        ret = session->open_cursor(
            session, "table:mytable", NULL, "overwrite", &cursor);
        cursor->set_key(cursor, key);
        cursor->set_value(cursor, value);
        ret = cursor->insert(cursor);
        /* Insert a new record and assign a record number. */
        uint64_t recno;
        const char *value = "some value";
        ret = session->open_cursor(
            session, "table:mytable", NULL, "append", &cursor);
        cursor->set_value(cursor, value);
        ret = cursor->insert(cursor);
        if (ret == 0)
                recno = cursor->get_key(cursor, &recno);
Parameters:
cursorthe cursor handle
Returns:
zero on success and a non-zero error code on failure. See Error Returns for details.
def wiredtiger.Cursor.next (   self,
  args 
)

next(self) -> int

Return the next record.

        ret = cursor->next(cursor);
Parameters:
cursorthe cursor handle
Returns:
zero on success and a non-zero error code on failure. See Error Returns for details.
def wiredtiger.Cursor.prev (   self,
  args 
)

prev(self) -> int

Return the previous record.

        ret = cursor->prev(cursor);
Parameters:
cursorthe cursor handle
Returns:
zero on success and a non-zero error code on failure. See Error Returns for details.
def wiredtiger.Cursor.remove (   self,
  args 
)

remove(self) -> int

Remove a record.

The key must be set, and the key's record will be removed.

Removing a record in a fixed-length column-store is identical to setting the record's value to 0.

        const char *key = "some key";
        cursor->set_key(cursor, key);
        ret = cursor->remove(cursor);
Parameters:
cursorthe cursor handle
Returns:
zero on success and a non-zero error code on failure. See Error Returns for details. In particular, if no record with the specified key exists, WT_NOTFOUND is returned.
def wiredtiger.Cursor.reset (   self,
  args 
)

reset(self) -> int

Reset the position of the cursor.

Any resources held by the cursor are released, and the cursor position is no longer valid. Subsequent iteration with WT_CURSOR::next will move to the first record, or with WT_CURSOR::prev will move to the last record.

        ret = cursor->reset(cursor);
Parameters:
cursorthe cursor handle
Returns:
zero on success and a non-zero error code on failure. See Error Returns for details.
def wiredtiger.Cursor.search (   self,
  args 
)

search(self) -> int

Move to the record matching the key.

The key must first be set.

        const char *key = "some key";
        cursor->set_key(cursor, key);
        ret = cursor->search(cursor);
Parameters:
cursorthe cursor handle
Returns:
zero on success and a non-zero error code on failure. See Error Returns for details.
def wiredtiger.Cursor.search_near (   self,
  args 
)

search_near(self) -> int

Move to the record matching the key if it exists, or a record that would be adjacent.

Either the smallest record larger than the key or the largest record smaller than the key (in other words, a logically adjacent key). The key must first be set.

        cursor->set_key(cursor, key);
        ret = cursor->search_near(cursor, &exact);
        if (ret == 0) {
                if (exact == 0) {
                        /* an exact match */
                } else if (exact < 0) {
                        /* returned smaller key */
                } else if (exact > 0) {
                        /* returned larger key */
                }
        }
        /*
         * An example of a forward scan through the table, where all keys
         * greater than or equal to a specified prefix are included in the
         * scan.
         */
        cursor->set_key(cursor, key);
        ret = cursor->search_near(cursor, &exact);
        if (ret == 0 && exact >= 0) {
                /* include first key returned in the scan */
        }

        while ((ret = cursor->next(cursor)) == 0) {
                /* the rest of the scan */
        }
        /*
         * An example of a backward scan through the table, where all keys
         * less than a specified prefix are included in the scan.
         */
        cursor->set_key(cursor, key);
        ret = cursor->search_near(cursor, &exact);
        if (ret == 0 && exact < 0) {
                /* include first key returned in the scan */
        }

        while ((ret = cursor->prev(cursor)) == 0) {
                /* the rest of the scan */
        }
Parameters:
cursorthe cursor handle
exactpthe status of the search: 0 if an exact match is found, < 0 if a smaller key is returned, > 0 if a larger key is returned
Returns:
zero on success and a non-zero error code on failure. See Error Returns for details.
def wiredtiger.Cursor.set_key (   self,
  args 
)

set_key(self) -> None

Set the key for the next operation.

                                /* Set the cursor's string key. */
        const char *key = "another key";
        cursor->set_key(cursor, key);
        uint64_t recno = 37;    /* Set the cursor's record number key. */
        cursor->set_key(cursor, recno);
Parameters:
cursorthe cursor handle

If an error occurs during this operation, a flag will be set in the cursor, and the next operation to access the key will fail. This simplifies error handling in applications.

def wiredtiger.Cursor.set_value (   self,
  args 
)

set_value(self) -> None

Set the value for the next operation.

                                /* Set the cursor's string value. */
        const char *value = "another value";
        cursor->set_value(cursor, value);
        WT_ITEM value;          /* Set the cursor's raw value. */
        value.data = "another value";
        value.size = strlen("another value");
        cursor->set_value(cursor, &value);
Parameters:
cursorthe cursor handle

If an error occurs during this operation, a flag will be set in the cursor, and the next operation to access the value will fail. This simplifies error handling in applications.

def wiredtiger.Cursor.update (   self,
  args 
)

update(self) -> int

Update a record.

Both key and value must be set, the key must exist, and the value of the key's record will be updated.

        const char *key = "some key";
        const char *value = "some value";
        cursor->set_key(cursor, key);
        cursor->set_value(cursor, value);
        ret = cursor->update(cursor);
Parameters:
cursorthe cursor handle
Returns:
zero on success and a non-zero error code on failure. See Error Returns for details. In particular, if no record with the specified key exists, WT_NOTFOUND is returned.