Commit | Line | Data |
---|---|---|
86530b38 AT |
1 | #------------------------------------------------------------------------- |
2 | # This file contains real Python object wrappers for DB and DBEnv | |
3 | # C "objects" that can be usefully subclassed. The previous SWIG | |
4 | # based interface allowed this thanks to SWIG's shadow classes. | |
5 | # -- Gregory P. Smith | |
6 | #------------------------------------------------------------------------- | |
7 | # | |
8 | # (C) Copyright 2001 Autonomous Zone Industries | |
9 | # | |
10 | # License: This is free software. You may use this software for any | |
11 | # purpose including modification/redistribution, so long as | |
12 | # this header remains intact and that you do not claim any | |
13 | # rights of ownership or authorship of this software. This | |
14 | # software has been tested, but no warranty is expressed or | |
15 | # implied. | |
16 | # | |
17 | ||
18 | # | |
19 | # TODO it would be *really nice* to have an automatic shadow class populator | |
20 | # so that new methods don't need to be added here manually after being | |
21 | # added to _bsddb.c. | |
22 | # | |
23 | ||
24 | import db | |
25 | ||
26 | try: | |
27 | from UserDict import DictMixin | |
28 | except ImportError: | |
29 | # DictMixin is new in Python 2.3 | |
30 | class DictMixin: pass | |
31 | ||
32 | class DBEnv: | |
33 | def __init__(self, *args, **kwargs): | |
34 | self._cobj = apply(db.DBEnv, args, kwargs) | |
35 | ||
36 | def close(self, *args, **kwargs): | |
37 | return apply(self._cobj.close, args, kwargs) | |
38 | def open(self, *args, **kwargs): | |
39 | return apply(self._cobj.open, args, kwargs) | |
40 | def remove(self, *args, **kwargs): | |
41 | return apply(self._cobj.remove, args, kwargs) | |
42 | def set_shm_key(self, *args, **kwargs): | |
43 | return apply(self._cobj.set_shm_key, args, kwargs) | |
44 | def set_cachesize(self, *args, **kwargs): | |
45 | return apply(self._cobj.set_cachesize, args, kwargs) | |
46 | def set_data_dir(self, *args, **kwargs): | |
47 | return apply(self._cobj.set_data_dir, args, kwargs) | |
48 | def set_flags(self, *args, **kwargs): | |
49 | return apply(self._cobj.set_flags, args, kwargs) | |
50 | def set_lg_bsize(self, *args, **kwargs): | |
51 | return apply(self._cobj.set_lg_bsize, args, kwargs) | |
52 | def set_lg_dir(self, *args, **kwargs): | |
53 | return apply(self._cobj.set_lg_dir, args, kwargs) | |
54 | def set_lg_max(self, *args, **kwargs): | |
55 | return apply(self._cobj.set_lg_max, args, kwargs) | |
56 | def set_lk_detect(self, *args, **kwargs): | |
57 | return apply(self._cobj.set_lk_detect, args, kwargs) | |
58 | def set_lk_max(self, *args, **kwargs): | |
59 | return apply(self._cobj.set_lk_max, args, kwargs) | |
60 | def set_lk_max_locks(self, *args, **kwargs): | |
61 | return apply(self._cobj.set_lk_max_locks, args, kwargs) | |
62 | def set_lk_max_lockers(self, *args, **kwargs): | |
63 | return apply(self._cobj.set_lk_max_lockers, args, kwargs) | |
64 | def set_lk_max_objects(self, *args, **kwargs): | |
65 | return apply(self._cobj.set_lk_max_objects, args, kwargs) | |
66 | def set_mp_mmapsize(self, *args, **kwargs): | |
67 | return apply(self._cobj.set_mp_mmapsize, args, kwargs) | |
68 | def set_timeout(self, *args, **kwargs): | |
69 | return apply(self._cobj.set_timeout, args, kwargs) | |
70 | def set_tmp_dir(self, *args, **kwargs): | |
71 | return apply(self._cobj.set_tmp_dir, args, kwargs) | |
72 | def txn_begin(self, *args, **kwargs): | |
73 | return apply(self._cobj.txn_begin, args, kwargs) | |
74 | def txn_checkpoint(self, *args, **kwargs): | |
75 | return apply(self._cobj.txn_checkpoint, args, kwargs) | |
76 | def txn_stat(self, *args, **kwargs): | |
77 | return apply(self._cobj.txn_stat, args, kwargs) | |
78 | def set_tx_max(self, *args, **kwargs): | |
79 | return apply(self._cobj.set_tx_max, args, kwargs) | |
80 | def lock_detect(self, *args, **kwargs): | |
81 | return apply(self._cobj.lock_detect, args, kwargs) | |
82 | def lock_get(self, *args, **kwargs): | |
83 | return apply(self._cobj.lock_get, args, kwargs) | |
84 | def lock_id(self, *args, **kwargs): | |
85 | return apply(self._cobj.lock_id, args, kwargs) | |
86 | def lock_put(self, *args, **kwargs): | |
87 | return apply(self._cobj.lock_put, args, kwargs) | |
88 | def lock_stat(self, *args, **kwargs): | |
89 | return apply(self._cobj.lock_stat, args, kwargs) | |
90 | def log_archive(self, *args, **kwargs): | |
91 | return apply(self._cobj.log_archive, args, kwargs) | |
92 | def set_get_returns_none(self, *args, **kwargs): | |
93 | return apply(self._cobj.set_get_returns_none, args, kwargs) | |
94 | ||
95 | if db.version() >= (4,1): | |
96 | def dbremove(self, *args, **kwargs): | |
97 | return apply(self._cobj.dbremove, args, kwargs) | |
98 | def dbrename(self, *args, **kwargs): | |
99 | return apply(self._cobj.dbrename, args, kwargs) | |
100 | def set_encrypt(self, *args, **kwargs): | |
101 | return apply(self._cobj.set_encrypt, args, kwargs) | |
102 | ||
103 | ||
104 | class DB(DictMixin): | |
105 | def __init__(self, dbenv, *args, **kwargs): | |
106 | # give it the proper DBEnv C object that its expecting | |
107 | self._cobj = apply(db.DB, (dbenv._cobj,) + args, kwargs) | |
108 | ||
109 | # TODO are there other dict methods that need to be overridden? | |
110 | def __len__(self): | |
111 | return len(self._cobj) | |
112 | def __getitem__(self, arg): | |
113 | return self._cobj[arg] | |
114 | def __setitem__(self, key, value): | |
115 | self._cobj[key] = value | |
116 | def __delitem__(self, arg): | |
117 | del self._cobj[arg] | |
118 | ||
119 | def append(self, *args, **kwargs): | |
120 | return apply(self._cobj.append, args, kwargs) | |
121 | def associate(self, *args, **kwargs): | |
122 | return apply(self._cobj.associate, args, kwargs) | |
123 | def close(self, *args, **kwargs): | |
124 | return apply(self._cobj.close, args, kwargs) | |
125 | def consume(self, *args, **kwargs): | |
126 | return apply(self._cobj.consume, args, kwargs) | |
127 | def consume_wait(self, *args, **kwargs): | |
128 | return apply(self._cobj.consume_wait, args, kwargs) | |
129 | def cursor(self, *args, **kwargs): | |
130 | return apply(self._cobj.cursor, args, kwargs) | |
131 | def delete(self, *args, **kwargs): | |
132 | return apply(self._cobj.delete, args, kwargs) | |
133 | def fd(self, *args, **kwargs): | |
134 | return apply(self._cobj.fd, args, kwargs) | |
135 | def get(self, *args, **kwargs): | |
136 | return apply(self._cobj.get, args, kwargs) | |
137 | def pget(self, *args, **kwargs): | |
138 | return apply(self._cobj.pget, args, kwargs) | |
139 | def get_both(self, *args, **kwargs): | |
140 | return apply(self._cobj.get_both, args, kwargs) | |
141 | def get_byteswapped(self, *args, **kwargs): | |
142 | return apply(self._cobj.get_byteswapped, args, kwargs) | |
143 | def get_size(self, *args, **kwargs): | |
144 | return apply(self._cobj.get_size, args, kwargs) | |
145 | def get_type(self, *args, **kwargs): | |
146 | return apply(self._cobj.get_type, args, kwargs) | |
147 | def join(self, *args, **kwargs): | |
148 | return apply(self._cobj.join, args, kwargs) | |
149 | def key_range(self, *args, **kwargs): | |
150 | return apply(self._cobj.key_range, args, kwargs) | |
151 | def has_key(self, *args, **kwargs): | |
152 | return apply(self._cobj.has_key, args, kwargs) | |
153 | def items(self, *args, **kwargs): | |
154 | return apply(self._cobj.items, args, kwargs) | |
155 | def keys(self, *args, **kwargs): | |
156 | return apply(self._cobj.keys, args, kwargs) | |
157 | def open(self, *args, **kwargs): | |
158 | return apply(self._cobj.open, args, kwargs) | |
159 | def put(self, *args, **kwargs): | |
160 | return apply(self._cobj.put, args, kwargs) | |
161 | def remove(self, *args, **kwargs): | |
162 | return apply(self._cobj.remove, args, kwargs) | |
163 | def rename(self, *args, **kwargs): | |
164 | return apply(self._cobj.rename, args, kwargs) | |
165 | def set_bt_minkey(self, *args, **kwargs): | |
166 | return apply(self._cobj.set_bt_minkey, args, kwargs) | |
167 | def set_cachesize(self, *args, **kwargs): | |
168 | return apply(self._cobj.set_cachesize, args, kwargs) | |
169 | def set_flags(self, *args, **kwargs): | |
170 | return apply(self._cobj.set_flags, args, kwargs) | |
171 | def set_h_ffactor(self, *args, **kwargs): | |
172 | return apply(self._cobj.set_h_ffactor, args, kwargs) | |
173 | def set_h_nelem(self, *args, **kwargs): | |
174 | return apply(self._cobj.set_h_nelem, args, kwargs) | |
175 | def set_lorder(self, *args, **kwargs): | |
176 | return apply(self._cobj.set_lorder, args, kwargs) | |
177 | def set_pagesize(self, *args, **kwargs): | |
178 | return apply(self._cobj.set_pagesize, args, kwargs) | |
179 | def set_re_delim(self, *args, **kwargs): | |
180 | return apply(self._cobj.set_re_delim, args, kwargs) | |
181 | def set_re_len(self, *args, **kwargs): | |
182 | return apply(self._cobj.set_re_len, args, kwargs) | |
183 | def set_re_pad(self, *args, **kwargs): | |
184 | return apply(self._cobj.set_re_pad, args, kwargs) | |
185 | def set_re_source(self, *args, **kwargs): | |
186 | return apply(self._cobj.set_re_source, args, kwargs) | |
187 | def set_q_extentsize(self, *args, **kwargs): | |
188 | return apply(self._cobj.set_q_extentsize, args, kwargs) | |
189 | def stat(self, *args, **kwargs): | |
190 | return apply(self._cobj.stat, args, kwargs) | |
191 | def sync(self, *args, **kwargs): | |
192 | return apply(self._cobj.sync, args, kwargs) | |
193 | def type(self, *args, **kwargs): | |
194 | return apply(self._cobj.type, args, kwargs) | |
195 | def upgrade(self, *args, **kwargs): | |
196 | return apply(self._cobj.upgrade, args, kwargs) | |
197 | def values(self, *args, **kwargs): | |
198 | return apply(self._cobj.values, args, kwargs) | |
199 | def verify(self, *args, **kwargs): | |
200 | return apply(self._cobj.verify, args, kwargs) | |
201 | def set_get_returns_none(self, *args, **kwargs): | |
202 | return apply(self._cobj.set_get_returns_none, args, kwargs) | |
203 | ||
204 | if db.version() >= (4,1): | |
205 | def set_encrypt(self, *args, **kwargs): | |
206 | return apply(self._cobj.set_encrypt, args, kwargs) |