Python wrapper around C ::__WT_CURSOR. More...
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 |
Python wrapper around C ::__WT_CURSOR.
def wiredtiger.Cursor.__iter__ | ( | self | ) |
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. */ }
cursor | the cursor handle |
other | another cursor handle |
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);
cursor | the cursor handle |
def wiredtiger.Cursor.get_keys | ( | self | ) |
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);
cursor | the cursor handle |
def wiredtiger.Cursor.get_value | ( | self | ) |
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);
cursor | the cursor handle |
def wiredtiger.Cursor.get_values | ( | self | ) |
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);
cursor | the cursor handle |
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);
cursor | the cursor handle |
def wiredtiger.Cursor.next | ( | self, | |
args | |||
) |
next(self) -> int
Return the next record.
ret = cursor->next(cursor);
cursor | the cursor handle |
def wiredtiger.Cursor.prev | ( | self, | |
args | |||
) |
prev(self) -> int
Return the previous record.
ret = cursor->prev(cursor);
cursor | the cursor handle |
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.
cursor | the cursor handle |
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);
cursor | the cursor handle |
def wiredtiger.Cursor.search | ( | self, | |
args | |||
) |
search(self) -> int
Move to the record matching the key.
The key must first be set.
cursor | the cursor handle |
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 */ }
cursor | the cursor handle |
exactp | the 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 |
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);
cursor | the 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);
cursor | the 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);
cursor | the cursor handle |