def test_cursor_random_multiple_page_records(self): uri = self.type + 'random' if self.type == 'file:': simple_populate(self, uri, 'allocation_size=512,leaf_page_max=512,key_format=' +\ self.fmt, 10000) else: complex_populate(self, uri, 'allocation_size=512,leaf_page_max=512,key_format=' +\ self.fmt, 10000) # Close the connection so everything is forced to disk (otherwise the # values are on an insert list and the underlying engine doesn't make # random selections, it selects the middle of the list. self.reopen_conn() cursor = self.session.open_cursor(uri, None, "next_random=true") last = '' match = 0 for i in range(1,10): cursor.next() current = cursor.get_key() if current == last: match += 1 last = current self.assertLess(match, 5, 'next_random did not return random records, too many matches found')
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 cursor_random_multiple_page_records(self, reopen): uri = self.type if uri.startswith('file:'): simple_populate(self, uri, 'allocation_size=512,leaf_page_max=512,key_format=S', 10000) else: complex_populate(self, uri, 'allocation_size=512,leaf_page_max=512,key_format=S', 10000) # Optionally close the connection so everything is forced to disk, # insert lists are an entirely different path in the code. if reopen: self.reopen_conn() cursor = self.session.open_cursor(uri, None, self.config) last = '' match = 0 for i in range(1,10): self.assertEqual(cursor.next(), 0) current = cursor.get_key() if current == last: match += 1 last = current self.assertLess(match, 5, 'next_random did not return random records, too many matches found')
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_illegal_extractor(self): complex_populate(self, "table:A", "key_format=S", 10) msg = "/unknown extractor/" self.assertRaisesWithMessage( wiredtiger.WiredTigerError, lambda: self.session.create("index:A:xyzzy", 'key_format=S,columns=(column2),extractor="xyzzy"'), msg, )
def test_truncate_complex(self): # We only care about tables. if self.type == 'file:': return uri = self.type + self.name # list: truncation patterns # # begin and end: -1 means pass None for the cursor arg to truncate. An # integer N, with 1 <= N < self.nentries, truncates from/to a cursor # positioned at that row. list = [ (-1, self.nentries), # begin to end, begin = None (1, -1), # begin to end, end = None (1, self.nentries), # begin to end (-1, self.nentries - self.skip), # begin to middle, begin = None (1, self.nentries - self.skip), # begin to middle (self.skip, -1), # middle to end, end = None (self.skip, self.nentries), # middle to end ( self.skip, # middle to different middle self.nentries - self.skip), (1, 1), # begin to begin (self.nentries, self.nentries), # end to end (self.skip, self.skip) # middle to same middle ] # Build the layout we're going to test for begin, end in list: ''' print '===== run:', uri print 'key:', self.keyfmt, 'begin:', begin, 'end:', end ''' # Create the object. complex_populate(self, uri, self.config + self.keyfmt, self.nentries) # Build a dictionary of what the object should look like for # later comparison cursor = self.session.open_cursor(uri, None) expected = {} for i in range(1, self.nentries + 1): expected[key_populate(cursor, i)] = \ complex_value_populate(cursor, i) cursor.close() # Optionally close and re-open the object to get a disk image # instead of a big insert list. if self.reopen: self.reopen_conn() self.truncateRangeAndCheck(uri, begin, end, expected) self.session.drop(uri, None)
def load_commandline(self, args, fail): errfile= "errfile" complex_populate(self, self.uri, "key_format=S,value_format=S", 20) self.runWt(["dump", self.uri], outfilename="dump.out") loadargs = ["load", "-f", "dump.out"] + args self.runWt(loadargs, errfilename=errfile) if fail: self.check_non_empty_file(errfile) else: self.check_empty_file(errfile)
def load_commandline(self, args, fail): errfile = "errfile" complex_populate(self, self.uri, "key_format=S,value_format=S", 20) self.runWt(["dump", self.uri], outfilename="dump.out") loadargs = ["load", "-f", "dump.out"] + args self.runWt(loadargs, errfilename=errfile, failure=fail) if fail: self.check_non_empty_file(errfile) else: self.check_empty_file(errfile)
def test_truncate_complex(self): # We only care about tables. if self.type == 'file:': return uri = self.type + self.name # list: truncation patterns # # begin and end: -1 means pass None for the cursor arg to truncate. An # integer N, with 1 <= N < self.nentries, truncates from/to a cursor # positioned at that row. list = [ (-1, self.nentries), # begin to end, begin = None (1, -1), # begin to end, end = None (1, self.nentries), # begin to end (-1, self.nentries - self.skip), # begin to middle, begin = None (1, self.nentries - self.skip), # begin to middle (self.skip, -1), # middle to end, end = None (self.skip, self.nentries), # middle to end (self.skip, # middle to different middle self.nentries - self.skip), (1, 1), # begin to begin (self.nentries, self.nentries), # end to end (self.skip, self.skip) # middle to same middle ] # Build the layout we're going to test for begin,end in list: ''' print '===== run:', uri print 'key:', self.keyfmt, 'begin:', begin, 'end:', end ''' # Create the object. complex_populate( self, uri, self.config + self.keyfmt, self.nentries) # Build a dictionary of what the object should look like for # later comparison cursor = self.session.open_cursor(uri, None) expected = {} for i in range(1, self.nentries + 1): expected[key_populate(cursor, i)] = \ complex_value_populate(cursor, i) cursor.close() # Optionally close and re-open the object to get a disk image # instead of a big insert list. if self.reopen: self.reopen_conn() self.truncateRangeAndCheck(uri, begin, end, expected) self.session.drop(uri, None)
def test_cursor_random_multiple_insert_records(self): uri = self.type if uri.startswith("file:"): simple_populate(self, uri, "allocation_size=512,leaf_page_max=512,key_format=S", 100) else: complex_populate(self, uri, "allocation_size=512,leaf_page_max=512,key_format=S", 100) # In a insert list, next_random always selects the middle key/value # pair, all we can do is confirm cursor.next works. cursor = self.session.open_cursor(uri, None, self.config) self.assertEqual(cursor.next(), 0)
def test_stat_cursor_conn_clear(self): uri = "table:" + self.pfx complex_populate(self, uri, "key_format=S", 100) # cursor_insert should clear # cache_bytes_dirty should not clear cursor = self.session.open_cursor("statistics:", None, "statistics=(all,clear)") self.assertGreater(cursor[stat.conn.cache_bytes_dirty][2], 0) self.assertGreater(cursor[stat.conn.cursor_insert][2], 0) cursor = self.session.open_cursor("statistics:", None, "statistics=(all,clear)") self.assertGreater(cursor[stat.conn.cache_bytes_dirty][2], 0) self.assertEqual(cursor[stat.conn.cursor_insert][2], 0)
def test_duplicate_cursor(self): uri = self.uri + self.name # A simple, one-file file or table object. simple_populate(self, uri, self.config + self.fmt, self.nentries) self.iterate(uri) self.session.drop(uri, None) # A complex, multi-file table object. if self.uri == "table:": complex_populate(self, uri, self.config + self.fmt, self.nentries) self.iterate(uri) self.session.drop(uri, None)
def test_cursor_random_multiple_insert_records(self): uri = self.type if uri.startswith('file:'): simple_populate(self, uri, 'allocation_size=512,leaf_page_max=512,key_format=S', 100) else: complex_populate(self, uri, 'allocation_size=512,leaf_page_max=512,key_format=S', 100) # In a insert list, next_random always selects the middle key/value # pair, all we can do is confirm cursor.next works. cursor = self.session.open_cursor(uri, None, self.config) self.assertEqual(cursor.next(), 0)
def test_truncate_uri(self): uri = self.type + self.name # A simple, one-file file or table object. simple_populate(self, uri, 'key_format=S', 100) self.session.truncate(uri, None, None, None) confirm_empty(self, uri) self.session.drop(uri, None) if self.type == "table:": complex_populate(self, uri, 'key_format=S', 100) self.session.truncate(uri, None, None, None) confirm_empty(self, uri) self.session.drop(uri, None)
def test_stat_cursor_conn_clear(self): uri = 'table:' + self.pfx complex_populate(self, uri, 'key_format=S', 100) # cursor_insert should clear # cache_bytes_dirty should not clear cursor = self.session.open_cursor('statistics:', None, 'statistics=(all,clear)') self.assertGreater(cursor[stat.conn.cache_bytes_dirty][2], 0) self.assertGreater(cursor[stat.conn.cursor_insert][2], 0) cursor = self.session.open_cursor('statistics:', None, 'statistics=(all,clear)') self.assertGreater(cursor[stat.conn.cache_bytes_dirty][2], 0) self.assertEqual(cursor[stat.conn.cursor_insert][2], 0)
def test_cursor09(self): uri = self.type + "cursor09" if self.complex: complex_populate(self, uri, self.config, 100) else: simple_populate(self, uri, self.config, 100) cursor = self.session.open_cursor(uri, None, None) cursor[key_populate(cursor, 10)] = ( tuple(complex_value_populate(cursor, 10)) if self.complex else value_populate(cursor, 10) ) msg = "/requires key be set/" self.assertRaisesWithMessage(wiredtiger.WiredTigerError, cursor.search, msg)
def test_cursor09(self): uri = self.type + 'cursor09' if self.complex: complex_populate(self, uri, self.config, 100) else: simple_populate(self, uri, self.config, 100) cursor = self.session.open_cursor(uri, None, None) cursor[key_populate(cursor, 10)] = \ tuple(complex_value_populate(cursor, 10)) if self.complex \ else value_populate(cursor, 10) msg = '/requires key be set/' self.assertRaisesWithMessage(wiredtiger.WiredTigerError, cursor.search, msg)
def test_cursor_random_multiple_insert_records(self): uri = self.type + 'random' if self.type == 'file:': simple_populate(self, uri, 'allocation_size=512,leaf_page_max=512,key_format=' +\ self.fmt, 100) else: complex_populate(self, uri, 'allocation_size=512,leaf_page_max=512,key_format=' +\ self.fmt, 100) # In a insert list, next_random always selects the middle key/value # pair, all we can do is confirm cursor.next works. cursor = self.session.open_cursor(uri, None, "next_random=true") self.assertEqual(cursor.next(), 0)
def test_truncate_cursor_order(self): uri = self.type + self.name # A simple, one-file file or table object. simple_populate(self, uri, 'key_format=' + self.keyfmt, 100) c1 = self.session.open_cursor(uri, None) c1.set_key(key_populate(c1, 1000)) c2 = self.session.open_cursor(uri, None) c2.set_key(key_populate(c2, 2000)) self.session.truncate(None, c1, c2, None) self.assertEquals(c1.close(), 0) self.assertEquals(c2.close(), 0) self.session.drop(uri) if self.type == "table:": complex_populate(self, uri, 'key_format=' + self.keyfmt, 100) c1 = self.session.open_cursor(uri, None) c1.set_key(key_populate(c1, 1000)) c2 = self.session.open_cursor(uri, None) c2.set_key(key_populate(c2, 2000)) self.session.truncate(None, c1, c2, None) self.assertEquals(c1.close(), 0) self.assertEquals(c2.close(), 0) self.session.drop(uri)
def test_compact(self): # Populate an object uri = self.uri + self.name if self.uri == "file:": simple_populate(self, uri, self.config, self.nentries - 1) else: complex_populate(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) # If it's a simple object, confirm it worked. if self.uri == "file:": self.assertLess(os.stat(self.name).st_size, 10 * 1024)
def populate(self, uri): if self.complex: complex_populate(self, uri, self.config, 100) else: simple_populate(self, uri, self.config, 100)
def test_cursor_comparison(self): uri = self.type + 'compare' uriX = self.type + 'compareX' # Build the object. if self.type == 'file:': simple_populate(self, uri, 'key_format=' + self.keyfmt + self.config, 100) simple_populate(self, uriX, 'key_format=' + self.keyfmt + self.config, 100) else: complex_populate(self, uri, 'key_format=' + self.keyfmt + self.config, 100) complex_populate(self, uriX, 'key_format=' + self.keyfmt + self.config, 100) c1 = self.session.open_cursor(uri, None) c2 = self.session.open_cursor(uri, None) # Confirm failure 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 before they're positioned. c1.set_key(key_populate(c1, 10)) c2.set_key(key_populate(c2, 20)) self.assertGreater(c2.compare(c1), 0) self.assertLess(c1.compare(c2), 0) c2.set_key(key_populate(c2, 10)) self.assertEqual(c1.compare(c2), 0) self.assertEqual(c2.compare(c1), 0) # Confirm failure for different objects. cX = self.session.open_cursor(uriX, None) cX.set_key(key_populate(cX, 10)) msg = '/must reference the same object/' self.assertRaisesWithMessage( wiredtiger.WiredTigerError, lambda: cX.compare(c1), msg) # Test cursors after they're positioned (shouldn't matter for compare). c1.set_key(key_populate(c1, 10)) self.assertEqual(c1.search(), 0) c2.set_key(key_populate(c2, 20)) self.assertEqual(c2.search(), 0) self.assertGreater(c2.compare(c1), 0) self.assertLess(c1.compare(c2), 0) c2.set_key(key_populate(c2, 10)) self.assertEqual(c2.search(), 0) self.assertEqual(c1.compare(c2), 0) self.assertEqual(c2.compare(c1), 0) # Confirm failure for different objects. cX = self.session.open_cursor(uriX, None) cX.set_key(key_populate(cX, 10)) self.assertEqual(cX.search(), 0) msg = '/must reference the same object/' self.assertRaisesWithMessage( wiredtiger.WiredTigerError, lambda: cX.compare(c1), msg)
def pop(self, uri): if self.complex == 1: complex_populate(self, uri, 'key_format=' + self.keyfmt, 100) else: simple_populate(self, uri, 'key_format=' + self.keyfmt, 100)
def test_cursor_comparison(self): uri = self.type + "compare" uriX = self.type + "compareX" # Build the object. if self.type == "file:": simple_populate(self, uri, "key_format=" + self.keyfmt + self.config, 100) simple_populate(self, uriX, "key_format=" + self.keyfmt + self.config, 100) ix0_0 = None ix0_1 = None ix1_0 = None ixX_0 = None else: complex_populate(self, uri, "key_format=" + self.keyfmt + self.config, 100) complex_populate(self, uriX, "key_format=" + self.keyfmt + self.config, 100) ix0_0 = self.session.open_cursor(complex_populate_index_name(self, uri, 0), None) ix0_1 = self.session.open_cursor(complex_populate_index_name(self, uri, 0), None) ix1_0 = self.session.open_cursor(complex_populate_index_name(self, uri, 1), None) ixX_0 = self.session.open_cursor(complex_populate_index_name(self, uriX, 0), None) ix0_0.next() ix0_1.next() ix1_0.next() ixX_0.next() c1 = self.session.open_cursor(uri, None) c2 = self.session.open_cursor(uri, None) # Confirm failure 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 before they're positioned. c1.set_key(key_populate(c1, 10)) c2.set_key(key_populate(c2, 20)) self.assertGreater(c2.compare(c1), 0) self.assertLess(c1.compare(c2), 0) c2.set_key(key_populate(c2, 10)) self.assertEqual(c1.compare(c2), 0) self.assertEqual(c2.compare(c1), 0) # Confirm failure for different objects. cX = self.session.open_cursor(uriX, None) cX.set_key(key_populate(cX, 10)) msg = "/must reference the same object/" self.assertRaisesWithMessage(wiredtiger.WiredTigerError, lambda: cX.compare(c1), msg) msg = "/wt_cursor.* is None/" self.assertRaisesHavingMessage(exceptions.RuntimeError, lambda: cX.compare(None), msg) if ix0_0 != None: self.assertEqual(ix0_0.compare(ix0_1), 0) ix0_1.reset() ix0_1.prev() self.assertLess(ix0_0.compare(ix0_1), 0) self.assertGreater(ix0_1.compare(ix0_0), 0) # Main table vs. index not allowed msg = "/must reference the same object/" self.assertRaisesWithMessage(wiredtiger.WiredTigerError, lambda: c1.compare(ix0_0), msg) # Two unrelated indices not allowed self.assertRaisesWithMessage(wiredtiger.WiredTigerError, lambda: ixX_0.compare(ix0_0), msg) # Two different indices from same table not allowed self.assertRaisesWithMessage(wiredtiger.WiredTigerError, lambda: ix0_0.compare(ix1_0), msg) # Test cursors after they're positioned (shouldn't matter for compare). c1.set_key(key_populate(c1, 10)) self.assertEqual(c1.search(), 0) c2.set_key(key_populate(c2, 20)) self.assertEqual(c2.search(), 0) self.assertGreater(c2.compare(c1), 0) self.assertLess(c1.compare(c2), 0) c2.set_key(key_populate(c2, 10)) self.assertEqual(c2.search(), 0) self.assertEqual(c1.compare(c2), 0) self.assertEqual(c2.compare(c1), 0) # Confirm failure for different objects. cX = self.session.open_cursor(uriX, None) cX.set_key(key_populate(cX, 10)) self.assertEqual(cX.search(), 0) msg = "/must reference the same object/" self.assertRaisesWithMessage(wiredtiger.WiredTigerError, lambda: cX.compare(c1), msg)
def test_cursor_comparison(self): uri = self.type + 'compare' uriX = self.type + 'compareX' # Build the object. if self.type == 'file:': simple_populate( self, uri, 'key_format=' + self.keyfmt + self.config, 100) simple_populate( self, uriX, 'key_format=' + self.keyfmt + self.config, 100) ix0_0 = None ix0_1 = None ix1_0 = None ixX_0 = None else: complex_populate( self, uri, 'key_format=' + self.keyfmt + self.config, 100) complex_populate( self, uriX, 'key_format=' + self.keyfmt + self.config, 100) ix0_0 = self.session.open_cursor( complex_populate_index_name(self, uri, 0), None) ix0_1 = self.session.open_cursor( complex_populate_index_name(self, uri, 0), None) ix1_0 = self.session.open_cursor( complex_populate_index_name(self, uri, 1), None) ixX_0 = self.session.open_cursor( complex_populate_index_name(self, uriX, 0), None) ix0_0.next() ix0_1.next() ix1_0.next() ixX_0.next() c1 = self.session.open_cursor(uri, None) c2 = self.session.open_cursor(uri, None) # Confirm failure 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 before they're positioned. c1.set_key(key_populate(c1, 10)) c2.set_key(key_populate(c2, 20)) self.assertGreater(c2.compare(c1), 0) self.assertLess(c1.compare(c2), 0) c2.set_key(key_populate(c2, 10)) self.assertEqual(c1.compare(c2), 0) self.assertEqual(c2.compare(c1), 0) # Confirm failure for different objects. cX = self.session.open_cursor(uriX, None) cX.set_key(key_populate(cX, 10)) msg = '/must reference the same object/' self.assertRaisesWithMessage( wiredtiger.WiredTigerError, lambda: cX.compare(c1), msg) msg = '/wt_cursor.* is None/' self.assertRaisesHavingMessage( exceptions.RuntimeError, lambda: cX.compare(None), msg) if ix0_0 != None: self.assertEqual(ix0_0.compare(ix0_1), 0) ix0_1.reset() ix0_1.prev() self.assertLess(ix0_0.compare(ix0_1), 0) self.assertGreater(ix0_1.compare(ix0_0), 0) # Main table vs. index not allowed msg = '/must reference the same object/' self.assertRaisesWithMessage( wiredtiger.WiredTigerError, lambda: c1.compare(ix0_0), msg) # Two unrelated indices not allowed self.assertRaisesWithMessage( wiredtiger.WiredTigerError, lambda: ixX_0.compare(ix0_0), msg) # Two different indices from same table not allowed self.assertRaisesWithMessage( wiredtiger.WiredTigerError, lambda: ix0_0.compare(ix1_0), msg) # Test cursors after they're positioned (shouldn't matter for compare). c1.set_key(key_populate(c1, 10)) self.assertEqual(c1.search(), 0) c2.set_key(key_populate(c2, 20)) self.assertEqual(c2.search(), 0) self.assertGreater(c2.compare(c1), 0) self.assertLess(c1.compare(c2), 0) c2.set_key(key_populate(c2, 10)) self.assertEqual(c2.search(), 0) self.assertEqual(c1.compare(c2), 0) self.assertEqual(c2.compare(c1), 0) # Confirm failure for different objects. cX = self.session.open_cursor(uriX, None) cX.set_key(key_populate(cX, 10)) self.assertEqual(cX.search(), 0) msg = '/must reference the same object/' self.assertRaisesWithMessage( wiredtiger.WiredTigerError, lambda: cX.compare(c1), msg)
def test_cursor_equality(self): uri = self.type + 'equality' uriX = self.type + 'compareX' # Build the object. if self.type == 'file:': simple_populate( self, uri, 'key_format=' + self.keyfmt + self.config, 100) simple_populate( self, uriX, 'key_format=' + self.keyfmt + self.config, 100) ix0_0 = None ix0_1 = None ix1_0 = None ixX_0 = None else: complex_populate( self, uri, 'key_format=' + self.keyfmt + self.config, 100) complex_populate( self, uriX, 'key_format=' + self.keyfmt + self.config, 100) ix0_0 = self.session.open_cursor( complex_populate_index_name(self, uri, 0), None) ix0_1 = self.session.open_cursor( complex_populate_index_name(self, uri, 0), None) ix1_0 = self.session.open_cursor( complex_populate_index_name(self, uri, 1), None) ixX_0 = self.session.open_cursor( complex_populate_index_name(self, uriX, 0), None) ix0_0.next() ix0_1.next() ix1_0.next() ixX_0.next() c1 = self.session.open_cursor(uri, None) c2 = self.session.open_cursor(uri, None) # Confirm failure unless the keys are set. msg = '/requires key be set/' self.assertRaisesWithMessage( wiredtiger.WiredTigerError, lambda: c1.equals(c2), msg) self.assertRaisesWithMessage( wiredtiger.WiredTigerError, lambda: c2.equals(c1), msg) # Test cursors before they're positioned. c1.set_key(key_populate(c1, 10)) c2.set_key(key_populate(c2, 20)) self.assertFalse(c1.equals(c2)) self.assertFalse(c2.equals(c1)) c2.set_key(key_populate(c2, 10)) self.assertTrue(c1.equals(c2)) self.assertTrue(c2.equals(c1)) # Confirm failure for different objects. cX = self.session.open_cursor(uriX, None) cX.set_key(key_populate(cX, 10)) msg = '/must reference the same object/' self.assertRaisesWithMessage( wiredtiger.WiredTigerError, lambda: cX.equals(c1), msg) msg = '/wt_cursor.* is None/' self.assertRaisesHavingMessage( exceptions.RuntimeError, lambda: cX.equals(None), msg) if ix0_0 != None: self.assertTrue(ix0_0.equals(ix0_1)) ix0_1.reset() ix0_1.prev() self.assertFalse(ix0_0.equals(ix0_1)) # Main table vs. index not allowed msg = '/must reference the same object/' self.assertRaisesWithMessage( wiredtiger.WiredTigerError, lambda: c1.equals(ix0_0), msg) # Two unrelated indices not allowed self.assertRaisesWithMessage( wiredtiger.WiredTigerError, lambda: ixX_0.equals(ix0_0), msg) # Two different indices from same table not allowed self.assertRaisesWithMessage( wiredtiger.WiredTigerError, lambda: ix0_0.equals(ix1_0), msg) # Test cursors after they're positioned (internally, it's a different # search path if keys are positioned in the tree). c1.set_key(key_populate(c1, 10)) self.assertEqual(c1.search(), 0) c2.set_key(key_populate(c2, 20)) self.assertEqual(c2.search(), 0) self.assertFalse(c1.equals(c2)) self.assertFalse(c2.equals(c1)) c2.set_key(key_populate(c2, 10)) self.assertEqual(c2.search(), 0) self.assertTrue(c1.equals(c2)) self.assertTrue(c2.equals(c1)) # Confirm failure for different objects. cX = self.session.open_cursor(uriX, None) cX.set_key(key_populate(cX, 10)) self.assertEqual(cX.search(), 0) msg = '/must reference the same object/' self.assertRaisesWithMessage( wiredtiger.WiredTigerError, lambda: cX.equals(c1), msg)
def test_cursor_comparison(self): uri = self.type + 'compare' uriX = self.type + 'compareX' # Build the object. if self.type == 'file:': simple_populate(self, uri, 'key_format=' + self.keyfmt + self.config, 100) simple_populate(self, uriX, 'key_format=' + self.keyfmt + self.config, 100) else: complex_populate(self, uri, 'key_format=' + self.keyfmt + self.config, 100) complex_populate(self, uriX, 'key_format=' + self.keyfmt + self.config, 100) c1 = self.session.open_cursor(uri, None) c2 = self.session.open_cursor(uri, None) # Confirm failure 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 before they're positioned. c1.set_key(key_populate(c1, 10)) c2.set_key(key_populate(c2, 20)) self.assertGreater(c2.compare(c1), 0) self.assertLess(c1.compare(c2), 0) c2.set_key(key_populate(c2, 10)) self.assertEqual(c1.compare(c2), 0) self.assertEqual(c2.compare(c1), 0) # Confirm failure for different objects. cX = self.session.open_cursor(uriX, None) cX.set_key(key_populate(cX, 10)) msg = '/must reference the same object/' self.assertRaisesWithMessage(wiredtiger.WiredTigerError, lambda: cX.compare(c1), msg) # Test cursors after they're positioned (shouldn't matter for compare). c1.set_key(key_populate(c1, 10)) self.assertEqual(c1.search(), 0) c2.set_key(key_populate(c2, 20)) self.assertEqual(c2.search(), 0) self.assertGreater(c2.compare(c1), 0) self.assertLess(c1.compare(c2), 0) c2.set_key(key_populate(c2, 10)) self.assertEqual(c2.search(), 0) self.assertEqual(c1.compare(c2), 0) self.assertEqual(c2.compare(c1), 0) # Confirm failure for different objects. cX = self.session.open_cursor(uriX, None) cX.set_key(key_populate(cX, 10)) self.assertEqual(cX.search(), 0) msg = '/must reference the same object/' self.assertRaisesWithMessage(wiredtiger.WiredTigerError, lambda: cX.compare(c1), msg)
def test_cursor_equality(self): uri = self.type + 'equality' uriX = self.type + 'compareX' # Build the object. if self.type == 'file:': simple_populate(self, uri, 'key_format=' + self.keyfmt + self.config, 100) simple_populate(self, uriX, 'key_format=' + self.keyfmt + self.config, 100) else: complex_populate(self, uri, 'key_format=' + self.keyfmt + self.config, 100) complex_populate(self, uriX, 'key_format=' + self.keyfmt + self.config, 100) c1 = self.session.open_cursor(uri, None) c2 = self.session.open_cursor(uri, None) # Confirm failure unless the keys are set. msg = '/requires key be set/' self.assertRaisesWithMessage( wiredtiger.WiredTigerError, lambda: c1.equals(c2), msg) self.assertRaisesWithMessage( wiredtiger.WiredTigerError, lambda: c2.equals(c1), msg) # Test cursors before they're positioned. c1.set_key(key_populate(c1, 10)) c2.set_key(key_populate(c2, 20)) self.assertFalse(c1.equals(c2)) self.assertFalse(c2.equals(c1)) c2.set_key(key_populate(c2, 10)) self.assertTrue(c1.equals(c2)) self.assertTrue(c2.equals(c1)) # Confirm failure for different objects. cX = self.session.open_cursor(uriX, None) cX.set_key(key_populate(cX, 10)) msg = '/must reference the same object/' self.assertRaisesWithMessage( wiredtiger.WiredTigerError, lambda: cX.compare(c1), msg) # Test cursors after they're positioned (internally, it's a different # search path if keys are positioned in the tree). c1.set_key(key_populate(c1, 10)) self.assertEqual(c1.search(), 0) c2.set_key(key_populate(c2, 20)) self.assertEqual(c2.search(), 0) self.assertFalse(c1.equals(c2)) self.assertFalse(c2.equals(c1)) c2.set_key(key_populate(c2, 10)) self.assertEqual(c2.search(), 0) self.assertTrue(c1.equals(c2)) self.assertTrue(c2.equals(c1)) # Confirm failure for different objects. cX = self.session.open_cursor(uriX, None) cX.set_key(key_populate(cX, 10)) self.assertEqual(cX.search(), 0) msg = '/must reference the same object/' self.assertRaisesWithMessage( wiredtiger.WiredTigerError, lambda: cX.compare(c1), msg)
def test_cursor_equality(self): uri = self.type + 'equality' uriX = self.type + 'compareX' # Build the object. if self.type == 'file:': simple_populate(self, uri, 'key_format=' + self.keyfmt + self.config, 100) simple_populate(self, uriX, 'key_format=' + self.keyfmt + self.config, 100) else: complex_populate(self, uri, 'key_format=' + self.keyfmt + self.config, 100) complex_populate(self, uriX, 'key_format=' + self.keyfmt + self.config, 100) c1 = self.session.open_cursor(uri, None) c2 = self.session.open_cursor(uri, None) # Confirm failure unless the keys are set. msg = '/requires key be set/' self.assertRaisesWithMessage(wiredtiger.WiredTigerError, lambda: c1.equals(c2), msg) self.assertRaisesWithMessage(wiredtiger.WiredTigerError, lambda: c2.equals(c1), msg) # Test cursors before they're positioned. c1.set_key(key_populate(c1, 10)) c2.set_key(key_populate(c2, 20)) self.assertFalse(c1.equals(c2)) self.assertFalse(c2.equals(c1)) c2.set_key(key_populate(c2, 10)) self.assertTrue(c1.equals(c2)) self.assertTrue(c2.equals(c1)) # Confirm failure for different objects. cX = self.session.open_cursor(uriX, None) cX.set_key(key_populate(cX, 10)) msg = '/must reference the same object/' self.assertRaisesWithMessage(wiredtiger.WiredTigerError, lambda: cX.compare(c1), msg) # Test cursors after they're positioned (internally, it's a different # search path if keys are positioned in the tree). c1.set_key(key_populate(c1, 10)) self.assertEqual(c1.search(), 0) c2.set_key(key_populate(c2, 20)) self.assertEqual(c2.search(), 0) self.assertFalse(c1.equals(c2)) self.assertFalse(c2.equals(c1)) c2.set_key(key_populate(c2, 10)) self.assertEqual(c2.search(), 0) self.assertTrue(c1.equals(c2)) self.assertTrue(c2.equals(c1)) # Confirm failure for different objects. cX = self.session.open_cursor(uriX, None) cX.set_key(key_populate(cX, 10)) self.assertEqual(cX.search(), 0) msg = '/must reference the same object/' self.assertRaisesWithMessage(wiredtiger.WiredTigerError, lambda: cX.compare(c1), msg)
def test_illegal_extractor(self): complex_populate(self, 'table:A', 'key_format=S', 10) msg = '/unknown extractor/' self.assertRaisesWithMessage(wiredtiger.WiredTigerError, lambda: self.session.create('index:A:xyzzy', 'key_format=S,columns=(column2),extractor="xyzzy"'), msg)