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_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_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_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_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_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 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 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 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 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()