def test_cursor_comparison(self):
uri = self.type + 'compare'
# Build the object.
if self.type == 'file:':
simple_populate(self, uri, 'key_format=' + self.keyfmt, 100)
else:
complex_populate(self, uri, 'key_format=' + self.keyfmt, 100)
c1 = self.session.open_cursor(uri, None)
c2 = self.session.open_cursor(uri, None)
# Confirm the method fails unless the keys are set.
msg = '/requires key be set/'
self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
lambda: c1.compare(c2), msg)
self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
lambda: c2.compare(c1), msg)
# Test cursors in all three orders.
c1.set_key(key_populate(c1, 10))
self.assertEquals(c1.search(), 0)
c2.set_key(key_populate(c2, 20))
self.assertEquals(c2.search(), 0)
self.assertGreater(c2.compare(c1), 0)
self.assertLess(c1.compare(c2), 0)
c2.set_key(key_populate(c2, 10))
self.assertEquals(c1.compare(c2), 0)
def test_truncate_address_deleted_empty_page(self):
# Create the object on disk.
self.address_deleted()
# Open a cursor and update pages in the middle of the range, forcing
# creation of empty pages (once the underlying leaf page is freed, we
# have to magic up a page if we need it). Confirm we can read/write
# the value as well as write the page and get it back.
cursor = self.session.open_cursor(self.uri, None)
for i in range(3000, 7000, 137):
k = key_populate(cursor, i)
v = 'changed value: ' + str(i)
cursor[k] = v
for i in range(3000, 7000, 137):
k = key_populate(cursor, i)
v = 'changed value: ' + str(i)
cursor.set_key(k)
self.assertEqual(cursor.search(), 0)
self.assertEqual(cursor.get_value(), v)
self.assertEqual(cursor.close(), 0)
self.session.checkpoint()
self.reopen_conn()
self.session.verify(self.uri)
cursor = self.session.open_cursor(self.uri, None)
for i in range(3000, 7000, 137):
k = key_populate(cursor, i)
v = 'changed value: ' + str(i)
cursor.set_key(k)
self.assertEqual(cursor.search(), 0)
self.assertEqual(cursor.get_value(), v)
self.assertEqual(cursor.close(), 0)
def test_bulk_load_col_delete(self):
if self.keyfmt != 'r':
return
uri = self.type + self.name
self.session.create(
uri, 'key_format=' + self.keyfmt + ',value_format=' + self.valfmt)
cursor = self.session.open_cursor(uri, None, "bulk")
for i in range(1, 1000):
if i % 7 == 0:
cursor[key_populate(cursor, i)] = value_populate(cursor, i)
# Ensure we create all the missing records.
i = i + 1
cursor[key_populate(cursor, i)] = value_populate(cursor, i)
cursor.close()
cursor = self.session.open_cursor(uri, None, None)
# Verify all the records are there, in their proper state.
for i in range(1, 1000):
cursor.set_key(key_populate(cursor, i))
if i % 7 == 0:
cursor.search()
self.assertEqual(cursor.get_value(), value_populate(cursor, i))
elif cursor.value_format == '8t':
cursor.search()
self.assertEqual(cursor.get_value(), 0)
else:
self.assertEqual(cursor.search(), wiredtiger.WT_NOTFOUND)
def test_compact(self):
# Populate an object
uri = self.type + self.name
self.pop(self, uri, self.config, self.nentries - 1)
# Reopen the connection to force the object to disk.
self.reopen_conn()
# Remove most of the object.
c1 = self.session.open_cursor(uri, None)
c1.set_key(key_populate(c1, 5))
c2 = self.session.open_cursor(uri, None)
c2.set_key(key_populate(c2, self.nentries - 5))
self.session.truncate(None, c1, c2, None)
c1.close()
c2.close()
# Compact it, using either the session method or the utility.
if self.utility == 1:
self.session.checkpoint(None)
self.close_conn()
self.runWt(["compact", uri])
else:
# Optionally reopen the connection so we do more on-disk tests.
if self.reopen == 1:
self.session.checkpoint(None)
self.reopen_conn()
self.session.compact(uri, None)
# Confirm compaction worked.
stat_cursor = self.session.open_cursor('statistics:' + uri, None, None)
self.assertLess(stat_cursor[stat.dsrc.btree_row_leaf][2], self.maxpages)
stat_cursor.close()
def test_truncate_address_deleted_empty_page(self):
# Create the object on disk.
self.address_deleted()
# Open a cursor and update pages in the middle of the range, forcing
# creation of empty pages (once the underlying leaf page is freed, we
# have to magic up a page if we need it). Confirm we can read/write
# the value as well as write the page and get it back.
cursor = self.session.open_cursor(self.uri, None)
for i in range(3000, 7000, 137):
k = key_populate(cursor, i)
v = 'changed value: ' + str(i)
cursor[k] = v
for i in range(3000, 7000, 137):
k = key_populate(cursor, i)
v = 'changed value: ' + str(i)
cursor.set_key(k)
self.assertEqual(cursor.search(), 0)
self.assertEqual(cursor.get_value(), v)
self.assertEqual(cursor.close(), 0)
self.session.checkpoint()
self.reopen_conn()
self.session.verify(self.uri)
cursor = self.session.open_cursor(self.uri, None)
for i in range(3000, 7000, 137):
k = key_populate(cursor, i)
v = 'changed value: ' + str(i)
cursor.set_key(k)
self.assertEqual(cursor.search(), 0)
self.assertEqual(cursor.get_value(), v)
self.assertEqual(cursor.close(), 0)
def test_overwrite_update(self):
uri = self.type + self.name
simple_populate(self, uri, 'key_format=' + self.keyfmt, 100)
# Update of an existing record with overwrite off succeeds.
cursor = self.session.open_cursor(uri, None, "overwrite=false")
cursor.set_key(key_populate(cursor, 5))
cursor.set_value('XXXXXXXXXX')
self.assertEquals(cursor.update(), 0)
# Update of an existing record with overwrite on succeeds.
cursor = self.session.open_cursor(uri, None)
cursor.set_key(key_populate(cursor, 6))
cursor.set_value('XXXXXXXXXX')
self.assertEquals(cursor.update(), 0)
# Update of a non-existent record with overwrite off fails.
cursor = self.session.open_cursor(uri, None, "overwrite=false")
cursor.set_key(key_populate(cursor, 200))
cursor.set_value('XXXXXXXXXX')
self.assertEquals(cursor.update(), wiredtiger.WT_NOTFOUND)
# Update of a non-existent record with overwrite on succeeds.
cursor = self.session.open_cursor(uri, None)
cursor.set_key(key_populate(cursor, 201))
cursor.set_value('XXXXXXXXXX')
self.assertEquals(cursor.update(), 0)
def test_insert_over_delete_replace(self):
table_config = self.get_table_config()
msg = '/WT_CACHE_FULL.*/'
self.assertRaisesHavingMessage(wiredtiger.WiredTigerError,
lambda:simple_populate(self,
"table:" + self.name, table_config, 10000000), msg)
cursor = self.session.open_cursor('table:' + self.name, None)
cursor.prev()
last_key = int(cursor.get_key())
# Now that the database contains as much data as will fit into
# the configured cache, verify removes succeed.
cursor = self.session.open_cursor('table:' + self.name, None)
for i in range(1, last_key / 4, 1):
cursor.set_key(key_populate(cursor, i))
cursor.remove()
cursor.reset()
# Spin inserting to give eviction a chance to reclaim space
inserted = False
for i in range(1, 1000):
try:
cursor[key_populate(cursor, 1)] = value_populate(cursor, 1)
except wiredtiger.WiredTigerError:
cursor.reset()
sleep(1)
continue
inserted = True
break
self.assertTrue(inserted)
def test_cursor_comparison(self):
uri = self.type + 'compare'
# Build the object.
if self.type == 'file:':
simple_populate(self, uri, 'key_format=' + self.keyfmt, 100)
else:
complex_populate(self, uri, 'key_format=' + self.keyfmt, 100)
c1 = self.session.open_cursor(uri, None)
c2 = self.session.open_cursor(uri, None)
# Confirm the method fails unless the keys are set.
msg = '/requires key be set/'
self.assertRaisesWithMessage(
wiredtiger.WiredTigerError, lambda: c1.compare(c2), msg)
self.assertRaisesWithMessage(
wiredtiger.WiredTigerError, lambda: c2.compare(c1), msg)
# Test cursors in all three orders.
c1.set_key(key_populate(c1, 10))
self.assertEquals(c1.search(), 0)
c2.set_key(key_populate(c2, 20))
self.assertEquals(c2.search(), 0)
self.assertGreater(c2.compare(c1), 0)
self.assertLess(c1.compare(c2), 0)
c2.set_key(key_populate(c2, 10))
self.assertEquals(c1.compare(c2), 0)
def test_compact(self):
# Populate an object
uri = self.type + self.name
self.pop(self, uri, self.config, self.nentries - 1)
# Reopen the connection to force the object to disk.
self.reopen_conn()
# Remove most of the object.
c1 = self.session.open_cursor(uri, None)
c1.set_key(key_populate(c1, 5))
c2 = self.session.open_cursor(uri, None)
c2.set_key(key_populate(c2, self.nentries - 5))
self.session.truncate(None, c1, c2, None)
c1.close()
c2.close()
# Compact it, using either the session method or the utility.
if self.utility == 1:
self.session.checkpoint(None)
self.close_conn()
self.runWt(["compact", uri])
else:
# Optionally reopen the connection so we do more on-disk tests.
if self.reopen == 1:
self.session.checkpoint(None)
self.reopen_conn()
self.session.compact(uri, None)
# Confirm compaction worked.
stat_cursor = self.session.open_cursor('statistics:' + uri, None, None)
self.assertLess(stat_cursor[stat.dsrc.btree_row_leaf][2],
self.maxpages)
stat_cursor.close()
def test_bulk_load_col_delete(self):
if self.keyfmt != 'r':
return
uri = self.type + self.name
self.session.create(uri,
'key_format=' + self.keyfmt + ',value_format=' + self.valfmt)
cursor = self.session.open_cursor(uri, None, "bulk")
for i in range(1, 1000):
if i % 7 == 0:
cursor[key_populate(cursor, i)] = value_populate(cursor, i)
# Ensure we create all the missing records.
i = i + 1
cursor[key_populate(cursor, i)] = value_populate(cursor, i)
cursor.close()
cursor = self.session.open_cursor(uri, None, None)
# Verify all the records are there, in their proper state.
for i in range(1, 1000):
cursor.set_key(key_populate(cursor, i))
if i % 7 == 0:
cursor.search()
self.assertEqual(cursor.get_value(), value_populate(cursor, i))
elif cursor.value_format == '8t':
cursor.search()
self.assertEqual(cursor.get_value(), 0)
else:
self.assertEqual(cursor.search(), wiredtiger.WT_NOTFOUND)
def test_checkpoint_last(self):
# Create an object, change one record to an easily recognizable string,
# then checkpoint it and open a cursor, confirming we see the correct
# value. Repeat this action, we want to be sure the engine gets the
# latest checkpoint information each time.
uri = self.uri
simple_populate(self, uri, 'key_format=' + self.fmt, 100)
for value in ('FIRST', 'SECOND', 'THIRD', 'FOURTH', 'FIFTH'):
# Update the object.
cursor = self.session.open_cursor(uri, None, "overwrite")
cursor.set_key(key_populate(cursor, 10))
cursor.set_value(value)
cursor.insert()
cursor.close()
# Checkpoint the object.
self.session.checkpoint()
# Verify the "last" checkpoint sees the correct value.
cursor = self.session.open_cursor(
uri, None, "checkpoint=WiredTigerCheckpoint")
cursor.set_key(key_populate(cursor, 10))
cursor.search()
self.assertEquals(cursor.get_value(), value)
def test_search_invisible_two(self):
uri = 'file:test_bug008' # This is a btree layer test.
# Populate the tree and reopen the connection, forcing it to disk
# and moving the records to an on-page format.
simple_populate(self, uri, self.fmt, 100)
self.reopen_conn()
# Add some additional visible records.
cursor = self.session.open_cursor(uri, None)
for i in range(100, 120):
cursor.set_key(key_populate(cursor, i))
cursor.set_value(value_populate(cursor, i))
cursor.insert()
cursor.close()
# Begin a transaction, and add some additional records.
self.session.begin_transaction()
cursor = self.session.open_cursor(uri, None)
for i in range(120, 140):
cursor.set_key(key_populate(cursor, i))
cursor.set_value(value_populate(cursor, i))
cursor.insert()
# Open a separate session and cursor.
s = self.conn.open_session()
cursor = s.open_cursor(uri, None)
# Search for an invisible record.
cursor.set_key(key_populate(cursor, 130))
if self.empty:
# Invisible updates to fixed-length column-store objects are
# invisible to the reader, but the fact that they exist past
# the end of the initial records causes the instantiation of
# empty records: confirm successful return of an empty row.
cursor.search()
self.assertEqual(cursor.get_key(), 130)
self.assertEqual(cursor.get_value(), 0)
else:
# Otherwise, we should not find any matching records.
self.assertEqual(cursor.search(), wiredtiger.WT_NOTFOUND)
# Search-near for an invisible record, which should succeed, returning
# the last visible record.
cursor.set_key(key_populate(cursor, 130))
cursor.search_near()
if self.empty:
# Invisible updates to fixed-length column-store objects are
# invisible to the reader, but the fact that they exist past
# the end of the initial records causes the instantiation of
# empty records: confirm successful return of an empty row.
cursor.search()
self.assertEqual(cursor.get_key(), 130)
self.assertEqual(cursor.get_value(), 0)
else:
# Otherwise, we should find the closest record for which we can see
# the value.
self.assertEqual(cursor.get_key(), key_populate(cursor, 119))
self.assertEqual(cursor.get_value(), value_populate(cursor, 119))
def test_search_invisible_two(self):
uri = 'file:test_bug008' # This is a btree layer test.
# Populate the tree and reopen the connection, forcing it to disk
# and moving the records to an on-page format.
simple_populate(self, uri, self.fmt, 100)
self.reopen_conn()
# Add some additional visible records.
cursor = self.session.open_cursor(uri, None)
for i in range(100, 120):
cursor.set_key(key_populate(cursor, i))
cursor.set_value(value_populate(cursor, i))
cursor.insert()
cursor.close()
# Begin a transaction, and add some additional records.
self.session.begin_transaction()
cursor = self.session.open_cursor(uri, None)
for i in range(120, 140):
cursor.set_key(key_populate(cursor, i))
cursor.set_value(value_populate(cursor, i))
cursor.insert()
# Open a separate session and cursor.
s = self.conn.open_session()
cursor = s.open_cursor(uri, None)
# Search for an invisible record.
cursor.set_key(key_populate(cursor, 130))
if self.empty:
# Invisible updates to fixed-length column-store objects are
# invisible to the reader, but the fact that they exist past
# the end of the initial records causes the instantiation of
# empty records: confirm successful return of an empty row.
cursor.search()
self.assertEqual(cursor.get_key(), 130)
self.assertEqual(cursor.get_value(), 0)
else:
# Otherwise, we should not find any matching records.
self.assertEqual(cursor.search(), wiredtiger.WT_NOTFOUND)
# Search-near for an invisible record, which should succeed, returning
# the last visible record.
cursor.set_key(key_populate(cursor, 130))
cursor.search_near()
if self.empty:
# Invisible updates to fixed-length column-store objects are
# invisible to the reader, but the fact that they exist past
# the end of the initial records causes the instantiation of
# empty records: confirm successful return of an empty row.
cursor.search()
self.assertEqual(cursor.get_key(), 130)
self.assertEqual(cursor.get_value(), 0)
else:
# Otherwise, we should find the closest record for which we can see
# the value.
self.assertEqual(cursor.get_key(), key_populate(cursor, 119))
self.assertEqual(cursor.get_value(), value_populate(cursor, 119))
def test_bulk_load_row_order_check(self):
uri = self.type + self.name
self.session.create(uri, 'key_format=S,value_format=S')
cursor = self.session.open_cursor(uri, None, "bulk")
cursor[key_populate(cursor, 10)] = value_populate(cursor, 10)
cursor.set_key(key_populate(cursor, 1))
cursor.set_value(value_populate(cursor, 1))
msg = '/compares smaller than previously inserted key/'
self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
lambda: cursor.insert(), msg)
def test_bulk_load_row_order_check(self):
uri = self.type + self.name
self.session.create(uri, 'key_format=S,value_format=S')
cursor = self.session.open_cursor(uri, None, "bulk")
cursor[key_populate(cursor, 10)] = value_populate(cursor, 10)
cursor.set_key(key_populate(cursor, 1))
cursor.set_value(value_populate(cursor, 1))
msg = '/compares smaller than previously inserted key/'
self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
lambda: cursor.insert(), msg)
def test_overwrite_reconfig(self):
simple_populate(self, self.uri, 'key_format=' + self.fmt, 100)
cursor = self.session.open_cursor(self.uri, None)
cursor.set_key(key_populate(cursor, 10))
cursor.set_value('XXXXXXXXXX')
self.assertRaises(wiredtiger.WiredTigerError, lambda: cursor.insert())
cursor.set_key(key_populate(cursor, 10))
dupc = self.session.open_cursor(None, cursor, "overwrite");
dupc.set_value('XXXXXXXXXX')
dupc.insert()
def test_search_empty(self):
# Create the object and open a cursor.
self.session.create(self.uri, self.fmt)
cursor = self.session.open_cursor(self.uri, None)
# Search for a record past the end of the table, which should fail.
cursor.set_key(key_populate(cursor, 100))
self.assertEqual(cursor.search(), wiredtiger.WT_NOTFOUND)
# Search-near for a record past the end of the table, which should fail.
cursor.set_key(key_populate(cursor, 100))
self.assertEqual(cursor.search_near(), wiredtiger.WT_NOTFOUND)
def test_search_empty(self):
# Create the object and open a cursor.
self.session.create(self.uri, self.fmt)
cursor = self.session.open_cursor(self.uri, None)
# Search for a record past the end of the table, which should fail.
cursor.set_key(key_populate(cursor, 100))
self.assertEqual(cursor.search(), wiredtiger.WT_NOTFOUND)
# Search-near for a record past the end of the table, which should fail.
cursor.set_key(key_populate(cursor, 100))
self.assertEqual(cursor.search_near(), wiredtiger.WT_NOTFOUND)
def test_truncate_cursor_order(self):
uri = self.type + self.name
simple_populate(self, uri, 'key_format=' + self.keyfmt, 100)
c1 = self.session.open_cursor(uri, None)
c2 = self.session.open_cursor(uri, None)
c1.set_key(key_populate(c1, 20))
c2.set_key(key_populate(c2, 10))
msg = '/the start cursor position is after the stop cursor position/'
self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
lambda: self.session.truncate(None, c1, c2, None), msg)
c2.set_key(key_populate(c2, 20))
self.session.truncate(None, c1, c2, None)
def test_truncate_cursor_order(self):
uri = self.type + self.name
simple_populate(self, uri, 'key_format=' + self.keyfmt, 100)
c1 = self.session.open_cursor(uri, None)
c2 = self.session.open_cursor(uri, None)
c1.set_key(key_populate(c1, 20))
c2.set_key(key_populate(c2, 10))
msg = '/the start cursor position is after the stop cursor position/'
self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
lambda: self.session.truncate(None, c1, c2, None), msg)
c2.set_key(key_populate(c2, 20))
self.session.truncate(None, c1, c2, None)
def test_bulk_load_row_order_nocheck(self):
uri = self.type + self.name
self.session.create(uri, 'key_format=S,value_format=S')
cursor = self.session.open_cursor(uri, None, "bulk,skip_sort_check")
cursor[key_populate(cursor, 10)] = value_populate(cursor, 10)
cursor[key_populate(cursor, 1)] = value_populate(cursor, 1)
if not wiredtiger.diagnostic_build():
self.skipTest('requires a diagnostic build')
# Close explicitly, there's going to be a fallure.
msg = '/are incorrectly sorted/'
self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
lambda: self.conn.close(), msg)
def test_smoke(self):
simple_populate(self,
self.uri, self.config + self.keyfmt, self.nentries)
self.reopen_conn()
c = self.session.open_cursor(self.uri, None)
c.set_key(key_populate(c, 100))
self.assertEqual(c.search(), 0)
self.assertEqual(c.get_value(), value_populate(c, 100))
c.set_key(key_populate(c, 101))
self.assertEqual(c.search(), 0)
self.assertEqual(c.get_value(), value_populate(c, 101))
c.set_key(key_populate(c, 9999))
self.assertEqual(c.search(), 0)
self.assertEqual(c.get_value(), value_populate(c, 9999))
def test_bulk_load_row_order_nocheck(self):
uri = self.type + self.name
self.session.create(uri, 'key_format=S,value_format=S')
cursor = self.session.open_cursor(uri, None, "bulk,skip_sort_check")
cursor[key_populate(cursor, 10)] = value_populate(cursor, 10)
cursor[key_populate(cursor, 1)] = value_populate(cursor, 1)
if not wiredtiger.diagnostic_build():
self.skipTest('requires a diagnostic build')
# Close explicitly, there's going to be a fallure.
msg = '/are incorrectly sorted/'
self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
lambda: self.conn.close(), msg)
def test_smoke(self):
simple_populate(self, self.uri, self.config + self.keyfmt,
self.nentries)
self.reopen_conn()
c = self.session.open_cursor(self.uri, None)
c.set_key(key_populate(c, 100))
self.assertEqual(c.search(), 0)
self.assertEqual(c.get_value(), value_populate(c, 100))
c.set_key(key_populate(c, 101))
self.assertEqual(c.search(), 0)
self.assertEqual(c.get_value(), value_populate(c, 101))
c.set_key(key_populate(c, 9999))
self.assertEqual(c.search(), 0)
self.assertEqual(c.get_value(), value_populate(c, 9999))
def test_stat_cursor_size(self):
self.pop(self, self.uri, 'key_format=S' + self.cfg, 100)
self.openAndWalkStatCursor()
cursor = self.session.open_cursor(self.uri, None)
for i in range(100, 40000 + 1):
if i % 100 == 0:
self.openAndWalkStatCursor()
if self.pop == simple_populate:
cursor[key_populate(cursor, i)] = value_populate(cursor, i)
else:
cursor[key_populate(cursor, i)] = \
tuple(complex_value_populate(cursor, i))
cursor.close()
self.openAndWalkStatCursor()
def test_stat_cursor_size(self):
self.pop(self, self.uri, 'key_format=S' + self.cfg, 100)
self.openAndWalkStatCursor()
cursor = self.session.open_cursor(self.uri, None)
for i in range(100, 40000 + 1):
if i % 100 == 0:
self.openAndWalkStatCursor()
if self.pop == simple_populate:
cursor[key_populate(cursor, i)] = value_populate(cursor, i)
else:
cursor[key_populate(cursor, i)] = \
tuple(complex_value_populate(cursor, i))
cursor.close()
self.openAndWalkStatCursor()
def test_colmax_op(self):
recno = self.recno
uri = self.type + self.name
self.session.create(uri,
'key_format=r' + ',value_format=' + self.valfmt)
# Insert a big record with/without a bulk cursor.
bulk_config = ""
if self.bulk:
bulk_config = "bulk"
cursor = self.session.open_cursor(uri, None, bulk_config)
# Optionaly make the big record the only record in the table.
if not self.single:
for i in range(1, 723):
cursor[key_populate(cursor, i)] = value_populate(cursor, i)
# Confirm searching past the end of the table works.
if not self.bulk:
cursor.set_key(recno)
self.assertEqual(cursor.search(), wiredtiger.WT_NOTFOUND)
# Insert the big record.
cursor[key_populate(cursor, recno)] = value_populate(cursor, recno)
# Optionally flush to disk; re-open the cursor as necessary.
if self.bulk or self.reopen:
cursor.close()
if self.reopen == 1:
self.reopen_conn()
if self.bulk or self.reopen:
cursor = self.session.open_cursor(uri, None, None)
# Search for the large record.
cursor.set_key(recno)
self.assertEqual(cursor.search(), 0)
self.assertEqual(cursor.get_value(), value_populate(cursor, recno))
# Update it.
cursor[key_populate(cursor, recno)] = value_populate(cursor, 37)
cursor.set_key(recno)
self.assertEqual(cursor.search(), 0)
self.assertEqual(cursor.get_value(), value_populate(cursor, 37))
# Remove it.
cursor.set_key(recno)
self.assertEqual(cursor.remove(), 0)
cursor.set_key(key_populate(cursor, recno))
self.assertEqual(cursor.search(), wiredtiger.WT_NOTFOUND)
def test_colmax_op(self):
recno = self.recno
uri = self.type + self.name
self.session.create(uri, 'key_format=r' +',value_format=' + self.valfmt)
# Insert a big record with/without a bulk cursor.
bulk_config = ""
if self.bulk:
bulk_config = "bulk"
cursor = self.session.open_cursor(uri, None, bulk_config)
# Optionaly make the big record the only record in the table.
if not self.single:
for i in range(1, 723):
cursor[key_populate(cursor, i)] = value_populate(cursor, i)
# Confirm searching past the end of the table works.
if not self.bulk:
cursor.set_key(recno)
self.assertEqual(cursor.search(), wiredtiger.WT_NOTFOUND)
# Insert the big record.
cursor[key_populate(cursor, recno)] = value_populate(cursor, recno)
# Optionally flush to disk; re-open the cursor as necessary.
if self.bulk or self.reopen:
cursor.close()
if self.reopen == 1:
self.reopen_conn()
if self.bulk or self.reopen:
cursor = self.session.open_cursor(uri, None, None)
# Search for the large record.
cursor.set_key(recno)
self.assertEqual(cursor.search(), 0)
self.assertEqual(cursor.get_value(), value_populate(cursor, recno))
# Update it.
cursor[key_populate(cursor, recno)] = value_populate(cursor, 37)
cursor.set_key(recno)
self.assertEqual(cursor.search(), 0)
self.assertEqual(cursor.get_value(), value_populate(cursor, 37))
# Remove it.
cursor.set_key(recno)
self.assertEqual(cursor.remove(), 0)
cursor.set_key(key_populate(cursor, recno))
self.assertEqual(cursor.search(), wiredtiger.WT_NOTFOUND)
def test_bulk_load_order_check(self):
uri = self.type + self.name
self.session.create(uri,
'key_format=' + self.keyfmt + ',value_format=' + self.valfmt)
cursor = self.session.open_cursor(uri, None, "bulk")
cursor[key_populate(cursor, 10)] = value_populate(cursor, 10)
for i in [1, 9, 10]:
cursor.set_key(key_populate(cursor, 1))
cursor.set_value(value_populate(cursor, 1))
msg = '/than previously inserted key/'
self.assertRaisesWithMessage(
wiredtiger.WiredTigerError, lambda: cursor.insert(), msg)
cursor[key_populate(cursor, 11)] = value_populate(cursor, 11)
def test_bulk_load_order_check(self):
uri = self.type + self.name
self.session.create(
uri, 'key_format=' + self.keyfmt + ',value_format=' + self.valfmt)
cursor = self.session.open_cursor(uri, None, "bulk")
cursor[key_populate(cursor, 10)] = value_populate(cursor, 10)
for i in [1, 9, 10]:
cursor.set_key(key_populate(cursor, 1))
cursor.set_value(value_populate(cursor, 1))
msg = '/than previously inserted key/'
self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
lambda: cursor.insert(), msg)
cursor[key_populate(cursor, 11)] = value_populate(cursor, 11)
def test_bulk_load_var_append(self):
if self.keyfmt != 'r':
return
uri = self.type + self.name
self.session.create(
uri, 'key_format=' + self.keyfmt + ',value_format=' + self.valfmt)
cursor = self.session.open_cursor(uri, None, "bulk,append")
for i in range(1, 1000):
cursor[key_populate(cursor, 37)] = value_populate(cursor, i)
cursor.close()
cursor = self.session.open_cursor(uri, None, None)
for i in range(1, 1000):
cursor.set_key(key_populate(cursor, i))
cursor.search()
self.assertEqual(cursor.get_value(), value_populate(cursor, i))
def test_bulk_load(self):
uri = self.type + self.name
self.session.create(
uri, 'key_format=' + self.keyfmt + ',value_format=' + self.valfmt)
cursor = self.session.open_cursor(uri, None, "bulk")
for i in range(1, 1000):
cursor[key_populate(cursor, i)] = value_populate(cursor, i)
def test_bulk_load(self):
uri = self.type + self.name
self.session.create(uri,
'key_format=' + self.keyfmt + ',value_format=' + self.valfmt)
cursor = self.session.open_cursor(uri, None, "bulk")
for i in range(1, 1000):
cursor[key_populate(cursor, i)] = value_populate(cursor, i)
def test_bulk_load_var_append(self):
if self.keyfmt != 'r':
return
uri = self.type + self.name
self.session.create(uri,
'key_format=' + self.keyfmt + ',value_format=' + self.valfmt)
cursor = self.session.open_cursor(uri, None, "bulk,append")
for i in range(1, 1000):
cursor[key_populate(cursor, 37)] = value_populate(cursor, i)
cursor.close()
cursor = self.session.open_cursor(uri, None, None)
for i in range(1, 1000):
cursor.set_key(key_populate(cursor, i))
cursor.search()
self.assertEqual(cursor.get_value(), value_populate(cursor, i))
def set_kv(self, cursor):
cursor.set_key(key_populate(cursor, 10))
if self.complex == 1:
v = complex_value_populate(cursor, 10)
cursor.set_value(v[0], v[1], v[2], v[3])
else:
cursor.set_value(value_populate(cursor, 10))
def empty(self):
uri = self.type + self.name
self.session = self.conn.open_session()
self.session.create(uri, 'key_format=' + self.fmt)
# Add a few records to the object and remove them.
cursor = self.session.open_cursor(uri, None, None)
for i in range(1,5):
key = key_populate(cursor, i)
cursor[key] = "XXX"
del cursor[key]
# Perform a checkpoint (we shouldn't write any underlying pages because
# of a checkpoint, either).
self.session.checkpoint("name=ckpt")
# Open and close a checkpoint cursor.
cursor = self.session.open_cursor(uri, None, "checkpoint=ckpt")
cursor.close()
self.session.close()
# The file should not have grown.
name = self.name
if self.type == "table:":
name = name + '.wt'
self.assertEquals(os.stat(name).st_size, 4*1024)
def test_bulkload_checkpoint(self):
# Open a bulk cursor and insert a few records.
self.session.create(self.uri, 'key_format=S,value_format=S')
cursor = self.session.open_cursor(self.uri, None, 'bulk')
for i in range(1, 10):
cursor.set_key(key_populate(cursor, i))
cursor.set_value(value_populate(cursor, i))
cursor.insert()
# Checkpoint a few times (to test the drop code).
for i in range(1, 5):
if self.ckpt_type == 'named':
self.session.checkpoint('name=myckpt')
else:
self.session.checkpoint()
# Close the bulk cursor.
cursor.close()
# In the case of named checkpoints, verify they're still there,
# reflecting an empty file.
if self.ckpt_type == 'named':
cursor = self.session.open_cursor(self.uri, None,
'checkpoint=myckpt')
self.assertEquals(cursor.next(), wiredtiger.WT_NOTFOUND)
cursor.close()
def empty(self):
uri = self.type + self.name
self.session = self.conn.open_session()
self.session.create(uri, 'key_format=' + self.fmt)
# Add a few records to the object and remove them.
cursor = self.session.open_cursor(uri, None, None)
for i in range(1, 5):
cursor.set_key(key_populate(cursor, i))
cursor.set_value("XXX")
cursor.insert()
cursor.remove()
# Perform a checkpoint (we shouldn't write any underlying pages because
# of a checkpoint, either).
self.session.checkpoint("name=ckpt")
# Open and close a checkpoint cursor.
cursor = self.session.open_cursor(uri, None, "checkpoint=ckpt")
cursor.close()
self.session.close()
# The file should not have grown.
name = self.name
if self.type == "table:":
name = name + '.wt'
self.assertEquals(os.stat(name).st_size, 4 * 1024)
def test_basic_data_source_stats(self):
# Build an object.
config = self.config + ',key_format=' + self.keyfmt
self.session.create(self.uri, config)
cursor = self.session.open_cursor(self.uri, None, None)
value = ""
for i in range(1, self.nentries):
value = value + 1000 * "a"
cursor[key_populate(cursor, i)] = value
cursor.close()
# Force the object to disk, otherwise we can't check the overflow count.
self.reopen_conn()
# See that we can get a specific stat value by its key and verify its
# entry is self-consistent.
cursor = self.session.open_cursor('statistics:' + self.uri, None, None)
self.check_stats(cursor, 8192, 'btree: maximum leaf page size')
self.check_stats(cursor, 4096, 'btree: maximum internal page size')
self.check_stats(cursor, 10, 'btree: overflow pages')
values = cursor[stat.dsrc.btree_overflow]
self.assertEqual(values[0], 'btree: overflow pages')
val = self.statstr_to_int(values[1])
self.assertEqual(val, values[2])
cursor.close()
cursor = self.session.open_cursor('statistics:' + self.uri, None,
"statistics=(size)")
values = cursor[stat.dsrc.block_size]
self.assertNotEqual(values[2], 0)
cursor.close()
def test_bug006(self):
uri = self.uri + self.name
self.session.create(uri, 'value_format=S,key_format=S')
cursor = self.session.open_cursor(uri, None)
for i in range(1, 1000):
cursor[key_populate(cursor, i)] = value_populate(cursor, i)
# Table operations should fail, the cursor is open.
self.assertRaises(
wiredtiger.WiredTigerError, lambda: self.session.drop(uri, None))
self.assertRaises(
wiredtiger.WiredTigerError,
lambda: self.session.rename(uri, self.uri + "new", None))
self.assertRaises(
wiredtiger.WiredTigerError, lambda: self.session.salvage(uri, None))
self.assertRaises(
wiredtiger.WiredTigerError, lambda: self.session.upgrade(uri, None))
self.assertRaises(
wiredtiger.WiredTigerError, lambda: self.session.verify(uri, None))
cursor.close()
# Table operations should succeed, the cursor is closed.
self.session.rename(uri, self.uri + "new", None)
self.session.rename(self.uri + "new", uri, None)
self.session.salvage(uri, None)
self.session.truncate(uri, None, None, None)
self.session.upgrade(uri, None)
self.session.verify(uri, None)
self.session.drop(uri, None)
def test_basic_data_source_stats(self):
# Build an object.
config = self.config + ',key_format=' + self.keyfmt
self.session.create(self.uri, config)
cursor = self.session.open_cursor(self.uri, None, None)
value = ""
for i in range(1, self.nentries):
value = value + 1000 * "a"
cursor[key_populate(cursor, i)] = value
cursor.close()
# Force the object to disk, otherwise we can't check the overflow count.
self.reopen_conn()
# See that we can get a specific stat value by its key and verify its
# entry is self-consistent.
cursor = self.session.open_cursor('statistics:' + self.uri, None, None)
self.check_stats(cursor, 8192, 'btree: maximum leaf page size')
self.check_stats(cursor, 4096, 'btree: maximum internal page size')
self.check_stats(cursor, 10, 'btree: overflow pages')
values = cursor[stat.dsrc.btree_overflow]
self.assertEqual(values[0], 'btree: overflow pages')
val = self.statstr_to_int(values[1])
self.assertEqual(val, values[2])
cursor.close()
cursor = self.session.open_cursor(
'statistics:' + self.uri, None, "statistics=(size)")
values = cursor[stat.dsrc.block_size]
self.assertNotEqual(values[2], 0)
cursor.close()
def test_bug006(self):
uri = self.uri + self.name
self.session.create(uri, 'value_format=S,key_format=S')
cursor = self.session.open_cursor(uri, None)
for i in range(1, 1000):
cursor.set_key(key_populate(cursor, i))
cursor.set_value(value_populate(cursor, i))
cursor.insert()
# Table operations should fail, the cursor is open.
self.assertRaises(wiredtiger.WiredTigerError,
lambda: self.session.drop(uri, None))
self.assertRaises(
wiredtiger.WiredTigerError,
lambda: self.session.rename(uri, self.uri + "new", None))
self.assertRaises(wiredtiger.WiredTigerError,
lambda: self.session.salvage(uri, None))
self.assertRaises(wiredtiger.WiredTigerError,
lambda: self.session.truncate(uri, None, None, None))
self.assertRaises(wiredtiger.WiredTigerError,
lambda: self.session.upgrade(uri, None))
self.assertRaises(wiredtiger.WiredTigerError,
lambda: self.session.verify(uri, None))
cursor.close()
# Table operations should succeed, the cursor is closed.
self.session.rename(uri, self.uri + "new", None)
self.session.rename(self.uri + "new", uri, None)
self.session.salvage(uri, None)
self.session.truncate(uri, None, None, None)
self.session.upgrade(uri, None)
self.session.verify(uri, None)
self.session.drop(uri, None)
def set_kv(self, cursor):
cursor.set_key(key_populate(cursor, 10))
if self.complex == 1:
v = complex_value_populate(cursor, 10)
cursor.set_value(v[0], v[1], v[2], v[3])
else:
cursor.set_value(value_populate(cursor, 10))
def truncateRangeAndCheck(self, uri, begin, end, expected):
self.pr('truncateRangeAndCheck: ' + str(begin) + ',' + str(end))
cur1 = self.cursorKey(uri, begin)
cur2 = self.cursorKey(uri, end)
self.session.truncate(None, cur1, cur2, None)
if not cur1:
begin = 1
else:
cur1.close()
if not cur2:
end = self.nentries
else:
cur2.close()
# If the object should be empty, confirm that.
if begin == 1 and end == self.nentries:
confirm_empty(self, uri)
return
# Check the expected values against the object.
cursor = self.session.open_cursor(uri, None)
for i in range(begin, end + 1):
expected[key_populate(cursor, i)] = [0]
for k, v in expected.iteritems():
cursor.set_key(k)
if v == [0] and \
cursor.key_format == 'r' and cursor.value_format == '8t':
cursor.search()
self.assertEqual(cursor.get_values(), [0])
elif v == [0]:
self.assertEqual(cursor.search(), wiredtiger.WT_NOTFOUND)
else:
cursor.search()
self.assertEqual(cursor.get_values(), v)
cursor.close()
def test_bulk_load_checkpoint(self):
# Open a bulk cursor and insert a few records.
self.session.create(self.uri, 'key_format=S,value_format=S')
cursor = self.session.open_cursor(self.uri, None, 'bulk')
for i in range(1, 10):
cursor.set_key(key_populate(cursor, i))
cursor.set_value(value_populate(cursor, i))
cursor.insert()
# Checkpoint a few times (to test the drop code).
for i in range(1, 5):
if self.name == 0:
self.session.checkpoint()
else:
self.session.checkpoint('name=myckpt')
# Close the bulk cursor.
cursor.close()
# In the case of named checkpoints, verify they're still there,
# reflecting an empty file.
if self.name == 1:
cursor = self.session.open_cursor(
self.uri, None, 'checkpoint=myckpt')
self.assertEquals(cursor.next(), wiredtiger.WT_NOTFOUND)
cursor.close()
def test_eviction(self):
cursors = []
for i in range(0, self.ntables):
this_uri = 'table:%s-%03d' % (self.table_name, i)
simple_populate(
self, this_uri,
'key_format=S,allocation_size=1KB,leaf_page_max=1KB',
self.nrows)
# Switch over to on-disk trees with multiple leaf pages
self.reopen_conn()
# Make sure we have a cursor for the table so it stays in cache.
for i in range(0, self.ntables):
this_uri = 'table:%s-%03d' % (self.table_name, i)
cursors.append(self.session.open_cursor(this_uri, None))
# Make use of the cache.
for i in range(0, self.nops):
for i in range(0, self.ntables):
cursors[i].set_key(
helper.key_populate(cursors[i],
random.randint(0, self.nrows - 1)))
cursors[i].search()
cursors[i].reset()
def truncateRangeAndCheck(self, uri, begin, end, expected):
self.pr('truncateRangeAndCheck: ' + str(begin) + ',' + str(end))
cur1 = self.cursorKey(uri, begin)
cur2 = self.cursorKey(uri, end)
self.session.truncate(None, cur1, cur2, None)
if not cur1:
begin = 1
else:
cur1.close()
if not cur2:
end = self.nentries
else:
cur2.close()
# If the object should be empty, confirm that.
if begin == 1 and end == self.nentries:
confirm_empty(self, uri)
return
# Check the expected values against the object.
cursor = self.session.open_cursor(uri, None)
for i in range(begin, end + 1):
expected[key_populate(cursor, i)] = [0]
for k, v in expected.iteritems():
cursor.set_key(k)
if v == [0] and \
cursor.key_format == 'r' and cursor.value_format == '8t':
cursor.search()
self.assertEqual(cursor.get_values(), [0])
elif v == [0]:
self.assertEqual(cursor.search(), wiredtiger.WT_NOTFOUND)
else:
cursor.search()
self.assertEqual(cursor.get_values(), v)
cursor.close()
def iterate(self, uri):
cursor = self.session.open_cursor(uri, None, None)
next = 0
while True:
nextret = cursor.next()
if nextret != 0:
break
next += 1
self.assertEqual(cursor.get_key(), key_populate(cursor, next))
dupc = self.session.open_cursor(None, cursor, None)
self.assertEqual(cursor.compare(dupc), 0)
self.assertEqual(dupc.get_key(), key_populate(dupc, next))
cursor.close()
cursor = dupc
self.assertEqual(next, self.nentries)
self.assertEqual(nextret, wiredtiger.WT_NOTFOUND)
cursor.close()
def backward(self, c, max, notfound):
for i in range(max, 0, -1):
c.set_key(key_populate(c, i))
if i in notfound:
self.assertEqual(c.search(), wiredtiger.WT_NOTFOUND)
else:
self.assertEqual(c.search(), 0)
self.assertEqual(c.get_value(), value_populate(c, i))
def iterate(self, uri):
cursor = self.session.open_cursor(uri, None, None)
next = 0
while True:
nextret = cursor.next()
if nextret != 0:
break
next += 1
self.assertEqual(cursor.get_key(), key_populate(cursor, next))
dupc = self.session.open_cursor(None, cursor, None)
self.assertEqual(cursor.compare(dupc), 0)
self.assertEqual(dupc.get_key(), key_populate(dupc, next))
cursor.close()
cursor = dupc
self.assertEqual(next, self.nentries)
self.assertEqual(nextret, wiredtiger.WT_NOTFOUND)
cursor.close()
def test_bulk_load_busy(self):
uri = self.type + self.name
self.session.create(uri, 'key_format=S,value_format=S')
cursor = self.session.open_cursor(uri, None)
cursor[key_populate(cursor, 1)] = value_populate(cursor, 1)
# Don't close the insert cursor, we want EBUSY.
self.assertRaises(wiredtiger.WiredTigerError,
lambda: self.session.open_cursor(uri, None, "bulk"))
def backward(self, c, max, notfound):
for i in range(max, 0, -1):
c.set_key(key_populate(c, i))
if i in notfound:
self.assertEqual(c.search(), wiredtiger.WT_NOTFOUND)
else:
self.assertEqual(c.search(), 0)
self.assertEqual(c.get_value(), value_populate(c, i))
def test_bulk_load_busy(self):
uri = self.type + self.name
self.session.create(uri, 'key_format=S,value_format=S')
cursor = self.session.open_cursor(uri, None)
cursor[key_populate(cursor, 1)] = value_populate(cursor, 1)
# Don't close the insert cursor, we want EBUSY.
self.assertRaises(wiredtiger.WiredTigerError,
lambda: self.session.open_cursor(uri, None, "bulk"))
def test_bug004(self):
# Create the object, fill with overflow keys and values.
self.session.create(self.uri, self.config)
c1 = self.session.open_cursor(self.uri, None)
for i in range(1, self.nentries):
c1.set_key(key_populate(c1, i) + 'abcdef' * 100)
c1.set_value(value_populate(c1, i) + 'abcdef' * 100)
c1.insert()
c1.close()
# Verify the object, force it to disk, and verify the on-disk version.
self.session.verify(self.uri)
self.reopen_conn()
self.session.verify(self.uri)
# Create a new session and start a transaction to force the engine
# to access old versions of the key/value pairs.
tmp_session = self.conn.open_session(None)
tmp_session.begin_transaction("isolation=snapshot")
# Load the object and use truncate to delete a set of records. (I'm
# using truncate because it doesn't instantiate keys, all other ops
# currently do -- that's unlikely to change, but is a problem for the
# test going forward.)
c1 = self.session.open_cursor(self.uri, None)
c1.set_key(key_populate(c1, self.nentries - 5) + 'abcdef' * 100)
c2 = self.session.open_cursor(self.uri, None)
c2.set_key(key_populate(c2, self.nentries + 5) + 'abcdef' * 100)
self.session.truncate(None, c1, c2, None)
c1.close()
c2.close()
# Checkpoint, freeing overflow blocks.
self.session.checkpoint()
# Use the snapshot cursor to retrieve the old key/value pairs
c1 = tmp_session.open_cursor(self.uri, None)
c1.set_key(key_populate(c1, 1) + 'abcdef' * 100)
c1.search()
for i in range(2, self.nentries):
c1.next()
self.assertEquals(
c1.get_key(), key_populate(c1, i) + 'abcdef' * 100)
self.assertEquals(
c1.get_value(), value_populate(c1, i) + 'abcdef' * 100)
def test_search_eot(self):
# Populate the tree and reopen the connection, forcing it to disk
# and moving the records to an on-page format.
simple_populate(self, self.uri, self.fmt, 100)
self.reopen_conn()
# Open a cursor.
cursor = self.session.open_cursor(self.uri, None)
# Search for a record at the end of the table, which should succeed.
cursor.set_key(key_populate(cursor, 100))
self.assertEqual(cursor.search(), 0)
self.assertEqual(cursor.get_key(), key_populate(cursor, 100))
self.assertEqual(cursor.get_value(), value_populate(cursor, 100))
# Search-near for a record at the end of the table, which should
# succeed, returning the last record.
cursor.set_key(key_populate(cursor, 100))
self.assertEqual(cursor.search_near(), 0)
self.assertEqual(cursor.get_key(), key_populate(cursor, 100))
self.assertEqual(cursor.get_value(), value_populate(cursor, 100))
# Search for a record past the end of the table, which should fail.
cursor.set_key(key_populate(cursor, 200))
self.assertEqual(cursor.search(), wiredtiger.WT_NOTFOUND)
# Search-near for a record past the end of the table, which should
# succeed, returning the last record.
cursor.set_key(key_populate(cursor, 200))
self.assertEqual(cursor.search_near(), -1)
self.assertEqual(cursor.get_key(), key_populate(cursor, 100))
self.assertEqual(cursor.get_value(), value_populate(cursor, 100))
def test_search_eot(self):
# Populate the tree and reopen the connection, forcing it to disk
# and moving the records to an on-page format.
simple_populate(self, self.uri, self.fmt, 100)
self.reopen_conn()
# Open a cursor.
cursor = self.session.open_cursor(self.uri, None)
# Search for a record at the end of the table, which should succeed.
cursor.set_key(key_populate(cursor, 100))
self.assertEqual(cursor.search(), 0)
self.assertEqual(cursor.get_key(), key_populate(cursor, 100))
self.assertEqual(cursor.get_value(), value_populate(cursor, 100))
# Search-near for a record at the end of the table, which should
# succeed, returning the last record.
cursor.set_key(key_populate(cursor, 100))
self.assertEqual(cursor.search_near(), 0)
self.assertEqual(cursor.get_key(), key_populate(cursor, 100))
self.assertEqual(cursor.get_value(), value_populate(cursor, 100))
# Search for a record past the end of the table, which should fail.
cursor.set_key(key_populate(cursor, 200))
self.assertEqual(cursor.search(), wiredtiger.WT_NOTFOUND)
# Search-near for a record past the end of the table, which should
# succeed, returning the last record.
cursor.set_key(key_populate(cursor, 200))
self.assertEqual(cursor.search_near(), -1)
self.assertEqual(cursor.get_key(), key_populate(cursor, 100))
self.assertEqual(cursor.get_value(), value_populate(cursor, 100))
def update(self, uri, dsize, upd, rows):
self.pr('update: ' + uri + ' with ' + str(rows) + ' rows')
cursor = self.session.open_cursor(uri, None)
for i in range(1, rows + 1):
cursor.set_key(key_populate(cursor, i))
my_data = str(i) + ':' + upd * dsize
cursor.set_value(my_data)
cursor.insert()
cursor.close()
