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_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_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_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_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 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 populate(self, uri):
if self.complex:
complex_populate(self, uri, self.config, 100)
else:
simple_populate(self, uri, self.config, 100)
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)
