1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
#!/usr/bin/env python
#
# See the file LICENSE for redistribution information.
#
# Copyright (c) 2008-2011 WiredTiger, Inc.
# All rights reserved.
#
# test001.py
# Basic operations
#
import unittest
import wiredtiger
import wttest
import os
import sys
class test_compress01_base(wttest.WiredTigerTestCase):
"""
Test basic compression
"""
nrecords = 10000
# running tests from the base class uses no compressor,
# a reasonable way to test the test case.
def __init__(self, testname, compressor_name=None, abbrev='none'):
wttest.WiredTigerTestCase.__init__(self, testname)
self.compressor_name = compressor_name
self.table_name1 = 'test_compress01' + abbrev + '.wt'
# bigvalue = '1234567891011121314....'
self.bigvalue = ''.join([`num` for num in xrange(1,10000)]) # about 38K chars long
def create_table(self, tablename):
extra_params = ',internal_node_min=512,internal_node_max=16384,leaf_node_min=131072,leaf_node_max=131072'
comp_params = ''
if self.compressor_name != None:
comp_params = ',block_compressor=' + self.compressor_name
params = 'key_format=S,value_format=S' + extra_params + comp_params
self.pr('create_table: ' + tablename + ', params: ' + params)
self.session.create('file:' + tablename, params)
def cursor_s(self, tablename, key):
cursor = self.session.open_cursor('file:' + tablename, None)
cursor.set_key(key)
return cursor
def cursor_ss(self, tablename, key, val):
cursor = self.cursor_s(tablename, key)
cursor.set_value(val)
return cursor
def record_count(self):
return self.nrecords
def do_insert(self):
"""
Create a table, add keys with big values, get them back
"""
self.create_table(self.table_name1)
self.pr("inserting `len(self.bigvalue)` byte values")
for idx in xrange(1,self.record_count()):
val = `idx` + self.bigvalue + `idx`
inscursor = self.cursor_ss(self.table_name1, 'key' + `idx`, val)
inscursor.insert()
inscursor.close
def do_verify(self):
self.pr('search')
for idx in xrange(1,self.record_count()):
val = `idx` + self.bigvalue + `idx`
getcursor = self.cursor_s(self.table_name1, 'key' + `idx`)
ret = getcursor.search()
self.assertTrue(ret == 0)
self.assertEquals(getcursor.get_value(), val)
getcursor.close(None)
def do_fresh_cache(self):
# Since we are running WT in-process, we just need
# to shut down the connection and start again.
self.conn.close(None)
self.conn = self.setUpConnectionOpen(".")
self.session = self.setUpSessionOpen(self.conn)
def test_insert_and_verify(self):
self.do_insert()
# We want a fresh cache so that compressed pages
# are really read from disk.
self.do_fresh_cache()
self.do_verify()
def extensionArg(self, name):
if name != None:
extensionsdir = os.path.dirname(__file__) + os.sep + '../../ext/compressors';
extensionsarg = 'extensions=["' + extensionsdir + os.sep + name + os.sep + name + '.so"]'
return extensionsarg
else:
return ''
# override WiredTigerTestCase
def setUpConnectionOpen(self, dir):
return self.setUpConnectionWithExtension(dir, self.compressor_name)
def setUpConnectionWithExtension(self, dir, name):
conn = wiredtiger.wiredtiger_open(dir, 'create,' + self.extensionArg(name))
self.pr(`conn`)
return conn
class test_compress01_1_nop(test_compress01_base):
def __init__(self, testname):
test_compress01_base.__init__(self, testname, 'nop_compress', 'nop')
class test_compress01_2_bz(test_compress01_base):
def __init__(self, testname):
test_compress01_base.__init__(self, testname, 'bzip2_compress', 'bz')
if __name__ == '__main__':
wttest.run(test_compress01_base)
wttest.run(test_compress01_1_nop)
wttest.run(test_compress01_2_bz)
|
