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 sys

    25 absolute_import = (sys.version_info[0] >= 3)

    26 if absolute_import :

    27     # Because this syntaxis is not valid before Python 2.5

    28     exec("from . import db")

    29 else :

    30     import db

    31 

    32 if sys.version_info[0:2] <= (2, 5) :

    33     try:

    34         from UserDict import DictMixin

    35     except ImportError:

    36         # DictMixin is new in Python 2.3

    37         class DictMixin: pass

    38     MutableMapping = DictMixin

    39 else :

    40     import collections

    41     MutableMapping = collections.MutableMapping

    42 

    43 class DBEnv:

    44     def __init__(self, *args, **kwargs):

    45         self._cobj = apply(db.DBEnv, args, kwargs)

    46 

    47     def close(self, *args, **kwargs):

    48         return apply(self._cobj.close, args, kwargs)

    49     def open(self, *args, **kwargs):

    50         return apply(self._cobj.open, args, kwargs)

    51     def remove(self, *args, **kwargs):

    52         return apply(self._cobj.remove, args, kwargs)

    53     def set_shm_key(self, *args, **kwargs):

    54         return apply(self._cobj.set_shm_key, args, kwargs)

    55     def set_cachesize(self, *args, **kwargs):

    56         return apply(self._cobj.set_cachesize, args, kwargs)

    57     def set_data_dir(self, *args, **kwargs):

    58         return apply(self._cobj.set_data_dir, args, kwargs)

    59     def set_flags(self, *args, **kwargs):

    60         return apply(self._cobj.set_flags, args, kwargs)

    61     def set_lg_bsize(self, *args, **kwargs):

    62         return apply(self._cobj.set_lg_bsize, args, kwargs)

    63     def set_lg_dir(self, *args, **kwargs):

    64         return apply(self._cobj.set_lg_dir, args, kwargs)

    65     def set_lg_max(self, *args, **kwargs):

    66         return apply(self._cobj.set_lg_max, args, kwargs)

    67     def set_lk_detect(self, *args, **kwargs):

    68         return apply(self._cobj.set_lk_detect, args, kwargs)

    69     if db.version() < (4,5):

    70         def set_lk_max(self, *args, **kwargs):

    71             return apply(self._cobj.set_lk_max, args, kwargs)

    72     def set_lk_max_locks(self, *args, **kwargs):

    73         return apply(self._cobj.set_lk_max_locks, args, kwargs)

    74     def set_lk_max_lockers(self, *args, **kwargs):

    75         return apply(self._cobj.set_lk_max_lockers, args, kwargs)

    76     def set_lk_max_objects(self, *args, **kwargs):

    77         return apply(self._cobj.set_lk_max_objects, args, kwargs)

    78     def set_mp_mmapsize(self, *args, **kwargs):

    79         return apply(self._cobj.set_mp_mmapsize, args, kwargs)

    80     def set_timeout(self, *args, **kwargs):

    81         return apply(self._cobj.set_timeout, args, kwargs)

    82     def set_tmp_dir(self, *args, **kwargs):

    83         return apply(self._cobj.set_tmp_dir, args, kwargs)

    84     def txn_begin(self, *args, **kwargs):

    85         return apply(self._cobj.txn_begin, args, kwargs)

    86     def txn_checkpoint(self, *args, **kwargs):

    87         return apply(self._cobj.txn_checkpoint, args, kwargs)

    88     def txn_stat(self, *args, **kwargs):

    89         return apply(self._cobj.txn_stat, args, kwargs)

    90     def set_tx_max(self, *args, **kwargs):

    91         return apply(self._cobj.set_tx_max, args, kwargs)

    92     def set_tx_timestamp(self, *args, **kwargs):

    93         return apply(self._cobj.set_tx_timestamp, args, kwargs)

    94     def lock_detect(self, *args, **kwargs):

    95         return apply(self._cobj.lock_detect, args, kwargs)

    96     def lock_get(self, *args, **kwargs):

    97         return apply(self._cobj.lock_get, args, kwargs)

    98     def lock_id(self, *args, **kwargs):

    99         return apply(self._cobj.lock_id, args, kwargs)

   100     def lock_put(self, *args, **kwargs):

   101         return apply(self._cobj.lock_put, args, kwargs)

   102     def lock_stat(self, *args, **kwargs):

   103         return apply(self._cobj.lock_stat, args, kwargs)

   104     def log_archive(self, *args, **kwargs):

   105         return apply(self._cobj.log_archive, args, kwargs)

   106 

   107     def set_get_returns_none(self, *args, **kwargs):

   108         return apply(self._cobj.set_get_returns_none, args, kwargs)

   109 

   110     def log_stat(self, *args, **kwargs):

   111         return apply(self._cobj.log_stat, args, kwargs)

   112 

   113     if db.version() >= (4,1):

   114         def dbremove(self, *args, **kwargs):

   115             return apply(self._cobj.dbremove, args, kwargs)

   116         def dbrename(self, *args, **kwargs):

   117             return apply(self._cobj.dbrename, args, kwargs)

   118         def set_encrypt(self, *args, **kwargs):

   119             return apply(self._cobj.set_encrypt, args, kwargs)

   120 

   121     if db.version() >= (4,4):

   122         def lsn_reset(self, *args, **kwargs):

   123             return apply(self._cobj.lsn_reset, args, kwargs)

   124 

   125 

   126 class DB(MutableMapping):

   127     def __init__(self, dbenv, *args, **kwargs):

   128         # give it the proper DBEnv C object that its expecting

   129         self._cobj = apply(db.DB, (dbenv._cobj,) + args, kwargs)

   130 

   131     # TODO are there other dict methods that need to be overridden?

   132     def __len__(self):

   133         return len(self._cobj)

   134     def __getitem__(self, arg):

   135         return self._cobj[arg]

   136     def __setitem__(self, key, value):

   137         self._cobj[key] = value

   138     def __delitem__(self, arg):

   139         del self._cobj[arg]

   140 

   141     if sys.version_info[0:2] >= (2, 6) :

   142         def __iter__(self) :

   143             return self._cobj.__iter__()

   144 

   145     def append(self, *args, **kwargs):

   146         return apply(self._cobj.append, args, kwargs)

   147     def associate(self, *args, **kwargs):

   148         return apply(self._cobj.associate, args, kwargs)

   149     def close(self, *args, **kwargs):

   150         return apply(self._cobj.close, args, kwargs)

   151     def consume(self, *args, **kwargs):

   152         return apply(self._cobj.consume, args, kwargs)

   153     def consume_wait(self, *args, **kwargs):

   154         return apply(self._cobj.consume_wait, args, kwargs)

   155     def cursor(self, *args, **kwargs):

   156         return apply(self._cobj.cursor, args, kwargs)

   157     def delete(self, *args, **kwargs):

   158         return apply(self._cobj.delete, args, kwargs)

   159     def fd(self, *args, **kwargs):

   160         return apply(self._cobj.fd, args, kwargs)

   161     def get(self, *args, **kwargs):

   162         return apply(self._cobj.get, args, kwargs)

   163     def pget(self, *args, **kwargs):

   164         return apply(self._cobj.pget, args, kwargs)

   165     def get_both(self, *args, **kwargs):

   166         return apply(self._cobj.get_both, args, kwargs)

   167     def get_byteswapped(self, *args, **kwargs):

   168         return apply(self._cobj.get_byteswapped, args, kwargs)

   169     def get_size(self, *args, **kwargs):

   170         return apply(self._cobj.get_size, args, kwargs)

   171     def get_type(self, *args, **kwargs):

   172         return apply(self._cobj.get_type, args, kwargs)

   173     def join(self, *args, **kwargs):

   174         return apply(self._cobj.join, args, kwargs)

   175     def key_range(self, *args, **kwargs):

   176         return apply(self._cobj.key_range, args, kwargs)

   177     def has_key(self, *args, **kwargs):

   178         return apply(self._cobj.has_key, args, kwargs)

   179     def items(self, *args, **kwargs):

   180         return apply(self._cobj.items, args, kwargs)

   181     def keys(self, *args, **kwargs):

   182         return apply(self._cobj.keys, args, kwargs)

   183     def open(self, *args, **kwargs):

   184         return apply(self._cobj.open, args, kwargs)

   185     def put(self, *args, **kwargs):

   186         return apply(self._cobj.put, args, kwargs)

   187     def remove(self, *args, **kwargs):

   188         return apply(self._cobj.remove, args, kwargs)

   189     def rename(self, *args, **kwargs):

   190         return apply(self._cobj.rename, args, kwargs)

   191     def set_bt_minkey(self, *args, **kwargs):

   192         return apply(self._cobj.set_bt_minkey, args, kwargs)

   193     def set_bt_compare(self, *args, **kwargs):

   194         return apply(self._cobj.set_bt_compare, args, kwargs)

   195     def set_cachesize(self, *args, **kwargs):

   196         return apply(self._cobj.set_cachesize, args, kwargs)

   197     def set_flags(self, *args, **kwargs):

   198         return apply(self._cobj.set_flags, args, kwargs)

   199     def set_h_ffactor(self, *args, **kwargs):

   200         return apply(self._cobj.set_h_ffactor, args, kwargs)

   201     def set_h_nelem(self, *args, **kwargs):

   202         return apply(self._cobj.set_h_nelem, args, kwargs)

   203     def set_lorder(self, *args, **kwargs):

   204         return apply(self._cobj.set_lorder, args, kwargs)

   205     def set_pagesize(self, *args, **kwargs):

   206         return apply(self._cobj.set_pagesize, args, kwargs)

   207     def set_re_delim(self, *args, **kwargs):

   208         return apply(self._cobj.set_re_delim, args, kwargs)

   209     def set_re_len(self, *args, **kwargs):

   210         return apply(self._cobj.set_re_len, args, kwargs)

   211     def set_re_pad(self, *args, **kwargs):

   212         return apply(self._cobj.set_re_pad, args, kwargs)

   213     def set_re_source(self, *args, **kwargs):

   214         return apply(self._cobj.set_re_source, args, kwargs)

   215     def set_q_extentsize(self, *args, **kwargs):

   216         return apply(self._cobj.set_q_extentsize, args, kwargs)

   217     def stat(self, *args, **kwargs):

   218         return apply(self._cobj.stat, args, kwargs)

   219     def sync(self, *args, **kwargs):

   220         return apply(self._cobj.sync, args, kwargs)

   221     def type(self, *args, **kwargs):

   222         return apply(self._cobj.type, args, kwargs)

   223     def upgrade(self, *args, **kwargs):

   224         return apply(self._cobj.upgrade, args, kwargs)

   225     def values(self, *args, **kwargs):

   226         return apply(self._cobj.values, args, kwargs)

   227     def verify(self, *args, **kwargs):

   228         return apply(self._cobj.verify, args, kwargs)

   229     def set_get_returns_none(self, *args, **kwargs):

   230         return apply(self._cobj.set_get_returns_none, args, kwargs)

   231 

   232     if db.version() >= (4,1):

   233         def set_encrypt(self, *args, **kwargs):

   234             return apply(self._cobj.set_encrypt, args, kwargs)

   235 

   236 

   237 class DBSequence:

   238     def __init__(self, *args, **kwargs):

   239         self._cobj = apply(db.DBSequence, args, kwargs)

   240 

   241     def close(self, *args, **kwargs):

   242         return apply(self._cobj.close, args, kwargs)

   243     def get(self, *args, **kwargs):

   244         return apply(self._cobj.get, args, kwargs)

   245     def get_dbp(self, *args, **kwargs):

   246         return apply(self._cobj.get_dbp, args, kwargs)

   247     def get_key(self, *args, **kwargs):

   248         return apply(self._cobj.get_key, args, kwargs)

   249     def init_value(self, *args, **kwargs):

   250         return apply(self._cobj.init_value, args, kwargs)

   251     def open(self, *args, **kwargs):

   252         return apply(self._cobj.open, args, kwargs)

   253     def remove(self, *args, **kwargs):

   254         return apply(self._cobj.remove, args, kwargs)

   255     def stat(self, *args, **kwargs):

   256         return apply(self._cobj.stat, args, kwargs)

   257     def set_cachesize(self, *args, **kwargs):

   258         return apply(self._cobj.set_cachesize, args, kwargs)

   259     def set_flags(self, *args, **kwargs):

   260         return apply(self._cobj.set_flags, args, kwargs)

   261     def set_range(self, *args, **kwargs):

   262         return apply(self._cobj.set_range, args, kwargs)

   263     def get_cachesize(self, *args, **kwargs):

   264         return apply(self._cobj.get_cachesize, args, kwargs)

   265     def get_flags(self, *args, **kwargs):

   266         return apply(self._cobj.get_flags, args, kwargs)

   267     def get_range(self, *args, **kwargs):

   268         return apply(self._cobj.get_range, args, kwargs)