bsddb3-6.2.7/0000775000175000017500000000000013617133046012523 5ustar jceajcea00000000000000bsddb3-6.2.7/LICENSE.txt0000664000175000017500000000333413316226204014344 0ustar jceajcea00000000000000Except when noted in individual files, this project is distributed under BSD 3-Clause License. More details in . License Text: """ Copyright (c) 2008-2018, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ NOTE: If this file is changed, "docs/license.rst" must be updated too. bsddb3-6.2.7/setup.cfg0000644000175000017500000000010313617133046014334 0ustar jceajcea00000000000000[sdist] formats = gztar,zip [egg_info] tag_build = tag_date = 0 bsddb3-6.2.7/setup.py0000664000175000017500000000313713617051124014235 0ustar jceajcea00000000000000#!/usr/bin/env python """ Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ import sys if sys.version_info[0] == 2 : import setup2 else : # >= Python 3.0 import setup3 bsddb3-6.2.7/PKG-INFO0000664000175000017500000000544013617133046013623 0ustar jceajcea00000000000000Metadata-Version: 2.1 Name: bsddb3 Version: 6.2.7 Summary: Python bindings for Oracle Berkeley DB Home-page: https://www.jcea.es/programacion/pybsddb.htm Author: Jesus Cea, Robin Dunn, Gregory P. Smith, Andrew Kuchling, Barry Warsaw Author-email: pybsddb@jcea.es License: 3-clause BSD License Description: This module provides a nearly complete wrapping of the Oracle/Sleepycat C API for the Database Environment, Database, Cursor, Log Cursor, Sequence and Transaction objects, and each of these is exposed as a Python type in the bsddb3.db module. The database objects can use various access methods: btree, hash, recno, and queue. Complete support of Berkeley DB distributed transactions. Complete support for Berkeley DB Replication Manager. Complete support for Berkeley DB Base Replication. Support for RPC. Please see the documents in the docs directory of the source distribution or at the website for more details on the types and methods provided. The goal is to mirror most of the real Berkeley DB API so fall back to the Oracle Berkeley DB documentation as appropriate. If you need to support ancient versiones of Python and/or Berkeley DB , you can use old releases of this bindings. `Homepage `__ -- `Releases (changelog) `__ -- `Documentation `__ -- `Mailing List `__ -- `Donation `__ Platform: UNKNOWN Classifier: License :: OSI Approved :: BSD License Classifier: Development Status :: 5 - Production/Stable Classifier: Intended Audience :: Developers Classifier: Intended Audience :: Information Technology Classifier: Natural Language :: English Classifier: Natural Language :: Spanish Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python Classifier: Topic :: Database Classifier: Topic :: Software Development Classifier: Topic :: System :: Clustering Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 2.6 Classifier: Programming Language :: Python :: 2.7 Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.3 Classifier: Programming Language :: Python :: 3.4 Classifier: Programming Language :: Python :: 3.5 Classifier: Programming Language :: Python :: 3.6 Classifier: Programming Language :: Python :: 3.7 Classifier: Programming Language :: Python :: 3.8 Classifier: Programming Language :: Python :: 3.9 Description-Content-Type: text/x-rst bsddb3-6.2.7/docs/0000775000175000017500000000000013617133045013452 5ustar jceajcea00000000000000bsddb3-6.2.7/docs/dbtxn.rst0000644000175000017500000000403413316226204015316 0ustar jceajcea00000000000000===== DBTxn ===== Read :Oracle:`Oracle documentation ` for better understanding. :OracleAPIC:`More info... ` DBTxn Methods ------------- .. function:: abort() Aborts the transaction :OracleAPIC:`More info... ` .. function:: commit(flags=0) Ends the transaction, committing any changes to the databases. :OracleAPIC:`More info... ` .. function:: id() The txn_id function returns the unique transaction id associated with the specified transaction. :OracleAPIC:`More info... ` .. function:: prepare(gid) Initiates the beginning of a two-phase commit. A global identifier parameter is required, which is a value unique across all processes involved in the commit. It must be a string of DB_GID_SIZE bytes. :OracleAPIC:`More info... ` .. function:: discard() This method frees up all the per-process resources associated with the specified transaction, neither committing nor aborting the transaction. The transaction will be keep in "unresolved" state. This call may be used only after calls to "dbenv.txn_recover()". A "unresolved" transaction will be returned again thru new calls to "dbenv.txn_recover()". For example, when there are multiple global transaction managers recovering transactions in a single Berkeley DB environment, any transactions returned by "dbenv.txn_recover()" that are not handled by the current global transaction manager should be discarded using "txn.discard()". :OracleAPIC:`More info... ` .. function:: set_timeout(timeout, flags) Sets timeout values for locks or transactions for the specified transaction. :OracleAPIC:`More info... ` .. function:: get_name(name) Returns the string associated with the transaction. :OracleAPIC:`More info... ` .. function:: set_name(name) Associates the specified string with the transaction. :OracleAPIC:`More info... ` bsddb3-6.2.7/docs/README.txt0000644000175000017500000000073713316226203015150 0ustar jceajcea00000000000000Documentation in ReST format. You can read them "as is", or you can process it first with Python "docutils" package. The root document is "contents.rst". The "make" process is taken directly from the Python 2.6 documentation. If you do "make html", you can find the generated HTML in directory "build/html/". You don't need to to this if you only want to read the documentation. Files "Makefile", "conf.py" and directory "tools" are taken from Python 2.6 subversion, r61329. bsddb3-6.2.7/docs/contents.rst0000644000175000017500000000307613316226203016040 0ustar jceajcea00000000000000================================================================ Python Bindings for Berkeley DB 4.7, 4.8, 5.1, 5.3, 6.1 and 6.2 ================================================================ Introduction ------------ .. _Berkeley DB: http://www.oracle.com/technetwork/database/berkeleydb/overview/index.html This handcrafted package contains Python wrappers for `Berkeley DB`_, the Open Source embedded database system. Berkeley DB is a programmatic toolkit that provides high-performance built-in database support for desktop and server applications. The Berkeley DB access methods include B+tree, Extended Linear Hashing, Fixed and Variable-length records, and Queues. Berkeley DB provides full transactional support, database recovery, online backups, multi-threaded and multi-process access, etc. The Python wrappers allow you to store Python string objects of any length, keyed either by strings or integers depending on the database access method. With the use of another module in the package standard shelve-like functionality is provided allowing you to store any picklable Python object! Berkeley DB is very powerful and versatile, but it is complex to use correctly. :Oracle:`Oracle documentation ` is very complete. Please, review it. Since June 2013 (release 6.0.0), this project accepts donations. Please, contribute if you can. Details. Documentation Index ------------------- .. toctree:: introduction.rst dbenv.rst db.rst dbcursor.rst dblogcursor.rst dbtxn.rst dblock.rst dbsequence.rst dbsite.rst history.rst license.rst donate.rst bsddb3-6.2.7/docs/history.rst0000644000175000017500000000151413617050277015711 0ustar jceajcea00000000000000History ------- .. _Digital Creations: http://www.digicool.com/ .. _wxPython: http://www.wxpython.org/ This module was started by Andrew Kuchling (amk) to remove the dependency on SWIG in a package by Gregory P. Smith who based his work on a similar package by Robin Dunn which wrapped Berkeley DB 2.7.x. Development then returned full circle back to Robin Dunn working in behalf of `Digital Creations`_ to complete the SWIG-less wrapping of the DB 3.x API and to build a solid unit test suite. Having completed that, Robin was now busy with another project (wxPython_) and Greg returned as maintainer. .. I can't use tildes because my ZOPE configuration. .. Something to fix in the future. `Jesus Cea Avion `__ is the maintainer of this code since February 2008, and ported it to Python 3.x. bsddb3-6.2.7/docs/license.rst0000664000175000017500000000657413617050636015646 0ustar jceajcea00000000000000======= LICENSE ======= Except when noted in individual files, this project is distributed under `BSD 3-Clause License `__. .. note:: If this file is changed, "LICENSE.txt" and "licenses.txt" must be updated too. License Text (BSD 3-Clause License) ----------------------------------- Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. License of individual files --------------------------- The history of this project is long and complicated, and so are their copyrights and licenses. I (Jesus Cea) wrote this document in orden to clarify the situation. This code was integrated once in Python 2.x, so I guess somebody did the paperwork related to contributor agreement. This code is derived from that version, so that could be a license checkpoint/blank sheet. I must verify that. New files will be covered by the 3-clause BSD license. License of Python files +++++++++++++++++++++++ * Except the following files, license is 3-clause BSD license. Jesus Cea Avion. * test2.py, test3.py: Zope Public License, version 2.0. Zope Corporation and contributors. * Lib*/bsddb/dbrecio.py: Itamar Shtull-Trauring . * Lib*/bsddb/__init__.py: 3-clause BSD license. Digital Creations and Andrew Kuchling. * Lib*/bsddb/db.py: 3-clause BSD license. Digital Creations and Andrew Kuchling. * Lib*/bsddb/dbobj.py, dbutils.py: Free software. Autonomous Zone Industries, Gregory P. Smith. * Lib*/bsddb/dbtables.py: Free software. Autonomous Zone Industries, Gregory P. Smith. * Lib*/bsddb/test/test_dbtables.py: Free software. Autonomous Zone Industries, Gregory P. Smith. * Lib*/bsddb/dbshelve.py: Free software. Total Control Software. License of C files ++++++++++++++++++ * Modules/bsddb.h, _bsddb.c: 3-clause BSD license. Digital Creations, Andrew Kuchling, Robin Dunn, Gregory P. Smith, Duncan Grisby, Jesus Cea Avion. bsddb3-6.2.7/docs/bitcoin.png0000644000175000017500000000207713316226203015606 0ustar jceajcea00000000000000PNG  IHDRL\sRGBbKGD pHYs+tIME X4%IDATxn0 EÀ'tܧaul Hq `0ݧ/<jM{>/xyWW#>Q s~o>2Q5F *R 69:T~IENDB`bsddb3-6.2.7/docs/dblock.rst0000644000175000017500000000037613316226203015441 0ustar jceajcea00000000000000DBLock ------ Read :Oracle:`Oracle documentation ` for better understanding. The DBLock objects have no methods or attributes. They are just opaque handles to the lock in question. They are managed via DBEnv methods. bsddb3-6.2.7/docs/dblogcursor.rst0000644000175000017500000000373313316226204016531 0ustar jceajcea00000000000000=========== DBLogCursor =========== Read :Oracle:`Oracle documentation ` for better understanding. :OracleAPIC:`More info... ` DBLogCursor Methods ------------------- .. function:: close() Discards the log cursor. :OracleAPIC:`More info... ` DBLogCursor Get Methods ----------------------- These DBLogCursor methods are all wrappers around the get() function in the C API. These functions returns a tuple. The first element is a LSN tuple, and the second element is a string/bytes with the log data. If the following methods don't have log data to return, they return None. .. function:: current() Return the log record to which the log currently refers. :OracleAPIC:`More info... ` .. function:: first() The first record from any of the log files found in the log directory is returned. This method will return None if the log is empty. :OracleAPIC:`More info... ` .. function:: last() The last record in the log is returned. This method will return None if the log is empty. :OracleAPIC:`More info... ` .. function:: next() The current log position is advanced to the next record in the log, and that record is returned. If the cursor position was not set previously, it will return the first record in the log. This method will return None if the log is empty. :OracleAPIC:`More info... ` .. function:: prev() The current log position is advanced to the previous record in the log, and that record is returned. If the cursor position was not set previously, it will return the last record in the log. This method will return None if the log is empty. :OracleAPIC:`More info... ` .. function:: set(lsn) Retrieve the record specified by the lsn parameter. :OracleAPIC:`More info... ` bsddb3-6.2.7/docs/introduction.rst0000644000175000017500000002707513316226204016732 0ustar jceajcea00000000000000==================================================================== Berkeley DB 4.7, 4.8, 5.1, 5.3, 6.1 and 6.2 Python Extension Package ==================================================================== Introduction ------------ This is a simple bit of documentation for the bsddb3.db Python extension module which wraps the Berkeley DB C library. The extension module is located in a Python package along with a few pure python modules. It is expected that this module will be used in the following general ways by different programmers in different situations. The goals of this module are to allow all of these methods without making things too complex for the simple cases, and without leaving out funtionality needed by the complex cases. 1. **Backwards compatibility:** It is desirable for this package to be a near drop-in replacement for the bsddb module shipped with Python which is designed to wrap either DB 1.85, or the 1.85 compatibility interface. This means that there will need to be equivalent object creation functions available, (btopen(), hashopen(), and rnopen()) and the objects returned will need to have the same or at least similar methods available, (specifically, first(), last(), next(), and prev() will need to be available without the user needing to explicitly use a cursor.) All of these have been implemented in Python code in the bsddb3.__init__.py module. 2. **Simple persistent dictionary:** One small step beyond the above. The programmer may be aware of and use the new DB object type directly, but only needs it from a single process and thread. The programmer should not have to be bothered with using a DBEnv, and the DB object should behave as much like a dictionary as possible. 3. **Concurrent access dictionaries:** This refers to the ability to simultaneously have one writer and multiple readers of a DB (either in multiple threads or processes) and is implemented simply by creating a DBEnv with certain flags. No extra work is required to allow this access mode in bsddb3. 4. **Advanced transactional data store:** This mode of use is where the full capabilities of the Berkeley DB library are called into action. The programmer will probably not use the dictionary access methods as much as the regular methods of the DB object, so he can pass transaction objects to the methods. Again, most of this advanced functionality is activated simply by opening a DBEnv with the proper flags, and also by using transactions and being aware of and reacting to deadlock exceptions, etc. Types Provided -------------- The bsddb3.db extension module provides the following object types: - **DB:** The basic database object, capable of Hash, BTree, Recno, and Queue access methods. - **DBEnv:** Provides a Database Environment for more advanced database use. Apps using transactions, logging, concurrent access, etc. will need to have an environment object. - **DBCursor:** A pointer-like object used to traverse a database. - **DBTxn:** A database transaction. Allows for multi-file commit, abort and checkpoint of database modifications. - **DBLock:** An opaque handle for a lock. See DBEnv.lock_get() and DBEnv.lock_put(). Locks are not necessarily associated with anything in the database, but can be used for any syncronization task across all threads and processes that have the DBEnv open. - **DBSequence:** Sequences provide an arbitrary number of persistent objects that return an increasing or decreasing sequence of integers. Opening a sequence handle associates it with a record in a database. - **DBSite:** Site object for Replication Manager. Top level functions ------------------- .. function:: version() Returns a tuple with major, minor and patch level. :OracleAPIC:`More info... ` .. function:: full_version() Returns a tuple with the full version string, family, release, major, minor and patch level. :OracleAPIC:`More info... ` Exceptions Provided ------------------- The Berkeley DB C API uses function return codes to signal various errors. The bsddb3.db module checks for these error codes and turns them into Python exceptions, allowing you to use familiar try:... except:... constructs and not have to bother with checking every method's return value. Each of the error codes is turned into an exception specific to that error code, as outlined in the table below. If you are using the C API documentation then it is very easy to map the error return codes specified there to the name of the Python exception that will be raised. Simply refer to the table below. Each exception derives from the DBError exception class so if you just want to catch generic errors you can use DBError to do it. Since DBNotFoundError is raised when a given key is not found in the database, DBNotFoundError also derives from the standard KeyError exception to help make a DB look and act like a dictionary. We do the same trick with DBKeyEmptyError. When any of these exceptions is raised, the associated value is a tuple containing an integer representing the error code and a string for the error message itself. +----------------------------+-------------------------------------------+ | **DBError** | Base class, all others derive from this | +----------------------------+-------------------------------------------+ | **DBCursorClosedError** | When trying to use a closed cursor | +----------------------------+-------------------------------------------+ | **DBForeignConflictError** | DB_FOREIGN_CONFLICT | +----------------------------+-------------------------------------------+ | **DBKeyEmptyError** | DB_KEYEMPTY (also derives from KeyError) | +----------------------------+-------------------------------------------+ | **DBKeyExistError** | DB_KEYEXIST | +----------------------------+-------------------------------------------+ | **DBLockDeadlockError** | DB_LOCK_DEADLOCK | +----------------------------+-------------------------------------------+ | **DBLockNotGrantedError** | DB_LOCK_NOTGRANTED | +----------------------------+-------------------------------------------+ | **DBNotFoundError** | DB_NOTFOUND (also derives from KeyError) | +----------------------------+-------------------------------------------+ | **DBOldVersionError** | DB_OLD_VERSION | +----------------------------+-------------------------------------------+ | **DBPageNotFoundError** | DB_PAGE_NOTFOUND | +----------------------------+-------------------------------------------+ | **DBRepHandleDeadError** | DB_REP_HANDLE_DEAD | +----------------------------+-------------------------------------------+ | **DBRepLeaseExpiredError** | DB_REP_LEASE_EXPIRED | +----------------------------+-------------------------------------------+ | **DBRepLockoutError** | DB_REP_LOCKOUT | +----------------------------+-------------------------------------------+ | **DBRepUnavailError** | DB_REP_UNAVAIL | +----------------------------+-------------------------------------------+ | **DBRunRecoveryError** | DB_RUNRECOVERY | +----------------------------+-------------------------------------------+ | **DBSecondaryBadError** | DB_SECONDARY_BAD | +----------------------------+-------------------------------------------+ | **DBVerifyBadError** | DB_VERIFY_BAD | +----------------------------+-------------------------------------------+ | **DBNoServerError** | DB_NOSERVER | +----------------------------+-------------------------------------------+ | **DBNoServerHomeError** | DB_NOSERVER_HOME | +----------------------------+-------------------------------------------+ | **DBNoServerIDError** | DB_NOSERVER_ID | +----------------------------+-------------------------------------------+ | **DBInvalidArgError** | EINVAL | +----------------------------+-------------------------------------------+ | **DBAccessError** | EACCES | +----------------------------+-------------------------------------------+ | **DBNoSpaceError** | ENOSPC | +----------------------------+-------------------------------------------+ | **DBNoMemoryError** | DB_BUFFER_SMALL | +----------------------------+-------------------------------------------+ | **DBAgainError** | EAGAIN | +----------------------------+-------------------------------------------+ | **DBBusyError** | EBUSY | +----------------------------+-------------------------------------------+ | **DBFileExistsError** | EEXIST | +----------------------------+-------------------------------------------+ | **DBNoSuchFileError** | ENOENT | +----------------------------+-------------------------------------------+ | **DBPermissionsError** | EPERM | +----------------------------+-------------------------------------------+ Other Package Modules --------------------- - **dbshelve.py:** This is an implementation of the standard Python shelve concept for storing objects that uses bsddb3 specifically, and also exposes some of the more advanced methods and capabilities of the underlying DB. - **dbtables.py:** This is a module by Gregory Smith that implements a simplistic table structure on top of a DB. - **dbutils.py:** A catch-all for python code that is generally useful when working with DB's - **dbobj.py:** Contains subclassable versions of DB and DBEnv. - **dbrecio.py:** Contains the DBRecIO class that can be used to do partial reads and writes from a DB record using a file-like interface. Contributed by Itamar Shtull-Trauring. Testing ------- A full unit test suite is being developed to exercise the various object types, their methods and the various usage modes described in the introduction. `PyUnit `__ is used and the tests are structured such that they can be run unattended and automated. There are currently 482 test cases! (March 2010) Reference --------- See the C language API :OracleAPIC:`online documentation ` on Oracle's website for more details of the functionality of each of these methods. The names of all the Python methods should be the same or similar to the names in the C API. Berkeley DB is very powerful and versatile, but it is complex to use correctly. :Oracle:`Oracle documentation ` is very complete. Please, review it. **NOTE:** All the methods shown below having more than one keyword argument are actually implemented using keyword argument parsing, so you can use keywords to provide optional parameters as desired. Those that have only a single optional argument are implemented without keyword parsing to help keep the implementation simple. If this is too confusing let me know and I'll think about using keywords for everything. bsddb3-6.2.7/docs/dbcursor.rst0000644000175000017500000001546313316226204016032 0ustar jceajcea00000000000000======== DBCursor ======== Read :Oracle:`Oracle documentation ` for better understanding. :OracleAPIC:`More info... ` DBCursor Methods ---------------- .. function:: close() Discards the cursor. If the cursor is created within a transaction then you *must* be sure to close the cursor before commiting the transaction. :OracleAPIC:`More info... ` .. function:: count(flags=0) Returns a count of the number of duplicate data items for the key referenced by the cursor. :OracleAPIC:`More info... ` .. function:: delete(flags=0) Deletes the key/data pair currently referenced by the cursor. :OracleAPIC:`More info... ` .. function:: dup(flags=0) Create a new cursor. :OracleAPIC:`More info... ` .. function:: set_priority(priority) Set the cache priority for pages referenced by the DBC handle. :OracleAPIC:`More info... ` .. function:: get_priority() Returns the cache priority for pages referenced by the DBC handle. :OracleAPIC:`More info... ` .. function:: put(key, data, flags=0, dlen=-1, doff=-1) Stores the key/data pair into the database. Partial data records can be written using dlen and doff. :OracleAPIC:`More info... ` .. function:: get(flags, dlen=-1, doff=-1) See get(key, data, flags, dlen=-1, doff=-1) below. .. function:: get(key, flags, dlen=-1, doff=-1) See get(key, data, flags, dlen=-1, doff=-1) below. .. function:: get(key, data, flags, dlen=-1, doff=-1) Retrieves key/data pairs from the database using the cursor. All the specific functionalities of the get method are actually provided by the various methods below, which are the preferred way to fetch data using the cursor. These generic interfaces are only provided as an inconvenience. Partial data records are returned if dlen and doff are used in this method and in many of the specific methods below. :OracleAPIC:`More info... ` .. function:: pget(flags, dlen=-1, doff=-1) See pget(key, data, flags, dlen=-1, doff=-1) below. .. function:: pget(key, flags, dlen=-1, doff=-1) See pget(key, data, flags, dlen=-1, doff=-1) below. .. function:: pget(key, data, flags, dlen=-1, doff=-1) Similar to the already described get(). This method is available only on secondary databases. It will return the primary key, given the secondary one, and associated data :OracleAPIC:`More info... ` DBCursor Get Methods -------------------- These DBCursor methods are all wrappers around the get() function in the C API. .. function:: current(flags=0, dlen=-1, doff=-1) Returns the key/data pair currently referenced by the cursor. :OracleAPIC:`More info... ` .. function:: get_current_size() Returns length of the data for the current entry referenced by the cursor. .. function:: first(flags=0, dlen=-1, doff=-1) Position the cursor to the first key/data pair and return it. :OracleAPIC:`More info... ` .. function:: last(flags=0, dlen=-1, doff=-1) Position the cursor to the last key/data pair and return it. :OracleAPIC:`More info... ` .. function:: next(flags=0, dlen=-1, doff=-1) Position the cursor to the next key/data pair and return it. :OracleAPIC:`More info... ` .. function:: prev(flags=0, dlen=-1, doff=-1) Position the cursor to the previous key/data pair and return it. :OracleAPIC:`More info... ` .. function:: consume(flags=0, dlen=-1, doff=-1) For a database with the Queue access method, returns the record number and data from the first available record and deletes it from the queue. *NOTE:* This method is deprecated in Berkeley DB version 3.2 in favor of the new consume method in the DB class. .. function:: get_both(key, data, flags=0) Like set() but positions the cursor to the record matching both key and data. (An alias for this is set_both, which makes more sense to me...) :OracleAPIC:`More info... ` .. function:: get_recno() Return the record number associated with the cursor. The database must use the BTree access method and have been created with the DB_RECNUM flag. :OracleAPIC:`More info... ` .. function:: join_item(flags=0) For cursors returned from the DB.join method, returns the combined key value from the joined cursors. :OracleAPIC:`More info... ` .. function:: next_dup(flags=0, dlen=-1, doff=-1) If the next key/data pair of the database is a duplicate record for the current key/data pair, the cursor is moved to the next key/data pair of the database, and that pair is returned. :OracleAPIC:`More info... ` .. function:: next_nodup(flags=0, dlen=-1, doff=-1) The cursor is moved to the next non-duplicate key/data pair of the database, and that pair is returned. :OracleAPIC:`More info... ` .. function:: prev_dup(flags=0, dlen=-1, doff=-1) If the previous key/data pair of the database is a duplicate data record for the current key/data pair, the cursor is moved to the previous key/data pair of the database, and that pair is returned. :OracleAPIC:`More info... ` .. function:: prev_nodup(flags=0, dlen=-1, doff=-1) The cursor is moved to the previous non-duplicate key/data pair of the database, and that pair is returned. :OracleAPIC:`More info... ` .. function:: set(key, flags=0, dlen=-1, doff=-1) Move the cursor to the specified key in the database and return the key/data pair found there. :OracleAPIC:`More info... ` .. function:: set_range(key, flags=0, dlen=-1, doff=-1) Identical to set() except that in the case of the BTree access method, the returned key/data pair is the smallest key greater than or equal to the specified key (as determined by the comparison function), permitting partial key matches and range searches. :OracleAPIC:`More info... ` .. function:: set_recno(recno, flags=0, dlen=-1, doff=-1) Move the cursor to the specific numbered record of the database, and return the associated key/data pair. The underlying database must be of type Btree and it must have been created with the DB_RECNUM flag. :OracleAPIC:`More info... ` .. function:: set_both(key, data, flags=0) See get_both(). The only difference in behaviour can be disabled using set_get_returns_none(2). :OracleAPIC:`More info... ` bsddb3-6.2.7/docs/donate.rst0000644000175000017500000000457513617050335015467 0ustar jceajcea00000000000000======= DONATE! ======= .. _BitCoins: https://en.wikipedia.org/wiki/Bitcoin .. _4A86FE43: http://pgp.rediris.es:11371/pks/lookup?search=0x4A86FE43&op=vindex&fingerprint=on&exact=on Work on this project is currently driven by my own interests, needs and spare time. If you appreciate this software or if you want to sponsor a currently not translated API feature, please consider donation to the project. PyBSDDB/BSDDB3 needs your help. You can donate using BitCoins_. The destination address is 16avqyUK4vDqBdpUy365PPW44zNqVHLZSC. .. image:: bitcoin.png :align: center :alt: 16avqyUK4vDqBdpUy365PPW44zNqVHLZSC. Since donations thru BitCoin are not revocable, please be sure your are transfering to the right account (this document could have been modified for a third party). You can verify it in two diffent ways: 1. Reading this document in the project original website: `https://www.jcea.es/programacion/pybsddb_doc/donate.html `__. Make sure you are seeing the right webpage. 2. Verifying the PGP digital signature of the following document: .. code-block:: none -----BEGIN PGP SIGNED MESSAGE----- Hash: SHA256 The BitCoin address for donating to PyBSDDB/BSDDB3 project is "16avqyUK4vDqBdpUy365PPW44zNqVHLZSC". -----BEGIN PGP SIGNATURE----- Version: GnuPG v1 iQEcBAEBCAAGBQJT0AKrAAoJEGjgN61Khv5DK1kH/3JctpZUr+h8iFCfpRCaHsX8 +6dmncm3ebAWt9kCRqZZ74Eq8h9918C4UwxLLPrskAIqQw3g2IyTdaPOHomM23XH Ru1ok5fhCjNMCw4+dnnO/AXxEY6cIf2PjsQlkUznCe0zz1ndZQ33XbdI/1ItUEhy nZVWblnCCAQnO69Nhf6vPxfRDol1oDTh0bginhflmS01P2r8m9Mzx9h7Rrx7oKwG meNIVIzwdA+Tbex0GvQGorPSwEuid/mVYuDp9jSLp8XgeXBQfeqPWv+PO2tkijYE Zs1A1YuFA3S8uDnZhe9P7u4w7PGlCNIrDvTyippXiYB9fnSHu6mPmCw3wv+SWkM= =9xWm -----END PGP SIGNATURE----- Doing something like :kbd:`gpg --verify` and pasting this block, your should get something like: .. code-block:: none gpg: Signature made Wed 23 Jul 2014 08:44:59 PM CEST using RSA key ID 4A86FE43 gpg: Good signature from "Jesús Cea Avión " My PGP key ID is "4A86FE43_". My key fingerprint is:: pub 4096R/1567BC0F 2014-01-13 Key fingerprint = 8627 62C4 6EC3 567C B58C 7FB1 A510 404E 1567 BC0F uid Jesús Cea Avión sub 2048R/4A86FE43 2014-01-13 sub 2048R/05488493 2014-01-13 bsddb3-6.2.7/docs/db.rst0000644000175000017500000006214213316226203014567 0ustar jceajcea00000000000000== DB == Read :Oracle:`Oracle documentation ` for better understanding. :OracleAPIC:`More info... ` DB Methods ---------- .. function:: DB(dbEnv=None, flags=0) Constructor. :OracleAPIC:`More info... ` .. function:: append(data, txn=None) A convenient version of put() that can be used for Recno or Queue databases. The DB_APPEND flag is automatically used, and the record number is returned. :OracleAPIC:`More info... ` .. function:: associate(secondaryDB, callback, flags=0, txn=None) Used to associate secondaryDB to act as a secondary index for this (primary) database. The callback parameter should be a reference to a Python callable object that will construct and return the secondary key or DB_DONOTINDEX if the item should not be indexed. The parameters the callback will receive are the primaryKey and primaryData values. :OracleAPIC:`More info... ` .. function:: close(flags=0) Flushes cached data and closes the database. :OracleAPIC:`More info... ` .. function:: compact(start=None, stop=None, flags=0, compact_fillpercent=0, compact_pages=0, compact_timeout=0) Compacts Btree and Recno access method databases, and optionally returns unused Btree, Hash or Recno database pages to the underlying filesystem. The method returns the number of pages returned to the filesystem. :OracleAPIC:`More info... ` .. function:: consume(txn=None, flags=0) For a database with the Queue access method, returns the record number and data from the first available record and deletes it from the queue. :OracleAPIC:`More info... ` .. function:: consume_wait(txn=None, flags=0) For a database with the Queue access method, returns the record number and data from the first available record and deletes it from the queue. If the Queue database is empty, the thread of control will wait until there is data in the queue before returning. :OracleAPIC:`More info... ` .. function:: cursor(txn=None, flags=0) Create a cursor on the DB and returns a DBCursor object. If a transaction is passed then the cursor can only be used within that transaction and you *must* be sure to close the cursor before commiting the transaction. :OracleAPIC:`More info... ` .. function:: delete(key, txn=None, flags=0) Removes a key/data pair from the database. :OracleAPIC:`More info... ` .. function:: exists(key, txn=None, flags=0) Test if a key exists in the database. Returns True or False. :OracleAPIC:`More info... ` .. function:: fd() Returns a file descriptor for the database. :OracleAPIC:`More info... ` .. function:: get(key, default=None, txn=None, flags=0, dlen=-1, doff=-1) Returns the data object associated with key. If key is an integer then the DB_SET_RECNO flag is automatically set for BTree databases and the actual key and the data value are returned as a tuple. If default is given then it is returned if the key is not found in the database. Partial records can be read using dlen and doff, however be sure to not read beyond the end of the actual data or you may get garbage. :OracleAPIC:`More info... ` .. function:: pget(key, default=None, txn=None, flags=0, dlen=-1, doff=-1) This method is available only on secondary databases. It will return the primary key, given the secondary one, and associated data. :OracleAPIC:`More info... ` .. function:: get_transactional() Returns True if the database is transactional. False if not. :OracleAPIC:`More info... ` .. function:: get_priority() Returns the cache priority for pages referenced by the DB handle. This priority value is set using the DB->set_priority() method. :OracleAPIC:`More info... ` .. function:: set_priority(priority) Set the cache priority for pages referenced by the DB handle. The priority of a page biases the replacement algorithm to be more or less likely to discard a page when space is needed in the buffer pool. The bias is temporary, and pages will eventually be discarded if they are not referenced again. The DB->set_priority() method is only advisory, and does not guarantee pages will be treated in a specific way. The value provided must be symbolic. Check the Oracle documentation. :OracleAPIC:`More info... ` .. function:: get_dbname() Returns a tuple with the filename and the database name. If there is no database name, the value returned will be None. :OracleAPIC:`More info... ` .. function:: get_open_flags() Returns the current open method flags. That is, this method returns the flags that were specified when DB->open() was called. :OracleAPIC:`More info... ` .. function:: set_private(object) Link an object to the DB object. This allows to pass around an arbitrary object. For instance, for callback context. .. function:: get_private() Give the object linked to the DB. .. function:: get_both(key, data, txn=None, flags=0) A convenient version of get() that automatically sets the DB_GET_BOTH flag, and which will be successful only if both the key and data value are found in the database. (Can be used to verify the presence of a record in the database when duplicate keys are allowed.) :OracleAPIC:`More info... ` .. function:: get_byteswapped() May be used to determine if the database was created on a machine with the same endianess as the current machine. :OracleAPIC:`More info... ` .. function:: get_size(key, txn=None) Return the size of the data object associated with key. .. function:: get_type() Return the database's access method type. :OracleAPIC:`More info... ` .. function:: join(cursorList, flags=0) Create and return a specialized cursor for use in performing joins on secondary indices. :OracleAPIC:`More info... ` .. function:: key_range(key, txn=None, flags=0) Returns an estimate of the proportion of keys that are less than, equal to and greater than the specified key. :OracleAPIC:`More info... ` .. function:: open(filename, dbname=None, dbtype=DB_UNKNOWN, flags=0, mode=0660, txn=None) Opens the database named dbname in the file named filename. The dbname argument is optional and allows applications to have multiple logical databases in a single physical file. It is an error to attempt to open a second database in a file that was not initially created using a database name. In-memory databases never intended to be shared or preserved on disk may be created by setting both the filename and dbname arguments to None. :OracleAPIC:`More info... ` .. function:: put(key, data, txn=None, flags=0, dlen=-1, doff=-1) Stores the key/data pair in the database. If the DB_APPEND flag is used and the database is using the Recno or Queue access method then the record number allocated to the data is returned. Partial data objects can be written using dlen and doff. :OracleAPIC:`More info... ` .. function:: remove(filename, dbname=None, flags=0) Remove a database. :OracleAPIC:`More info... ` .. function:: rename(filename, dbname, newname, flags=0) Rename a database. :OracleAPIC:`More info... ` .. function:: set_encrypt(passwd, flags=0) Set the password used by the Berkeley DB library to perform encryption and decryption. Because databases opened within Berkeley DB environments use the password specified to the environment, it is an error to attempt to set a password in a database created within an environment. :OracleAPIC:`More info... ` .. function:: get_encrypt_flags() Returns the encryption flags. :OracleAPIC:`More info... ` .. function:: set_bt_compare(compareFunc) Set the B-Tree database comparison function. This can only be called once before the database has been opened. compareFunc takes two arguments: (left key string, right key string) It must return a -1, 0, 1 integer similar to cmp. You can shoot your database in the foot, beware! Read the Berkeley DB docs for the full details of how the comparison function MUST behave. :OracleAPIC:`More info... ` .. function:: get_bt_minkey() Returns the minimum number of key/data pairs intended to be stored on any single Btree leaf page. This value can be set using the DB->set_bt_minkey() method. :OracleAPIC:`More info... ` .. function:: set_bt_minkey(minKeys) Set the minimum number of keys that will be stored on any single BTree page. :OracleAPIC:`More info... ` .. function:: set_cachesize(gbytes, bytes, ncache=0) Set the size of the database's shared memory buffer pool. :OracleAPIC:`More info... ` .. function:: get_cachesize() Returns a tuple with the current size and composition of the cache. :OracleAPIC:`More info... ` .. function:: set_dup_compare(compareFunc) Set the duplicate data item comparison function. This can only be called once before the database has been opened. compareFunc takes two arguments: (left key string, right key string) It must return a -1, 0, 1 integer similar to cmp. You can shoot your database in the foot, beware! Read the Berkeley DB docs for the full details of how the comparison function MUST behave. :OracleAPIC:`More info... ` .. function:: set_get_returns_none(flag) Controls what get and related methods do when a key is not found. See the DBEnv set_get_returns_none documentation. The previous setting is returned. .. function:: get_flags() Returns the current database flags as set by the DB->set_flags() method. :OracleAPIC:`More info... ` .. function:: set_flags(flags) Set additional flags on the database before opening. :OracleAPIC:`More info... ` .. function:: get_h_ffactor() Returns the hash table density as set by the DB->set_h_ffactor() method. :OracleAPIC:`More info... ` .. function:: set_h_ffactor(ffactor) Set the desired density within the hash table. :OracleAPIC:`More info... ` .. function:: get_h_nelem() Returns the estimate of the final size of the hash table as set by the DB->set_h_nelem() method. :OracleAPIC:`More info... ` .. function:: set_h_nelem(nelem) Set an estimate of the final size of the hash table. :OracleAPIC:`More info... ` .. function:: get_lorder() Returns the database byte order; a byte order of 4,321 indicates a big endian order, and a byte order of 1,234 indicates a little endian order. This value is set using the DB->set_lorder() method. :OracleAPIC:`More info... ` .. function:: set_lorder(lorder) Set the byte order for integers in the stored database metadata. :OracleAPIC:`More info... ` .. function:: get_pagesize() Returns the database's current page size, as set by the DB->set_pagesize() method. :OracleAPIC:`More info... ` .. function:: set_pagesize(pagesize) Set the size of the pages used to hold items in the database, in bytes. :OracleAPIC:`More info... ` .. function:: get_re_delim() Returns the delimiting byte, which is used to mark the end of a record in the backing source file for the Recno access method. The return value will be a numeric byte value. :OracleAPIC:`More info... ` .. function:: set_re_delim(delim) Set the delimiting byte used to mark the end of a record in the backing source file for the Recno access method. You can specify a char or a numeric byte value. :OracleAPIC:`More info... ` .. function:: get_re_len() Returns the length of the records held in a Queue access method database. This value can be set using the DB->set_re_len() method. :OracleAPIC:`More info... ` .. function:: set_re_len(length) For the Queue access method, specify that the records are of length length. For the Recno access method, specify that the records are fixed-length, not byte delimited, and are of length length. :OracleAPIC:`More info... ` .. function:: get_re_pad() Returns the pad character used for short, fixed-length records used by the Queue and Recno access methods. The method returns a byte value. :OracleAPIC:`More info... ` .. function:: set_re_pad(pad) Set the padding character for short, fixed-length records for the Queue and Recno access methods. You can specify a char or a numeric byte value. :OracleAPIC:`More info... ` .. function:: get_re_source() Returns the source file used by the Recno access method. This file is configured for the Recno access method using the DB->set_re_source() method. :OracleAPIC:`More info... ` .. function:: set_re_source(source) Set the underlying source file for the Recno access method. :OracleAPIC:`More info... ` .. function:: get_q_extentsize() Returns the number of pages in an extent. This value is used only for Queue databases and is set using the DB->set_q_extentsize() method. :OracleAPIC:`More info... ` .. function:: set_q_extentsize(extentsize) Set the size of the extents used to hold pages in a Queue database, specified as a number of pages. Each extent is created as a separate physical file. If no extent size is set, the default behavior is to create only a single underlying database file. :OracleAPIC:`More info... ` .. function:: stat(flags=0, txn=None) Return a dictionary containing database statistics with the following keys. For Hash databases: +-----------+-------------------------------------------------+ | magic | Magic number that identifies the file as a Hash | | | database. | +-----------+-------------------------------------------------+ | version | Version of the Hash database. | +-----------+-------------------------------------------------+ | nkeys | Number of unique keys in the database. | +-----------+-------------------------------------------------+ | ndata | Number of key/data pairs in the database. | +-----------+-------------------------------------------------+ | pagecnt | The number of pages in the database. | +-----------+-------------------------------------------------+ | pagesize | Underlying Hash database page (& bucket) size. | +-----------+-------------------------------------------------+ | nelem | Estimated size of the hash table specified at | | | database creation time. | +-----------+-------------------------------------------------+ | ffactor | Desired fill factor (number of items per bucket)| | | specified at database creation time. | +-----------+-------------------------------------------------+ | buckets | Number of hash buckets. | +-----------+-------------------------------------------------+ | free | Number of pages on the free list. | +-----------+-------------------------------------------------+ | bfree | Number of bytes free on bucket pages. | +-----------+-------------------------------------------------+ | bigpages | Number of big key/data pages. | +-----------+-------------------------------------------------+ | big_bfree | Number of bytes free on big item pages. | +-----------+-------------------------------------------------+ | overflows | Number of overflow pages (overflow pages are | | | pages that contain items that did not fit in | | | the main bucket page). | +-----------+-------------------------------------------------+ | ovfl_free | Number of bytes free on overflow pages. | +-----------+-------------------------------------------------+ | dup | Number of duplicate pages. | +-----------+-------------------------------------------------+ | dup_free | Number of bytes free on duplicate pages. | +-----------+-------------------------------------------------+ For BTree and Recno databases: +-------------+-----------------------------------------------+ | magic | Magic number that identifies the file as a | | | Btree database. | +-------------+-----------------------------------------------+ | version | Version of the Btree database. | +-------------+-----------------------------------------------+ | nkeys | For the Btree Access Method, the number of | | | unique keys in the database. | | | | | | For the Recno Access Method, the number of | | | records in the database. If the database has | | | been configured to not re-number records | | | during deletion, the number of records may | | | include records that have been deleted. | +-------------+-----------------------------------------------+ | ndata | For the Btree Access Method, the number of | | | key/data pairs in the database. | | | | | | For the Recno Access Method, the number of | | | records in the database. If the database has | | | been configured to not re-number records | | | during deletion, the number of records may | | | include records that have been deleted. | +-------------+-----------------------------------------------+ | pagecnt | The number of pages in the database. | +-------------+-----------------------------------------------+ | pagesize | Underlying database page size. | +-------------+-----------------------------------------------+ | minkey | Minimum keys per page. | +-------------+-----------------------------------------------+ | re_len | Length of fixed-length records. | +-------------+-----------------------------------------------+ | re_pad | Padding byte value for fixed-length records. | +-------------+-----------------------------------------------+ | levels | Number of levels in the database. | +-------------+-----------------------------------------------+ | int_pg | Number of database internal pages. | +-------------+-----------------------------------------------+ | leaf_pg | Number of database leaf pages. | +-------------+-----------------------------------------------+ | dup_pg | Number of database duplicate pages. | +-------------+-----------------------------------------------+ | over_pg | Number of database overflow pages. | +-------------+-----------------------------------------------+ | empty_pg | Number of empty database pages. | +-------------+-----------------------------------------------+ | free | Number of pages on the free list. | +-------------+-----------------------------------------------+ | int_pgfree | Num of bytes free in database internal pages. | +-------------+-----------------------------------------------+ | leaf_pgfree | Number of bytes free in database leaf pages. | +-------------+-----------------------------------------------+ | dup_pgfree | Num bytes free in database duplicate pages. | +-------------+-----------------------------------------------+ | over_pgfree | Num of bytes free in database overflow pages. | +-------------+-----------------------------------------------+ For Queue databases: +-------------+-----------------------------------------------+ | magic | Magic number that identifies the file as a | | | Queue database. | +-------------+-----------------------------------------------+ | version | Version of the Queue file type. | +-------------+-----------------------------------------------+ | nkeys | Number of records in the database. | +-------------+-----------------------------------------------+ | ndata | Number of records in the database. | +-------------+-----------------------------------------------+ | pagesize | Underlying database page size. | +-------------+-----------------------------------------------+ | extentsize | Underlying database extent size, in pages. | +-------------+-----------------------------------------------+ | pages | Number of pages in the database. | +-------------+-----------------------------------------------+ | re_len | Length of the records. | +-------------+-----------------------------------------------+ | re_pad | Padding byte value for the records. | +-------------+-----------------------------------------------+ | pgfree | Number of bytes free in database pages. | +-------------+-----------------------------------------------+ | first_recno | First undeleted record in the database. | +-------------+-----------------------------------------------+ | cur_recno | Last allocated record number in the database. | +-------------+-----------------------------------------------+ :OracleAPIC:`More info... ` .. function:: stat_print(flags=0) Displays the database statistical information. :OracleAPIC:`More info... ` .. function:: sync(flags=0) Flushes any cached information to disk. :OracleAPIC:`More info... ` .. function:: truncate(txn=None, flags=0) Empties the database, discarding all records it contains. The number of records discarded from the database is returned. :OracleAPIC:`More info... ` .. function:: upgrade(filename, flags=0) Upgrades all of the databases included in the file filename, if necessary. :OracleAPIC:`More info... ` .. function:: verify(filename, dbname=None, outfile=None, flags=0) Verifies the integrity of all databases in the file specified by the filename argument, and optionally outputs the databases' key/data pairs to a file. :OracleAPIC:`More info... ` DB Mapping and Compatibility Methods ------------------------------------ These methods of the DB type are for implementing the Mapping Interface, as well as others for making a DB behave as much like a dictionary as possible. The main downside to using a DB as a dictionary is you are not able to specify a transaction object. .. function:: DB_length() [ usage: len(db) ] Return the number of key/data pairs in the database. .. function:: DB_subscript(key) [ usage: db[key] ] Return the data associated with key. .. function:: DB_ass_sub(key, data) [ usage: db[key] = data ] Assign or update a key/data pair, or delete a key/data pair if data is NULL. .. function:: keys(txn=None) Return a list of all keys in the database. Warning: this method traverses the entire database so it can possibly take a long time to complete. .. function:: items(txn=None) Return a list of tuples of all key/data pairs in the database. Warning: this method traverses the entire database so it can possibly take a long time to complete. .. function:: values(txn=None) Return a list of all data values in the database. Warning: this method traverses the entire database so it can possibly take a long time to complete. .. function:: has_key(key, txn=None) Returns true if key is present in the database. bsddb3-6.2.7/docs/dbsequence.rst0000644000175000017500000001051513316226203016315 0ustar jceajcea00000000000000========== DBSequence ========== Read :Oracle:`Oracle documentation ` for better understanding. Sequences provide an arbitrary number of persistent objects that return an increasing or decreasing sequence of integers. Opening a sequence handle associates it with a record in a database. The handle can maintain a cache of values from the database so that a database update is not needed as the application allocates a value. :OracleAPIC:`More info... ` DBSequence Methods ------------------ .. function:: DBSequence(db, flags=0) Constructor. :OracleAPIC:`More info... ` .. function:: open(key, txn=None, flags=0) Opens the sequence represented by the key. :OracleAPIC:`More info... ` .. function:: close(flags=0) Close a DBSequence handle. :OracleAPIC:`More info... ` .. function:: initial_value(value) Set the initial value for a sequence. This call is only effective when the sequence is being created. :OracleAPIC:`More info... ` .. function:: get(delta=1, txn=None, flags=0) Returns the next available element in the sequence and changes the sequence value by delta. :OracleAPIC:`More info... ` .. function:: get_dbp() Returns the DB object associated to the DBSequence. :OracleAPIC:`More info... ` .. function:: get_key() Returns the key for the sequence. :OracleAPIC:`More info... ` .. function:: remove(txn=None, flags=0) Removes the sequence from the database. This method should not be called if there are other open handles on this sequence. :OracleAPIC:`More info... ` .. function:: get_cachesize() Returns the current cache size. :OracleAPIC:`More info... ` .. function:: set_cachesize(size) Configure the number of elements cached by a sequence handle. :OracleAPIC:`More info... ` .. function:: get_flags() Returns the current flags. :OracleAPIC:`More info... ` .. function:: set_flags(flags) Configure a sequence. :OracleAPIC:`More info... ` .. function:: stat(flags=0) Returns a dictionary of sequence statistics with the following keys: +------------+----------------------------------------------+ | wait | The number of times a thread of control was | | | forced to wait on the handle mutex. | +------------+----------------------------------------------+ | nowait | The number of times that a thread | | | of control was able to obtain handle mutex | | | without waiting. | +------------+----------------------------------------------+ | current | The current value of the sequence | | | in the database. | +------------+----------------------------------------------+ | value | The current cached value of the sequence. | +------------+----------------------------------------------+ | last_value | The last cached value of the sequence. | +------------+----------------------------------------------+ | min | The minimum permitted value of the sequence. | +------------+----------------------------------------------+ | max | The maximum permitted value of the sequence. | +------------+----------------------------------------------+ | cache_size | The number of values that will be cached in | | | this handle. | +------------+----------------------------------------------+ | flags | The flags value for the sequence. | +------------+----------------------------------------------+ :OracleAPIC:`More info... ` .. function:: stat_print(flags=0) Prints diagnostic information. :OracleAPIC:`More info... ` .. function:: get_range() Returns a tuple representing the range of values in the sequence. :OracleAPIC:`More info... ` .. function:: set_range((min,max)) Configure a sequence range. :OracleAPIC:`More info... ` bsddb3-6.2.7/docs/dbenv.rst0000644000175000017500000021171613316226203015303 0ustar jceajcea00000000000000===== DBEnv ===== Read :Oracle:`Oracle documentation ` for better understanding. :OracleAPIC:`More info... ` DBEnv Attributes ---------------- .. function:: DBEnv(flags=0) database home directory (read-only) DBEnv Methods ------------- .. function:: DBEnv(flags=0) Constructor. :OracleAPIC:`More info... ` .. function:: set_rpc_server(host, cl_timeout=0, sv_timeout=0) Establishes a connection for this dbenv to a RPC server. This function is not available if linked to Berkeley DB 4.8 or up. :OracleAPIC:`More info... ` .. function:: close(flags=0) Close the database environment, freeing resources. :OracleAPIC:`More info... ` .. function:: open(homedir, flags=0, mode=0660) Prepare the database environment for use. :OracleAPIC:`More info... ` .. function:: log_cursor() Returns a created log cursor. :OracleAPIC:`More info... ` .. function:: memp_stat(flags=0) Returns the memory pool (that is, the buffer cache) subsystem statistics. The returning value is a tuple. The first element is a dictionary with the general stats. The second element is another dictionary, keyed by filename, and the values are the stats for each file. The first dictionary contains these data: +-------------------+---------------------------------------------+ | gbytes | Gigabytes of cache (total cache size is | | | st_gbytes + st_bytes). | +-------------------+---------------------------------------------+ | bytes | Bytes of cache (total cache size is | | | st_gbytes + st_bytes). | +-------------------+---------------------------------------------+ | ncache | Number of caches. | +-------------------+---------------------------------------------+ | max_ncache | Maximum number of caches, as configured | | | with the DB_ENV->set_cache_max() method. | +-------------------+---------------------------------------------+ | regsize | Individual cache size, in bytes. | +-------------------+---------------------------------------------+ | mmapsize | Maximum memory-mapped file size. | +-------------------+---------------------------------------------+ | maxopenfd | Maximum open file descriptors. | +-------------------+---------------------------------------------+ | maxwrite | Maximum sequential buffer writes. | +-------------------+---------------------------------------------+ | maxwrite_sleep | Microseconds to pause after writing maximum | | | sequential buffers. | +-------------------+---------------------------------------------+ | map | Requested pages mapped into the process' | | | address space (there is no available | | | information about whether or not this | | | request caused disk I/O, although examining | | | the application page fault rate may be | | | helpful). | +-------------------+---------------------------------------------+ | cache_hit | Requested pages found in the cache. | +-------------------+---------------------------------------------+ | cache_miss | Requested pages not found in the cache. | +-------------------+---------------------------------------------+ | page_create | Pages created in the cache. | +-------------------+---------------------------------------------+ | page_in | Pages read into the cache. | +-------------------+---------------------------------------------+ | page_out | Pages written from the cache to the backing | | | file. | +-------------------+---------------------------------------------+ | ro_evict | Clean pages forced from the cache. | +-------------------+---------------------------------------------+ | rw_evict | Dirty pages forced from the cache. | +-------------------+---------------------------------------------+ | page_trickle | Dirty pages written using the | | | DB_ENV->memp_trickle() method. | +-------------------+---------------------------------------------+ | pages | Pages in the cache. | +-------------------+---------------------------------------------+ | page_clean | Clean pages currently in the cache. | +-------------------+---------------------------------------------+ | page_dirty | Dirty pages currently in the cache. | +-------------------+---------------------------------------------+ | hash_buckets | Number of hash buckets in buffer hash | | | table. | +-------------------+---------------------------------------------+ | hash_searches | Total number of buffer hash table lookups. | +-------------------+---------------------------------------------+ | hash_longest | Longest chain ever encountered in buffer | | | hash table lookups. | +-------------------+---------------------------------------------+ | hash_examined | Total number of hash elements traversed | | | during hash table lookups. | +-------------------+---------------------------------------------+ | hash_nowait | Number of times that a thread of control | | | was able to obtain a hash bucket lock | | | without waiting. | +-------------------+---------------------------------------------+ | hash_wait | Number of times that a thread of control | | | was forced to wait before obtaining a hash | | | bucket lock. | +-------------------+---------------------------------------------+ | hash_max_nowait | The number of times a thread of control was | | | able to obtain the hash bucket lock without | | | waiting on the bucket which had the maximum | | | number of times that a thread of control | | | needed to wait. | +-------------------+---------------------------------------------+ | hash_max_wait | Maximum number of times any hash bucket | | | lock was waited for by a thread of control. | +-------------------+---------------------------------------------+ | region_wait | Number of times that a thread of control | | | was forced to wait before obtaining a cache | | | region mutex. | +-------------------+---------------------------------------------+ | region_nowait | Number of times that a thread of control | | | was able to obtain a cache region mutex | | | without waiting. | +-------------------+---------------------------------------------+ | mvcc_frozen | Number of buffers frozen. | +-------------------+---------------------------------------------+ | mvcc_thawed | Number of buffers thawed. | +-------------------+---------------------------------------------+ | mvcc_freed | Number of frozen buffers freed. | +-------------------+---------------------------------------------+ | alloc | Number of page allocations. | +-------------------+---------------------------------------------+ | alloc_buckets | Number of hash buckets checked during | | | allocation. | +-------------------+---------------------------------------------+ | alloc_max_buckets | Maximum number of hash buckets checked | | | during an allocation. | +-------------------+---------------------------------------------+ | alloc_pages | Number of pages checked during allocation. | +-------------------+---------------------------------------------+ | alloc_max_pages | Maximum number of pages checked during an | | | allocation. | +-------------------+---------------------------------------------+ | io_wait | Number of operations blocked waiting for | | | I/O to complete. | +-------------------+---------------------------------------------+ | sync_interrupted | Number of mpool sync operations | | | interrupted. | +-------------------+---------------------------------------------+ The second dictionary contains these data: +-------------------+---------------------------------------------+ | pagesize | Page size in bytes. | +-------------------+---------------------------------------------+ | cache_hit | Requested pages found in the cache. | +-------------------+---------------------------------------------+ | cache_miss | Requested pages not found in the cache. | +-------------------+---------------------------------------------+ | map | Requested pages mapped into the process' | | | address space. | +-------------------+---------------------------------------------+ | page_create | Pages created in the cache. | +-------------------+---------------------------------------------+ | page_in | Pages read into the cache. | +-------------------+---------------------------------------------+ | page_out | Pages written from the cache to the backing | | | file. | +-------------------+---------------------------------------------+ :OracleAPIC:`More info... ` .. function:: memp_stat_print(flags=0) Displays cache subsystem statistical information. :OracleAPIC:`More info... ` .. function:: memp_sync(lsn=None) Flushes modified pages in the cache to their backing files. If provided, lsn is a tuple: (file, offset). :OracleAPIC:`More info... ` .. function:: memp_trickle(percent) Ensures that a specified percent of the pages in the cache are clean, by writing dirty pages to their backing files. :OracleAPIC:`More info... ` .. function:: remove(homedir, flags=0) Remove a database environment. :OracleAPIC:`More info... ` .. function:: dbremove(file, database=None, txn=None, flags=0) Removes the database specified by the file and database parameters. If no database is specified, the underlying file represented by file is removed, incidentally removing all of the databases it contained. :OracleAPIC:`More info... ` .. function:: dbrename(file, database=None, newname, txn=None, flags=0) Renames the database specified by the file and database parameters to newname. If no database is specified, the underlying file represented by file is renamed, incidentally renaming all of the databases it contained. :OracleAPIC:`More info... ` .. function:: fileid_reset(file, flags=0) All databases contain an ID string used to identify the database in the database environment cache. If a physical database file is copied, and used in the same environment as another file with the same ID strings, corruption can occur. The DB_ENV->fileid_reset method creates new ID strings for all of the databases in the physical file. :OracleAPIC:`More info... ` .. function:: get_thread_count() Returns the thread count as set by the DB_ENV->set_thread_count() method. :OracleAPIC:`More info... ` .. function:: set_thread_count(count) Declare an approximate number of threads in the database environment. The DB_ENV->set_thread_count() method must be called prior to opening the database environment if the DB_ENV->failchk() method will be used. The DB_ENV->set_thread_count() method does not set the maximum number of threads but is used to determine memory sizing and the thread control block reclamation policy. :OracleAPIC:`More info... ` .. function:: set_encrypt(passwd, flags=0) Set the password used by the Berkeley DB library to perform encryption and decryption. :OracleAPIC:`More info... ` .. function:: get_encrypt_flags() Returns the encryption flags. :OracleAPIC:`More info... ` .. function:: get_intermediate_dir_mode() Returns the intermediate directory permissions. Intermediate directories are directories needed for recovery. Normally, Berkeley DB does not create these directories and will do so only if the DB_ENV->set_intermediate_dir_mode() method is called. :OracleAPIC:`More info... ` .. function:: set_intermediate_dir_mode(mode) By default, Berkeley DB does not create intermediate directories needed for recovery, that is, if the file /a/b/c/mydatabase is being recovered, and the directory path b/c does not exist, recovery will fail. This default behavior is because Berkeley DB does not know what permissions are appropriate for intermediate directory creation, and creating the directory might result in a security problem. The DB_ENV->set_intermediate_dir_mode() method causes Berkeley DB to create any intermediate directories needed during recovery, using the specified permissions. :OracleAPIC:`More info... ` .. function:: get_timeout(flags) Returns a timeout value, in microseconds. :OracleAPIC:`More info... ` .. function:: set_timeout(timeout, flags) Sets timeout values for locks or transactions in the database environment. :OracleAPIC:`More info... ` .. function:: get_mp_max_openfd() Returns the maximum number of file descriptors the library will open concurrently when flushing dirty pages from the cache. :OracleAPIC:`More info... ` .. function:: set_mp_max_openfd(max_open_fd) Limits the number of file descriptors the library will open concurrently when flushing dirty pages from the cache. :OracleAPIC:`More info... ` .. function:: get_mp_max_write() Returns a tuple with the current maximum number of sequential write operations and microseconds to pause that the library can schedule when flushing dirty pages from the cache. :OracleAPIC:`More info... ` .. function:: set_mp_max_write(maxwrite, maxwrite_sleep) Limits the number of sequential write operations scheduled by the library when flushing dirty pages from the cache. :OracleAPIC:`More info... ` .. function:: set_shm_key(key) Specify a base segment ID for Berkeley DB environment shared memory regions created in system memory on VxWorks or systems supporting X/Open-style shared memory interfaces; for example, UNIX systems supporting shmget(2) and related System V IPC interfaces. :OracleAPIC:`More info... ` .. function:: get_shm_key() Returns the base segment ID. :OracleAPIC:`More info... ` .. function:: set_cache_max(gbytes, bytes) Sets the maximum cache size, in bytes. The specified size is rounded to the nearest multiple of the cache region size, which is the initial cache size divided by the number of regions specified to the DB_ENV->set_cachesize() method. If no value is specified, it defaults to the initial cache size. :OracleAPIC:`More info... ` .. function:: get_cache_max() Returns the maximum size of the cache as set using the DB_ENV->set_cache_max() method. :OracleAPIC:`More info... ` .. function:: set_cachesize(gbytes, bytes, ncache=0) Set the size of the shared memory buffer pool. :OracleAPIC:`More info... ` .. function:: get_cachesize() Returns a tuple with the current size and composition of the cache. :OracleAPIC:`More info... ` .. function:: set_data_dir(dir) Set the environment data directory. You can call this function multiple times, adding new directories. :OracleAPIC:`More info... ` .. function:: get_data_dirs() Return a tuple with the directories. :OracleAPIC:`More info... ` .. function:: get_flags() Returns the configuration flags set for a DB_ENV handle. :OracleAPIC:`More info... ` .. function:: set_flags(flags, onoff) Set additional flags for the DBEnv. The onoff parameter specifes if the flag is set or cleared. :OracleAPIC:`More info... ` .. function:: set_tmp_dir(dir) Set the directory to be used for temporary files. :OracleAPIC:`More info... ` .. function:: get_tmp_dir() Returns the database environment temporary file directory. :OracleAPIC:`More info... ` .. function:: set_get_returns_none(flag) By default when DB.get or DBCursor.get, get_both, first, last, next or prev encounter a DB_NOTFOUND error they return None instead of raising DBNotFoundError. This behaviour emulates Python dictionaries and is convenient for looping. You can use this method to toggle that behaviour for all of the aformentioned methods or extend it to also apply to the DBCursor.set, set_both, set_range, and set_recno methods. Supported values of flag: - **0** all DB and DBCursor get and set methods will raise a DBNotFoundError rather than returning None. - **1** *Default in module version <4.2.4* The DB.get and DBCursor.get, get_both, first, last, next and prev methods return None. - **2** *Default in module version >=4.2.4* Extends the behaviour of **1** to the DBCursor set, set_both, set_range and set_recno methods. The default of returning None makes it easy to do things like this without having to catch DBNotFoundError (KeyError):: data = mydb.get(key) if data: doSomething(data) or this:: rec = cursor.first() while rec: print rec rec = cursor.next() Making the cursor set methods return None is useful in order to do this:: rec = mydb.set() while rec: key, val = rec doSomething(key, val) rec = mydb.next() The downside to this it that it is inconsistent with the rest of the package and noticeably diverges from the Oracle Berkeley DB API. If you prefer to have the get and set methods raise an exception when a key is not found, use this method to tell them to do so. Calling this method on a DBEnv object will set the default for all DB's later created within that environment. Calling it on a DB object sets the behaviour for that DB only. The previous setting is returned. .. function:: set_private(object) Link an object to the DBEnv object. This allows to pass around an arbitrary object. For instance, for callback context. .. function:: get_private() Give the object linked to the DBEnv. .. function:: get_open_flags() Returns the current open method flags. That is, this method returns the flags that were specified when DB_ENV->open() was called. :OracleAPIC:`More info... ` .. function:: get_lg_filemode() Returns the log file mode. :OracleAPIC:`More info... ` .. function:: set_lg_filemode(filemode) Set the absolute file mode for created log files. :OracleAPIC:`More info... ` .. function:: get_lg_bsize() Returns the size of the log buffer, in bytes. :OracleAPIC:`More info... ` .. function:: set_lg_bsize(size) Set the size of the in-memory log buffer, in bytes. :OracleAPIC:`More info... ` .. function:: get_lg_dir() Returns the log directory, which is the location for logging files. :OracleAPIC:`More info... ` .. function:: set_lg_dir(dir) The path of a directory to be used as the location of logging files. Log files created by the Log Manager subsystem will be created in this directory. :OracleAPIC:`More info... ` .. function:: set_lg_max(size) Set the maximum size of a single file in the log, in bytes. :OracleAPIC:`More info... ` .. function:: get_lg_max(size) Returns the maximum log file size. :OracleAPIC:`More info... ` .. function:: get_lg_regionmax() Returns the size of the underlying logging subsystem region. :OracleAPIC:`More info... ` .. function:: set_lg_regionmax(size) Set the maximum size of a single region in the log, in bytes. :OracleAPIC:`More info... ` .. function:: get_lk_partitions() Returns the number of lock table partitions used in the Berkeley DB environment. :OracleAPIC:`More info... ` .. function:: set_lk_partitions(partitions) Set the number of lock table partitions in the Berkeley DB environment. :OracleAPIC:`More info... ` .. function:: get_lk_detect() Returns the deadlock detector configuration. :OracleAPIC:`More info... ` .. function:: set_lk_detect(mode) Set the automatic deadlock detection mode. :OracleAPIC:`More info... ` .. function:: set_lk_max(max) Set the maximum number of locks. (This method is deprecated.) :OracleAPIC:`More info... ` .. function:: get_lk_max_locks() Returns the maximum number of potential locks. :OracleAPIC:`More info... ` .. function:: set_lk_max_locks(max) Set the maximum number of locks supported by the Berkeley DB lock subsystem. :OracleAPIC:`More info... ` .. function:: get_lk_max_lockers() Returns the maximum number of potential lockers. :OracleAPIC:`More info... ` .. function:: set_lk_max_lockers(max) Set the maximum number of simultaneous locking entities supported by the Berkeley DB lock subsystem. :OracleAPIC:`More info... ` .. function:: get_lk_max_objects() Returns the maximum number of locked objects. :OracleAPIC:`More info... ` .. function:: set_lk_max_objects(max) Set the maximum number of simultaneously locked objects supported by the Berkeley DB lock subsystem. :OracleAPIC:`More info... ` .. function:: get_mp_mmapsize() Returns the the maximum file size, in bytes, for a file to be mapped into the process address space. :OracleAPIC:`More info... ` .. function:: set_mp_mmapsize(size) Files that are opened read-only in the memory pool (and that satisfy a few other criteria) are, by default, mapped into the process address space instead of being copied into the local cache. This can result in better-than-usual performance, as available virtual memory is normally much larger than the local cache, and page faults are faster than page copying on many systems. However, in the presence of limited virtual memory it can cause resource starvation, and in the presence of large databases, it can result in immense process sizes. This method sets the maximum file size, in bytes, for a file to be mapped into the process address space. If no value is specified, it defaults to 10MB. :OracleAPIC:`More info... ` .. function:: stat_print(flags=0) Displays the default subsystem statistical information. :OracleAPIC:`More info... ` .. function:: log_file(lsn) Maps lsn to filenames, returning the name of the file containing the named record. :OracleAPIC:`More info... ` .. function:: log_printf(string, txn=None) Appends an informational message to the Berkeley DB database environment log files. :OracleAPIC:`More info... ` .. function:: log_archive(flags=0) Returns a list of log or database file names. By default, log_archive returns the names of all of the log files that are no longer in use (e.g., no longer involved in active transactions), and that may safely be archived for catastrophic recovery and then removed from the system. :OracleAPIC:`More info... ` .. function:: log_flush() Force log records to disk. Useful if the environment, database or transactions are used as ACI, instead of ACID. For example, if the environment is opened as DB_TXN_NOSYNC. :OracleAPIC:`More info... ` .. function:: log_get_config(which) Returns whether the specified which parameter is currently set or not. You can manage this value using the DB_ENV->log_set_config() method. :OracleAPIC:`More info... ` .. function:: log_set_config(flags, onoff) Configures the Berkeley DB logging subsystem. :OracleAPIC:`More info... ` .. function:: lock_detect(atype, flags=0) Run one iteration of the deadlock detector, returns the number of transactions aborted. :OracleAPIC:`More info... ` .. function:: lock_get(locker, obj, lock_mode, flags=0) Acquires a lock and returns a handle to it as a DBLock object. The locker parameter is an integer representing the entity doing the locking, and obj is an object representing the item to be locked. :OracleAPIC:`More info... ` .. function:: lock_id() Acquires a locker id, guaranteed to be unique across all threads and processes that have the DBEnv open. :OracleAPIC:`More info... ` .. function:: lock_id_free(id) Frees a locker ID allocated by the "dbenv.lock_id()" method. :OracleAPIC:`More info... ` .. function:: lock_put(lock) Release the lock. :OracleAPIC:`More info... ` .. function:: lock_stat(flags=0) Returns a dictionary of locking subsystem statistics with the following keys: +----------------+---------------------------------------------+ | id | Last allocated lock ID. | +----------------+---------------------------------------------+ | cur_maxid | The current maximum unused locker ID. | +----------------+---------------------------------------------+ | nmodes | Number of lock modes. | +----------------+---------------------------------------------+ | maxlocks | Maximum number of locks possible. | +----------------+---------------------------------------------+ | maxlockers | Maximum number of lockers possible. | +----------------+---------------------------------------------+ | maxobjects | Maximum number of objects possible. | +----------------+---------------------------------------------+ | nlocks | Number of current locks. | +----------------+---------------------------------------------+ | maxnlocks | Maximum number of locks at once. | +----------------+---------------------------------------------+ | nlockers | Number of current lockers. | +----------------+---------------------------------------------+ | nobjects | Number of current lock objects. | +----------------+---------------------------------------------+ | maxnobjects | Maximum number of lock objects at once. | +----------------+---------------------------------------------+ | maxnlockers | Maximum number of lockers at once. | +----------------+---------------------------------------------+ | nrequests | Total number of locks requested. | +----------------+---------------------------------------------+ | nreleases | Total number of locks released. | +----------------+---------------------------------------------+ | nupgrade | Total number of locks upgraded. | +----------------+---------------------------------------------+ | ndowngrade | Total number of locks downgraded. | +----------------+---------------------------------------------+ | lock_wait | The number of lock requests not immediately | | | available due to conflicts, for which the | | | thread of control waited. | +----------------+---------------------------------------------+ | lock_nowait | The number of lock requests not immediately | | | available due to conflicts, for which the | | | thread of control did not wait. | +----------------+---------------------------------------------+ | ndeadlocks | Number of deadlocks. | +----------------+---------------------------------------------+ | locktimeout | Lock timeout value. | +----------------+---------------------------------------------+ | nlocktimeouts | The number of lock requests that have timed | | | out. | +----------------+---------------------------------------------+ | txntimeout | Transaction timeout value. | +----------------+---------------------------------------------+ | ntxntimeouts | The number of transactions that have timed | | | out. This value is also a component of | | | ndeadlocks, the total number of deadlocks | | | detected. | +----------------+---------------------------------------------+ | objs_wait | The number of requests to allocate or | | | deallocate an object for which the thread | | | of control waited. | +----------------+---------------------------------------------+ | objs_nowait | The number of requests to allocate or | | | deallocate an object for which the thread | | | of control did not wait. | +----------------+---------------------------------------------+ | lockers_wait | The number of requests to allocate or | | | deallocate a locker for which the thread of | | | control waited. | +----------------+---------------------------------------------+ | lockers_nowait | The number of requests to allocate or | | | deallocate a locker for which the thread of | | | control did not wait. | +----------------+---------------------------------------------+ | locks_wait | The number of requests to allocate or | | | deallocate a lock structure for which the | | | thread of control waited. | +----------------+---------------------------------------------+ | locks_nowait | The number of requests to allocate or | | | deallocate a lock structure for which the | | | thread of control did not wait. | +----------------+---------------------------------------------+ | hash_len | Maximum length of a lock hash bucket. | +----------------+---------------------------------------------+ | regsize | Size of the region. | +----------------+---------------------------------------------+ | region_wait | Number of times a thread of control was | | | forced to wait before obtaining the region | | | lock. | +----------------+---------------------------------------------+ | region_nowait | Number of times a thread of control was | | | able to obtain the region lock without | | | waiting. | +----------------+---------------------------------------------+ :OracleAPIC:`More info... ` .. function:: lock_stat_print(flags=0) Displays the locking subsystem statistical information. :OracleAPIC:`More info... ` .. function:: get_tx_max() Returns the number of active transactions. :OracleAPIC:`More info... ` .. function:: set_tx_max(max) Set the maximum number of active transactions. :OracleAPIC:`More info... ` .. function:: get_tx_timestamp() Returns the recovery timestamp. :OracleAPIC:`More info... ` .. function:: set_tx_timestamp(timestamp) Recover to the time specified by timestamp rather than to the most current possible date. :OracleAPIC:`More info... ` .. function:: txn_begin(parent=None, flags=0) Creates and begins a new transaction. A DBTxn object is returned. :OracleAPIC:`More info... ` .. function:: txn_checkpoint(kbyte=0, min=0, flag=0) Flushes the underlying memory pool, writes a checkpoint record to the log and then flushes the log. :OracleAPIC:`More info... ` .. function:: txn_stat(flags=0) Return a dictionary of transaction statistics with the following keys: +--------------+---------------------------------------------+ | last_ckp | The LSN of the last checkpoint. | +--------------+---------------------------------------------+ | time_ckp | Time the last completed checkpoint finished | | | (as the number of seconds since the Epoch, | | | returned by the IEEE/ANSI Std 1003.1 POSIX | | | time interface). | +--------------+---------------------------------------------+ | last_txnid | Last transaction ID allocated. | +--------------+---------------------------------------------+ | maxtxns | Max number of active transactions possible. | +--------------+---------------------------------------------+ | nactive | Number of transactions currently active. | +--------------+---------------------------------------------+ | maxnactive | Max number of active transactions at once. | +--------------+---------------------------------------------+ | nsnapshot | The number of transactions on the snapshot | | | list. These are transactions which modified | | | a database opened with DB_MULTIVERSION, and | | | which have committed or aborted, but the | | | copies of pages they created are still in | | | the cache. | +--------------+---------------------------------------------+ | maxnsnapshot | The maximum number of transactions on the | | | snapshot list at any one time. | +--------------+---------------------------------------------+ | nbegins | Number of transactions that have begun. | +--------------+---------------------------------------------+ | naborts | Number of transactions that have aborted. | +--------------+---------------------------------------------+ | ncommits | Number of transactions that have committed. | +--------------+---------------------------------------------+ | nrestores | Number of transactions that have been | | | restored. | +--------------+---------------------------------------------+ | regsize | Size of the region. | +--------------+---------------------------------------------+ | region_wait | Number of times that a thread of control | | | was forced to wait before obtaining the | | | region lock. | +--------------+---------------------------------------------+ | region_nowait| Number of times that a thread of control | | | was able to obtain the region lock without | | | waiting. | +--------------+---------------------------------------------+ :OracleAPIC:`More info... ` .. function:: txn_stat_print(flags=0) Displays the transaction subsystem statistical information. :OracleAPIC:`More info... ` .. function:: lsn_reset(file=None,flags=0) This method allows database files to be moved from one transactional database environment to another. :OracleAPIC:`More info... ` .. function:: log_stat(flags=0) Returns a dictionary of logging subsystem statistics with the following keys: +-------------------+---------------------------------------------+ | magic | The magic number that identifies a file as | | | a log file. | +-------------------+---------------------------------------------+ | version | The version of the log file type. | +-------------------+---------------------------------------------+ | mode | The mode of any created log files. | +-------------------+---------------------------------------------+ | lg_bsize | The in-memory log record cache size. | +-------------------+---------------------------------------------+ | lg_size | The log file size. | +-------------------+---------------------------------------------+ | record | The number of records written to this log. | +-------------------+---------------------------------------------+ | w_mbytes | The number of megabytes written to this | | | log. | +-------------------+---------------------------------------------+ | w_bytes | The number of bytes over and above w_mbytes | | | written to this log. | +-------------------+---------------------------------------------+ | wc_mbytes | The number of megabytes written to this log | | | since the last checkpoint. | +-------------------+---------------------------------------------+ | wc_bytes | The number of bytes over and above | | | wc_mbytes written to this log since the | | | last checkpoint. | +-------------------+---------------------------------------------+ | wcount | The number of times the log has been | | | written to disk. | +-------------------+---------------------------------------------+ | wcount_fill | The number of times the log has been | | | written to disk because the in-memory log | | | record cache filled up. | +-------------------+---------------------------------------------+ | rcount | The number of times the log has been read | | | from disk. | +-------------------+---------------------------------------------+ | scount | The number of times the log has been | | | flushed to disk. | +-------------------+---------------------------------------------+ | cur_file | The current log file number. | +-------------------+---------------------------------------------+ | cur_offset | The byte offset in the current log file. | +-------------------+---------------------------------------------+ | disk_file | The log file number of the last record | | | known to be on disk. | +-------------------+---------------------------------------------+ | disk_offset | The byte offset of the last record known to | | | be on disk. | +-------------------+---------------------------------------------+ | maxcommitperflush | The maximum number of commits contained in | | | a single log flush. | +-------------------+---------------------------------------------+ | mincommitperflush | The minimum number of commits contained in | | | a single log flush that contained a commit. | +-------------------+---------------------------------------------+ | regsize | The size of the log region, in bytes. | +-------------------+---------------------------------------------+ | region_wait | The number of times that a thread of | | | control was forced to wait before obtaining | | | the log region mutex. | +-------------------+---------------------------------------------+ | region_nowait | The number of times that a thread of | | | control was able to obtain the log region | | | mutex without waiting. | +-------------------+---------------------------------------------+ :OracleAPIC:`More info... ` .. function:: log_stat_print(flags=0) Displays the logging subsystem statistical information. :OracleAPIC:`More info... ` .. function:: txn_recover() Returns a list of tuples (GID, TXN) of transactions prepared but still unresolved. This is used while doing environment recovery in an application using distributed transactions. This method must be called only from a single thread at a time. It should be called after DBEnv recovery. :OracleAPIC:`More info... ` .. function:: set_verbose(which, onoff) Turns specific additional informational and debugging messages in the Berkeley DB message output on and off. To see the additional messages, verbose messages must also be configured for the application. :OracleAPIC:`More info... ` .. function:: get_verbose(which) Returns whether the specified *which* parameter is currently set or not. :OracleAPIC:`More info... ` .. function:: set_event_notify(eventFunc) Configures a callback function which is called to notify the process of specific Berkeley DB events. :OracleAPIC:`More info... ` .. function:: mutex_stat(flags=0) Returns a dictionary of mutex subsystem statistics with the following keys: +-----------------+--------------------------------------------+ | mutex_align | The mutex alignment, in bytes. | +-----------------+--------------------------------------------+ | mutex_tas_spins | The number of times test-and-set mutexes | | | will spin without blocking. | +-----------------+--------------------------------------------+ | mutex_cnt | The total number of mutexes configured. | +-----------------+--------------------------------------------+ | mutex_free | The number of mutexes currently available. | +-----------------+--------------------------------------------+ | mutex_inuse | The number of mutexes currently in use. | +-----------------+--------------------------------------------+ | mutex_inuse_max | The maximum number of mutexes ever in use. | +-----------------+--------------------------------------------+ | regsize | The size of the mutex region, in bytes. | +-----------------+--------------------------------------------+ | region_wait | The number of times that a thread of | | | control was forced to wait before | | | obtaining the mutex region mutex. | +-----------------+--------------------------------------------+ | region_nowait | The number of times that a thread of | | | control was able to obtain the mutex | | | region mutex without waiting. | +-----------------+--------------------------------------------+ :OracleAPIC:`More info... ` .. function:: mutex_stat_print(flags=0) Displays the mutex subsystem statistical information. :OracleAPIC:`More info... ` .. function:: mutex_set_max(value) Configure the total number of mutexes to allocate. :OracleAPIC:`More info... ` .. function:: mutex_get_max() Returns the total number of mutexes allocated. :OracleAPIC:`More info... ` .. function:: mutex_set_increment(value) Configure the number of additional mutexes to allocate. :OracleAPIC:`More info... ` .. function:: mutex_get_increment() Returns the number of additional mutexes to allocate. :OracleAPIC:`More info... ` .. function:: mutex_set_align(align) Set the mutex alignment, in bytes. :OracleAPIC:`More info... ` .. function:: mutex_get_align() Returns the mutex alignment, in bytes. :OracleAPIC:`More info... ` .. function:: mutex_set_tas_spins(tas_spins) Specify that test-and-set mutexes should spin tas_spins times without blocking. Check the default values in the Oracle webpage. :OracleAPIC:`More info... ` .. function:: mutex_get_tas_spins() Returns the test-and-set spin count. :OracleAPIC:`More info... ` DBEnv Replication Manager Methods --------------------------------- This module automates many of the tasks needed to provide replication abilities in a Berkeley DB system. The module is fairly limited, but enough in many cases. Users more demanding must use the **full** Base Replication API. This module requires pthread support (in Unix), so you must compile Berkeley DB with it if you want to be able to use the Replication Manager. .. function:: repmgr_start(nthreads, flags) Starts the replication manager. :OracleAPIC:`More info... ` .. function:: repmgr_site(host, port) Returns a DB_SITE handle that defines a site's host/port network address. You use the DB_SITE handle to configure and manage replication sites. :OracleAPIC:`More info... ` .. function:: repmgr_site_by_eid(eid) Returns a DB_SITE handle based on the site's Environment ID value. You use the DB_SITE handle to configure and manage replication sites. :OracleAPIC:`More info... ` .. function:: repmgr_set_ack_policy(ack_policy) Specifies how master and client sites will handle acknowledgment of replication messages which are necessary for "permanent" records. :OracleAPIC:`More info... ` .. function:: repmgr_get_ack_policy() Returns the replication manager's client acknowledgment policy. :OracleAPIC:`More info... ` .. function:: repmgr_site_list() Returns a dictionary with the status of the sites currently known by the replication manager. The keys are the Environment ID assigned by the replication manager. This is the same value that is passed to the application's event notification function for the DB_EVENT_REP_NEWMASTER event. The values are tuples containing the hostname, the TCP/IP port number and the link status. :OracleAPIC:`More info... ` .. function:: repmgr_stat(flags=0) Returns a dictionary with the replication manager statistics. Keys are: +-----------------+-------------------------------------------------+ | perm_failed | The number of times a message critical for | | | maintaining database integrity (for example, a | | | transaction commit), originating at this site, | | | did not receive sufficient acknowledgement from | | | clients, according to the configured | | | acknowledgement policy and acknowledgement | | | timeout. | +-----------------+-------------------------------------------------+ | msgs_queued | The number of outgoing messages which could not | | | be transmitted immediately, due to a full | | | network buffer, and had to be queued for later | | | delivery. | +-----------------+-------------------------------------------------+ | msgs_dropped | The number of outgoing messages that were | | | completely dropped, because the outgoing | | | message queue was full. (Berkeley DB | | | replication is tolerant of dropped messages, | | | and will automatically request retransmission | | | of any missing messages as needed.) | +-----------------+-------------------------------------------------+ | connection_drop | The number of times an existing TCP/IP | | | connection failed. | +-----------------+-------------------------------------------------+ | connect_fail | The number of times an attempt to open a new | | | TCP/IP connection failed. | +-----------------+-------------------------------------------------+ :OracleAPIC:`More info... ` .. function:: repmgr_stat_print(flags=0) Displays the replication manager statistical information. :OracleAPIC:`More info... ` DBEnv Replication Methods ------------------------- This section provides the raw methods for replication. If possible, it is recommended to use the Replication Manager. .. function:: rep_elect(nsites, nvotes) Holds an election for the master of a replication group. :OracleAPIC:`More info... ` .. function:: rep_set_transport(envid, transportFunc) Initializes the communication infrastructure for a database environment participating in a replicated application. :OracleAPIC:`More info... ` .. function:: rep_process_messsage(control, rec, envid) Processes an incoming replication message sent by a member of the replication group to the local database environment. Returns a two element tuple. :OracleAPIC:`More info... ` .. function:: rep_start(flags, cdata=None) Configures the database environment as a client or master in a group of replicated database environments. The DB_ENV->rep_start method is not called by most replication applications. It should only be called by applications implementing their own network transport layer, explicitly holding replication group elections and handling replication messages outside of the replication manager framework. :OracleAPIC:`More info... ` .. function:: rep_sync() Forces master synchronization to begin for this client. This method is the other half of setting the DB_REP_CONF_DELAYCLIENT flag via the DB_ENV->rep_set_config method. :OracleAPIC:`More info... ` .. function:: rep_set_config(which, onoff) Configures the Berkeley DB replication subsystem. :OracleAPIC:`More info... ` .. function:: rep_get_config(which) Returns whether the specified which parameter is currently set or not. :OracleAPIC:`More info... ` .. function:: rep_set_limit(bytes) Sets a byte-count limit on the amount of data that will be transmitted from a site in response to a single message processed by the DB_ENV->rep_process_message method. The limit is not a hard limit, and the record that exceeds the limit is the last record to be sent. :OracleAPIC:`More info... ` .. function:: rep_get_limit() Gets a byte-count limit on the amount of data that will be transmitted from a site in response to a single message processed by the DB_ENV->rep_process_message method. The limit is not a hard limit, and the record that exceeds the limit is the last record to be sent. :OracleAPIC:`More info... ` .. function:: rep_set_request(minimum, maximum) Sets a threshold for the minimum and maximum time that a client waits before requesting retransmission of a missing message. Specifically, if the client detects a gap in the sequence of incoming log records or database pages, Berkeley DB will wait for at least min microseconds before requesting retransmission of the missing record. Berkeley DB will double that amount before requesting the same missing record again, and so on, up to a maximum threshold of max microseconds. :OracleAPIC:`More info... ` .. function:: rep_get_request() Returns a tuple with the minimum and maximum number of microseconds a client waits before requesting retransmission. :OracleAPIC:`More info... ` .. function:: rep_set_nsites(nsites) Specifies the total number of sites in a replication group. :OracleAPIC:`More info... ` .. function:: rep_get_nsites() Returns the total number of sites in the replication group. :OracleAPIC:`More info... ` .. function:: rep_set_priority(priority) Specifies the database environment's priority in replication group elections. The priority must be a positive integer, or 0 if this environment cannot be a replication group master. :OracleAPIC:`More info... ` .. function:: rep_get_priority() Returns the database environment priority. :OracleAPIC:`More info... ` .. function:: rep_set_timeout(which, timeout) Specifies a variety of replication timeout values. :OracleAPIC:`More info... ` .. function:: rep_get_timeout(which) Returns the timeout value for the specified *which* parameter. :OracleAPIC:`More info... ` .. function:: rep_set_clockskew(fast, slow) Sets the clock skew ratio among replication group members based on the fastest and slowest measurements among the group for use with master leases. :OracleAPIC:`More info... ` .. function:: rep_get_clockskew() Returns a tuple with the current clock skew values. :OracleAPIC:`More info... ` .. function:: rep_stat(flags=0) Returns a dictionary with the replication subsystem statistics. Keys are: +---------------------+---------------------------------------------+ | st_bulk_fills | The number of times the bulk buffer filled | | | up, forcing the buffer content to be sent. | +---------------------+---------------------------------------------+ | bulk_overflows | The number of times a record was bigger | | | than the entire bulk buffer, and therefore | | | had to be sent as a singleton. | +---------------------+---------------------------------------------+ | bulk_records | The number of records added to a bulk | | | buffer. | +---------------------+---------------------------------------------+ | bulk_transfers | The number of bulk buffers transferred (via | | | a call to the application's send function). | +---------------------+---------------------------------------------+ | client_rerequests | The number of times this client site | | | received a "re-request" message, indicating | | | that a request it previously sent to | | | another client could not be serviced by | | | that client. (Compare to client_svc_miss.) | +---------------------+---------------------------------------------+ | client_svc_miss | The number of "request" type messages | | | received by this client that could not be | | | processed, forcing the originating | | | requester to try sending the request to the | | | master (or another client). | +---------------------+---------------------------------------------+ | client_svc_req | The number of "request" type messages | | | received by this client. ("Request" | | | messages are usually sent from a client to | | | the master, but a message marked with the | | | DB_REP_ANYWHERE flag in the invocation of | | | the application's send function may be sent | | | to another client instead.) | +---------------------+---------------------------------------------+ | dupmasters | The number of duplicate master conditions | | | originally detected at this site. | +---------------------+---------------------------------------------+ | egen | The current election generation number. | +---------------------+---------------------------------------------+ | election_cur_winner | The election winner. | +---------------------+---------------------------------------------+ | election_gen | The election generation number. | +---------------------+---------------------------------------------+ | election_lsn | The maximum LSN of election winner. | +---------------------+---------------------------------------------+ | election_nsites | The number sites responding to this site | | | during the last election. | +---------------------+---------------------------------------------+ | election_nvotes | The number of votes required in the last | | | election. | +---------------------+---------------------------------------------+ | election_priority | The election priority. | +---------------------+---------------------------------------------+ | election_sec | The number of seconds the last election | | | took (the total election time is | | | election_sec plus election_usec). | +---------------------+---------------------------------------------+ | election_status | The current election phase (0 if no | | | election is in progress). | +---------------------+---------------------------------------------+ | election_tiebreaker | The election tiebreaker value. | +---------------------+---------------------------------------------+ | election_usec | The number of microseconds the last | | | election took (the total election time is | | | election_sec plus election_usec). | +---------------------+---------------------------------------------+ | election_votes | The number of votes received in the last | | | election. | +---------------------+---------------------------------------------+ | elections | The number of elections held. | +---------------------+---------------------------------------------+ | elections_won | The number of elections won. | +---------------------+---------------------------------------------+ | env_id | The current environment ID. | +---------------------+---------------------------------------------+ | env_priority | The current environment priority. | +---------------------+---------------------------------------------+ | gen | The current generation number. | +---------------------+---------------------------------------------+ | log_duplicated | The number of duplicate log records | | | received. | +---------------------+---------------------------------------------+ | log_queued | The number of log records currently queued. | +---------------------+---------------------------------------------+ | log_queued_max | The maximum number of log records ever | | | queued at once. | +---------------------+---------------------------------------------+ | log_queued_total | The total number of log records queued. | +---------------------+---------------------------------------------+ | log_records | The number of log records received and | | | appended to the log. | +---------------------+---------------------------------------------+ | log_requested | The number of times log records were missed | | | and requested. | +---------------------+---------------------------------------------+ | master | The current master environment ID. | +---------------------+---------------------------------------------+ | master_changes | The number of times the master has changed. | +---------------------+---------------------------------------------+ | max_lease_sec | The number of seconds of the longest lease | | | (the total lease time is max_lease_sec plus | | | max_lease_usec). | +---------------------+---------------------------------------------+ | max_lease_usec | The number of microseconds of the longest | | | lease (the total lease time is | | | max_lease_sec plus max_lease_usec). | +---------------------+---------------------------------------------+ | max_perm_lsn | The LSN of the maximum permanent log | | | record, or 0 if there are no permanent log | | | records. | +---------------------+---------------------------------------------+ | msgs_badgen | The number of messages received with a bad | | | generation number. | +---------------------+---------------------------------------------+ | msgs_processed | The number of messages received and | | | processed. | +---------------------+---------------------------------------------+ | msgs_recover | The number of messages ignored due to | | | pending recovery. | +---------------------+---------------------------------------------+ | msgs_send_failures | The number of failed message sends. | +---------------------+---------------------------------------------+ | msgs_sent | The number of messages sent. | +---------------------+---------------------------------------------+ | newsites | The number of new site messages received. | +---------------------+---------------------------------------------+ | next_lsn | In replication environments configured as | | | masters, the next LSN expected. In | | | replication environments configured as | | | clients, the next LSN to be used. | +---------------------+---------------------------------------------+ | next_pg | The next page number we expect to receive. | +---------------------+---------------------------------------------+ | nsites | The number of sites used in the last | | | election. | +---------------------+---------------------------------------------+ | nthrottles | Transmission limited. This indicates the | | | number of times that data transmission was | | | stopped to limit the amount of data sent in | | | response to a single call to | | | DB_ENV->rep_process_message. | +---------------------+---------------------------------------------+ | outdated | The number of outdated conditions detected. | +---------------------+---------------------------------------------+ | pg_duplicated | The number of duplicate pages received. | +---------------------+---------------------------------------------+ | pg_records | The number of pages received and stored. | +---------------------+---------------------------------------------+ | pg_requested | The number of pages missed and requested | | | from the master. | +---------------------+---------------------------------------------+ | startsync_delayed | The number of times the client had to delay | | | the start of a cache flush operation | | | (initiated by the master for an impending | | | checkpoint) because it was missing some | | | previous log record(s). | +---------------------+---------------------------------------------+ | startup_complete | The client site has completed its startup | | | procedures and is now handling live records | | | from the master. | +---------------------+---------------------------------------------+ | status |The current replication mode. Set to | | | DB_REP_MASTER if the environment is a | | | replication master, DB_REP_CLIENT if the | | | environment is a replication client, or 0 | | | if replication is not configured. | +---------------------+---------------------------------------------+ | txns_applied | The number of transactions applied. | +---------------------+---------------------------------------------+ | waiting_lsn | The LSN of the first log record we have | | | after missing log records being waited for, | | | or 0 if no log records are currently | | | missing. | +---------------------+---------------------------------------------+ | waiting_pg | The page number of the first page we have | | | after missing pages being waited for, or 0 | | | if no pages are currently missing. | +---------------------+---------------------------------------------+ :OracleAPIC:`More info... ` .. function:: rep_stat_print(flags=0) Displays the replication subsystem statistical information. :OracleAPIC:`More info... ` bsddb3-6.2.7/docs/dbsite.rst0000644000175000017500000000254113316226204015452 0ustar jceajcea00000000000000========== DBSite ========== Read :Oracle:`Oracle documentation ` for better understanding. You use the DB_SITE handle to configure and manage replication sites. :OracleAPIC:`More info... ` DBSite Methods ------------------ .. function:: close(flags=0) Close a DBSite handle. :OracleAPIC:`More info... ` .. function:: get_address() Returns a replication site's network address. That is, this method returns a tuple with the site's hostname and port. :OracleAPIC:`More info... ` .. function:: get_config() Returns whether the specified which parameter is currently set. :OracleAPIC:`More info... ` .. function:: get_eid() Returns a replication site's Environment ID (EID). :OracleAPIC:`More info... ` .. function:: remove() Removes the site from the replication group. If called at the master site, repmgr updates the membership database directly. If called from a client, this method causes a request to be sent to the master to perform the operation. The method then awaits confirmation. :OracleAPIC:`More info... ` .. function:: set_config(which, value) Configures a replication site. :OracleAPIC:`More info... ` bsddb3-6.2.7/docs/html/0000775000175000017500000000000013617133045014416 5ustar jceajcea00000000000000bsddb3-6.2.7/docs/html/contents.html0000664000175000017500000002337413617125467017163 0ustar jceajcea00000000000000 Python Bindings for Berkeley DB 4.7, 4.8, 5.1, 5.3, 6.1 and 6.2 — PyBSDDB 6.2.7 documentation

Python Bindings for Berkeley DB 4.7, 4.8, 5.1, 5.3, 6.1 and 6.2

Introduction

This handcrafted package contains Python wrappers for Berkeley DB, the Open Source embedded database system. Berkeley DB is a programmatic toolkit that provides high-performance built-in database support for desktop and server applications.

The Berkeley DB access methods include B+tree, Extended Linear Hashing, Fixed and Variable-length records, and Queues. Berkeley DB provides full transactional support, database recovery, online backups, multi-threaded and multi-process access, etc.

The Python wrappers allow you to store Python string objects of any length, keyed either by strings or integers depending on the database access method. With the use of another module in the package standard shelve-like functionality is provided allowing you to store any picklable Python object!

Berkeley DB is very powerful and versatile, but it is complex to use correctly. Oracle documentation is very complete. Please, review it.

Since June 2013 (release 6.0.0), this project accepts donations. Please, contribute if you can. Details.

©2008-2020 Jesus Cea Avion. | Powered by Sphinx 2.3.1 & Alabaster 0.7.12
bsddb3-6.2.7/docs/html/dbsequence.html0000664000175000017500000003304213617125467017435 0ustar jceajcea00000000000000 DBSequence — PyBSDDB 6.2.7 documentation

DBSequence

Read Oracle documentation for better understanding.

Sequences provide an arbitrary number of persistent objects that return an increasing or decreasing sequence of integers. Opening a sequence handle associates it with a record in a database. The handle can maintain a cache of values from the database so that a database update is not needed as the application allocates a value.

More info…

DBSequence Methods

DBSequence(db, flags=0)

Constructor. More info…

open(key, txn=None, flags=0)

Opens the sequence represented by the key. More info…

close(flags=0)

Close a DBSequence handle. More info…

initial_value(value)

Set the initial value for a sequence. This call is only effective when the sequence is being created. More info…

get(delta=1, txn=None, flags=0)

Returns the next available element in the sequence and changes the sequence value by delta. More info…

get_dbp()

Returns the DB object associated to the DBSequence. More info…

get_key()

Returns the key for the sequence. More info…

remove(txn=None, flags=0)

Removes the sequence from the database. This method should not be called if there are other open handles on this sequence. More info…

get_cachesize()

Returns the current cache size. More info…

set_cachesize(size)

Configure the number of elements cached by a sequence handle. More info…

get_flags()

Returns the current flags. More info…

set_flags(flags)

Configure a sequence. More info…

stat(flags=0)

Returns a dictionary of sequence statistics with the following keys:

wait

The number of times a thread of control was forced to wait on the handle mutex.

nowait

The number of times that a thread of control was able to obtain handle mutex without waiting.

current

The current value of the sequence in the database.

value

The current cached value of the sequence.

last_value

The last cached value of the sequence.

min

The minimum permitted value of the sequence.

max

The maximum permitted value of the sequence.

cache_size

The number of values that will be cached in this handle.

flags

The flags value for the sequence.

More info…

stat_print(flags=0)

Prints diagnostic information. More info…

get_range()

Returns a tuple representing the range of values in the sequence. More info…

set_range((min, max))

Configure a sequence range. More info…

©2008-2020 Jesus Cea Avion. | Powered by Sphinx 2.3.1 & Alabaster 0.7.12
bsddb3-6.2.7/docs/html/search.html0000664000175000017500000000773313617125467016574 0ustar jceajcea00000000000000 Search — PyBSDDB 6.2.7 documentation

Search

Please activate JavaScript to enable the search functionality.

From here you can search these documents. Enter your search words into the box below and click "search". Note that the search function will automatically search for all of the words. Pages containing fewer words won't appear in the result list.

©2008-2020 Jesus Cea Avion. | Powered by Sphinx 2.3.1 & Alabaster 0.7.12
bsddb3-6.2.7/docs/html/dbcursor.html0000664000175000017500000005371213617125467017150 0ustar jceajcea00000000000000 DBCursor — PyBSDDB 6.2.7 documentation

DBCursor

Read Oracle documentation for better understanding.

More info…

DBCursor Methods

close()

Discards the cursor. If the cursor is created within a transaction then you must be sure to close the cursor before commiting the transaction. More info…

count(flags=0)

Returns a count of the number of duplicate data items for the key referenced by the cursor. More info…

delete(flags=0)

Deletes the key/data pair currently referenced by the cursor. More info…

dup(flags=0)

Create a new cursor. More info…

set_priority(priority)

Set the cache priority for pages referenced by the DBC handle. More info…

get_priority()

Returns the cache priority for pages referenced by the DBC handle. More info…

put(key, data, flags=0, dlen=-1, doff=-1)

Stores the key/data pair into the database. Partial data records can be written using dlen and doff. More info…

get(flags, dlen=-1, doff=-1)

See get(key, data, flags, dlen=-1, doff=-1) below.

get(key, flags, dlen=-1, doff=-1)

See get(key, data, flags, dlen=-1, doff=-1) below.

get(key, data, flags, dlen=-1, doff=-1)

Retrieves key/data pairs from the database using the cursor. All the specific functionalities of the get method are actually provided by the various methods below, which are the preferred way to fetch data using the cursor. These generic interfaces are only provided as an inconvenience. Partial data records are returned if dlen and doff are used in this method and in many of the specific methods below. More info…

pget(flags, dlen=-1, doff=-1)

See pget(key, data, flags, dlen=-1, doff=-1) below.

pget(key, flags, dlen=-1, doff=-1)

See pget(key, data, flags, dlen=-1, doff=-1) below.

pget(key, data, flags, dlen=-1, doff=-1)

Similar to the already described get(). This method is available only on secondary databases. It will return the primary key, given the secondary one, and associated data More info…

DBCursor Get Methods

These DBCursor methods are all wrappers around the get() function in the C API.

current(flags=0, dlen=-1, doff=-1)

Returns the key/data pair currently referenced by the cursor. More info…

get_current_size()

Returns length of the data for the current entry referenced by the cursor.

first(flags=0, dlen=-1, doff=-1)

Position the cursor to the first key/data pair and return it. More info…

last(flags=0, dlen=-1, doff=-1)

Position the cursor to the last key/data pair and return it. More info…

next(flags=0, dlen=-1, doff=-1)

Position the cursor to the next key/data pair and return it. More info…

prev(flags=0, dlen=-1, doff=-1)

Position the cursor to the previous key/data pair and return it. More info…

consume(flags=0, dlen=-1, doff=-1)

For a database with the Queue access method, returns the record number and data from the first available record and deletes it from the queue.

NOTE: This method is deprecated in Berkeley DB version 3.2 in favor of the new consume method in the DB class.

get_both(key, data, flags=0)

Like set() but positions the cursor to the record matching both key and data. (An alias for this is set_both, which makes more sense to me…) More info…

get_recno()

Return the record number associated with the cursor. The database must use the BTree access method and have been created with the DB_RECNUM flag. More info…

join_item(flags=0)

For cursors returned from the DB.join method, returns the combined key value from the joined cursors. More info…

next_dup(flags=0, dlen=-1, doff=-1)

If the next key/data pair of the database is a duplicate record for the current key/data pair, the cursor is moved to the next key/data pair of the database, and that pair is returned. More info…

next_nodup(flags=0, dlen=-1, doff=-1)

The cursor is moved to the next non-duplicate key/data pair of the database, and that pair is returned. More info…

prev_dup(flags=0, dlen=-1, doff=-1)

If the previous key/data pair of the database is a duplicate data record for the current key/data pair, the cursor is moved to the previous key/data pair of the database, and that pair is returned. More info…

prev_nodup(flags=0, dlen=-1, doff=-1)

The cursor is moved to the previous non-duplicate key/data pair of the database, and that pair is returned. More info…

set(key, flags=0, dlen=-1, doff=-1)

Move the cursor to the specified key in the database and return the key/data pair found there. More info…

set_range(key, flags=0, dlen=-1, doff=-1)

Identical to set() except that in the case of the BTree access method, the returned key/data pair is the smallest key greater than or equal to the specified key (as determined by the comparison function), permitting partial key matches and range searches. More info…

set_recno(recno, flags=0, dlen=-1, doff=-1)

Move the cursor to the specific numbered record of the database, and return the associated key/data pair. The underlying database must be of type Btree and it must have been created with the DB_RECNUM flag. More info…

set_both(key, data, flags=0)

See get_both(). The only difference in behaviour can be disabled using set_get_returns_none(2). More info…

©2008-2020 Jesus Cea Avion. | Powered by Sphinx 2.3.1 & Alabaster 0.7.12
bsddb3-6.2.7/docs/html/genindex.html0000664000175000017500000007251013617125467017123 0ustar jceajcea00000000000000 Index — PyBSDDB 6.2.7 documentation

Index

A | C | D | E | F | G | H | I | J | K | L | M | N | O | P | R | S | T | U | V

A

C

D

E

F

G

H

I

J

K

L

M

N

O

P

R

S

T

U

V

©2008-2020 Jesus Cea Avion. | Powered by Sphinx 2.3.1 & Alabaster 0.7.12
bsddb3-6.2.7/docs/html/db.html0000664000175000017500000014465113617125467015715 0ustar jceajcea00000000000000 DB — PyBSDDB 6.2.7 documentation

DB

Read Oracle documentation for better understanding.

More info…

DB Methods

DB(dbEnv=None, flags=0)

Constructor. More info…

append(data, txn=None)

A convenient version of put() that can be used for Recno or Queue databases. The DB_APPEND flag is automatically used, and the record number is returned. More info…

associate(secondaryDB, callback, flags=0, txn=None)

Used to associate secondaryDB to act as a secondary index for this (primary) database. The callback parameter should be a reference to a Python callable object that will construct and return the secondary key or DB_DONOTINDEX if the item should not be indexed. The parameters the callback will receive are the primaryKey and primaryData values. More info…

close(flags=0)

Flushes cached data and closes the database. More info…

compact(start=None, stop=None, flags=0,
compact_fillpercent=0, compact_pages=0, compact_timeout=0)

Compacts Btree and Recno access method databases, and optionally returns unused Btree, Hash or Recno database pages to the underlying filesystem.

The method returns the number of pages returned to the filesystem. More info…

consume(txn=None, flags=0)

For a database with the Queue access method, returns the record number and data from the first available record and deletes it from the queue. More info…

consume_wait(txn=None, flags=0)

For a database with the Queue access method, returns the record number and data from the first available record and deletes it from the queue. If the Queue database is empty, the thread of control will wait until there is data in the queue before returning. More info…

cursor(txn=None, flags=0)

Create a cursor on the DB and returns a DBCursor object. If a transaction is passed then the cursor can only be used within that transaction and you must be sure to close the cursor before commiting the transaction. More info…

delete(key, txn=None, flags=0)

Removes a key/data pair from the database. More info…

exists(key, txn=None, flags=0)

Test if a key exists in the database. Returns True or False. More info…

fd()

Returns a file descriptor for the database. More info…

get(key, default=None, txn=None, flags=0, dlen=-1, doff=-1)

Returns the data object associated with key. If key is an integer then the DB_SET_RECNO flag is automatically set for BTree databases and the actual key and the data value are returned as a tuple. If default is given then it is returned if the key is not found in the database. Partial records can be read using dlen and doff, however be sure to not read beyond the end of the actual data or you may get garbage. More info…

pget(key, default=None, txn=None, flags=0, dlen=-1, doff=-1)

This method is available only on secondary databases. It will return the primary key, given the secondary one, and associated data. More info…

get_transactional()

Returns True if the database is transactional. False if not. More info…

get_priority()

Returns the cache priority for pages referenced by the DB handle. This priority value is set using the DB->set_priority() method. More info…

set_priority(priority)

Set the cache priority for pages referenced by the DB handle.

The priority of a page biases the replacement algorithm to be more or less likely to discard a page when space is needed in the buffer pool. The bias is temporary, and pages will eventually be discarded if they are not referenced again. The DB->set_priority() method is only advisory, and does not guarantee pages will be treated in a specific way.

The value provided must be symbolic. Check the Oracle documentation.

More info…

get_dbname()

Returns a tuple with the filename and the database name. If there is no database name, the value returned will be None. More info…

get_open_flags()

Returns the current open method flags. That is, this method returns the flags that were specified when DB->open() was called. More info…

set_private(object)

Link an object to the DB object. This allows to pass around an arbitrary object. For instance, for callback context.

get_private()

Give the object linked to the DB.

get_both(key, data, txn=None, flags=0)

A convenient version of get() that automatically sets the DB_GET_BOTH flag, and which will be successful only if both the key and data value are found in the database. (Can be used to verify the presence of a record in the database when duplicate keys are allowed.) More info…

get_byteswapped()

May be used to determine if the database was created on a machine with the same endianess as the current machine. More info…

get_size(key, txn=None)

Return the size of the data object associated with key.

get_type()

Return the database’s access method type. More info…

join(cursorList, flags=0)

Create and return a specialized cursor for use in performing joins on secondary indices. More info…

key_range(key, txn=None, flags=0)

Returns an estimate of the proportion of keys that are less than, equal to and greater than the specified key. More info…

open(filename, dbname=None, dbtype=DB_UNKNOWN, flags=0, mode=0660, txn=None)

Opens the database named dbname in the file named filename. The dbname argument is optional and allows applications to have multiple logical databases in a single physical file. It is an error to attempt to open a second database in a file that was not initially created using a database name. In-memory databases never intended to be shared or preserved on disk may be created by setting both the filename and dbname arguments to None. More info…

put(key, data, txn=None, flags=0, dlen=-1, doff=-1)

Stores the key/data pair in the database. If the DB_APPEND flag is used and the database is using the Recno or Queue access method then the record number allocated to the data is returned. Partial data objects can be written using dlen and doff. More info…

remove(filename, dbname=None, flags=0)

Remove a database. More info…

rename(filename, dbname, newname, flags=0)

Rename a database. More info…

set_encrypt(passwd, flags=0)

Set the password used by the Berkeley DB library to perform encryption and decryption. Because databases opened within Berkeley DB environments use the password specified to the environment, it is an error to attempt to set a password in a database created within an environment. More info…

get_encrypt_flags()

Returns the encryption flags. More info…

set_bt_compare(compareFunc)

Set the B-Tree database comparison function. This can only be called once before the database has been opened. compareFunc takes two arguments: (left key string, right key string) It must return a -1, 0, 1 integer similar to cmp. You can shoot your database in the foot, beware! Read the Berkeley DB docs for the full details of how the comparison function MUST behave. More info…

get_bt_minkey()

Returns the minimum number of key/data pairs intended to be stored on any single Btree leaf page. This value can be set using the DB->set_bt_minkey() method. More info…

set_bt_minkey(minKeys)

Set the minimum number of keys that will be stored on any single BTree page. More info…

set_cachesize(gbytes, bytes, ncache=0)

Set the size of the database’s shared memory buffer pool. More info…

get_cachesize()

Returns a tuple with the current size and composition of the cache. More info…

set_dup_compare(compareFunc)

Set the duplicate data item comparison function. This can only be called once before the database has been opened. compareFunc takes two arguments: (left key string, right key string) It must return a -1, 0, 1 integer similar to cmp. You can shoot your database in the foot, beware! Read the Berkeley DB docs for the full details of how the comparison function MUST behave. More info…

set_get_returns_none(flag)

Controls what get and related methods do when a key is not found.

See the DBEnv set_get_returns_none documentation.

The previous setting is returned.

get_flags()

Returns the current database flags as set by the DB->set_flags() method. More info…

set_flags(flags)

Set additional flags on the database before opening. More info…

get_h_ffactor()

Returns the hash table density as set by the DB->set_h_ffactor() method. More info…

set_h_ffactor(ffactor)

Set the desired density within the hash table. More info…

get_h_nelem()

Returns the estimate of the final size of the hash table as set by the DB->set_h_nelem() method. More info…

set_h_nelem(nelem)

Set an estimate of the final size of the hash table. More info…

get_lorder()

Returns the database byte order; a byte order of 4,321 indicates a big endian order, and a byte order of 1,234 indicates a little endian order. This value is set using the DB->set_lorder() method. More info…

set_lorder(lorder)

Set the byte order for integers in the stored database metadata. More info…

get_pagesize()

Returns the database’s current page size, as set by the DB->set_pagesize() method. More info…

set_pagesize(pagesize)

Set the size of the pages used to hold items in the database, in bytes. More info…

get_re_delim()

Returns the delimiting byte, which is used to mark the end of a record in the backing source file for the Recno access method. The return value will be a numeric byte value. More info…

set_re_delim(delim)

Set the delimiting byte used to mark the end of a record in the backing source file for the Recno access method. You can specify a char or a numeric byte value. More info…

get_re_len()

Returns the length of the records held in a Queue access method database. This value can be set using the DB->set_re_len() method. More info…

set_re_len(length)

For the Queue access method, specify that the records are of length length. For the Recno access method, specify that the records are fixed-length, not byte delimited, and are of length length. More info…

get_re_pad()

Returns the pad character used for short, fixed-length records used by the Queue and Recno access methods. The method returns a byte value. More info…

set_re_pad(pad)

Set the padding character for short, fixed-length records for the Queue and Recno access methods. You can specify a char or a numeric byte value. More info…

get_re_source()

Returns the source file used by the Recno access method. This file is configured for the Recno access method using the DB->set_re_source() method. More info…

set_re_source(source)

Set the underlying source file for the Recno access method. More info…

get_q_extentsize()

Returns the number of pages in an extent. This value is used only for Queue databases and is set using the DB->set_q_extentsize() method. More info…

set_q_extentsize(extentsize)

Set the size of the extents used to hold pages in a Queue database, specified as a number of pages. Each extent is created as a separate physical file. If no extent size is set, the default behavior is to create only a single underlying database file. More info…

stat(flags=0, txn=None)

Return a dictionary containing database statistics with the following keys.

For Hash databases:

magic

Magic number that identifies the file as a Hash database.

version

Version of the Hash database.

nkeys

Number of unique keys in the database.

ndata

Number of key/data pairs in the database.

pagecnt

The number of pages in the database.

pagesize

Underlying Hash database page (& bucket) size.

nelem

Estimated size of the hash table specified at database creation time.

ffactor

Desired fill factor (number of items per bucket) specified at database creation time.

buckets

Number of hash buckets.

free

Number of pages on the free list.

bfree

Number of bytes free on bucket pages.

bigpages

Number of big key/data pages.

big_bfree

Number of bytes free on big item pages.

overflows

Number of overflow pages (overflow pages are pages that contain items that did not fit in the main bucket page).

ovfl_free

Number of bytes free on overflow pages.

dup

Number of duplicate pages.

dup_free

Number of bytes free on duplicate pages.

For BTree and Recno databases:

magic

Magic number that identifies the file as a Btree database.

version

Version of the Btree database.

nkeys

For the Btree Access Method, the number of unique keys in the database.

For the Recno Access Method, the number of records in the database. If the database has been configured to not re-number records during deletion, the number of records may include records that have been deleted.

ndata

For the Btree Access Method, the number of key/data pairs in the database.

For the Recno Access Method, the number of records in the database. If the database has been configured to not re-number records during deletion, the number of records may include records that have been deleted.

pagecnt

The number of pages in the database.

pagesize

Underlying database page size.

minkey

Minimum keys per page.

re_len

Length of fixed-length records.

re_pad

Padding byte value for fixed-length records.

levels

Number of levels in the database.

int_pg

Number of database internal pages.

leaf_pg

Number of database leaf pages.

dup_pg

Number of database duplicate pages.

over_pg

Number of database overflow pages.

empty_pg

Number of empty database pages.

free

Number of pages on the free list.

int_pgfree

Num of bytes free in database internal pages.

leaf_pgfree

Number of bytes free in database leaf pages.

dup_pgfree

Num bytes free in database duplicate pages.

over_pgfree

Num of bytes free in database overflow pages.

For Queue databases:

magic

Magic number that identifies the file as a Queue database.

version

Version of the Queue file type.

nkeys

Number of records in the database.

ndata

Number of records in the database.

pagesize

Underlying database page size.

extentsize

Underlying database extent size, in pages.

pages

Number of pages in the database.

re_len

Length of the records.

re_pad

Padding byte value for the records.

pgfree

Number of bytes free in database pages.

first_recno

First undeleted record in the database.

cur_recno

Last allocated record number in the database.

More info…

stat_print(flags=0)

Displays the database statistical information. More info…

sync(flags=0)

Flushes any cached information to disk. More info…

truncate(txn=None, flags=0)

Empties the database, discarding all records it contains. The number of records discarded from the database is returned. More info…

upgrade(filename, flags=0)

Upgrades all of the databases included in the file filename, if necessary. More info…

verify(filename, dbname=None, outfile=None, flags=0)

Verifies the integrity of all databases in the file specified by the filename argument, and optionally outputs the databases’ key/data pairs to a file. More info…

DB Mapping and Compatibility Methods

These methods of the DB type are for implementing the Mapping Interface, as well as others for making a DB behave as much like a dictionary as possible. The main downside to using a DB as a dictionary is you are not able to specify a transaction object.

DB_length() [ usage: len(db) ]

Return the number of key/data pairs in the database.

DB_subscript(key) [ usage: db[key] ]

Return the data associated with key.

DB_ass_sub(key, data) [ usage: db[key] = data ]

Assign or update a key/data pair, or delete a key/data pair if data is NULL.

keys(txn=None)

Return a list of all keys in the database. Warning: this method traverses the entire database so it can possibly take a long time to complete.

items(txn=None)

Return a list of tuples of all key/data pairs in the database. Warning: this method traverses the entire database so it can possibly take a long time to complete.

values(txn=None)

Return a list of all data values in the database. Warning: this method traverses the entire database so it can possibly take a long time to complete.

has_key(key, txn=None)

Returns true if key is present in the database.

©2008-2020 Jesus Cea Avion. | Powered by Sphinx 2.3.1 & Alabaster 0.7.12
bsddb3-6.2.7/docs/html/dbsite.html0000664000175000017500000001677113617125467016603 0ustar jceajcea00000000000000 DBSite — PyBSDDB 6.2.7 documentation

DBSite

Read Oracle documentation for better understanding.

You use the DB_SITE handle to configure and manage replication sites.

More info…

DBSite Methods

close(flags=0)

Close a DBSite handle. More info…

get_address()

Returns a replication site’s network address. That is, this method returns a tuple with the site’s hostname and port. More info…

get_config()

Returns whether the specified which parameter is currently set. More info…

get_eid()

Returns a replication site’s Environment ID (EID). More info…

remove()

Removes the site from the replication group. If called at the master site, repmgr updates the membership database directly. If called from a client, this method causes a request to be sent to the master to perform the operation. The method then awaits confirmation. More info…

set_config(which, value)

Configures a replication site. More info…

©2008-2020 Jesus Cea Avion. | Powered by Sphinx 2.3.1 & Alabaster 0.7.12
bsddb3-6.2.7/docs/html/images/0000775000175000017500000000000013617133045015663 5ustar jceajcea00000000000000bsddb3-6.2.7/docs/html/images/bitcoin.png0000664000175000017500000000207713316226203020021 0ustar jceajcea00000000000000PNG  IHDRL\sRGBbKGD pHYs+tIME X4%IDATxn0 EÀ'tܧaul Hq `0ݧ/<jM{>/xyWW#>Q s~o>2Q5F *R 69:T~IENDB`bsddb3-6.2.7/docs/html/dblogcursor.html0000664000175000017500000002117013617125467017643 0ustar jceajcea00000000000000 DBLogCursor — PyBSDDB 6.2.7 documentation

DBLogCursor

Read Oracle documentation for better understanding.

More info…

DBLogCursor Methods

close()

Discards the log cursor. More info…

DBLogCursor Get Methods

These DBLogCursor methods are all wrappers around the get() function in the C API.

These functions returns a tuple. The first element is a LSN tuple, and the second element is a string/bytes with the log data.

If the following methods don’t have log data to return, they return None.

current()

Return the log record to which the log currently refers. More info…

first()

The first record from any of the log files found in the log directory is returned.

This method will return None if the log is empty.

More info…

last()

The last record in the log is returned.

This method will return None if the log is empty.

More info…

next()

The current log position is advanced to the next record in the log, and that record is returned. If the cursor position was not set previously, it will return the first record in the log.

This method will return None if the log is empty.

More info…

prev()

The current log position is advanced to the previous record in the log, and that record is returned. If the cursor position was not set previously, it will return the last record in the log.

This method will return None if the log is empty.

More info…

set(lsn)

Retrieve the record specified by the lsn parameter.

More info…

©2008-2020 Jesus Cea Avion. | Powered by Sphinx 2.3.1 & Alabaster 0.7.12
bsddb3-6.2.7/docs/html/dbtxn.html0000664000175000017500000002154313617125467016441 0ustar jceajcea00000000000000 DBTxn — PyBSDDB 6.2.7 documentation

DBTxn

Read Oracle documentation for better understanding.

More info…

DBTxn Methods

abort()

Aborts the transaction More info…

commit(flags=0)

Ends the transaction, committing any changes to the databases. More info…

id()

The txn_id function returns the unique transaction id associated with the specified transaction. More info…

prepare(gid)

Initiates the beginning of a two-phase commit. A global identifier parameter is required, which is a value unique across all processes involved in the commit. It must be a string of DB_GID_SIZE bytes. More info…

discard()

This method frees up all the per-process resources associated with the specified transaction, neither committing nor aborting the transaction. The transaction will be keep in “unresolved” state. This call may be used only after calls to “dbenv.txn_recover()”. A “unresolved” transaction will be returned again thru new calls to “dbenv.txn_recover()”.

For example, when there are multiple global transaction managers recovering transactions in a single Berkeley DB environment, any transactions returned by “dbenv.txn_recover()” that are not handled by the current global transaction manager should be discarded using “txn.discard()”.

More info…

set_timeout(timeout, flags)

Sets timeout values for locks or transactions for the specified transaction. More info…

get_name(name)

Returns the string associated with the transaction. More info…

set_name(name)

Associates the specified string with the transaction. More info…

©2008-2020 Jesus Cea Avion. | Powered by Sphinx 2.3.1 & Alabaster 0.7.12
bsddb3-6.2.7/docs/html/static/0000775000175000017500000000000013617133045015705 5ustar jceajcea00000000000000bsddb3-6.2.7/docs/html/static/pygments.css0000664000175000017500000001127613617125465020303 0ustar jceajcea00000000000000.highlight .hll { background-color: #ffffcc } .highlight { background: #f8f8f8; } .highlight .c { color: #8f5902; font-style: italic } /* Comment */ .highlight .err { color: #a40000; border: 1px solid #ef2929 } /* Error */ .highlight .g { color: #000000 } /* Generic */ .highlight .k { color: #004461; font-weight: bold } /* Keyword */ .highlight .l { color: #000000 } /* Literal */ .highlight .n { color: #000000 } /* Name */ .highlight .o { color: #582800 } /* Operator */ .highlight .x { color: #000000 } /* Other */ .highlight .p { color: #000000; font-weight: bold } /* Punctuation */ .highlight .ch { color: #8f5902; font-style: italic } /* Comment.Hashbang */ .highlight .cm { color: #8f5902; font-style: italic } /* Comment.Multiline */ .highlight .cp { color: #8f5902 } /* Comment.Preproc */ .highlight .cpf { color: #8f5902; font-style: italic } /* Comment.PreprocFile */ .highlight .c1 { color: #8f5902; font-style: italic } /* Comment.Single */ .highlight .cs { color: #8f5902; font-style: italic } /* Comment.Special */ .highlight .gd { color: #a40000 } /* Generic.Deleted */ .highlight .ge { color: #000000; font-style: italic } /* Generic.Emph */ .highlight .gr { color: #ef2929 } /* Generic.Error */ .highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */ .highlight .gi { color: #00A000 } /* Generic.Inserted */ .highlight .go { color: #888888 } /* Generic.Output */ .highlight .gp { color: #745334 } /* Generic.Prompt */ .highlight .gs { color: #000000; font-weight: bold } /* Generic.Strong */ .highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */ .highlight .gt { color: #a40000; font-weight: bold } /* Generic.Traceback */ .highlight .kc { color: #004461; font-weight: bold } /* Keyword.Constant */ .highlight .kd { color: #004461; font-weight: bold } /* Keyword.Declaration */ .highlight .kn { color: #004461; font-weight: bold } /* Keyword.Namespace */ .highlight .kp { color: #004461; font-weight: bold } /* Keyword.Pseudo */ .highlight .kr { color: #004461; font-weight: bold } /* Keyword.Reserved */ .highlight .kt { color: #004461; font-weight: bold } /* Keyword.Type */ .highlight .ld { color: #000000 } /* Literal.Date */ .highlight .m { color: #990000 } /* Literal.Number */ .highlight .s { color: #4e9a06 } /* Literal.String */ .highlight .na { color: #c4a000 } /* Name.Attribute */ .highlight .nb { color: #004461 } /* Name.Builtin */ .highlight .nc { color: #000000 } /* Name.Class */ .highlight .no { color: #000000 } /* Name.Constant */ .highlight .nd { color: #888888 } /* Name.Decorator */ .highlight .ni { color: #ce5c00 } /* Name.Entity */ .highlight .ne { color: #cc0000; font-weight: bold } /* Name.Exception */ .highlight .nf { color: #000000 } /* Name.Function */ .highlight .nl { color: #f57900 } /* Name.Label */ .highlight .nn { color: #000000 } /* Name.Namespace */ .highlight .nx { color: #000000 } /* Name.Other */ .highlight .py { color: #000000 } /* Name.Property */ .highlight .nt { color: #004461; font-weight: bold } /* Name.Tag */ .highlight .nv { color: #000000 } /* Name.Variable */ .highlight .ow { color: #004461; font-weight: bold } /* Operator.Word */ .highlight .w { color: #f8f8f8; text-decoration: underline } /* Text.Whitespace */ .highlight .mb { color: #990000 } /* Literal.Number.Bin */ .highlight .mf { color: #990000 } /* Literal.Number.Float */ .highlight .mh { color: #990000 } /* Literal.Number.Hex */ .highlight .mi { color: #990000 } /* Literal.Number.Integer */ .highlight .mo { color: #990000 } /* Literal.Number.Oct */ .highlight .sa { color: #4e9a06 } /* Literal.String.Affix */ .highlight .sb { color: #4e9a06 } /* Literal.String.Backtick */ .highlight .sc { color: #4e9a06 } /* Literal.String.Char */ .highlight .dl { color: #4e9a06 } /* Literal.String.Delimiter */ .highlight .sd { color: #8f5902; font-style: italic } /* Literal.String.Doc */ .highlight .s2 { color: #4e9a06 } /* Literal.String.Double */ .highlight .se { color: #4e9a06 } /* Literal.String.Escape */ .highlight .sh { color: #4e9a06 } /* Literal.String.Heredoc */ .highlight .si { color: #4e9a06 } /* Literal.String.Interpol */ .highlight .sx { color: #4e9a06 } /* Literal.String.Other */ .highlight .sr { color: #4e9a06 } /* Literal.String.Regex */ .highlight .s1 { color: #4e9a06 } /* Literal.String.Single */ .highlight .ss { color: #4e9a06 } /* Literal.String.Symbol */ .highlight .bp { color: #3465a4 } /* Name.Builtin.Pseudo */ .highlight .fm { color: #000000 } /* Name.Function.Magic */ .highlight .vc { color: #000000 } /* Name.Variable.Class */ .highlight .vg { color: #000000 } /* Name.Variable.Global */ .highlight .vi { color: #000000 } /* Name.Variable.Instance */ .highlight .vm { color: #000000 } /* Name.Variable.Magic */ .highlight .il { color: #990000 } /* Literal.Number.Integer.Long */bsddb3-6.2.7/docs/html/static/doctools.js0000664000175000017500000002206613600252535020075 0ustar jceajcea00000000000000/* * doctools.js * ~~~~~~~~~~~ * * Sphinx JavaScript utilities for all documentation. * * :copyright: Copyright 2007-2019 by the Sphinx team, see AUTHORS. * :license: BSD, see LICENSE for details. * */ /** * select a different prefix for underscore */ $u = _.noConflict(); /** * make the code below compatible with browsers without * an installed firebug like debugger if (!window.console || !console.firebug) { var names = ["log", "debug", "info", "warn", "error", "assert", "dir", "dirxml", "group", "groupEnd", "time", "timeEnd", "count", "trace", "profile", "profileEnd"]; window.console = {}; for (var i = 0; i < names.length; ++i) window.console[names[i]] = function() {}; } */ /** * small helper function to urldecode strings */ jQuery.urldecode = function(x) { return decodeURIComponent(x).replace(/\+/g, ' '); }; /** * small helper function to urlencode strings */ jQuery.urlencode = encodeURIComponent; /** * This function returns the parsed url parameters of the * current request. Multiple values per key are supported, * it will always return arrays of strings for the value parts. */ jQuery.getQueryParameters = function(s) { if (typeof s === 'undefined') s = document.location.search; var parts = s.substr(s.indexOf('?') + 1).split('&'); var result = {}; for (var i = 0; i < parts.length; i++) { var tmp = parts[i].split('=', 2); var key = jQuery.urldecode(tmp[0]); var value = jQuery.urldecode(tmp[1]); if (key in result) result[key].push(value); else result[key] = [value]; } return result; }; /** * highlight a given string on a jquery object by wrapping it in * span elements with the given class name. */ jQuery.fn.highlightText = function(text, className) { function highlight(node, addItems) { if (node.nodeType === 3) { var val = node.nodeValue; var pos = val.toLowerCase().indexOf(text); if (pos >= 0 && !jQuery(node.parentNode).hasClass(className) && !jQuery(node.parentNode).hasClass("nohighlight")) { var span; var isInSVG = jQuery(node).closest("body, svg, foreignObject").is("svg"); if (isInSVG) { span = document.createElementNS("http://www.w3.org/2000/svg", "tspan"); } else { span = document.createElement("span"); span.className = className; } span.appendChild(document.createTextNode(val.substr(pos, text.length))); node.parentNode.insertBefore(span, node.parentNode.insertBefore( document.createTextNode(val.substr(pos + text.length)), node.nextSibling)); node.nodeValue = val.substr(0, pos); if (isInSVG) { var rect = document.createElementNS("http://www.w3.org/2000/svg", "rect"); var bbox = node.parentElement.getBBox(); rect.x.baseVal.value = bbox.x; rect.y.baseVal.value = bbox.y; rect.width.baseVal.value = bbox.width; rect.height.baseVal.value = bbox.height; rect.setAttribute('class', className); addItems.push({ "parent": node.parentNode, "target": rect}); } } } else if (!jQuery(node).is("button, select, textarea")) { jQuery.each(node.childNodes, function() { highlight(this, addItems); }); } } var addItems = []; var result = this.each(function() { highlight(this, addItems); }); for (var i = 0; i < addItems.length; ++i) { jQuery(addItems[i].parent).before(addItems[i].target); } return result; }; /* * backward compatibility for jQuery.browser * This will be supported until firefox bug is fixed. */ if (!jQuery.browser) { jQuery.uaMatch = function(ua) { ua = ua.toLowerCase(); var match = /(chrome)[ \/]([\w.]+)/.exec(ua) || /(webkit)[ \/]([\w.]+)/.exec(ua) || /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) || /(msie) ([\w.]+)/.exec(ua) || ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) || []; return { browser: match[ 1 ] || "", version: match[ 2 ] || "0" }; }; jQuery.browser = {}; jQuery.browser[jQuery.uaMatch(navigator.userAgent).browser] = true; } /** * Small JavaScript module for the documentation. */ var Documentation = { init : function() { this.fixFirefoxAnchorBug(); this.highlightSearchWords(); this.initIndexTable(); if (DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) { this.initOnKeyListeners(); } }, /** * i18n support */ TRANSLATIONS : {}, PLURAL_EXPR : function(n) { return n === 1 ? 0 : 1; }, LOCALE : 'unknown', // gettext and ngettext don't access this so that the functions // can safely bound to a different name (_ = Documentation.gettext) gettext : function(string) { var translated = Documentation.TRANSLATIONS[string]; if (typeof translated === 'undefined') return string; return (typeof translated === 'string') ? translated : translated[0]; }, ngettext : function(singular, plural, n) { var translated = Documentation.TRANSLATIONS[singular]; if (typeof translated === 'undefined') return (n == 1) ? singular : plural; return translated[Documentation.PLURALEXPR(n)]; }, addTranslations : function(catalog) { for (var key in catalog.messages) this.TRANSLATIONS[key] = catalog.messages[key]; this.PLURAL_EXPR = new Function('n', 'return +(' + catalog.plural_expr + ')'); this.LOCALE = catalog.locale; }, /** * add context elements like header anchor links */ addContextElements : function() { $('div[id] > :header:first').each(function() { $('\u00B6'). attr('href', '#' + this.id). attr('title', _('Permalink to this headline')). appendTo(this); }); $('dt[id]').each(function() { $('\u00B6'). attr('href', '#' + this.id). attr('title', _('Permalink to this definition')). appendTo(this); }); }, /** * workaround a firefox stupidity * see: https://bugzilla.mozilla.org/show_bug.cgi?id=645075 */ fixFirefoxAnchorBug : function() { if (document.location.hash && $.browser.mozilla) window.setTimeout(function() { document.location.href += ''; }, 10); }, /** * highlight the search words provided in the url in the text */ highlightSearchWords : function() { var params = $.getQueryParameters(); var terms = (params.highlight) ? params.highlight[0].split(/\s+/) : []; if (terms.length) { var body = $('div.body'); if (!body.length) { body = $('body'); } window.setTimeout(function() { $.each(terms, function() { body.highlightText(this.toLowerCase(), 'highlighted'); }); }, 10); $('

' + _('Hide Search Matches') + '

') .appendTo($('#searchbox')); } }, /** * init the domain index toggle buttons */ initIndexTable : function() { var togglers = $('img.toggler').click(function() { var src = $(this).attr('src'); var idnum = $(this).attr('id').substr(7); $('tr.cg-' + idnum).toggle(); if (src.substr(-9) === 'minus.png') $(this).attr('src', src.substr(0, src.length-9) + 'plus.png'); else $(this).attr('src', src.substr(0, src.length-8) + 'minus.png'); }).css('display', ''); if (DOCUMENTATION_OPTIONS.COLLAPSE_INDEX) { togglers.click(); } }, /** * helper function to hide the search marks again */ hideSearchWords : function() { $('#searchbox .highlight-link').fadeOut(300); $('span.highlighted').removeClass('highlighted'); }, /** * make the url absolute */ makeURL : function(relativeURL) { return DOCUMENTATION_OPTIONS.URL_ROOT + '/' + relativeURL; }, /** * get the current relative url */ getCurrentURL : function() { var path = document.location.pathname; var parts = path.split(/\//); $.each(DOCUMENTATION_OPTIONS.URL_ROOT.split(/\//), function() { if (this === '..') parts.pop(); }); var url = parts.join('/'); return path.substring(url.lastIndexOf('/') + 1, path.length - 1); }, initOnKeyListeners: function() { $(document).keyup(function(event) { var activeElementType = document.activeElement.tagName; // don't navigate when in search box or textarea if (activeElementType !== 'TEXTAREA' && activeElementType !== 'INPUT' && activeElementType !== 'SELECT') { switch (event.keyCode) { case 37: // left var prevHref = $('link[rel="prev"]').prop('href'); if (prevHref) { window.location.href = prevHref; return false; } case 39: // right var nextHref = $('link[rel="next"]').prop('href'); if (nextHref) { window.location.href = nextHref; return false; } } } }); } }; // quick alias for translations _ = Documentation.gettext; $(document).ready(function() { Documentation.init(); }); bsddb3-6.2.7/docs/html/static/plus.png0000664000175000017500000000013213600252535017370 0ustar jceajcea00000000000000PNG  IHDR (!IDATxc8 g>@;([[U @l-!a@IENDB`bsddb3-6.2.7/docs/html/static/basic.css0000664000175000017500000002774513617125465017526 0ustar jceajcea00000000000000/* * basic.css * ~~~~~~~~~ * * Sphinx stylesheet -- basic theme. * * :copyright: Copyright 2007-2019 by the Sphinx team, see AUTHORS. * :license: BSD, see LICENSE for details. * */ /* -- main layout ----------------------------------------------------------- */ div.clearer { clear: both; } /* -- relbar ---------------------------------------------------------------- */ div.related { width: 100%; font-size: 90%; } div.related h3 { display: none; } div.related ul { margin: 0; padding: 0 0 0 10px; list-style: none; } div.related li { display: inline; } div.related li.right { float: right; margin-right: 5px; } /* -- sidebar --------------------------------------------------------------- */ div.sphinxsidebarwrapper { padding: 10px 5px 0 10px; } div.sphinxsidebar { float: left; width: 230px; margin-left: -100%; font-size: 90%; word-wrap: break-word; overflow-wrap : break-word; } div.sphinxsidebar ul { list-style: none; } div.sphinxsidebar ul ul, div.sphinxsidebar ul.want-points { margin-left: 20px; list-style: square; } div.sphinxsidebar ul ul { margin-top: 0; margin-bottom: 0; } div.sphinxsidebar form { margin-top: 10px; } div.sphinxsidebar input { border: 1px solid #98dbcc; font-family: sans-serif; font-size: 1em; } div.sphinxsidebar #searchbox form.search { overflow: hidden; } div.sphinxsidebar #searchbox input[type="text"] { float: left; width: 80%; padding: 0.25em; box-sizing: border-box; } div.sphinxsidebar #searchbox input[type="submit"] { float: left; width: 20%; border-left: none; padding: 0.25em; box-sizing: border-box; } img { border: 0; max-width: 100%; } /* -- search page ----------------------------------------------------------- */ ul.search { margin: 10px 0 0 20px; padding: 0; } ul.search li { padding: 5px 0 5px 20px; background-image: url(file.png); background-repeat: no-repeat; background-position: 0 7px; } ul.search li a { font-weight: bold; } ul.search li div.context { color: #888; margin: 2px 0 0 30px; text-align: left; } ul.keywordmatches li.goodmatch a { font-weight: bold; } /* -- index page ------------------------------------------------------------ */ table.contentstable { width: 90%; margin-left: auto; margin-right: auto; } table.contentstable p.biglink { line-height: 150%; } a.biglink { font-size: 1.3em; } span.linkdescr { font-style: italic; padding-top: 5px; font-size: 90%; } /* -- general index --------------------------------------------------------- */ table.indextable { width: 100%; } table.indextable td { text-align: left; vertical-align: top; } table.indextable ul { margin-top: 0; margin-bottom: 0; list-style-type: none; } table.indextable > tbody > tr > td > ul { padding-left: 0em; } table.indextable tr.pcap { height: 10px; } table.indextable tr.cap { margin-top: 10px; background-color: #f2f2f2; } img.toggler { margin-right: 3px; margin-top: 3px; cursor: pointer; } div.modindex-jumpbox { border-top: 1px solid #ddd; border-bottom: 1px solid #ddd; margin: 1em 0 1em 0; padding: 0.4em; } div.genindex-jumpbox { border-top: 1px solid #ddd; border-bottom: 1px solid #ddd; margin: 1em 0 1em 0; padding: 0.4em; } /* -- domain module index --------------------------------------------------- */ table.modindextable td { padding: 2px; border-collapse: collapse; } /* -- general body styles --------------------------------------------------- */ div.body { min-width: 450px; max-width: 800px; } div.body p, div.body dd, div.body li, div.body blockquote { -moz-hyphens: auto; -ms-hyphens: auto; -webkit-hyphens: auto; hyphens: auto; } a.headerlink { visibility: hidden; } a.brackets:before, span.brackets > a:before{ content: "["; } a.brackets:after, span.brackets > a:after { content: "]"; } h1:hover > a.headerlink, h2:hover > a.headerlink, h3:hover > a.headerlink, h4:hover > a.headerlink, h5:hover > a.headerlink, h6:hover > a.headerlink, dt:hover > a.headerlink, caption:hover > a.headerlink, p.caption:hover > a.headerlink, div.code-block-caption:hover > a.headerlink { visibility: visible; } div.body p.caption { text-align: inherit; } div.body td { text-align: left; } .first { margin-top: 0 !important; } p.rubric { margin-top: 30px; font-weight: bold; } img.align-left, .figure.align-left, object.align-left { clear: left; float: left; margin-right: 1em; } img.align-right, .figure.align-right, object.align-right { clear: right; float: right; margin-left: 1em; } img.align-center, .figure.align-center, object.align-center { display: block; margin-left: auto; margin-right: auto; } img.align-default, .figure.align-default { display: block; margin-left: auto; margin-right: auto; } .align-left { text-align: left; } .align-center { text-align: center; } .align-default { text-align: center; } .align-right { text-align: right; } /* -- sidebars -------------------------------------------------------------- */ div.sidebar { margin: 0 0 0.5em 1em; border: 1px solid #ddb; padding: 7px 7px 0 7px; background-color: #ffe; width: 40%; float: right; } p.sidebar-title { font-weight: bold; } /* -- topics ---------------------------------------------------------------- */ div.topic { border: 1px solid #ccc; padding: 7px 7px 0 7px; margin: 10px 0 10px 0; } p.topic-title { font-size: 1.1em; font-weight: bold; margin-top: 10px; } /* -- admonitions ----------------------------------------------------------- */ div.admonition { margin-top: 10px; margin-bottom: 10px; padding: 7px; } div.admonition dt { font-weight: bold; } div.admonition dl { margin-bottom: 0; } p.admonition-title { margin: 0px 10px 5px 0px; font-weight: bold; } div.body p.centered { text-align: center; margin-top: 25px; } /* -- tables ---------------------------------------------------------------- */ table.docutils { border: 0; border-collapse: collapse; } table.align-center { margin-left: auto; margin-right: auto; } table.align-default { margin-left: auto; margin-right: auto; } table caption span.caption-number { font-style: italic; } table caption span.caption-text { } table.docutils td, table.docutils th { padding: 1px 8px 1px 5px; border-top: 0; border-left: 0; border-right: 0; border-bottom: 1px solid #aaa; } table.footnote td, table.footnote th { border: 0 !important; } th { text-align: left; padding-right: 5px; } table.citation { border-left: solid 1px gray; margin-left: 1px; } table.citation td { border-bottom: none; } th > p:first-child, td > p:first-child { margin-top: 0px; } th > p:last-child, td > p:last-child { margin-bottom: 0px; } /* -- figures --------------------------------------------------------------- */ div.figure { margin: 0.5em; padding: 0.5em; } div.figure p.caption { padding: 0.3em; } div.figure p.caption span.caption-number { font-style: italic; } div.figure p.caption span.caption-text { } /* -- field list styles ----------------------------------------------------- */ table.field-list td, table.field-list th { border: 0 !important; } .field-list ul { margin: 0; padding-left: 1em; } .field-list p { margin: 0; } .field-name { -moz-hyphens: manual; -ms-hyphens: manual; -webkit-hyphens: manual; hyphens: manual; } /* -- hlist styles ---------------------------------------------------------- */ table.hlist td { vertical-align: top; } /* -- other body styles ----------------------------------------------------- */ ol.arabic { list-style: decimal; } ol.loweralpha { list-style: lower-alpha; } ol.upperalpha { list-style: upper-alpha; } ol.lowerroman { list-style: lower-roman; } ol.upperroman { list-style: upper-roman; } li > p:first-child { margin-top: 0px; } li > p:last-child { margin-bottom: 0px; } dl.footnote > dt, dl.citation > dt { float: left; } dl.footnote > dd, dl.citation > dd { margin-bottom: 0em; } dl.footnote > dd:after, dl.citation > dd:after { content: ""; clear: both; } dl.field-list { display: grid; grid-template-columns: fit-content(30%) auto; } dl.field-list > dt { font-weight: bold; word-break: break-word; padding-left: 0.5em; padding-right: 5px; } dl.field-list > dt:after { content: ":"; } dl.field-list > dd { padding-left: 0.5em; margin-top: 0em; margin-left: 0em; margin-bottom: 0em; } dl { margin-bottom: 15px; } dd > p:first-child { margin-top: 0px; } dd ul, dd table { margin-bottom: 10px; } dd { margin-top: 3px; margin-bottom: 10px; margin-left: 30px; } dt:target, span.highlighted { background-color: #fbe54e; } rect.highlighted { fill: #fbe54e; } dl.glossary dt { font-weight: bold; font-size: 1.1em; } .optional { font-size: 1.3em; } .sig-paren { font-size: larger; } .versionmodified { font-style: italic; } .system-message { background-color: #fda; padding: 5px; border: 3px solid red; } .footnote:target { background-color: #ffa; } .line-block { display: block; margin-top: 1em; margin-bottom: 1em; } .line-block .line-block { margin-top: 0; margin-bottom: 0; margin-left: 1.5em; } .guilabel, .menuselection { font-family: sans-serif; } .accelerator { text-decoration: underline; } .classifier { font-style: oblique; } .classifier:before { font-style: normal; margin: 0.5em; content: ":"; } abbr, acronym { border-bottom: dotted 1px; cursor: help; } /* -- code displays --------------------------------------------------------- */ pre { overflow: auto; overflow-y: hidden; /* fixes display issues on Chrome browsers */ } span.pre { -moz-hyphens: none; -ms-hyphens: none; -webkit-hyphens: none; hyphens: none; } td.linenos pre { padding: 5px 0px; border: 0; background-color: transparent; color: #aaa; } table.highlighttable { margin-left: 0.5em; } table.highlighttable td { padding: 0 0.5em 0 0.5em; } div.code-block-caption { padding: 2px 5px; font-size: small; } div.code-block-caption code { background-color: transparent; } div.code-block-caption + div > div.highlight > pre { margin-top: 0; } div.doctest > div.highlight span.gp { /* gp: Generic.Prompt */ user-select: none; } div.code-block-caption span.caption-number { padding: 0.1em 0.3em; font-style: italic; } div.code-block-caption span.caption-text { } div.literal-block-wrapper { padding: 1em 1em 0; } div.literal-block-wrapper div.highlight { margin: 0; } code.descname { background-color: transparent; font-weight: bold; font-size: 1.2em; } code.descclassname { background-color: transparent; } code.xref, a code { background-color: transparent; font-weight: bold; } h1 code, h2 code, h3 code, h4 code, h5 code, h6 code { background-color: transparent; } .viewcode-link { float: right; } .viewcode-back { float: right; font-family: sans-serif; } div.viewcode-block:target { margin: -1px -10px; padding: 0 10px; } /* -- math display ---------------------------------------------------------- */ img.math { vertical-align: middle; } div.body div.math p { text-align: center; } span.eqno { float: right; } span.eqno a.headerlink { position: relative; left: 0px; z-index: 1; } div.math:hover a.headerlink { visibility: visible; } /* -- printout stylesheet --------------------------------------------------- */ @media print { div.document, div.documentwrapper, div.bodywrapper { margin: 0 !important; width: 100%; } div.sphinxsidebar, div.related, div.footer, #top-link { display: none; } }bsddb3-6.2.7/docs/html/static/custom.css0000664000175000017500000000005213553344306017731 0ustar jceajcea00000000000000/* This file intentionally left blank. */ bsddb3-6.2.7/docs/html/static/minus.png0000664000175000017500000000013213600252535017540 0ustar jceajcea00000000000000PNG  IHDR (!IDATxc8 g>@;(!&]f2nNIENDB`bsddb3-6.2.7/docs/html/static/language_data.js0000664000175000017500000002513713617125465021036 0ustar jceajcea00000000000000/* * language_data.js * ~~~~~~~~~~~~~~~~ * * This script contains the language-specific data used by searchtools.js, * namely the list of stopwords, stemmer, scorer and splitter. * * :copyright: Copyright 2007-2019 by the Sphinx team, see AUTHORS. * :license: BSD, see LICENSE for details. * */ var stopwords = ["a","and","are","as","at","be","but","by","for","if","in","into","is","it","near","no","not","of","on","or","such","that","the","their","then","there","these","they","this","to","was","will","with"]; /* Non-minified version JS is _stemmer.js if file is provided */ /** * Porter Stemmer */ var Stemmer = function() { var step2list = { ational: 'ate', tional: 'tion', enci: 'ence', anci: 'ance', izer: 'ize', bli: 'ble', alli: 'al', entli: 'ent', eli: 'e', ousli: 'ous', ization: 'ize', ation: 'ate', ator: 'ate', alism: 'al', iveness: 'ive', fulness: 'ful', ousness: 'ous', aliti: 'al', iviti: 'ive', biliti: 'ble', logi: 'log' }; var step3list = { icate: 'ic', ative: '', alize: 'al', iciti: 'ic', ical: 'ic', ful: '', ness: '' }; var c = "[^aeiou]"; // consonant var v = "[aeiouy]"; // vowel var C = c + "[^aeiouy]*"; // consonant sequence var V = v + "[aeiou]*"; // vowel sequence var mgr0 = "^(" + C + ")?" + V + C; // [C]VC... is m>0 var meq1 = "^(" + C + ")?" + V + C + "(" + V + ")?$"; // [C]VC[V] is m=1 var mgr1 = "^(" + C + ")?" + V + C + V + C; // [C]VCVC... is m>1 var s_v = "^(" + C + ")?" + v; // vowel in stem this.stemWord = function (w) { var stem; var suffix; var firstch; var origword = w; if (w.length < 3) return w; var re; var re2; var re3; var re4; firstch = w.substr(0,1); if (firstch == "y") w = firstch.toUpperCase() + w.substr(1); // Step 1a re = /^(.+?)(ss|i)es$/; re2 = /^(.+?)([^s])s$/; if (re.test(w)) w = w.replace(re,"$1$2"); else if (re2.test(w)) w = w.replace(re2,"$1$2"); // Step 1b re = /^(.+?)eed$/; re2 = /^(.+?)(ed|ing)$/; if (re.test(w)) { var fp = re.exec(w); re = new RegExp(mgr0); if (re.test(fp[1])) { re = /.$/; w = w.replace(re,""); } } else if (re2.test(w)) { var fp = re2.exec(w); stem = fp[1]; re2 = new RegExp(s_v); if (re2.test(stem)) { w = stem; re2 = /(at|bl|iz)$/; re3 = new RegExp("([^aeiouylsz])\\1$"); re4 = new RegExp("^" + C + v + "[^aeiouwxy]$"); if (re2.test(w)) w = w + "e"; else if (re3.test(w)) { re = /.$/; w = w.replace(re,""); } else if (re4.test(w)) w = w + "e"; } } // Step 1c re = /^(.+?)y$/; if (re.test(w)) { var fp = re.exec(w); stem = fp[1]; re = new RegExp(s_v); if (re.test(stem)) w = stem + "i"; } // Step 2 re = /^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/; if (re.test(w)) { var fp = re.exec(w); stem = fp[1]; suffix = fp[2]; re = new RegExp(mgr0); if (re.test(stem)) w = stem + step2list[suffix]; } // Step 3 re = /^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/; if (re.test(w)) { var fp = re.exec(w); stem = fp[1]; suffix = fp[2]; re = new RegExp(mgr0); if (re.test(stem)) w = stem + step3list[suffix]; } // Step 4 re = /^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/; re2 = /^(.+?)(s|t)(ion)$/; if (re.test(w)) { var fp = re.exec(w); stem = fp[1]; re = new RegExp(mgr1); if (re.test(stem)) w = stem; } else if (re2.test(w)) { var fp = re2.exec(w); stem = fp[1] + fp[2]; re2 = new RegExp(mgr1); if (re2.test(stem)) w = stem; } // Step 5 re = /^(.+?)e$/; if (re.test(w)) { var fp = re.exec(w); stem = fp[1]; re = new RegExp(mgr1); re2 = new RegExp(meq1); re3 = new RegExp("^" + C + v + "[^aeiouwxy]$"); if (re.test(stem) || (re2.test(stem) && !(re3.test(stem)))) w = stem; } re = /ll$/; re2 = new RegExp(mgr1); if (re.test(w) && re2.test(w)) { re = /.$/; w = w.replace(re,""); } // and turn initial Y back to y if (firstch == "y") w = firstch.toLowerCase() + w.substr(1); return w; } } var splitChars = (function() { var result = {}; var singles = [96, 180, 187, 191, 215, 247, 749, 885, 903, 907, 909, 930, 1014, 1648, 1748, 1809, 2416, 2473, 2481, 2526, 2601, 2609, 2612, 2615, 2653, 2702, 2706, 2729, 2737, 2740, 2857, 2865, 2868, 2910, 2928, 2948, 2961, 2971, 2973, 3085, 3089, 3113, 3124, 3213, 3217, 3241, 3252, 3295, 3341, 3345, 3369, 3506, 3516, 3633, 3715, 3721, 3736, 3744, 3748, 3750, 3756, 3761, 3781, 3912, 4239, 4347, 4681, 4695, 4697, 4745, 4785, 4799, 4801, 4823, 4881, 5760, 5901, 5997, 6313, 7405, 8024, 8026, 8028, 8030, 8117, 8125, 8133, 8181, 8468, 8485, 8487, 8489, 8494, 8527, 11311, 11359, 11687, 11695, 11703, 11711, 11719, 11727, 11735, 12448, 12539, 43010, 43014, 43019, 43587, 43696, 43713, 64286, 64297, 64311, 64317, 64319, 64322, 64325, 65141]; var i, j, start, end; for (i = 0; i < singles.length; i++) { result[singles[i]] = true; } var ranges = [[0, 47], [58, 64], [91, 94], [123, 169], [171, 177], [182, 184], [706, 709], [722, 735], [741, 747], [751, 879], [888, 889], [894, 901], [1154, 1161], [1318, 1328], [1367, 1368], [1370, 1376], [1416, 1487], [1515, 1519], [1523, 1568], [1611, 1631], [1642, 1645], [1750, 1764], [1767, 1773], [1789, 1790], [1792, 1807], [1840, 1868], [1958, 1968], [1970, 1983], [2027, 2035], [2038, 2041], [2043, 2047], [2070, 2073], [2075, 2083], [2085, 2087], [2089, 2307], [2362, 2364], [2366, 2383], [2385, 2391], [2402, 2405], [2419, 2424], [2432, 2436], [2445, 2446], [2449, 2450], [2483, 2485], [2490, 2492], [2494, 2509], [2511, 2523], [2530, 2533], [2546, 2547], [2554, 2564], [2571, 2574], [2577, 2578], [2618, 2648], [2655, 2661], [2672, 2673], [2677, 2692], [2746, 2748], [2750, 2767], [2769, 2783], [2786, 2789], [2800, 2820], [2829, 2830], [2833, 2834], [2874, 2876], [2878, 2907], [2914, 2917], [2930, 2946], [2955, 2957], [2966, 2968], [2976, 2978], [2981, 2983], [2987, 2989], [3002, 3023], [3025, 3045], [3059, 3076], [3130, 3132], [3134, 3159], [3162, 3167], [3170, 3173], [3184, 3191], [3199, 3204], [3258, 3260], [3262, 3293], [3298, 3301], [3312, 3332], [3386, 3388], [3390, 3423], [3426, 3429], [3446, 3449], [3456, 3460], [3479, 3481], [3518, 3519], [3527, 3584], [3636, 3647], [3655, 3663], [3674, 3712], [3717, 3718], [3723, 3724], [3726, 3731], [3752, 3753], [3764, 3772], [3774, 3775], [3783, 3791], [3802, 3803], [3806, 3839], [3841, 3871], [3892, 3903], [3949, 3975], [3980, 4095], [4139, 4158], [4170, 4175], [4182, 4185], [4190, 4192], [4194, 4196], [4199, 4205], [4209, 4212], [4226, 4237], [4250, 4255], [4294, 4303], [4349, 4351], [4686, 4687], [4702, 4703], [4750, 4751], [4790, 4791], [4806, 4807], [4886, 4887], [4955, 4968], [4989, 4991], [5008, 5023], [5109, 5120], [5741, 5742], [5787, 5791], [5867, 5869], [5873, 5887], [5906, 5919], [5938, 5951], [5970, 5983], [6001, 6015], [6068, 6102], [6104, 6107], [6109, 6111], [6122, 6127], [6138, 6159], [6170, 6175], [6264, 6271], [6315, 6319], [6390, 6399], [6429, 6469], [6510, 6511], [6517, 6527], [6572, 6592], [6600, 6607], [6619, 6655], [6679, 6687], [6741, 6783], [6794, 6799], [6810, 6822], [6824, 6916], [6964, 6980], [6988, 6991], [7002, 7042], [7073, 7085], [7098, 7167], [7204, 7231], [7242, 7244], [7294, 7400], [7410, 7423], [7616, 7679], [7958, 7959], [7966, 7967], [8006, 8007], [8014, 8015], [8062, 8063], [8127, 8129], [8141, 8143], [8148, 8149], [8156, 8159], [8173, 8177], [8189, 8303], [8306, 8307], [8314, 8318], [8330, 8335], [8341, 8449], [8451, 8454], [8456, 8457], [8470, 8472], [8478, 8483], [8506, 8507], [8512, 8516], [8522, 8525], [8586, 9311], [9372, 9449], [9472, 10101], [10132, 11263], [11493, 11498], [11503, 11516], [11518, 11519], [11558, 11567], [11622, 11630], [11632, 11647], [11671, 11679], [11743, 11822], [11824, 12292], [12296, 12320], [12330, 12336], [12342, 12343], [12349, 12352], [12439, 12444], [12544, 12548], [12590, 12592], [12687, 12689], [12694, 12703], [12728, 12783], [12800, 12831], [12842, 12880], [12896, 12927], [12938, 12976], [12992, 13311], [19894, 19967], [40908, 40959], [42125, 42191], [42238, 42239], [42509, 42511], [42540, 42559], [42592, 42593], [42607, 42622], [42648, 42655], [42736, 42774], [42784, 42785], [42889, 42890], [42893, 43002], [43043, 43055], [43062, 43071], [43124, 43137], [43188, 43215], [43226, 43249], [43256, 43258], [43260, 43263], [43302, 43311], [43335, 43359], [43389, 43395], [43443, 43470], [43482, 43519], [43561, 43583], [43596, 43599], [43610, 43615], [43639, 43641], [43643, 43647], [43698, 43700], [43703, 43704], [43710, 43711], [43715, 43738], [43742, 43967], [44003, 44015], [44026, 44031], [55204, 55215], [55239, 55242], [55292, 55295], [57344, 63743], [64046, 64047], [64110, 64111], [64218, 64255], [64263, 64274], [64280, 64284], [64434, 64466], [64830, 64847], [64912, 64913], [64968, 65007], [65020, 65135], [65277, 65295], [65306, 65312], [65339, 65344], [65371, 65381], [65471, 65473], [65480, 65481], [65488, 65489], [65496, 65497]]; for (i = 0; i < ranges.length; i++) { start = ranges[i][0]; end = ranges[i][1]; for (j = start; j <= end; j++) { result[j] = true; } } return result; })(); function splitQuery(query) { var result = []; var start = -1; for (var i = 0; i < query.length; i++) { if (splitChars[query.charCodeAt(i)]) { if (start !== -1) { result.push(query.slice(start, i)); start = -1; } } else if (start === -1) { start = i; } } if (start !== -1) { result.push(query.slice(start)); } return result; } bsddb3-6.2.7/docs/html/static/searchtools.js0000664000175000017500000003723513600252535020601 0ustar jceajcea00000000000000/* * searchtools.js * ~~~~~~~~~~~~~~~~ * * Sphinx JavaScript utilities for the full-text search. * * :copyright: Copyright 2007-2019 by the Sphinx team, see AUTHORS. * :license: BSD, see LICENSE for details. * */ if (!Scorer) { /** * Simple result scoring code. */ var Scorer = { // Implement the following function to further tweak the score for each result // The function takes a result array [filename, title, anchor, descr, score] // and returns the new score. /* score: function(result) { return result[4]; }, */ // query matches the full name of an object objNameMatch: 11, // or matches in the last dotted part of the object name objPartialMatch: 6, // Additive scores depending on the priority of the object objPrio: {0: 15, // used to be importantResults 1: 5, // used to be objectResults 2: -5}, // used to be unimportantResults // Used when the priority is not in the mapping. objPrioDefault: 0, // query found in title title: 15, partialTitle: 7, // query found in terms term: 5, partialTerm: 2 }; } if (!splitQuery) { function splitQuery(query) { return query.split(/\s+/); } } /** * Search Module */ var Search = { _index : null, _queued_query : null, _pulse_status : -1, htmlToText : function(htmlString) { var htmlElement = document.createElement('span'); htmlElement.innerHTML = htmlString; $(htmlElement).find('.headerlink').remove(); docContent = $(htmlElement).find('[role=main]')[0]; return docContent.textContent || docContent.innerText; }, init : function() { var params = $.getQueryParameters(); if (params.q) { var query = params.q[0]; $('input[name="q"]')[0].value = query; this.performSearch(query); } }, loadIndex : function(url) { $.ajax({type: "GET", url: url, data: null, dataType: "script", cache: true, complete: function(jqxhr, textstatus) { if (textstatus != "success") { document.getElementById("searchindexloader").src = url; } }}); }, setIndex : function(index) { var q; this._index = index; if ((q = this._queued_query) !== null) { this._queued_query = null; Search.query(q); } }, hasIndex : function() { return this._index !== null; }, deferQuery : function(query) { this._queued_query = query; }, stopPulse : function() { this._pulse_status = 0; }, startPulse : function() { if (this._pulse_status >= 0) return; function pulse() { var i; Search._pulse_status = (Search._pulse_status + 1) % 4; var dotString = ''; for (i = 0; i < Search._pulse_status; i++) dotString += '.'; Search.dots.text(dotString); if (Search._pulse_status > -1) window.setTimeout(pulse, 500); } pulse(); }, /** * perform a search for something (or wait until index is loaded) */ performSearch : function(query) { // create the required interface elements this.out = $('#search-results'); this.title = $('

' + _('Searching') + '

').appendTo(this.out); this.dots = $('').appendTo(this.title); this.status = $('

 

').appendTo(this.out); this.output = $('
    ').appendTo(this.out); $('#search-progress').text(_('Preparing search...')); this.startPulse(); // index already loaded, the browser was quick! if (this.hasIndex()) this.query(query); else this.deferQuery(query); }, /** * execute search (requires search index to be loaded) */ query : function(query) { var i; // stem the searchterms and add them to the correct list var stemmer = new Stemmer(); var searchterms = []; var excluded = []; var hlterms = []; var tmp = splitQuery(query); var objectterms = []; for (i = 0; i < tmp.length; i++) { if (tmp[i] !== "") { objectterms.push(tmp[i].toLowerCase()); } if ($u.indexOf(stopwords, tmp[i].toLowerCase()) != -1 || tmp[i].match(/^\d+$/) || tmp[i] === "") { // skip this "word" continue; } // stem the word var word = stemmer.stemWord(tmp[i].toLowerCase()); // prevent stemmer from cutting word smaller than two chars if(word.length < 3 && tmp[i].length >= 3) { word = tmp[i]; } var toAppend; // select the correct list if (word[0] == '-') { toAppend = excluded; word = word.substr(1); } else { toAppend = searchterms; hlterms.push(tmp[i].toLowerCase()); } // only add if not already in the list if (!$u.contains(toAppend, word)) toAppend.push(word); } var highlightstring = '?highlight=' + $.urlencode(hlterms.join(" ")); // console.debug('SEARCH: searching for:'); // console.info('required: ', searchterms); // console.info('excluded: ', excluded); // prepare search var terms = this._index.terms; var titleterms = this._index.titleterms; // array of [filename, title, anchor, descr, score] var results = []; $('#search-progress').empty(); // lookup as object for (i = 0; i < objectterms.length; i++) { var others = [].concat(objectterms.slice(0, i), objectterms.slice(i+1, objectterms.length)); results = results.concat(this.performObjectSearch(objectterms[i], others)); } // lookup as search terms in fulltext results = results.concat(this.performTermsSearch(searchterms, excluded, terms, titleterms)); // let the scorer override scores with a custom scoring function if (Scorer.score) { for (i = 0; i < results.length; i++) results[i][4] = Scorer.score(results[i]); } // now sort the results by score (in opposite order of appearance, since the // display function below uses pop() to retrieve items) and then // alphabetically results.sort(function(a, b) { var left = a[4]; var right = b[4]; if (left > right) { return 1; } else if (left < right) { return -1; } else { // same score: sort alphabetically left = a[1].toLowerCase(); right = b[1].toLowerCase(); return (left > right) ? -1 : ((left < right) ? 1 : 0); } }); // for debugging //Search.lastresults = results.slice(); // a copy //console.info('search results:', Search.lastresults); // print the results var resultCount = results.length; function displayNextItem() { // results left, load the summary and display it if (results.length) { var item = results.pop(); var listItem = $('
  • '); if (DOCUMENTATION_OPTIONS.BUILDER === 'dirhtml') { // dirhtml builder var dirname = item[0] + '/'; if (dirname.match(/\/index\/$/)) { dirname = dirname.substring(0, dirname.length-6); } else if (dirname == 'index/') { dirname = ''; } listItem.append($('').attr('href', DOCUMENTATION_OPTIONS.URL_ROOT + dirname + highlightstring + item[2]).html(item[1])); } else { // normal html builders listItem.append($('').attr('href', item[0] + DOCUMENTATION_OPTIONS.FILE_SUFFIX + highlightstring + item[2]).html(item[1])); } if (item[3]) { listItem.append($(' (' + item[3] + ')')); Search.output.append(listItem); listItem.slideDown(5, function() { displayNextItem(); }); } else if (DOCUMENTATION_OPTIONS.HAS_SOURCE) { $.ajax({url: DOCUMENTATION_OPTIONS.URL_ROOT + item[0] + DOCUMENTATION_OPTIONS.FILE_SUFFIX, dataType: "text", complete: function(jqxhr, textstatus) { var data = jqxhr.responseText; if (data !== '' && data !== undefined) { listItem.append(Search.makeSearchSummary(data, searchterms, hlterms)); } Search.output.append(listItem); listItem.slideDown(5, function() { displayNextItem(); }); }}); } else { // no source available, just display title Search.output.append(listItem); listItem.slideDown(5, function() { displayNextItem(); }); } } // search finished, update title and status message else { Search.stopPulse(); Search.title.text(_('Search Results')); if (!resultCount) Search.status.text(_('Your search did not match any documents. Please make sure that all words are spelled correctly and that you\'ve selected enough categories.')); else Search.status.text(_('Search finished, found %s page(s) matching the search query.').replace('%s', resultCount)); Search.status.fadeIn(500); } } displayNextItem(); }, /** * search for object names */ performObjectSearch : function(object, otherterms) { var filenames = this._index.filenames; var docnames = this._index.docnames; var objects = this._index.objects; var objnames = this._index.objnames; var titles = this._index.titles; var i; var results = []; for (var prefix in objects) { for (var name in objects[prefix]) { var fullname = (prefix ? prefix + '.' : '') + name; var fullnameLower = fullname.toLowerCase() if (fullnameLower.indexOf(object) > -1) { var score = 0; var parts = fullnameLower.split('.'); // check for different match types: exact matches of full name or // "last name" (i.e. last dotted part) if (fullnameLower == object || parts[parts.length - 1] == object) { score += Scorer.objNameMatch; // matches in last name } else if (parts[parts.length - 1].indexOf(object) > -1) { score += Scorer.objPartialMatch; } var match = objects[prefix][name]; var objname = objnames[match[1]][2]; var title = titles[match[0]]; // If more than one term searched for, we require other words to be // found in the name/title/description if (otherterms.length > 0) { var haystack = (prefix + ' ' + name + ' ' + objname + ' ' + title).toLowerCase(); var allfound = true; for (i = 0; i < otherterms.length; i++) { if (haystack.indexOf(otherterms[i]) == -1) { allfound = false; break; } } if (!allfound) { continue; } } var descr = objname + _(', in ') + title; var anchor = match[3]; if (anchor === '') anchor = fullname; else if (anchor == '-') anchor = objnames[match[1]][1] + '-' + fullname; // add custom score for some objects according to scorer if (Scorer.objPrio.hasOwnProperty(match[2])) { score += Scorer.objPrio[match[2]]; } else { score += Scorer.objPrioDefault; } results.push([docnames[match[0]], fullname, '#'+anchor, descr, score, filenames[match[0]]]); } } } return results; }, /** * search for full-text terms in the index */ performTermsSearch : function(searchterms, excluded, terms, titleterms) { var docnames = this._index.docnames; var filenames = this._index.filenames; var titles = this._index.titles; var i, j, file; var fileMap = {}; var scoreMap = {}; var results = []; // perform the search on the required terms for (i = 0; i < searchterms.length; i++) { var word = searchterms[i]; var files = []; var _o = [ {files: terms[word], score: Scorer.term}, {files: titleterms[word], score: Scorer.title} ]; // add support for partial matches if (word.length > 2) { for (var w in terms) { if (w.match(word) && !terms[word]) { _o.push({files: terms[w], score: Scorer.partialTerm}) } } for (var w in titleterms) { if (w.match(word) && !titleterms[word]) { _o.push({files: titleterms[w], score: Scorer.partialTitle}) } } } // no match but word was a required one if ($u.every(_o, function(o){return o.files === undefined;})) { break; } // found search word in contents $u.each(_o, function(o) { var _files = o.files; if (_files === undefined) return if (_files.length === undefined) _files = [_files]; files = files.concat(_files); // set score for the word in each file to Scorer.term for (j = 0; j < _files.length; j++) { file = _files[j]; if (!(file in scoreMap)) scoreMap[file] = {}; scoreMap[file][word] = o.score; } }); // create the mapping for (j = 0; j < files.length; j++) { file = files[j]; if (file in fileMap && fileMap[file].indexOf(word) === -1) fileMap[file].push(word); else fileMap[file] = [word]; } } // now check if the files don't contain excluded terms for (file in fileMap) { var valid = true; // check if all requirements are matched var filteredTermCount = // as search terms with length < 3 are discarded: ignore searchterms.filter(function(term){return term.length > 2}).length if ( fileMap[file].length != searchterms.length && fileMap[file].length != filteredTermCount ) continue; // ensure that none of the excluded terms is in the search result for (i = 0; i < excluded.length; i++) { if (terms[excluded[i]] == file || titleterms[excluded[i]] == file || $u.contains(terms[excluded[i]] || [], file) || $u.contains(titleterms[excluded[i]] || [], file)) { valid = false; break; } } // if we have still a valid result we can add it to the result list if (valid) { // select one (max) score for the file. // for better ranking, we should calculate ranking by using words statistics like basic tf-idf... var score = $u.max($u.map(fileMap[file], function(w){return scoreMap[file][w]})); results.push([docnames[file], titles[file], '', null, score, filenames[file]]); } } return results; }, /** * helper function to return a node containing the * search summary for a given text. keywords is a list * of stemmed words, hlwords is the list of normal, unstemmed * words. the first one is used to find the occurrence, the * latter for highlighting it. */ makeSearchSummary : function(htmlText, keywords, hlwords) { var text = Search.htmlToText(htmlText); var textLower = text.toLowerCase(); var start = 0; $.each(keywords, function() { var i = textLower.indexOf(this.toLowerCase()); if (i > -1) start = i; }); start = Math.max(start - 120, 0); var excerpt = ((start > 0) ? '...' : '') + $.trim(text.substr(start, 240)) + ((start + 240 - text.length) ? '...' : ''); var rv = $('
    ').text(excerpt); $.each(hlwords, function() { rv = rv.highlightText(this, 'highlighted'); }); return rv; } }; $(document).ready(function() { Search.init(); }); bsddb3-6.2.7/docs/html/static/jquery.js0000664000175000017500000025412113600252535017565 0ustar jceajcea00000000000000/*! jQuery v3.4.1 | (c) JS Foundation and other contributors | jquery.org/license */ !function(e,t){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=e.document?t(e,!0):function(e){if(!e.document)throw new Error("jQuery requires a window with a document");return t(e)}:t(e)}("undefined"!=typeof window?window:this,function(C,e){"use strict";var t=[],E=C.document,r=Object.getPrototypeOf,s=t.slice,g=t.concat,u=t.push,i=t.indexOf,n={},o=n.toString,v=n.hasOwnProperty,a=v.toString,l=a.call(Object),y={},m=function(e){return"function"==typeof e&&"number"!=typeof e.nodeType},x=function(e){return null!=e&&e===e.window},c={type:!0,src:!0,nonce:!0,noModule:!0};function b(e,t,n){var r,i,o=(n=n||E).createElement("script");if(o.text=e,t)for(r in c)(i=t[r]||t.getAttribute&&t.getAttribute(r))&&o.setAttribute(r,i);n.head.appendChild(o).parentNode.removeChild(o)}function w(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?n[o.call(e)]||"object":typeof e}var f="3.4.1",k=function(e,t){return new k.fn.init(e,t)},p=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;function d(e){var t=!!e&&"length"in e&&e.length,n=w(e);return!m(e)&&!x(e)&&("array"===n||0===t||"number"==typeof t&&0+~]|"+M+")"+M+"*"),U=new RegExp(M+"|>"),X=new RegExp($),V=new RegExp("^"+I+"$"),G={ID:new RegExp("^#("+I+")"),CLASS:new RegExp("^\\.("+I+")"),TAG:new RegExp("^("+I+"|[*])"),ATTR:new RegExp("^"+W),PSEUDO:new RegExp("^"+$),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+M+"*(even|odd|(([+-]|)(\\d*)n|)"+M+"*(?:([+-]|)"+M+"*(\\d+)|))"+M+"*\\)|)","i"),bool:new RegExp("^(?:"+R+")$","i"),needsContext:new RegExp("^"+M+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+M+"*((?:-\\d)?\\d*)"+M+"*\\)|)(?=[^-]|$)","i")},Y=/HTML$/i,Q=/^(?:input|select|textarea|button)$/i,J=/^h\d$/i,K=/^[^{]+\{\s*\[native \w/,Z=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ee=/[+~]/,te=new RegExp("\\\\([\\da-f]{1,6}"+M+"?|("+M+")|.)","ig"),ne=function(e,t,n){var r="0x"+t-65536;return r!=r||n?t:r<0?String.fromCharCode(r+65536):String.fromCharCode(r>>10|55296,1023&r|56320)},re=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,ie=function(e,t){return t?"\0"===e?"\ufffd":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},oe=function(){T()},ae=be(function(e){return!0===e.disabled&&"fieldset"===e.nodeName.toLowerCase()},{dir:"parentNode",next:"legend"});try{H.apply(t=O.call(m.childNodes),m.childNodes),t[m.childNodes.length].nodeType}catch(e){H={apply:t.length?function(e,t){L.apply(e,O.call(t))}:function(e,t){var n=e.length,r=0;while(e[n++]=t[r++]);e.length=n-1}}}function se(t,e,n,r){var i,o,a,s,u,l,c,f=e&&e.ownerDocument,p=e?e.nodeType:9;if(n=n||[],"string"!=typeof t||!t||1!==p&&9!==p&&11!==p)return n;if(!r&&((e?e.ownerDocument||e:m)!==C&&T(e),e=e||C,E)){if(11!==p&&(u=Z.exec(t)))if(i=u[1]){if(9===p){if(!(a=e.getElementById(i)))return n;if(a.id===i)return n.push(a),n}else if(f&&(a=f.getElementById(i))&&y(e,a)&&a.id===i)return n.push(a),n}else{if(u[2])return H.apply(n,e.getElementsByTagName(t)),n;if((i=u[3])&&d.getElementsByClassName&&e.getElementsByClassName)return H.apply(n,e.getElementsByClassName(i)),n}if(d.qsa&&!A[t+" "]&&(!v||!v.test(t))&&(1!==p||"object"!==e.nodeName.toLowerCase())){if(c=t,f=e,1===p&&U.test(t)){(s=e.getAttribute("id"))?s=s.replace(re,ie):e.setAttribute("id",s=k),o=(l=h(t)).length;while(o--)l[o]="#"+s+" "+xe(l[o]);c=l.join(","),f=ee.test(t)&&ye(e.parentNode)||e}try{return H.apply(n,f.querySelectorAll(c)),n}catch(e){A(t,!0)}finally{s===k&&e.removeAttribute("id")}}}return g(t.replace(B,"$1"),e,n,r)}function ue(){var r=[];return function e(t,n){return r.push(t+" ")>b.cacheLength&&delete e[r.shift()],e[t+" "]=n}}function le(e){return e[k]=!0,e}function ce(e){var t=C.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function fe(e,t){var n=e.split("|"),r=n.length;while(r--)b.attrHandle[n[r]]=t}function pe(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(r)return r;if(n)while(n=n.nextSibling)if(n===t)return-1;return e?1:-1}function de(t){return function(e){return"input"===e.nodeName.toLowerCase()&&e.type===t}}function he(n){return function(e){var t=e.nodeName.toLowerCase();return("input"===t||"button"===t)&&e.type===n}}function ge(t){return function(e){return"form"in e?e.parentNode&&!1===e.disabled?"label"in e?"label"in e.parentNode?e.parentNode.disabled===t:e.disabled===t:e.isDisabled===t||e.isDisabled!==!t&&ae(e)===t:e.disabled===t:"label"in e&&e.disabled===t}}function ve(a){return le(function(o){return o=+o,le(function(e,t){var n,r=a([],e.length,o),i=r.length;while(i--)e[n=r[i]]&&(e[n]=!(t[n]=e[n]))})})}function ye(e){return e&&"undefined"!=typeof e.getElementsByTagName&&e}for(e in d=se.support={},i=se.isXML=function(e){var t=e.namespaceURI,n=(e.ownerDocument||e).documentElement;return!Y.test(t||n&&n.nodeName||"HTML")},T=se.setDocument=function(e){var t,n,r=e?e.ownerDocument||e:m;return r!==C&&9===r.nodeType&&r.documentElement&&(a=(C=r).documentElement,E=!i(C),m!==C&&(n=C.defaultView)&&n.top!==n&&(n.addEventListener?n.addEventListener("unload",oe,!1):n.attachEvent&&n.attachEvent("onunload",oe)),d.attributes=ce(function(e){return e.className="i",!e.getAttribute("className")}),d.getElementsByTagName=ce(function(e){return e.appendChild(C.createComment("")),!e.getElementsByTagName("*").length}),d.getElementsByClassName=K.test(C.getElementsByClassName),d.getById=ce(function(e){return a.appendChild(e).id=k,!C.getElementsByName||!C.getElementsByName(k).length}),d.getById?(b.filter.ID=function(e){var t=e.replace(te,ne);return function(e){return e.getAttribute("id")===t}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n=t.getElementById(e);return n?[n]:[]}}):(b.filter.ID=function(e){var n=e.replace(te,ne);return function(e){var t="undefined"!=typeof e.getAttributeNode&&e.getAttributeNode("id");return t&&t.value===n}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n,r,i,o=t.getElementById(e);if(o){if((n=o.getAttributeNode("id"))&&n.value===e)return[o];i=t.getElementsByName(e),r=0;while(o=i[r++])if((n=o.getAttributeNode("id"))&&n.value===e)return[o]}return[]}}),b.find.TAG=d.getElementsByTagName?function(e,t){return"undefined"!=typeof t.getElementsByTagName?t.getElementsByTagName(e):d.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,r=[],i=0,o=t.getElementsByTagName(e);if("*"===e){while(n=o[i++])1===n.nodeType&&r.push(n);return r}return o},b.find.CLASS=d.getElementsByClassName&&function(e,t){if("undefined"!=typeof t.getElementsByClassName&&E)return t.getElementsByClassName(e)},s=[],v=[],(d.qsa=K.test(C.querySelectorAll))&&(ce(function(e){a.appendChild(e).innerHTML="    ",e.querySelectorAll("[msallowcapture^='']").length&&v.push("[*^$]="+M+"*(?:''|\"\")"),e.querySelectorAll("[selected]").length||v.push("\\["+M+"*(?:value|"+R+")"),e.querySelectorAll("[id~="+k+"-]").length||v.push("~="),e.querySelectorAll(":checked").length||v.push(":checked"),e.querySelectorAll("a#"+k+"+*").length||v.push(".#.+[+~]")}),ce(function(e){e.innerHTML="";var t=C.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&v.push("name"+M+"*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&v.push(":enabled",":disabled"),a.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&v.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),v.push(",.*:")})),(d.matchesSelector=K.test(c=a.matches||a.webkitMatchesSelector||a.mozMatchesSelector||a.oMatchesSelector||a.msMatchesSelector))&&ce(function(e){d.disconnectedMatch=c.call(e,"*"),c.call(e,"[s!='']:x"),s.push("!=",$)}),v=v.length&&new RegExp(v.join("|")),s=s.length&&new RegExp(s.join("|")),t=K.test(a.compareDocumentPosition),y=t||K.test(a.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)while(t=t.parentNode)if(t===e)return!0;return!1},D=t?function(e,t){if(e===t)return l=!0,0;var n=!e.compareDocumentPosition-!t.compareDocumentPosition;return n||(1&(n=(e.ownerDocument||e)===(t.ownerDocument||t)?e.compareDocumentPosition(t):1)||!d.sortDetached&&t.compareDocumentPosition(e)===n?e===C||e.ownerDocument===m&&y(m,e)?-1:t===C||t.ownerDocument===m&&y(m,t)?1:u?P(u,e)-P(u,t):0:4&n?-1:1)}:function(e,t){if(e===t)return l=!0,0;var n,r=0,i=e.parentNode,o=t.parentNode,a=[e],s=[t];if(!i||!o)return e===C?-1:t===C?1:i?-1:o?1:u?P(u,e)-P(u,t):0;if(i===o)return pe(e,t);n=e;while(n=n.parentNode)a.unshift(n);n=t;while(n=n.parentNode)s.unshift(n);while(a[r]===s[r])r++;return r?pe(a[r],s[r]):a[r]===m?-1:s[r]===m?1:0}),C},se.matches=function(e,t){return se(e,null,null,t)},se.matchesSelector=function(e,t){if((e.ownerDocument||e)!==C&&T(e),d.matchesSelector&&E&&!A[t+" "]&&(!s||!s.test(t))&&(!v||!v.test(t)))try{var n=c.call(e,t);if(n||d.disconnectedMatch||e.document&&11!==e.document.nodeType)return n}catch(e){A(t,!0)}return 0":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(te,ne),e[3]=(e[3]||e[4]||e[5]||"").replace(te,ne),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||se.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&se.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return G.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&X.test(n)&&(t=h(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(te,ne).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=p[e+" "];return t||(t=new RegExp("(^|"+M+")"+e+"("+M+"|$)"))&&p(e,function(e){return t.test("string"==typeof e.className&&e.className||"undefined"!=typeof e.getAttribute&&e.getAttribute("class")||"")})},ATTR:function(n,r,i){return function(e){var t=se.attr(e,n);return null==t?"!="===r:!r||(t+="","="===r?t===i:"!="===r?t!==i:"^="===r?i&&0===t.indexOf(i):"*="===r?i&&-1:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;function j(e,n,r){return m(n)?k.grep(e,function(e,t){return!!n.call(e,t,e)!==r}):n.nodeType?k.grep(e,function(e){return e===n!==r}):"string"!=typeof n?k.grep(e,function(e){return-1)[^>]*|#([\w-]+))$/;(k.fn.init=function(e,t,n){var r,i;if(!e)return this;if(n=n||q,"string"==typeof e){if(!(r="<"===e[0]&&">"===e[e.length-1]&&3<=e.length?[null,e,null]:L.exec(e))||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof k?t[0]:t,k.merge(this,k.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:E,!0)),D.test(r[1])&&k.isPlainObject(t))for(r in t)m(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return(i=E.getElementById(r[2]))&&(this[0]=i,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):m(e)?void 0!==n.ready?n.ready(e):e(k):k.makeArray(e,this)}).prototype=k.fn,q=k(E);var H=/^(?:parents|prev(?:Until|All))/,O={children:!0,contents:!0,next:!0,prev:!0};function P(e,t){while((e=e[t])&&1!==e.nodeType);return e}k.fn.extend({has:function(e){var t=k(e,this),n=t.length;return this.filter(function(){for(var e=0;e\x20\t\r\n\f]*)/i,he=/^$|^module$|\/(?:java|ecma)script/i,ge={option:[1,""],thead:[1,"","
    "],col:[2,"","
    "],tr:[2,"","
    "],td:[3,"","
    "],_default:[0,"",""]};function ve(e,t){var n;return n="undefined"!=typeof e.getElementsByTagName?e.getElementsByTagName(t||"*"):"undefined"!=typeof e.querySelectorAll?e.querySelectorAll(t||"*"):[],void 0===t||t&&A(e,t)?k.merge([e],n):n}function ye(e,t){for(var n=0,r=e.length;nx",y.noCloneChecked=!!me.cloneNode(!0).lastChild.defaultValue;var Te=/^key/,Ce=/^(?:mouse|pointer|contextmenu|drag|drop)|click/,Ee=/^([^.]*)(?:\.(.+)|)/;function ke(){return!0}function Se(){return!1}function Ne(e,t){return e===function(){try{return E.activeElement}catch(e){}}()==("focus"===t)}function Ae(e,t,n,r,i,o){var a,s;if("object"==typeof t){for(s in"string"!=typeof n&&(r=r||n,n=void 0),t)Ae(e,s,n,r,t[s],o);return e}if(null==r&&null==i?(i=n,r=n=void 0):null==i&&("string"==typeof n?(i=r,r=void 0):(i=r,r=n,n=void 0)),!1===i)i=Se;else if(!i)return e;return 1===o&&(a=i,(i=function(e){return k().off(e),a.apply(this,arguments)}).guid=a.guid||(a.guid=k.guid++)),e.each(function(){k.event.add(this,t,i,r,n)})}function De(e,i,o){o?(Q.set(e,i,!1),k.event.add(e,i,{namespace:!1,handler:function(e){var t,n,r=Q.get(this,i);if(1&e.isTrigger&&this[i]){if(r.length)(k.event.special[i]||{}).delegateType&&e.stopPropagation();else if(r=s.call(arguments),Q.set(this,i,r),t=o(this,i),this[i](),r!==(n=Q.get(this,i))||t?Q.set(this,i,!1):n={},r!==n)return e.stopImmediatePropagation(),e.preventDefault(),n.value}else r.length&&(Q.set(this,i,{value:k.event.trigger(k.extend(r[0],k.Event.prototype),r.slice(1),this)}),e.stopImmediatePropagation())}})):void 0===Q.get(e,i)&&k.event.add(e,i,ke)}k.event={global:{},add:function(t,e,n,r,i){var o,a,s,u,l,c,f,p,d,h,g,v=Q.get(t);if(v){n.handler&&(n=(o=n).handler,i=o.selector),i&&k.find.matchesSelector(ie,i),n.guid||(n.guid=k.guid++),(u=v.events)||(u=v.events={}),(a=v.handle)||(a=v.handle=function(e){return"undefined"!=typeof k&&k.event.triggered!==e.type?k.event.dispatch.apply(t,arguments):void 0}),l=(e=(e||"").match(R)||[""]).length;while(l--)d=g=(s=Ee.exec(e[l])||[])[1],h=(s[2]||"").split(".").sort(),d&&(f=k.event.special[d]||{},d=(i?f.delegateType:f.bindType)||d,f=k.event.special[d]||{},c=k.extend({type:d,origType:g,data:r,handler:n,guid:n.guid,selector:i,needsContext:i&&k.expr.match.needsContext.test(i),namespace:h.join(".")},o),(p=u[d])||((p=u[d]=[]).delegateCount=0,f.setup&&!1!==f.setup.call(t,r,h,a)||t.addEventListener&&t.addEventListener(d,a)),f.add&&(f.add.call(t,c),c.handler.guid||(c.handler.guid=n.guid)),i?p.splice(p.delegateCount++,0,c):p.push(c),k.event.global[d]=!0)}},remove:function(e,t,n,r,i){var o,a,s,u,l,c,f,p,d,h,g,v=Q.hasData(e)&&Q.get(e);if(v&&(u=v.events)){l=(t=(t||"").match(R)||[""]).length;while(l--)if(d=g=(s=Ee.exec(t[l])||[])[1],h=(s[2]||"").split(".").sort(),d){f=k.event.special[d]||{},p=u[d=(r?f.delegateType:f.bindType)||d]||[],s=s[2]&&new RegExp("(^|\\.)"+h.join("\\.(?:.*\\.|)")+"(\\.|$)"),a=o=p.length;while(o--)c=p[o],!i&&g!==c.origType||n&&n.guid!==c.guid||s&&!s.test(c.namespace)||r&&r!==c.selector&&("**"!==r||!c.selector)||(p.splice(o,1),c.selector&&p.delegateCount--,f.remove&&f.remove.call(e,c));a&&!p.length&&(f.teardown&&!1!==f.teardown.call(e,h,v.handle)||k.removeEvent(e,d,v.handle),delete u[d])}else for(d in u)k.event.remove(e,d+t[l],n,r,!0);k.isEmptyObject(u)&&Q.remove(e,"handle events")}},dispatch:function(e){var t,n,r,i,o,a,s=k.event.fix(e),u=new Array(arguments.length),l=(Q.get(this,"events")||{})[s.type]||[],c=k.event.special[s.type]||{};for(u[0]=s,t=1;t\x20\t\r\n\f]*)[^>]*)\/>/gi,qe=/\s*$/g;function Oe(e,t){return A(e,"table")&&A(11!==t.nodeType?t:t.firstChild,"tr")&&k(e).children("tbody")[0]||e}function Pe(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function Re(e){return"true/"===(e.type||"").slice(0,5)?e.type=e.type.slice(5):e.removeAttribute("type"),e}function Me(e,t){var n,r,i,o,a,s,u,l;if(1===t.nodeType){if(Q.hasData(e)&&(o=Q.access(e),a=Q.set(t,o),l=o.events))for(i in delete a.handle,a.events={},l)for(n=0,r=l[i].length;n")},clone:function(e,t,n){var r,i,o,a,s,u,l,c=e.cloneNode(!0),f=oe(e);if(!(y.noCloneChecked||1!==e.nodeType&&11!==e.nodeType||k.isXMLDoc(e)))for(a=ve(c),r=0,i=(o=ve(e)).length;r").attr(n.scriptAttrs||{}).prop({charset:n.scriptCharset,src:n.url}).on("load error",i=function(e){r.remove(),i=null,e&&t("error"===e.type?404:200,e.type)}),E.head.appendChild(r[0])},abort:function(){i&&i()}}});var Vt,Gt=[],Yt=/(=)\?(?=&|$)|\?\?/;k.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var e=Gt.pop()||k.expando+"_"+kt++;return this[e]=!0,e}}),k.ajaxPrefilter("json jsonp",function(e,t,n){var r,i,o,a=!1!==e.jsonp&&(Yt.test(e.url)?"url":"string"==typeof e.data&&0===(e.contentType||"").indexOf("application/x-www-form-urlencoded")&&Yt.test(e.data)&&"data");if(a||"jsonp"===e.dataTypes[0])return r=e.jsonpCallback=m(e.jsonpCallback)?e.jsonpCallback():e.jsonpCallback,a?e[a]=e[a].replace(Yt,"$1"+r):!1!==e.jsonp&&(e.url+=(St.test(e.url)?"&":"?")+e.jsonp+"="+r),e.converters["script json"]=function(){return o||k.error(r+" was not called"),o[0]},e.dataTypes[0]="json",i=C[r],C[r]=function(){o=arguments},n.always(function(){void 0===i?k(C).removeProp(r):C[r]=i,e[r]&&(e.jsonpCallback=t.jsonpCallback,Gt.push(r)),o&&m(i)&&i(o[0]),o=i=void 0}),"script"}),y.createHTMLDocument=((Vt=E.implementation.createHTMLDocument("").body).innerHTML="
    ",2===Vt.childNodes.length),k.parseHTML=function(e,t,n){return"string"!=typeof e?[]:("boolean"==typeof t&&(n=t,t=!1),t||(y.createHTMLDocument?((r=(t=E.implementation.createHTMLDocument("")).createElement("base")).href=E.location.href,t.head.appendChild(r)):t=E),o=!n&&[],(i=D.exec(e))?[t.createElement(i[1])]:(i=we([e],t,o),o&&o.length&&k(o).remove(),k.merge([],i.childNodes)));var r,i,o},k.fn.load=function(e,t,n){var r,i,o,a=this,s=e.indexOf(" ");return-1").append(k.parseHTML(e)).find(r):e)}).always(n&&function(e,t){a.each(function(){n.apply(this,o||[e.responseText,t,e])})}),this},k.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(e,t){k.fn[t]=function(e){return this.on(t,e)}}),k.expr.pseudos.animated=function(t){return k.grep(k.timers,function(e){return t===e.elem}).length},k.offset={setOffset:function(e,t,n){var r,i,o,a,s,u,l=k.css(e,"position"),c=k(e),f={};"static"===l&&(e.style.position="relative"),s=c.offset(),o=k.css(e,"top"),u=k.css(e,"left"),("absolute"===l||"fixed"===l)&&-1<(o+u).indexOf("auto")?(a=(r=c.position()).top,i=r.left):(a=parseFloat(o)||0,i=parseFloat(u)||0),m(t)&&(t=t.call(e,n,k.extend({},s))),null!=t.top&&(f.top=t.top-s.top+a),null!=t.left&&(f.left=t.left-s.left+i),"using"in t?t.using.call(e,f):c.css(f)}},k.fn.extend({offset:function(t){if(arguments.length)return void 0===t?this:this.each(function(e){k.offset.setOffset(this,t,e)});var e,n,r=this[0];return r?r.getClientRects().length?(e=r.getBoundingClientRect(),n=r.ownerDocument.defaultView,{top:e.top+n.pageYOffset,left:e.left+n.pageXOffset}):{top:0,left:0}:void 0},position:function(){if(this[0]){var e,t,n,r=this[0],i={top:0,left:0};if("fixed"===k.css(r,"position"))t=r.getBoundingClientRect();else{t=this.offset(),n=r.ownerDocument,e=r.offsetParent||n.documentElement;while(e&&(e===n.body||e===n.documentElement)&&"static"===k.css(e,"position"))e=e.parentNode;e&&e!==r&&1===e.nodeType&&((i=k(e).offset()).top+=k.css(e,"borderTopWidth",!0),i.left+=k.css(e,"borderLeftWidth",!0))}return{top:t.top-i.top-k.css(r,"marginTop",!0),left:t.left-i.left-k.css(r,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var e=this.offsetParent;while(e&&"static"===k.css(e,"position"))e=e.offsetParent;return e||ie})}}),k.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(t,i){var o="pageYOffset"===i;k.fn[t]=function(e){return _(this,function(e,t,n){var r;if(x(e)?r=e:9===e.nodeType&&(r=e.defaultView),void 0===n)return r?r[i]:e[t];r?r.scrollTo(o?r.pageXOffset:n,o?n:r.pageYOffset):e[t]=n},t,e,arguments.length)}}),k.each(["top","left"],function(e,n){k.cssHooks[n]=ze(y.pixelPosition,function(e,t){if(t)return t=_e(e,n),$e.test(t)?k(e).position()[n]+"px":t})}),k.each({Height:"height",Width:"width"},function(a,s){k.each({padding:"inner"+a,content:s,"":"outer"+a},function(r,o){k.fn[o]=function(e,t){var n=arguments.length&&(r||"boolean"!=typeof e),i=r||(!0===e||!0===t?"margin":"border");return _(this,function(e,t,n){var r;return x(e)?0===o.indexOf("outer")?e["inner"+a]:e.document.documentElement["client"+a]:9===e.nodeType?(r=e.documentElement,Math.max(e.body["scroll"+a],r["scroll"+a],e.body["offset"+a],r["offset"+a],r["client"+a])):void 0===n?k.css(e,t,i):k.style(e,t,n,i)},s,n?e:void 0,n)}})}),k.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(e,n){k.fn[n]=function(e,t){return 02;a== null&&(a=[]);if(y&&a.reduce===y)return e&&(c=b.bind(c,e)),f?a.reduce(c,d):a.reduce(c);j(a,function(a,b,i){f?d=c.call(e,d,a,b,i):(d=a,f=true)});if(!f)throw new TypeError("Reduce of empty array with no initial value");return d};b.reduceRight=b.foldr=function(a,c,d,e){var f=arguments.length>2;a==null&&(a=[]);if(z&&a.reduceRight===z)return e&&(c=b.bind(c,e)),f?a.reduceRight(c,d):a.reduceRight(c);var g=b.toArray(a).reverse();e&&!f&&(c=b.bind(c,e));return f?b.reduce(g,c,d,e):b.reduce(g,c)};b.find=b.detect= function(a,c,b){var e;E(a,function(a,g,h){if(c.call(b,a,g,h))return e=a,true});return e};b.filter=b.select=function(a,c,b){var e=[];if(a==null)return e;if(A&&a.filter===A)return a.filter(c,b);j(a,function(a,g,h){c.call(b,a,g,h)&&(e[e.length]=a)});return e};b.reject=function(a,c,b){var e=[];if(a==null)return e;j(a,function(a,g,h){c.call(b,a,g,h)||(e[e.length]=a)});return e};b.every=b.all=function(a,c,b){var e=true;if(a==null)return e;if(B&&a.every===B)return a.every(c,b);j(a,function(a,g,h){if(!(e= e&&c.call(b,a,g,h)))return n});return e};var E=b.some=b.any=function(a,c,d){c||(c=b.identity);var e=false;if(a==null)return e;if(C&&a.some===C)return a.some(c,d);j(a,function(a,b,h){if(e||(e=c.call(d,a,b,h)))return n});return!!e};b.include=b.contains=function(a,c){var b=false;if(a==null)return b;return p&&a.indexOf===p?a.indexOf(c)!=-1:b=E(a,function(a){return a===c})};b.invoke=function(a,c){var d=i.call(arguments,2);return b.map(a,function(a){return(b.isFunction(c)?c||a:a[c]).apply(a,d)})};b.pluck= function(a,c){return b.map(a,function(a){return a[c]})};b.max=function(a,c,d){if(!c&&b.isArray(a))return Math.max.apply(Math,a);if(!c&&b.isEmpty(a))return-Infinity;var e={computed:-Infinity};j(a,function(a,b,h){b=c?c.call(d,a,b,h):a;b>=e.computed&&(e={value:a,computed:b})});return e.value};b.min=function(a,c,d){if(!c&&b.isArray(a))return Math.min.apply(Math,a);if(!c&&b.isEmpty(a))return Infinity;var e={computed:Infinity};j(a,function(a,b,h){b=c?c.call(d,a,b,h):a;bd?1:0}),"value")};b.groupBy=function(a,c){var d={},e=b.isFunction(c)?c:function(a){return a[c]};j(a,function(a,b){var c=e(a,b);(d[c]||(d[c]=[])).push(a)});return d};b.sortedIndex=function(a, c,d){d||(d=b.identity);for(var e=0,f=a.length;e>1;d(a[g])=0})})};b.difference=function(a){var c=b.flatten(i.call(arguments,1));return b.filter(a,function(a){return!b.include(c,a)})};b.zip=function(){for(var a=i.call(arguments),c=b.max(b.pluck(a,"length")),d=Array(c),e=0;e=0;d--)b=[a[d].apply(this,b)];return b[0]}}; b.after=function(a,b){return a<=0?b():function(){if(--a<1)return b.apply(this,arguments)}};b.keys=J||function(a){if(a!==Object(a))throw new TypeError("Invalid object");var c=[],d;for(d in a)b.has(a,d)&&(c[c.length]=d);return c};b.values=function(a){return b.map(a,b.identity)};b.functions=b.methods=function(a){var c=[],d;for(d in a)b.isFunction(a[d])&&c.push(d);return c.sort()};b.extend=function(a){j(i.call(arguments,1),function(b){for(var d in b)a[d]=b[d]});return a};b.defaults=function(a){j(i.call(arguments, 1),function(b){for(var d in b)a[d]==null&&(a[d]=b[d])});return a};b.clone=function(a){return!b.isObject(a)?a:b.isArray(a)?a.slice():b.extend({},a)};b.tap=function(a,b){b(a);return a};b.isEqual=function(a,b){return q(a,b,[])};b.isEmpty=function(a){if(b.isArray(a)||b.isString(a))return a.length===0;for(var c in a)if(b.has(a,c))return false;return true};b.isElement=function(a){return!!(a&&a.nodeType==1)};b.isArray=o||function(a){return l.call(a)=="[object Array]"};b.isObject=function(a){return a===Object(a)}; b.isArguments=function(a){return l.call(a)=="[object Arguments]"};if(!b.isArguments(arguments))b.isArguments=function(a){return!(!a||!b.has(a,"callee"))};b.isFunction=function(a){return l.call(a)=="[object Function]"};b.isString=function(a){return l.call(a)=="[object String]"};b.isNumber=function(a){return l.call(a)=="[object Number]"};b.isNaN=function(a){return a!==a};b.isBoolean=function(a){return a===true||a===false||l.call(a)=="[object Boolean]"};b.isDate=function(a){return l.call(a)=="[object Date]"}; b.isRegExp=function(a){return l.call(a)=="[object RegExp]"};b.isNull=function(a){return a===null};b.isUndefined=function(a){return a===void 0};b.has=function(a,b){return I.call(a,b)};b.noConflict=function(){r._=G;return this};b.identity=function(a){return a};b.times=function(a,b,d){for(var e=0;e/g,">").replace(/"/g,""").replace(/'/g,"'").replace(/\//g,"/")};b.mixin=function(a){j(b.functions(a), function(c){K(c,b[c]=a[c])})};var L=0;b.uniqueId=function(a){var b=L++;return a?a+b:b};b.templateSettings={evaluate:/<%([\s\S]+?)%>/g,interpolate:/<%=([\s\S]+?)%>/g,escape:/<%-([\s\S]+?)%>/g};var t=/.^/,u=function(a){return a.replace(/\\\\/g,"\\").replace(/\\'/g,"'")};b.template=function(a,c){var d=b.templateSettings,d="var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('"+a.replace(/\\/g,"\\\\").replace(/'/g,"\\'").replace(d.escape||t,function(a,b){return"',_.escape("+ u(b)+"),'"}).replace(d.interpolate||t,function(a,b){return"',"+u(b)+",'"}).replace(d.evaluate||t,function(a,b){return"');"+u(b).replace(/[\r\n\t]/g," ")+";__p.push('"}).replace(/\r/g,"\\r").replace(/\n/g,"\\n").replace(/\t/g,"\\t")+"');}return __p.join('');",e=new Function("obj","_",d);return c?e(c,b):function(a){return e.call(this,a,b)}};b.chain=function(a){return b(a).chain()};var m=function(a){this._wrapped=a};b.prototype=m.prototype;var v=function(a,c){return c?b(a).chain():a},K=function(a,c){m.prototype[a]= function(){var a=i.call(arguments);H.call(a,this._wrapped);return v(c.apply(b,a),this._chain)}};b.mixin(b);j("pop,push,reverse,shift,sort,splice,unshift".split(","),function(a){var b=k[a];m.prototype[a]=function(){var d=this._wrapped;b.apply(d,arguments);var e=d.length;(a=="shift"||a=="splice")&&e===0&&delete d[0];return v(d,this._chain)}});j(["concat","join","slice"],function(a){var b=k[a];m.prototype[a]=function(){return v(b.apply(this._wrapped,arguments),this._chain)}});m.prototype.chain=function(){this._chain= true;return this};m.prototype.value=function(){return this._wrapped}}).call(this); bsddb3-6.2.7/docs/html/static/file.png0000664000175000017500000000043613600252535017333 0ustar jceajcea00000000000000PNG  IHDRaIDATxR){l ۶f=@ :3~箄rX$AX-D ~ lj(P%8<<9:: PO&$ l~X&EW^4wQ}^ͣ i0/H/@F)Dzq+j[SU5h/oY G&Lfs|{3%U+S`AFIENDB`bsddb3-6.2.7/docs/html/static/alabaster.css0000664000175000017500000002566113617125465020376 0ustar jceajcea00000000000000@import url("basic.css"); /* -- page layout ----------------------------------------------------------- */ body { font-family: Georgia, serif; font-size: 17px; background-color: #fff; color: #000; margin: 0; padding: 0; } div.document { width: 940px; margin: 30px auto 0 auto; } div.documentwrapper { float: left; width: 100%; } div.bodywrapper { margin: 0 0 0 220px; } div.sphinxsidebar { width: 220px; font-size: 14px; line-height: 1.5; } hr { border: 1px solid #B1B4B6; } div.body { background-color: #fff; color: #3E4349; padding: 0 30px 0 30px; } div.body > .section { text-align: left; } div.footer { width: 940px; margin: 20px auto 30px auto; font-size: 14px; color: #888; text-align: right; } div.footer a { color: #888; } p.caption { font-family: inherit; font-size: inherit; } div.relations { display: none; } div.sphinxsidebar a { color: #444; text-decoration: none; border-bottom: 1px dotted #999; } div.sphinxsidebar a:hover { border-bottom: 1px solid #999; } div.sphinxsidebarwrapper { padding: 18px 10px; } div.sphinxsidebarwrapper p.logo { padding: 0; margin: -10px 0 0 0px; text-align: center; } div.sphinxsidebarwrapper h1.logo { margin-top: -10px; text-align: center; margin-bottom: 5px; text-align: left; } div.sphinxsidebarwrapper h1.logo-name { margin-top: 0px; } div.sphinxsidebarwrapper p.blurb { margin-top: 0; font-style: normal; } div.sphinxsidebar h3, div.sphinxsidebar h4 { font-family: Georgia, serif; color: #444; font-size: 24px; font-weight: normal; margin: 0 0 5px 0; padding: 0; } div.sphinxsidebar h4 { font-size: 20px; } div.sphinxsidebar h3 a { color: #444; } div.sphinxsidebar p.logo a, div.sphinxsidebar h3 a, div.sphinxsidebar p.logo a:hover, div.sphinxsidebar h3 a:hover { border: none; } div.sphinxsidebar p { color: #555; margin: 10px 0; } div.sphinxsidebar ul { margin: 10px 0; padding: 0; color: #000; } div.sphinxsidebar ul li.toctree-l1 > a { font-size: 120%; } div.sphinxsidebar ul li.toctree-l2 > a { font-size: 110%; } div.sphinxsidebar input { border: 1px solid #CCC; font-family: Georgia, serif; font-size: 1em; } div.sphinxsidebar hr { border: none; height: 1px; color: #AAA; background: #AAA; text-align: left; margin-left: 0; width: 50%; } div.sphinxsidebar .badge { border-bottom: none; } div.sphinxsidebar .badge:hover { border-bottom: none; } /* To address an issue with donation coming after search */ div.sphinxsidebar h3.donation { margin-top: 10px; } /* -- body styles ----------------------------------------------------------- */ a { color: #004B6B; text-decoration: underline; } a:hover { color: #6D4100; text-decoration: underline; } div.body h1, div.body h2, div.body h3, div.body h4, div.body h5, div.body h6 { font-family: Georgia, serif; font-weight: normal; margin: 30px 0px 10px 0px; padding: 0; } div.body h1 { margin-top: 0; padding-top: 0; font-size: 240%; } div.body h2 { font-size: 180%; } div.body h3 { font-size: 150%; } div.body h4 { font-size: 130%; } div.body h5 { font-size: 100%; } div.body h6 { font-size: 100%; } a.headerlink { color: #DDD; padding: 0 4px; text-decoration: none; } a.headerlink:hover { color: #444; background: #EAEAEA; } div.body p, div.body dd, div.body li { line-height: 1.4em; } div.admonition { margin: 20px 0px; padding: 10px 30px; background-color: #EEE; border: 1px solid #CCC; } div.admonition tt.xref, div.admonition code.xref, div.admonition a tt { background-color: #FBFBFB; border-bottom: 1px solid #fafafa; } div.admonition p.admonition-title { font-family: Georgia, serif; font-weight: normal; font-size: 24px; margin: 0 0 10px 0; padding: 0; line-height: 1; } div.admonition p.last { margin-bottom: 0; } div.highlight { background-color: #fff; } dt:target, .highlight { background: #FAF3E8; } div.warning { background-color: #FCC; border: 1px solid #FAA; } div.danger { background-color: #FCC; border: 1px solid #FAA; -moz-box-shadow: 2px 2px 4px #D52C2C; -webkit-box-shadow: 2px 2px 4px #D52C2C; box-shadow: 2px 2px 4px #D52C2C; } div.error { background-color: #FCC; border: 1px solid #FAA; -moz-box-shadow: 2px 2px 4px #D52C2C; -webkit-box-shadow: 2px 2px 4px #D52C2C; box-shadow: 2px 2px 4px #D52C2C; } div.caution { background-color: #FCC; border: 1px solid #FAA; } div.attention { background-color: #FCC; border: 1px solid #FAA; } div.important { background-color: #EEE; border: 1px solid #CCC; } div.note { background-color: #EEE; border: 1px solid #CCC; } div.tip { background-color: #EEE; border: 1px solid #CCC; } div.hint { background-color: #EEE; border: 1px solid #CCC; } div.seealso { background-color: #EEE; border: 1px solid #CCC; } div.topic { background-color: #EEE; } p.admonition-title { display: inline; } p.admonition-title:after { content: ":"; } pre, tt, code { font-family: 'Consolas', 'Menlo', 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', monospace; font-size: 0.9em; } .hll { background-color: #FFC; margin: 0 -12px; padding: 0 12px; display: block; } img.screenshot { } tt.descname, tt.descclassname, code.descname, code.descclassname { font-size: 0.95em; } tt.descname, code.descname { padding-right: 0.08em; } img.screenshot { -moz-box-shadow: 2px 2px 4px #EEE; -webkit-box-shadow: 2px 2px 4px #EEE; box-shadow: 2px 2px 4px #EEE; } table.docutils { border: 1px solid #888; -moz-box-shadow: 2px 2px 4px #EEE; -webkit-box-shadow: 2px 2px 4px #EEE; box-shadow: 2px 2px 4px #EEE; } table.docutils td, table.docutils th { border: 1px solid #888; padding: 0.25em 0.7em; } table.field-list, table.footnote { border: none; -moz-box-shadow: none; -webkit-box-shadow: none; box-shadow: none; } table.footnote { margin: 15px 0; width: 100%; border: 1px solid #EEE; background: #FDFDFD; font-size: 0.9em; } table.footnote + table.footnote { margin-top: -15px; border-top: none; } table.field-list th { padding: 0 0.8em 0 0; } table.field-list td { padding: 0; } table.field-list p { margin-bottom: 0.8em; } /* Cloned from * https://github.com/sphinx-doc/sphinx/commit/ef60dbfce09286b20b7385333d63a60321784e68 */ .field-name { -moz-hyphens: manual; -ms-hyphens: manual; -webkit-hyphens: manual; hyphens: manual; } table.footnote td.label { width: .1px; padding: 0.3em 0 0.3em 0.5em; } table.footnote td { padding: 0.3em 0.5em; } dl { margin: 0; padding: 0; } dl dd { margin-left: 30px; } blockquote { margin: 0 0 0 30px; padding: 0; } ul, ol { /* Matches the 30px from the narrow-screen "li > ul" selector below */ margin: 10px 0 10px 30px; padding: 0; } pre { background: #EEE; padding: 7px 30px; margin: 15px 0px; line-height: 1.3em; } div.viewcode-block:target { background: #ffd; } dl pre, blockquote pre, li pre { margin-left: 0; padding-left: 30px; } tt, code { background-color: #ecf0f3; color: #222; /* padding: 1px 2px; */ } tt.xref, code.xref, a tt { background-color: #FBFBFB; border-bottom: 1px solid #fff; } a.reference { text-decoration: none; border-bottom: 1px dotted #004B6B; } /* Don't put an underline on images */ a.image-reference, a.image-reference:hover { border-bottom: none; } a.reference:hover { border-bottom: 1px solid #6D4100; } a.footnote-reference { text-decoration: none; font-size: 0.7em; vertical-align: top; border-bottom: 1px dotted #004B6B; } a.footnote-reference:hover { border-bottom: 1px solid #6D4100; } a:hover tt, a:hover code { background: #EEE; } @media screen and (max-width: 870px) { div.sphinxsidebar { display: none; } div.document { width: 100%; } div.documentwrapper { margin-left: 0; margin-top: 0; margin-right: 0; margin-bottom: 0; } div.bodywrapper { margin-top: 0; margin-right: 0; margin-bottom: 0; margin-left: 0; } ul { margin-left: 0; } li > ul { /* Matches the 30px from the "ul, ol" selector above */ margin-left: 30px; } .document { width: auto; } .footer { width: auto; } .bodywrapper { margin: 0; } .footer { width: auto; } .github { display: none; } } @media screen and (max-width: 875px) { body { margin: 0; padding: 20px 30px; } div.documentwrapper { float: none; background: #fff; } div.sphinxsidebar { display: block; float: none; width: 102.5%; margin: 50px -30px -20px -30px; padding: 10px 20px; background: #333; color: #FFF; } div.sphinxsidebar h3, div.sphinxsidebar h4, div.sphinxsidebar p, div.sphinxsidebar h3 a { color: #fff; } div.sphinxsidebar a { color: #AAA; } div.sphinxsidebar p.logo { display: none; } div.document { width: 100%; margin: 0; } div.footer { display: none; } div.bodywrapper { margin: 0; } div.body { min-height: 0; padding: 0; } .rtd_doc_footer { display: none; } .document { width: auto; } .footer { width: auto; } .footer { width: auto; } .github { display: none; } } /* misc. */ .revsys-inline { display: none!important; } /* Make nested-list/multi-paragraph items look better in Releases changelog * pages. Without this, docutils' magical list fuckery causes inconsistent * formatting between different release sub-lists. */ div#changelog > div.section > ul > li > p:only-child { margin-bottom: 0; } /* Hide fugly table cell borders in ..bibliography:: directive output */ table.docutils.citation, table.docutils.citation td, table.docutils.citation th { border: none; /* Below needed in some edge cases; if not applied, bottom shadows appear */ -moz-box-shadow: none; -webkit-box-shadow: none; box-shadow: none; } /* relbar */ .related { line-height: 30px; width: 100%; font-size: 0.9rem; } .related.top { border-bottom: 1px solid #EEE; margin-bottom: 20px; } .related.bottom { border-top: 1px solid #EEE; } .related ul { padding: 0; margin: 0; list-style: none; } .related li { display: inline; } nav#rellinks { float: right; } nav#rellinks li+li:before { content: "|"; } nav#breadcrumbs li+li:before { content: "\00BB"; } /* Hide certain items when printing */ @media print { div.related { display: none; } }bsddb3-6.2.7/docs/html/static/underscore-1.3.1.js0000664000175000017500000010454013600252535021054 0ustar jceajcea00000000000000// Underscore.js 1.3.1 // (c) 2009-2012 Jeremy Ashkenas, DocumentCloud Inc. // Underscore is freely distributable under the MIT license. // Portions of Underscore are inspired or borrowed from Prototype, // Oliver Steele's Functional, and John Resig's Micro-Templating. // For all details and documentation: // http://documentcloud.github.com/underscore (function() { // Baseline setup // -------------- // Establish the root object, `window` in the browser, or `global` on the server. var root = this; // Save the previous value of the `_` variable. var previousUnderscore = root._; // Establish the object that gets returned to break out of a loop iteration. var breaker = {}; // Save bytes in the minified (but not gzipped) version: var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype; // Create quick reference variables for speed access to core prototypes. var slice = ArrayProto.slice, unshift = ArrayProto.unshift, toString = ObjProto.toString, hasOwnProperty = ObjProto.hasOwnProperty; // All **ECMAScript 5** native function implementations that we hope to use // are declared here. var nativeForEach = ArrayProto.forEach, nativeMap = ArrayProto.map, nativeReduce = ArrayProto.reduce, nativeReduceRight = ArrayProto.reduceRight, nativeFilter = ArrayProto.filter, nativeEvery = ArrayProto.every, nativeSome = ArrayProto.some, nativeIndexOf = ArrayProto.indexOf, nativeLastIndexOf = ArrayProto.lastIndexOf, nativeIsArray = Array.isArray, nativeKeys = Object.keys, nativeBind = FuncProto.bind; // Create a safe reference to the Underscore object for use below. var _ = function(obj) { return new wrapper(obj); }; // Export the Underscore object for **Node.js**, with // backwards-compatibility for the old `require()` API. If we're in // the browser, add `_` as a global object via a string identifier, // for Closure Compiler "advanced" mode. if (typeof exports !== 'undefined') { if (typeof module !== 'undefined' && module.exports) { exports = module.exports = _; } exports._ = _; } else { root['_'] = _; } // Current version. _.VERSION = '1.3.1'; // Collection Functions // -------------------- // The cornerstone, an `each` implementation, aka `forEach`. // Handles objects with the built-in `forEach`, arrays, and raw objects. // Delegates to **ECMAScript 5**'s native `forEach` if available. var each = _.each = _.forEach = function(obj, iterator, context) { if (obj == null) return; if (nativeForEach && obj.forEach === nativeForEach) { obj.forEach(iterator, context); } else if (obj.length === +obj.length) { for (var i = 0, l = obj.length; i < l; i++) { if (i in obj && iterator.call(context, obj[i], i, obj) === breaker) return; } } else { for (var key in obj) { if (_.has(obj, key)) { if (iterator.call(context, obj[key], key, obj) === breaker) return; } } } }; // Return the results of applying the iterator to each element. // Delegates to **ECMAScript 5**'s native `map` if available. _.map = _.collect = function(obj, iterator, context) { var results = []; if (obj == null) return results; if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context); each(obj, function(value, index, list) { results[results.length] = iterator.call(context, value, index, list); }); if (obj.length === +obj.length) results.length = obj.length; return results; }; // **Reduce** builds up a single result from a list of values, aka `inject`, // or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available. _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) { var initial = arguments.length > 2; if (obj == null) obj = []; if (nativeReduce && obj.reduce === nativeReduce) { if (context) iterator = _.bind(iterator, context); return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator); } each(obj, function(value, index, list) { if (!initial) { memo = value; initial = true; } else { memo = iterator.call(context, memo, value, index, list); } }); if (!initial) throw new TypeError('Reduce of empty array with no initial value'); return memo; }; // The right-associative version of reduce, also known as `foldr`. // Delegates to **ECMAScript 5**'s native `reduceRight` if available. _.reduceRight = _.foldr = function(obj, iterator, memo, context) { var initial = arguments.length > 2; if (obj == null) obj = []; if (nativeReduceRight && obj.reduceRight === nativeReduceRight) { if (context) iterator = _.bind(iterator, context); return initial ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator); } var reversed = _.toArray(obj).reverse(); if (context && !initial) iterator = _.bind(iterator, context); return initial ? _.reduce(reversed, iterator, memo, context) : _.reduce(reversed, iterator); }; // Return the first value which passes a truth test. Aliased as `detect`. _.find = _.detect = function(obj, iterator, context) { var result; any(obj, function(value, index, list) { if (iterator.call(context, value, index, list)) { result = value; return true; } }); return result; }; // Return all the elements that pass a truth test. // Delegates to **ECMAScript 5**'s native `filter` if available. // Aliased as `select`. _.filter = _.select = function(obj, iterator, context) { var results = []; if (obj == null) return results; if (nativeFilter && obj.filter === nativeFilter) return obj.filter(iterator, context); each(obj, function(value, index, list) { if (iterator.call(context, value, index, list)) results[results.length] = value; }); return results; }; // Return all the elements for which a truth test fails. _.reject = function(obj, iterator, context) { var results = []; if (obj == null) return results; each(obj, function(value, index, list) { if (!iterator.call(context, value, index, list)) results[results.length] = value; }); return results; }; // Determine whether all of the elements match a truth test. // Delegates to **ECMAScript 5**'s native `every` if available. // Aliased as `all`. _.every = _.all = function(obj, iterator, context) { var result = true; if (obj == null) return result; if (nativeEvery && obj.every === nativeEvery) return obj.every(iterator, context); each(obj, function(value, index, list) { if (!(result = result && iterator.call(context, value, index, list))) return breaker; }); return result; }; // Determine if at least one element in the object matches a truth test. // Delegates to **ECMAScript 5**'s native `some` if available. // Aliased as `any`. var any = _.some = _.any = function(obj, iterator, context) { iterator || (iterator = _.identity); var result = false; if (obj == null) return result; if (nativeSome && obj.some === nativeSome) return obj.some(iterator, context); each(obj, function(value, index, list) { if (result || (result = iterator.call(context, value, index, list))) return breaker; }); return !!result; }; // Determine if a given value is included in the array or object using `===`. // Aliased as `contains`. _.include = _.contains = function(obj, target) { var found = false; if (obj == null) return found; if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1; found = any(obj, function(value) { return value === target; }); return found; }; // Invoke a method (with arguments) on every item in a collection. _.invoke = function(obj, method) { var args = slice.call(arguments, 2); return _.map(obj, function(value) { return (_.isFunction(method) ? method || value : value[method]).apply(value, args); }); }; // Convenience version of a common use case of `map`: fetching a property. _.pluck = function(obj, key) { return _.map(obj, function(value){ return value[key]; }); }; // Return the maximum element or (element-based computation). _.max = function(obj, iterator, context) { if (!iterator && _.isArray(obj)) return Math.max.apply(Math, obj); if (!iterator && _.isEmpty(obj)) return -Infinity; var result = {computed : -Infinity}; each(obj, function(value, index, list) { var computed = iterator ? iterator.call(context, value, index, list) : value; computed >= result.computed && (result = {value : value, computed : computed}); }); return result.value; }; // Return the minimum element (or element-based computation). _.min = function(obj, iterator, context) { if (!iterator && _.isArray(obj)) return Math.min.apply(Math, obj); if (!iterator && _.isEmpty(obj)) return Infinity; var result = {computed : Infinity}; each(obj, function(value, index, list) { var computed = iterator ? iterator.call(context, value, index, list) : value; computed < result.computed && (result = {value : value, computed : computed}); }); return result.value; }; // Shuffle an array. _.shuffle = function(obj) { var shuffled = [], rand; each(obj, function(value, index, list) { if (index == 0) { shuffled[0] = value; } else { rand = Math.floor(Math.random() * (index + 1)); shuffled[index] = shuffled[rand]; shuffled[rand] = value; } }); return shuffled; }; // Sort the object's values by a criterion produced by an iterator. _.sortBy = function(obj, iterator, context) { return _.pluck(_.map(obj, function(value, index, list) { return { value : value, criteria : iterator.call(context, value, index, list) }; }).sort(function(left, right) { var a = left.criteria, b = right.criteria; return a < b ? -1 : a > b ? 1 : 0; }), 'value'); }; // Groups the object's values by a criterion. Pass either a string attribute // to group by, or a function that returns the criterion. _.groupBy = function(obj, val) { var result = {}; var iterator = _.isFunction(val) ? val : function(obj) { return obj[val]; }; each(obj, function(value, index) { var key = iterator(value, index); (result[key] || (result[key] = [])).push(value); }); return result; }; // Use a comparator function to figure out at what index an object should // be inserted so as to maintain order. Uses binary search. _.sortedIndex = function(array, obj, iterator) { iterator || (iterator = _.identity); var low = 0, high = array.length; while (low < high) { var mid = (low + high) >> 1; iterator(array[mid]) < iterator(obj) ? low = mid + 1 : high = mid; } return low; }; // Safely convert anything iterable into a real, live array. _.toArray = function(iterable) { if (!iterable) return []; if (iterable.toArray) return iterable.toArray(); if (_.isArray(iterable)) return slice.call(iterable); if (_.isArguments(iterable)) return slice.call(iterable); return _.values(iterable); }; // Return the number of elements in an object. _.size = function(obj) { return _.toArray(obj).length; }; // Array Functions // --------------- // Get the first element of an array. Passing **n** will return the first N // values in the array. Aliased as `head`. The **guard** check allows it to work // with `_.map`. _.first = _.head = function(array, n, guard) { return (n != null) && !guard ? slice.call(array, 0, n) : array[0]; }; // Returns everything but the last entry of the array. Especcialy useful on // the arguments object. Passing **n** will return all the values in // the array, excluding the last N. The **guard** check allows it to work with // `_.map`. _.initial = function(array, n, guard) { return slice.call(array, 0, array.length - ((n == null) || guard ? 1 : n)); }; // Get the last element of an array. Passing **n** will return the last N // values in the array. The **guard** check allows it to work with `_.map`. _.last = function(array, n, guard) { if ((n != null) && !guard) { return slice.call(array, Math.max(array.length - n, 0)); } else { return array[array.length - 1]; } }; // Returns everything but the first entry of the array. Aliased as `tail`. // Especially useful on the arguments object. Passing an **index** will return // the rest of the values in the array from that index onward. The **guard** // check allows it to work with `_.map`. _.rest = _.tail = function(array, index, guard) { return slice.call(array, (index == null) || guard ? 1 : index); }; // Trim out all falsy values from an array. _.compact = function(array) { return _.filter(array, function(value){ return !!value; }); }; // Return a completely flattened version of an array. _.flatten = function(array, shallow) { return _.reduce(array, function(memo, value) { if (_.isArray(value)) return memo.concat(shallow ? value : _.flatten(value)); memo[memo.length] = value; return memo; }, []); }; // Return a version of the array that does not contain the specified value(s). _.without = function(array) { return _.difference(array, slice.call(arguments, 1)); }; // Produce a duplicate-free version of the array. If the array has already // been sorted, you have the option of using a faster algorithm. // Aliased as `unique`. _.uniq = _.unique = function(array, isSorted, iterator) { var initial = iterator ? _.map(array, iterator) : array; var result = []; _.reduce(initial, function(memo, el, i) { if (0 == i || (isSorted === true ? _.last(memo) != el : !_.include(memo, el))) { memo[memo.length] = el; result[result.length] = array[i]; } return memo; }, []); return result; }; // Produce an array that contains the union: each distinct element from all of // the passed-in arrays. _.union = function() { return _.uniq(_.flatten(arguments, true)); }; // Produce an array that contains every item shared between all the // passed-in arrays. (Aliased as "intersect" for back-compat.) _.intersection = _.intersect = function(array) { var rest = slice.call(arguments, 1); return _.filter(_.uniq(array), function(item) { return _.every(rest, function(other) { return _.indexOf(other, item) >= 0; }); }); }; // Take the difference between one array and a number of other arrays. // Only the elements present in just the first array will remain. _.difference = function(array) { var rest = _.flatten(slice.call(arguments, 1)); return _.filter(array, function(value){ return !_.include(rest, value); }); }; // Zip together multiple lists into a single array -- elements that share // an index go together. _.zip = function() { var args = slice.call(arguments); var length = _.max(_.pluck(args, 'length')); var results = new Array(length); for (var i = 0; i < length; i++) results[i] = _.pluck(args, "" + i); return results; }; // If the browser doesn't supply us with indexOf (I'm looking at you, **MSIE**), // we need this function. Return the position of the first occurrence of an // item in an array, or -1 if the item is not included in the array. // Delegates to **ECMAScript 5**'s native `indexOf` if available. // If the array is large and already in sort order, pass `true` // for **isSorted** to use binary search. _.indexOf = function(array, item, isSorted) { if (array == null) return -1; var i, l; if (isSorted) { i = _.sortedIndex(array, item); return array[i] === item ? i : -1; } if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item); for (i = 0, l = array.length; i < l; i++) if (i in array && array[i] === item) return i; return -1; }; // Delegates to **ECMAScript 5**'s native `lastIndexOf` if available. _.lastIndexOf = function(array, item) { if (array == null) return -1; if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) return array.lastIndexOf(item); var i = array.length; while (i--) if (i in array && array[i] === item) return i; return -1; }; // Generate an integer Array containing an arithmetic progression. A port of // the native Python `range()` function. See // [the Python documentation](http://docs.python.org/library/functions.html#range). _.range = function(start, stop, step) { if (arguments.length <= 1) { stop = start || 0; start = 0; } step = arguments[2] || 1; var len = Math.max(Math.ceil((stop - start) / step), 0); var idx = 0; var range = new Array(len); while(idx < len) { range[idx++] = start; start += step; } return range; }; // Function (ahem) Functions // ------------------ // Reusable constructor function for prototype setting. var ctor = function(){}; // Create a function bound to a given object (assigning `this`, and arguments, // optionally). Binding with arguments is also known as `curry`. // Delegates to **ECMAScript 5**'s native `Function.bind` if available. // We check for `func.bind` first, to fail fast when `func` is undefined. _.bind = function bind(func, context) { var bound, args; if (func.bind === nativeBind && nativeBind) return nativeBind.apply(func, slice.call(arguments, 1)); if (!_.isFunction(func)) throw new TypeError; args = slice.call(arguments, 2); return bound = function() { if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments))); ctor.prototype = func.prototype; var self = new ctor; var result = func.apply(self, args.concat(slice.call(arguments))); if (Object(result) === result) return result; return self; }; }; // Bind all of an object's methods to that object. Useful for ensuring that // all callbacks defined on an object belong to it. _.bindAll = function(obj) { var funcs = slice.call(arguments, 1); if (funcs.length == 0) funcs = _.functions(obj); each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); }); return obj; }; // Memoize an expensive function by storing its results. _.memoize = function(func, hasher) { var memo = {}; hasher || (hasher = _.identity); return function() { var key = hasher.apply(this, arguments); return _.has(memo, key) ? memo[key] : (memo[key] = func.apply(this, arguments)); }; }; // Delays a function for the given number of milliseconds, and then calls // it with the arguments supplied. _.delay = function(func, wait) { var args = slice.call(arguments, 2); return setTimeout(function(){ return func.apply(func, args); }, wait); }; // Defers a function, scheduling it to run after the current call stack has // cleared. _.defer = function(func) { return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1))); }; // Returns a function, that, when invoked, will only be triggered at most once // during a given window of time. _.throttle = function(func, wait) { var context, args, timeout, throttling, more; var whenDone = _.debounce(function(){ more = throttling = false; }, wait); return function() { context = this; args = arguments; var later = function() { timeout = null; if (more) func.apply(context, args); whenDone(); }; if (!timeout) timeout = setTimeout(later, wait); if (throttling) { more = true; } else { func.apply(context, args); } whenDone(); throttling = true; }; }; // Returns a function, that, as long as it continues to be invoked, will not // be triggered. The function will be called after it stops being called for // N milliseconds. _.debounce = function(func, wait) { var timeout; return function() { var context = this, args = arguments; var later = function() { timeout = null; func.apply(context, args); }; clearTimeout(timeout); timeout = setTimeout(later, wait); }; }; // Returns a function that will be executed at most one time, no matter how // often you call it. Useful for lazy initialization. _.once = function(func) { var ran = false, memo; return function() { if (ran) return memo; ran = true; return memo = func.apply(this, arguments); }; }; // Returns the first function passed as an argument to the second, // allowing you to adjust arguments, run code before and after, and // conditionally execute the original function. _.wrap = function(func, wrapper) { return function() { var args = [func].concat(slice.call(arguments, 0)); return wrapper.apply(this, args); }; }; // Returns a function that is the composition of a list of functions, each // consuming the return value of the function that follows. _.compose = function() { var funcs = arguments; return function() { var args = arguments; for (var i = funcs.length - 1; i >= 0; i--) { args = [funcs[i].apply(this, args)]; } return args[0]; }; }; // Returns a function that will only be executed after being called N times. _.after = function(times, func) { if (times <= 0) return func(); return function() { if (--times < 1) { return func.apply(this, arguments); } }; }; // Object Functions // ---------------- // Retrieve the names of an object's properties. // Delegates to **ECMAScript 5**'s native `Object.keys` _.keys = nativeKeys || function(obj) { if (obj !== Object(obj)) throw new TypeError('Invalid object'); var keys = []; for (var key in obj) if (_.has(obj, key)) keys[keys.length] = key; return keys; }; // Retrieve the values of an object's properties. _.values = function(obj) { return _.map(obj, _.identity); }; // Return a sorted list of the function names available on the object. // Aliased as `methods` _.functions = _.methods = function(obj) { var names = []; for (var key in obj) { if (_.isFunction(obj[key])) names.push(key); } return names.sort(); }; // Extend a given object with all the properties in passed-in object(s). _.extend = function(obj) { each(slice.call(arguments, 1), function(source) { for (var prop in source) { obj[prop] = source[prop]; } }); return obj; }; // Fill in a given object with default properties. _.defaults = function(obj) { each(slice.call(arguments, 1), function(source) { for (var prop in source) { if (obj[prop] == null) obj[prop] = source[prop]; } }); return obj; }; // Create a (shallow-cloned) duplicate of an object. _.clone = function(obj) { if (!_.isObject(obj)) return obj; return _.isArray(obj) ? obj.slice() : _.extend({}, obj); }; // Invokes interceptor with the obj, and then returns obj. // The primary purpose of this method is to "tap into" a method chain, in // order to perform operations on intermediate results within the chain. _.tap = function(obj, interceptor) { interceptor(obj); return obj; }; // Internal recursive comparison function. function eq(a, b, stack) { // Identical objects are equal. `0 === -0`, but they aren't identical. // See the Harmony `egal` proposal: http://wiki.ecmascript.org/doku.php?id=harmony:egal. if (a === b) return a !== 0 || 1 / a == 1 / b; // A strict comparison is necessary because `null == undefined`. if (a == null || b == null) return a === b; // Unwrap any wrapped objects. if (a._chain) a = a._wrapped; if (b._chain) b = b._wrapped; // Invoke a custom `isEqual` method if one is provided. if (a.isEqual && _.isFunction(a.isEqual)) return a.isEqual(b); if (b.isEqual && _.isFunction(b.isEqual)) return b.isEqual(a); // Compare `[[Class]]` names. var className = toString.call(a); if (className != toString.call(b)) return false; switch (className) { // Strings, numbers, dates, and booleans are compared by value. case '[object String]': // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is // equivalent to `new String("5")`. return a == String(b); case '[object Number]': // `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for // other numeric values. return a != +a ? b != +b : (a == 0 ? 1 / a == 1 / b : a == +b); case '[object Date]': case '[object Boolean]': // Coerce dates and booleans to numeric primitive values. Dates are compared by their // millisecond representations. Note that invalid dates with millisecond representations // of `NaN` are not equivalent. return +a == +b; // RegExps are compared by their source patterns and flags. case '[object RegExp]': return a.source == b.source && a.global == b.global && a.multiline == b.multiline && a.ignoreCase == b.ignoreCase; } if (typeof a != 'object' || typeof b != 'object') return false; // Assume equality for cyclic structures. The algorithm for detecting cyclic // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`. var length = stack.length; while (length--) { // Linear search. Performance is inversely proportional to the number of // unique nested structures. if (stack[length] == a) return true; } // Add the first object to the stack of traversed objects. stack.push(a); var size = 0, result = true; // Recursively compare objects and arrays. if (className == '[object Array]') { // Compare array lengths to determine if a deep comparison is necessary. size = a.length; result = size == b.length; if (result) { // Deep compare the contents, ignoring non-numeric properties. while (size--) { // Ensure commutative equality for sparse arrays. if (!(result = size in a == size in b && eq(a[size], b[size], stack))) break; } } } else { // Objects with different constructors are not equivalent. if ('constructor' in a != 'constructor' in b || a.constructor != b.constructor) return false; // Deep compare objects. for (var key in a) { if (_.has(a, key)) { // Count the expected number of properties. size++; // Deep compare each member. if (!(result = _.has(b, key) && eq(a[key], b[key], stack))) break; } } // Ensure that both objects contain the same number of properties. if (result) { for (key in b) { if (_.has(b, key) && !(size--)) break; } result = !size; } } // Remove the first object from the stack of traversed objects. stack.pop(); return result; } // Perform a deep comparison to check if two objects are equal. _.isEqual = function(a, b) { return eq(a, b, []); }; // Is a given array, string, or object empty? // An "empty" object has no enumerable own-properties. _.isEmpty = function(obj) { if (_.isArray(obj) || _.isString(obj)) return obj.length === 0; for (var key in obj) if (_.has(obj, key)) return false; return true; }; // Is a given value a DOM element? _.isElement = function(obj) { return !!(obj && obj.nodeType == 1); }; // Is a given value an array? // Delegates to ECMA5's native Array.isArray _.isArray = nativeIsArray || function(obj) { return toString.call(obj) == '[object Array]'; }; // Is a given variable an object? _.isObject = function(obj) { return obj === Object(obj); }; // Is a given variable an arguments object? _.isArguments = function(obj) { return toString.call(obj) == '[object Arguments]'; }; if (!_.isArguments(arguments)) { _.isArguments = function(obj) { return !!(obj && _.has(obj, 'callee')); }; } // Is a given value a function? _.isFunction = function(obj) { return toString.call(obj) == '[object Function]'; }; // Is a given value a string? _.isString = function(obj) { return toString.call(obj) == '[object String]'; }; // Is a given value a number? _.isNumber = function(obj) { return toString.call(obj) == '[object Number]'; }; // Is the given value `NaN`? _.isNaN = function(obj) { // `NaN` is the only value for which `===` is not reflexive. return obj !== obj; }; // Is a given value a boolean? _.isBoolean = function(obj) { return obj === true || obj === false || toString.call(obj) == '[object Boolean]'; }; // Is a given value a date? _.isDate = function(obj) { return toString.call(obj) == '[object Date]'; }; // Is the given value a regular expression? _.isRegExp = function(obj) { return toString.call(obj) == '[object RegExp]'; }; // Is a given value equal to null? _.isNull = function(obj) { return obj === null; }; // Is a given variable undefined? _.isUndefined = function(obj) { return obj === void 0; }; // Has own property? _.has = function(obj, key) { return hasOwnProperty.call(obj, key); }; // Utility Functions // ----------------- // Run Underscore.js in *noConflict* mode, returning the `_` variable to its // previous owner. Returns a reference to the Underscore object. _.noConflict = function() { root._ = previousUnderscore; return this; }; // Keep the identity function around for default iterators. _.identity = function(value) { return value; }; // Run a function **n** times. _.times = function (n, iterator, context) { for (var i = 0; i < n; i++) iterator.call(context, i); }; // Escape a string for HTML interpolation. _.escape = function(string) { return (''+string).replace(/&/g, '&').replace(//g, '>').replace(/"/g, '"').replace(/'/g, ''').replace(/\//g,'/'); }; // Add your own custom functions to the Underscore object, ensuring that // they're correctly added to the OOP wrapper as well. _.mixin = function(obj) { each(_.functions(obj), function(name){ addToWrapper(name, _[name] = obj[name]); }); }; // Generate a unique integer id (unique within the entire client session). // Useful for temporary DOM ids. var idCounter = 0; _.uniqueId = function(prefix) { var id = idCounter++; return prefix ? prefix + id : id; }; // By default, Underscore uses ERB-style template delimiters, change the // following template settings to use alternative delimiters. _.templateSettings = { evaluate : /<%([\s\S]+?)%>/g, interpolate : /<%=([\s\S]+?)%>/g, escape : /<%-([\s\S]+?)%>/g }; // When customizing `templateSettings`, if you don't want to define an // interpolation, evaluation or escaping regex, we need one that is // guaranteed not to match. var noMatch = /.^/; // Within an interpolation, evaluation, or escaping, remove HTML escaping // that had been previously added. var unescape = function(code) { return code.replace(/\\\\/g, '\\').replace(/\\'/g, "'"); }; // JavaScript micro-templating, similar to John Resig's implementation. // Underscore templating handles arbitrary delimiters, preserves whitespace, // and correctly escapes quotes within interpolated code. _.template = function(str, data) { var c = _.templateSettings; var tmpl = 'var __p=[],print=function(){__p.push.apply(__p,arguments);};' + 'with(obj||{}){__p.push(\'' + str.replace(/\\/g, '\\\\') .replace(/'/g, "\\'") .replace(c.escape || noMatch, function(match, code) { return "',_.escape(" + unescape(code) + "),'"; }) .replace(c.interpolate || noMatch, function(match, code) { return "'," + unescape(code) + ",'"; }) .replace(c.evaluate || noMatch, function(match, code) { return "');" + unescape(code).replace(/[\r\n\t]/g, ' ') + ";__p.push('"; }) .replace(/\r/g, '\\r') .replace(/\n/g, '\\n') .replace(/\t/g, '\\t') + "');}return __p.join('');"; var func = new Function('obj', '_', tmpl); if (data) return func(data, _); return function(data) { return func.call(this, data, _); }; }; // Add a "chain" function, which will delegate to the wrapper. _.chain = function(obj) { return _(obj).chain(); }; // The OOP Wrapper // --------------- // If Underscore is called as a function, it returns a wrapped object that // can be used OO-style. This wrapper holds altered versions of all the // underscore functions. Wrapped objects may be chained. var wrapper = function(obj) { this._wrapped = obj; }; // Expose `wrapper.prototype` as `_.prototype` _.prototype = wrapper.prototype; // Helper function to continue chaining intermediate results. var result = function(obj, chain) { return chain ? _(obj).chain() : obj; }; // A method to easily add functions to the OOP wrapper. var addToWrapper = function(name, func) { wrapper.prototype[name] = function() { var args = slice.call(arguments); unshift.call(args, this._wrapped); return result(func.apply(_, args), this._chain); }; }; // Add all of the Underscore functions to the wrapper object. _.mixin(_); // Add all mutator Array functions to the wrapper. each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) { var method = ArrayProto[name]; wrapper.prototype[name] = function() { var wrapped = this._wrapped; method.apply(wrapped, arguments); var length = wrapped.length; if ((name == 'shift' || name == 'splice') && length === 0) delete wrapped[0]; return result(wrapped, this._chain); }; }); // Add all accessor Array functions to the wrapper. each(['concat', 'join', 'slice'], function(name) { var method = ArrayProto[name]; wrapper.prototype[name] = function() { return result(method.apply(this._wrapped, arguments), this._chain); }; }); // Start chaining a wrapped Underscore object. wrapper.prototype.chain = function() { this._chain = true; return this; }; // Extracts the result from a wrapped and chained object. wrapper.prototype.value = function() { return this._wrapped; }; }).call(this); bsddb3-6.2.7/docs/html/static/documentation_options.js0000664000175000017500000000051213617125465022674 0ustar jceajcea00000000000000var DOCUMENTATION_OPTIONS = { URL_ROOT: document.getElementById("documentation_options").getAttribute('data-url_root'), VERSION: '6.2.7', LANGUAGE: 'None', COLLAPSE_INDEX: false, BUILDER: 'html', FILE_SUFFIX: '.html', HAS_SOURCE: false, SOURCELINK_SUFFIX: '.txt', NAVIGATION_WITH_KEYS: false };bsddb3-6.2.7/docs/html/static/jquery-3.4.1.js0000664000175000017500000104345413600252535020234 0ustar jceajcea00000000000000/*! * jQuery JavaScript Library v3.4.1 * https://jquery.com/ * * Includes Sizzle.js * https://sizzlejs.com/ * * Copyright JS Foundation and other contributors * Released under the MIT license * https://jquery.org/license * * Date: 2019-05-01T21:04Z */ ( function( global, factory ) { "use strict"; if ( typeof module === "object" && typeof module.exports === "object" ) { // For CommonJS and CommonJS-like environments where a proper `window` // is present, execute the factory and get jQuery. // For environments that do not have a `window` with a `document` // (such as Node.js), expose a factory as module.exports. // This accentuates the need for the creation of a real `window`. // e.g. var jQuery = require("jquery")(window); // See ticket #14549 for more info. module.exports = global.document ? factory( global, true ) : function( w ) { if ( !w.document ) { throw new Error( "jQuery requires a window with a document" ); } return factory( w ); }; } else { factory( global ); } // Pass this if window is not defined yet } )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) { // Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1 // throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode // arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common // enough that all such attempts are guarded in a try block. "use strict"; var arr = []; var document = window.document; var getProto = Object.getPrototypeOf; var slice = arr.slice; var concat = arr.concat; var push = arr.push; var indexOf = arr.indexOf; var class2type = {}; var toString = class2type.toString; var hasOwn = class2type.hasOwnProperty; var fnToString = hasOwn.toString; var ObjectFunctionString = fnToString.call( Object ); var support = {}; var isFunction = function isFunction( obj ) { // Support: Chrome <=57, Firefox <=52 // In some browsers, typeof returns "function" for HTML elements // (i.e., `typeof document.createElement( "object" ) === "function"`). // We don't want to classify *any* DOM node as a function. return typeof obj === "function" && typeof obj.nodeType !== "number"; }; var isWindow = function isWindow( obj ) { return obj != null && obj === obj.window; }; var preservedScriptAttributes = { type: true, src: true, nonce: true, noModule: true }; function DOMEval( code, node, doc ) { doc = doc || document; var i, val, script = doc.createElement( "script" ); script.text = code; if ( node ) { for ( i in preservedScriptAttributes ) { // Support: Firefox 64+, Edge 18+ // Some browsers don't support the "nonce" property on scripts. // On the other hand, just using `getAttribute` is not enough as // the `nonce` attribute is reset to an empty string whenever it // becomes browsing-context connected. // See https://github.com/whatwg/html/issues/2369 // See https://html.spec.whatwg.org/#nonce-attributes // The `node.getAttribute` check was added for the sake of // `jQuery.globalEval` so that it can fake a nonce-containing node // via an object. val = node[ i ] || node.getAttribute && node.getAttribute( i ); if ( val ) { script.setAttribute( i, val ); } } } doc.head.appendChild( script ).parentNode.removeChild( script ); } function toType( obj ) { if ( obj == null ) { return obj + ""; } // Support: Android <=2.3 only (functionish RegExp) return typeof obj === "object" || typeof obj === "function" ? class2type[ toString.call( obj ) ] || "object" : typeof obj; } /* global Symbol */ // Defining this global in .eslintrc.json would create a danger of using the global // unguarded in another place, it seems safer to define global only for this module var version = "3.4.1", // Define a local copy of jQuery jQuery = function( selector, context ) { // The jQuery object is actually just the init constructor 'enhanced' // Need init if jQuery is called (just allow error to be thrown if not included) return new jQuery.fn.init( selector, context ); }, // Support: Android <=4.0 only // Make sure we trim BOM and NBSP rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g; jQuery.fn = jQuery.prototype = { // The current version of jQuery being used jquery: version, constructor: jQuery, // The default length of a jQuery object is 0 length: 0, toArray: function() { return slice.call( this ); }, // Get the Nth element in the matched element set OR // Get the whole matched element set as a clean array get: function( num ) { // Return all the elements in a clean array if ( num == null ) { return slice.call( this ); } // Return just the one element from the set return num < 0 ? this[ num + this.length ] : this[ num ]; }, // Take an array of elements and push it onto the stack // (returning the new matched element set) pushStack: function( elems ) { // Build a new jQuery matched element set var ret = jQuery.merge( this.constructor(), elems ); // Add the old object onto the stack (as a reference) ret.prevObject = this; // Return the newly-formed element set return ret; }, // Execute a callback for every element in the matched set. each: function( callback ) { return jQuery.each( this, callback ); }, map: function( callback ) { return this.pushStack( jQuery.map( this, function( elem, i ) { return callback.call( elem, i, elem ); } ) ); }, slice: function() { return this.pushStack( slice.apply( this, arguments ) ); }, first: function() { return this.eq( 0 ); }, last: function() { return this.eq( -1 ); }, eq: function( i ) { var len = this.length, j = +i + ( i < 0 ? len : 0 ); return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] ); }, end: function() { return this.prevObject || this.constructor(); }, // For internal use only. // Behaves like an Array's method, not like a jQuery method. push: push, sort: arr.sort, splice: arr.splice }; jQuery.extend = jQuery.fn.extend = function() { var options, name, src, copy, copyIsArray, clone, target = arguments[ 0 ] || {}, i = 1, length = arguments.length, deep = false; // Handle a deep copy situation if ( typeof target === "boolean" ) { deep = target; // Skip the boolean and the target target = arguments[ i ] || {}; i++; } // Handle case when target is a string or something (possible in deep copy) if ( typeof target !== "object" && !isFunction( target ) ) { target = {}; } // Extend jQuery itself if only one argument is passed if ( i === length ) { target = this; i--; } for ( ; i < length; i++ ) { // Only deal with non-null/undefined values if ( ( options = arguments[ i ] ) != null ) { // Extend the base object for ( name in options ) { copy = options[ name ]; // Prevent Object.prototype pollution // Prevent never-ending loop if ( name === "__proto__" || target === copy ) { continue; } // Recurse if we're merging plain objects or arrays if ( deep && copy && ( jQuery.isPlainObject( copy ) || ( copyIsArray = Array.isArray( copy ) ) ) ) { src = target[ name ]; // Ensure proper type for the source value if ( copyIsArray && !Array.isArray( src ) ) { clone = []; } else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) { clone = {}; } else { clone = src; } copyIsArray = false; // Never move original objects, clone them target[ name ] = jQuery.extend( deep, clone, copy ); // Don't bring in undefined values } else if ( copy !== undefined ) { target[ name ] = copy; } } } } // Return the modified object return target; }; jQuery.extend( { // Unique for each copy of jQuery on the page expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ), // Assume jQuery is ready without the ready module isReady: true, error: function( msg ) { throw new Error( msg ); }, noop: function() {}, isPlainObject: function( obj ) { var proto, Ctor; // Detect obvious negatives // Use toString instead of jQuery.type to catch host objects if ( !obj || toString.call( obj ) !== "[object Object]" ) { return false; } proto = getProto( obj ); // Objects with no prototype (e.g., `Object.create( null )`) are plain if ( !proto ) { return true; } // Objects with prototype are plain iff they were constructed by a global Object function Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor; return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString; }, isEmptyObject: function( obj ) { var name; for ( name in obj ) { return false; } return true; }, // Evaluates a script in a global context globalEval: function( code, options ) { DOMEval( code, { nonce: options && options.nonce } ); }, each: function( obj, callback ) { var length, i = 0; if ( isArrayLike( obj ) ) { length = obj.length; for ( ; i < length; i++ ) { if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { break; } } } else { for ( i in obj ) { if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { break; } } } return obj; }, // Support: Android <=4.0 only trim: function( text ) { return text == null ? "" : ( text + "" ).replace( rtrim, "" ); }, // results is for internal usage only makeArray: function( arr, results ) { var ret = results || []; if ( arr != null ) { if ( isArrayLike( Object( arr ) ) ) { jQuery.merge( ret, typeof arr === "string" ? [ arr ] : arr ); } else { push.call( ret, arr ); } } return ret; }, inArray: function( elem, arr, i ) { return arr == null ? -1 : indexOf.call( arr, elem, i ); }, // Support: Android <=4.0 only, PhantomJS 1 only // push.apply(_, arraylike) throws on ancient WebKit merge: function( first, second ) { var len = +second.length, j = 0, i = first.length; for ( ; j < len; j++ ) { first[ i++ ] = second[ j ]; } first.length = i; return first; }, grep: function( elems, callback, invert ) { var callbackInverse, matches = [], i = 0, length = elems.length, callbackExpect = !invert; // Go through the array, only saving the items // that pass the validator function for ( ; i < length; i++ ) { callbackInverse = !callback( elems[ i ], i ); if ( callbackInverse !== callbackExpect ) { matches.push( elems[ i ] ); } } return matches; }, // arg is for internal usage only map: function( elems, callback, arg ) { var length, value, i = 0, ret = []; // Go through the array, translating each of the items to their new values if ( isArrayLike( elems ) ) { length = elems.length; for ( ; i < length; i++ ) { value = callback( elems[ i ], i, arg ); if ( value != null ) { ret.push( value ); } } // Go through every key on the object, } else { for ( i in elems ) { value = callback( elems[ i ], i, arg ); if ( value != null ) { ret.push( value ); } } } // Flatten any nested arrays return concat.apply( [], ret ); }, // A global GUID counter for objects guid: 1, // jQuery.support is not used in Core but other projects attach their // properties to it so it needs to exist. support: support } ); if ( typeof Symbol === "function" ) { jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ]; } // Populate the class2type map jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ), function( i, name ) { class2type[ "[object " + name + "]" ] = name.toLowerCase(); } ); function isArrayLike( obj ) { // Support: real iOS 8.2 only (not reproducible in simulator) // `in` check used to prevent JIT error (gh-2145) // hasOwn isn't used here due to false negatives // regarding Nodelist length in IE var length = !!obj && "length" in obj && obj.length, type = toType( obj ); if ( isFunction( obj ) || isWindow( obj ) ) { return false; } return type === "array" || length === 0 || typeof length === "number" && length > 0 && ( length - 1 ) in obj; } var Sizzle = /*! * Sizzle CSS Selector Engine v2.3.4 * https://sizzlejs.com/ * * Copyright JS Foundation and other contributors * Released under the MIT license * https://js.foundation/ * * Date: 2019-04-08 */ (function( window ) { var i, support, Expr, getText, isXML, tokenize, compile, select, outermostContext, sortInput, hasDuplicate, // Local document vars setDocument, document, docElem, documentIsHTML, rbuggyQSA, rbuggyMatches, matches, contains, // Instance-specific data expando = "sizzle" + 1 * new Date(), preferredDoc = window.document, dirruns = 0, done = 0, classCache = createCache(), tokenCache = createCache(), compilerCache = createCache(), nonnativeSelectorCache = createCache(), sortOrder = function( a, b ) { if ( a === b ) { hasDuplicate = true; } return 0; }, // Instance methods hasOwn = ({}).hasOwnProperty, arr = [], pop = arr.pop, push_native = arr.push, push = arr.push, slice = arr.slice, // Use a stripped-down indexOf as it's faster than native // https://jsperf.com/thor-indexof-vs-for/5 indexOf = function( list, elem ) { var i = 0, len = list.length; for ( ; i < len; i++ ) { if ( list[i] === elem ) { return i; } } return -1; }, booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped", // Regular expressions // http://www.w3.org/TR/css3-selectors/#whitespace whitespace = "[\\x20\\t\\r\\n\\f]", // http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier identifier = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+", // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace + // Operator (capture 2) "*([*^$|!~]?=)" + whitespace + // "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]" "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace + "*\\]", pseudos = ":(" + identifier + ")(?:\\((" + // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments: // 1. quoted (capture 3; capture 4 or capture 5) "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" + // 2. simple (capture 6) "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" + // 3. anything else (capture 2) ".*" + ")\\)|)", // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter rwhitespace = new RegExp( whitespace + "+", "g" ), rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ), rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ), rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ), rdescend = new RegExp( whitespace + "|>" ), rpseudo = new RegExp( pseudos ), ridentifier = new RegExp( "^" + identifier + "$" ), matchExpr = { "ID": new RegExp( "^#(" + identifier + ")" ), "CLASS": new RegExp( "^\\.(" + identifier + ")" ), "TAG": new RegExp( "^(" + identifier + "|[*])" ), "ATTR": new RegExp( "^" + attributes ), "PSEUDO": new RegExp( "^" + pseudos ), "CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ), "bool": new RegExp( "^(?:" + booleans + ")$", "i" ), // For use in libraries implementing .is() // We use this for POS matching in `select` "needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" ) }, rhtml = /HTML$/i, rinputs = /^(?:input|select|textarea|button)$/i, rheader = /^h\d$/i, rnative = /^[^{]+\{\s*\[native \w/, // Easily-parseable/retrievable ID or TAG or CLASS selectors rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, rsibling = /[+~]/, // CSS escapes // http://www.w3.org/TR/CSS21/syndata.html#escaped-characters runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ), funescape = function( _, escaped, escapedWhitespace ) { var high = "0x" + escaped - 0x10000; // NaN means non-codepoint // Support: Firefox<24 // Workaround erroneous numeric interpretation of +"0x" return high !== high || escapedWhitespace ? escaped : high < 0 ? // BMP codepoint String.fromCharCode( high + 0x10000 ) : // Supplemental Plane codepoint (surrogate pair) String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 ); }, // CSS string/identifier serialization // https://drafts.csswg.org/cssom/#common-serializing-idioms rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g, fcssescape = function( ch, asCodePoint ) { if ( asCodePoint ) { // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER if ( ch === "\0" ) { return "\uFFFD"; } // Control characters and (dependent upon position) numbers get escaped as code points return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " "; } // Other potentially-special ASCII characters get backslash-escaped return "\\" + ch; }, // Used for iframes // See setDocument() // Removing the function wrapper causes a "Permission Denied" // error in IE unloadHandler = function() { setDocument(); }, inDisabledFieldset = addCombinator( function( elem ) { return elem.disabled === true && elem.nodeName.toLowerCase() === "fieldset"; }, { dir: "parentNode", next: "legend" } ); // Optimize for push.apply( _, NodeList ) try { push.apply( (arr = slice.call( preferredDoc.childNodes )), preferredDoc.childNodes ); // Support: Android<4.0 // Detect silently failing push.apply arr[ preferredDoc.childNodes.length ].nodeType; } catch ( e ) { push = { apply: arr.length ? // Leverage slice if possible function( target, els ) { push_native.apply( target, slice.call(els) ); } : // Support: IE<9 // Otherwise append directly function( target, els ) { var j = target.length, i = 0; // Can't trust NodeList.length while ( (target[j++] = els[i++]) ) {} target.length = j - 1; } }; } function Sizzle( selector, context, results, seed ) { var m, i, elem, nid, match, groups, newSelector, newContext = context && context.ownerDocument, // nodeType defaults to 9, since context defaults to document nodeType = context ? context.nodeType : 9; results = results || []; // Return early from calls with invalid selector or context if ( typeof selector !== "string" || !selector || nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) { return results; } // Try to shortcut find operations (as opposed to filters) in HTML documents if ( !seed ) { if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) { setDocument( context ); } context = context || document; if ( documentIsHTML ) { // If the selector is sufficiently simple, try using a "get*By*" DOM method // (excepting DocumentFragment context, where the methods don't exist) if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) { // ID selector if ( (m = match[1]) ) { // Document context if ( nodeType === 9 ) { if ( (elem = context.getElementById( m )) ) { // Support: IE, Opera, Webkit // TODO: identify versions // getElementById can match elements by name instead of ID if ( elem.id === m ) { results.push( elem ); return results; } } else { return results; } // Element context } else { // Support: IE, Opera, Webkit // TODO: identify versions // getElementById can match elements by name instead of ID if ( newContext && (elem = newContext.getElementById( m )) && contains( context, elem ) && elem.id === m ) { results.push( elem ); return results; } } // Type selector } else if ( match[2] ) { push.apply( results, context.getElementsByTagName( selector ) ); return results; // Class selector } else if ( (m = match[3]) && support.getElementsByClassName && context.getElementsByClassName ) { push.apply( results, context.getElementsByClassName( m ) ); return results; } } // Take advantage of querySelectorAll if ( support.qsa && !nonnativeSelectorCache[ selector + " " ] && (!rbuggyQSA || !rbuggyQSA.test( selector )) && // Support: IE 8 only // Exclude object elements (nodeType !== 1 || context.nodeName.toLowerCase() !== "object") ) { newSelector = selector; newContext = context; // qSA considers elements outside a scoping root when evaluating child or // descendant combinators, which is not what we want. // In such cases, we work around the behavior by prefixing every selector in the // list with an ID selector referencing the scope context. // Thanks to Andrew Dupont for this technique. if ( nodeType === 1 && rdescend.test( selector ) ) { // Capture the context ID, setting it first if necessary if ( (nid = context.getAttribute( "id" )) ) { nid = nid.replace( rcssescape, fcssescape ); } else { context.setAttribute( "id", (nid = expando) ); } // Prefix every selector in the list groups = tokenize( selector ); i = groups.length; while ( i-- ) { groups[i] = "#" + nid + " " + toSelector( groups[i] ); } newSelector = groups.join( "," ); // Expand context for sibling selectors newContext = rsibling.test( selector ) && testContext( context.parentNode ) || context; } try { push.apply( results, newContext.querySelectorAll( newSelector ) ); return results; } catch ( qsaError ) { nonnativeSelectorCache( selector, true ); } finally { if ( nid === expando ) { context.removeAttribute( "id" ); } } } } } // All others return select( selector.replace( rtrim, "$1" ), context, results, seed ); } /** * Create key-value caches of limited size * @returns {function(string, object)} Returns the Object data after storing it on itself with * property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength) * deleting the oldest entry */ function createCache() { var keys = []; function cache( key, value ) { // Use (key + " ") to avoid collision with native prototype properties (see Issue #157) if ( keys.push( key + " " ) > Expr.cacheLength ) { // Only keep the most recent entries delete cache[ keys.shift() ]; } return (cache[ key + " " ] = value); } return cache; } /** * Mark a function for special use by Sizzle * @param {Function} fn The function to mark */ function markFunction( fn ) { fn[ expando ] = true; return fn; } /** * Support testing using an element * @param {Function} fn Passed the created element and returns a boolean result */ function assert( fn ) { var el = document.createElement("fieldset"); try { return !!fn( el ); } catch (e) { return false; } finally { // Remove from its parent by default if ( el.parentNode ) { el.parentNode.removeChild( el ); } // release memory in IE el = null; } } /** * Adds the same handler for all of the specified attrs * @param {String} attrs Pipe-separated list of attributes * @param {Function} handler The method that will be applied */ function addHandle( attrs, handler ) { var arr = attrs.split("|"), i = arr.length; while ( i-- ) { Expr.attrHandle[ arr[i] ] = handler; } } /** * Checks document order of two siblings * @param {Element} a * @param {Element} b * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b */ function siblingCheck( a, b ) { var cur = b && a, diff = cur && a.nodeType === 1 && b.nodeType === 1 && a.sourceIndex - b.sourceIndex; // Use IE sourceIndex if available on both nodes if ( diff ) { return diff; } // Check if b follows a if ( cur ) { while ( (cur = cur.nextSibling) ) { if ( cur === b ) { return -1; } } } return a ? 1 : -1; } /** * Returns a function to use in pseudos for input types * @param {String} type */ function createInputPseudo( type ) { return function( elem ) { var name = elem.nodeName.toLowerCase(); return name === "input" && elem.type === type; }; } /** * Returns a function to use in pseudos for buttons * @param {String} type */ function createButtonPseudo( type ) { return function( elem ) { var name = elem.nodeName.toLowerCase(); return (name === "input" || name === "button") && elem.type === type; }; } /** * Returns a function to use in pseudos for :enabled/:disabled * @param {Boolean} disabled true for :disabled; false for :enabled */ function createDisabledPseudo( disabled ) { // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable return function( elem ) { // Only certain elements can match :enabled or :disabled // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled if ( "form" in elem ) { // Check for inherited disabledness on relevant non-disabled elements: // * listed form-associated elements in a disabled fieldset // https://html.spec.whatwg.org/multipage/forms.html#category-listed // https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled // * option elements in a disabled optgroup // https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled // All such elements have a "form" property. if ( elem.parentNode && elem.disabled === false ) { // Option elements defer to a parent optgroup if present if ( "label" in elem ) { if ( "label" in elem.parentNode ) { return elem.parentNode.disabled === disabled; } else { return elem.disabled === disabled; } } // Support: IE 6 - 11 // Use the isDisabled shortcut property to check for disabled fieldset ancestors return elem.isDisabled === disabled || // Where there is no isDisabled, check manually /* jshint -W018 */ elem.isDisabled !== !disabled && inDisabledFieldset( elem ) === disabled; } return elem.disabled === disabled; // Try to winnow out elements that can't be disabled before trusting the disabled property. // Some victims get caught in our net (label, legend, menu, track), but it shouldn't // even exist on them, let alone have a boolean value. } else if ( "label" in elem ) { return elem.disabled === disabled; } // Remaining elements are neither :enabled nor :disabled return false; }; } /** * Returns a function to use in pseudos for positionals * @param {Function} fn */ function createPositionalPseudo( fn ) { return markFunction(function( argument ) { argument = +argument; return markFunction(function( seed, matches ) { var j, matchIndexes = fn( [], seed.length, argument ), i = matchIndexes.length; // Match elements found at the specified indexes while ( i-- ) { if ( seed[ (j = matchIndexes[i]) ] ) { seed[j] = !(matches[j] = seed[j]); } } }); }); } /** * Checks a node for validity as a Sizzle context * @param {Element|Object=} context * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value */ function testContext( context ) { return context && typeof context.getElementsByTagName !== "undefined" && context; } // Expose support vars for convenience support = Sizzle.support = {}; /** * Detects XML nodes * @param {Element|Object} elem An element or a document * @returns {Boolean} True iff elem is a non-HTML XML node */ isXML = Sizzle.isXML = function( elem ) { var namespace = elem.namespaceURI, docElem = (elem.ownerDocument || elem).documentElement; // Support: IE <=8 // Assume HTML when documentElement doesn't yet exist, such as inside loading iframes // https://bugs.jquery.com/ticket/4833 return !rhtml.test( namespace || docElem && docElem.nodeName || "HTML" ); }; /** * Sets document-related variables once based on the current document * @param {Element|Object} [doc] An element or document object to use to set the document * @returns {Object} Returns the current document */ setDocument = Sizzle.setDocument = function( node ) { var hasCompare, subWindow, doc = node ? node.ownerDocument || node : preferredDoc; // Return early if doc is invalid or already selected if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) { return document; } // Update global variables document = doc; docElem = document.documentElement; documentIsHTML = !isXML( document ); // Support: IE 9-11, Edge // Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936) if ( preferredDoc !== document && (subWindow = document.defaultView) && subWindow.top !== subWindow ) { // Support: IE 11, Edge if ( subWindow.addEventListener ) { subWindow.addEventListener( "unload", unloadHandler, false ); // Support: IE 9 - 10 only } else if ( subWindow.attachEvent ) { subWindow.attachEvent( "onunload", unloadHandler ); } } /* Attributes ---------------------------------------------------------------------- */ // Support: IE<8 // Verify that getAttribute really returns attributes and not properties // (excepting IE8 booleans) support.attributes = assert(function( el ) { el.className = "i"; return !el.getAttribute("className"); }); /* getElement(s)By* ---------------------------------------------------------------------- */ // Check if getElementsByTagName("*") returns only elements support.getElementsByTagName = assert(function( el ) { el.appendChild( document.createComment("") ); return !el.getElementsByTagName("*").length; }); // Support: IE<9 support.getElementsByClassName = rnative.test( document.getElementsByClassName ); // Support: IE<10 // Check if getElementById returns elements by name // The broken getElementById methods don't pick up programmatically-set names, // so use a roundabout getElementsByName test support.getById = assert(function( el ) { docElem.appendChild( el ).id = expando; return !document.getElementsByName || !document.getElementsByName( expando ).length; }); // ID filter and find if ( support.getById ) { Expr.filter["ID"] = function( id ) { var attrId = id.replace( runescape, funescape ); return function( elem ) { return elem.getAttribute("id") === attrId; }; }; Expr.find["ID"] = function( id, context ) { if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { var elem = context.getElementById( id ); return elem ? [ elem ] : []; } }; } else { Expr.filter["ID"] = function( id ) { var attrId = id.replace( runescape, funescape ); return function( elem ) { var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id"); return node && node.value === attrId; }; }; // Support: IE 6 - 7 only // getElementById is not reliable as a find shortcut Expr.find["ID"] = function( id, context ) { if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { var node, i, elems, elem = context.getElementById( id ); if ( elem ) { // Verify the id attribute node = elem.getAttributeNode("id"); if ( node && node.value === id ) { return [ elem ]; } // Fall back on getElementsByName elems = context.getElementsByName( id ); i = 0; while ( (elem = elems[i++]) ) { node = elem.getAttributeNode("id"); if ( node && node.value === id ) { return [ elem ]; } } } return []; } }; } // Tag Expr.find["TAG"] = support.getElementsByTagName ? function( tag, context ) { if ( typeof context.getElementsByTagName !== "undefined" ) { return context.getElementsByTagName( tag ); // DocumentFragment nodes don't have gEBTN } else if ( support.qsa ) { return context.querySelectorAll( tag ); } } : function( tag, context ) { var elem, tmp = [], i = 0, // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too results = context.getElementsByTagName( tag ); // Filter out possible comments if ( tag === "*" ) { while ( (elem = results[i++]) ) { if ( elem.nodeType === 1 ) { tmp.push( elem ); } } return tmp; } return results; }; // Class Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) { if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) { return context.getElementsByClassName( className ); } }; /* QSA/matchesSelector ---------------------------------------------------------------------- */ // QSA and matchesSelector support // matchesSelector(:active) reports false when true (IE9/Opera 11.5) rbuggyMatches = []; // qSa(:focus) reports false when true (Chrome 21) // We allow this because of a bug in IE8/9 that throws an error // whenever `document.activeElement` is accessed on an iframe // So, we allow :focus to pass through QSA all the time to avoid the IE error // See https://bugs.jquery.com/ticket/13378 rbuggyQSA = []; if ( (support.qsa = rnative.test( document.querySelectorAll )) ) { // Build QSA regex // Regex strategy adopted from Diego Perini assert(function( el ) { // Select is set to empty string on purpose // This is to test IE's treatment of not explicitly // setting a boolean content attribute, // since its presence should be enough // https://bugs.jquery.com/ticket/12359 docElem.appendChild( el ).innerHTML = "" + ""; // Support: IE8, Opera 11-12.16 // Nothing should be selected when empty strings follow ^= or $= or *= // The test attribute must be unknown in Opera but "safe" for WinRT // https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section if ( el.querySelectorAll("[msallowcapture^='']").length ) { rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" ); } // Support: IE8 // Boolean attributes and "value" are not treated correctly if ( !el.querySelectorAll("[selected]").length ) { rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" ); } // Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+ if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) { rbuggyQSA.push("~="); } // Webkit/Opera - :checked should return selected option elements // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked // IE8 throws error here and will not see later tests if ( !el.querySelectorAll(":checked").length ) { rbuggyQSA.push(":checked"); } // Support: Safari 8+, iOS 8+ // https://bugs.webkit.org/show_bug.cgi?id=136851 // In-page `selector#id sibling-combinator selector` fails if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) { rbuggyQSA.push(".#.+[+~]"); } }); assert(function( el ) { el.innerHTML = "" + ""; // Support: Windows 8 Native Apps // The type and name attributes are restricted during .innerHTML assignment var input = document.createElement("input"); input.setAttribute( "type", "hidden" ); el.appendChild( input ).setAttribute( "name", "D" ); // Support: IE8 // Enforce case-sensitivity of name attribute if ( el.querySelectorAll("[name=d]").length ) { rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" ); } // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled) // IE8 throws error here and will not see later tests if ( el.querySelectorAll(":enabled").length !== 2 ) { rbuggyQSA.push( ":enabled", ":disabled" ); } // Support: IE9-11+ // IE's :disabled selector does not pick up the children of disabled fieldsets docElem.appendChild( el ).disabled = true; if ( el.querySelectorAll(":disabled").length !== 2 ) { rbuggyQSA.push( ":enabled", ":disabled" ); } // Opera 10-11 does not throw on post-comma invalid pseudos el.querySelectorAll("*,:x"); rbuggyQSA.push(",.*:"); }); } if ( (support.matchesSelector = rnative.test( (matches = docElem.matches || docElem.webkitMatchesSelector || docElem.mozMatchesSelector || docElem.oMatchesSelector || docElem.msMatchesSelector) )) ) { assert(function( el ) { // Check to see if it's possible to do matchesSelector // on a disconnected node (IE 9) support.disconnectedMatch = matches.call( el, "*" ); // This should fail with an exception // Gecko does not error, returns false instead matches.call( el, "[s!='']:x" ); rbuggyMatches.push( "!=", pseudos ); }); } rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") ); rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") ); /* Contains ---------------------------------------------------------------------- */ hasCompare = rnative.test( docElem.compareDocumentPosition ); // Element contains another // Purposefully self-exclusive // As in, an element does not contain itself contains = hasCompare || rnative.test( docElem.contains ) ? function( a, b ) { var adown = a.nodeType === 9 ? a.documentElement : a, bup = b && b.parentNode; return a === bup || !!( bup && bup.nodeType === 1 && ( adown.contains ? adown.contains( bup ) : a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16 )); } : function( a, b ) { if ( b ) { while ( (b = b.parentNode) ) { if ( b === a ) { return true; } } } return false; }; /* Sorting ---------------------------------------------------------------------- */ // Document order sorting sortOrder = hasCompare ? function( a, b ) { // Flag for duplicate removal if ( a === b ) { hasDuplicate = true; return 0; } // Sort on method existence if only one input has compareDocumentPosition var compare = !a.compareDocumentPosition - !b.compareDocumentPosition; if ( compare ) { return compare; } // Calculate position if both inputs belong to the same document compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ? a.compareDocumentPosition( b ) : // Otherwise we know they are disconnected 1; // Disconnected nodes if ( compare & 1 || (!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) { // Choose the first element that is related to our preferred document if ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) { return -1; } if ( b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) { return 1; } // Maintain original order return sortInput ? ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) : 0; } return compare & 4 ? -1 : 1; } : function( a, b ) { // Exit early if the nodes are identical if ( a === b ) { hasDuplicate = true; return 0; } var cur, i = 0, aup = a.parentNode, bup = b.parentNode, ap = [ a ], bp = [ b ]; // Parentless nodes are either documents or disconnected if ( !aup || !bup ) { return a === document ? -1 : b === document ? 1 : aup ? -1 : bup ? 1 : sortInput ? ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) : 0; // If the nodes are siblings, we can do a quick check } else if ( aup === bup ) { return siblingCheck( a, b ); } // Otherwise we need full lists of their ancestors for comparison cur = a; while ( (cur = cur.parentNode) ) { ap.unshift( cur ); } cur = b; while ( (cur = cur.parentNode) ) { bp.unshift( cur ); } // Walk down the tree looking for a discrepancy while ( ap[i] === bp[i] ) { i++; } return i ? // Do a sibling check if the nodes have a common ancestor siblingCheck( ap[i], bp[i] ) : // Otherwise nodes in our document sort first ap[i] === preferredDoc ? -1 : bp[i] === preferredDoc ? 1 : 0; }; return document; }; Sizzle.matches = function( expr, elements ) { return Sizzle( expr, null, null, elements ); }; Sizzle.matchesSelector = function( elem, expr ) { // Set document vars if needed if ( ( elem.ownerDocument || elem ) !== document ) { setDocument( elem ); } if ( support.matchesSelector && documentIsHTML && !nonnativeSelectorCache[ expr + " " ] && ( !rbuggyMatches || !rbuggyMatches.test( expr ) ) && ( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) { try { var ret = matches.call( elem, expr ); // IE 9's matchesSelector returns false on disconnected nodes if ( ret || support.disconnectedMatch || // As well, disconnected nodes are said to be in a document // fragment in IE 9 elem.document && elem.document.nodeType !== 11 ) { return ret; } } catch (e) { nonnativeSelectorCache( expr, true ); } } return Sizzle( expr, document, null, [ elem ] ).length > 0; }; Sizzle.contains = function( context, elem ) { // Set document vars if needed if ( ( context.ownerDocument || context ) !== document ) { setDocument( context ); } return contains( context, elem ); }; Sizzle.attr = function( elem, name ) { // Set document vars if needed if ( ( elem.ownerDocument || elem ) !== document ) { setDocument( elem ); } var fn = Expr.attrHandle[ name.toLowerCase() ], // Don't get fooled by Object.prototype properties (jQuery #13807) val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ? fn( elem, name, !documentIsHTML ) : undefined; return val !== undefined ? val : support.attributes || !documentIsHTML ? elem.getAttribute( name ) : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null; }; Sizzle.escape = function( sel ) { return (sel + "").replace( rcssescape, fcssescape ); }; Sizzle.error = function( msg ) { throw new Error( "Syntax error, unrecognized expression: " + msg ); }; /** * Document sorting and removing duplicates * @param {ArrayLike} results */ Sizzle.uniqueSort = function( results ) { var elem, duplicates = [], j = 0, i = 0; // Unless we *know* we can detect duplicates, assume their presence hasDuplicate = !support.detectDuplicates; sortInput = !support.sortStable && results.slice( 0 ); results.sort( sortOrder ); if ( hasDuplicate ) { while ( (elem = results[i++]) ) { if ( elem === results[ i ] ) { j = duplicates.push( i ); } } while ( j-- ) { results.splice( duplicates[ j ], 1 ); } } // Clear input after sorting to release objects // See https://github.com/jquery/sizzle/pull/225 sortInput = null; return results; }; /** * Utility function for retrieving the text value of an array of DOM nodes * @param {Array|Element} elem */ getText = Sizzle.getText = function( elem ) { var node, ret = "", i = 0, nodeType = elem.nodeType; if ( !nodeType ) { // If no nodeType, this is expected to be an array while ( (node = elem[i++]) ) { // Do not traverse comment nodes ret += getText( node ); } } else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) { // Use textContent for elements // innerText usage removed for consistency of new lines (jQuery #11153) if ( typeof elem.textContent === "string" ) { return elem.textContent; } else { // Traverse its children for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { ret += getText( elem ); } } } else if ( nodeType === 3 || nodeType === 4 ) { return elem.nodeValue; } // Do not include comment or processing instruction nodes return ret; }; Expr = Sizzle.selectors = { // Can be adjusted by the user cacheLength: 50, createPseudo: markFunction, match: matchExpr, attrHandle: {}, find: {}, relative: { ">": { dir: "parentNode", first: true }, " ": { dir: "parentNode" }, "+": { dir: "previousSibling", first: true }, "~": { dir: "previousSibling" } }, preFilter: { "ATTR": function( match ) { match[1] = match[1].replace( runescape, funescape ); // Move the given value to match[3] whether quoted or unquoted match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape ); if ( match[2] === "~=" ) { match[3] = " " + match[3] + " "; } return match.slice( 0, 4 ); }, "CHILD": function( match ) { /* matches from matchExpr["CHILD"] 1 type (only|nth|...) 2 what (child|of-type) 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...) 4 xn-component of xn+y argument ([+-]?\d*n|) 5 sign of xn-component 6 x of xn-component 7 sign of y-component 8 y of y-component */ match[1] = match[1].toLowerCase(); if ( match[1].slice( 0, 3 ) === "nth" ) { // nth-* requires argument if ( !match[3] ) { Sizzle.error( match[0] ); } // numeric x and y parameters for Expr.filter.CHILD // remember that false/true cast respectively to 0/1 match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) ); match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" ); // other types prohibit arguments } else if ( match[3] ) { Sizzle.error( match[0] ); } return match; }, "PSEUDO": function( match ) { var excess, unquoted = !match[6] && match[2]; if ( matchExpr["CHILD"].test( match[0] ) ) { return null; } // Accept quoted arguments as-is if ( match[3] ) { match[2] = match[4] || match[5] || ""; // Strip excess characters from unquoted arguments } else if ( unquoted && rpseudo.test( unquoted ) && // Get excess from tokenize (recursively) (excess = tokenize( unquoted, true )) && // advance to the next closing parenthesis (excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) { // excess is a negative index match[0] = match[0].slice( 0, excess ); match[2] = unquoted.slice( 0, excess ); } // Return only captures needed by the pseudo filter method (type and argument) return match.slice( 0, 3 ); } }, filter: { "TAG": function( nodeNameSelector ) { var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase(); return nodeNameSelector === "*" ? function() { return true; } : function( elem ) { return elem.nodeName && elem.nodeName.toLowerCase() === nodeName; }; }, "CLASS": function( className ) { var pattern = classCache[ className + " " ]; return pattern || (pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) && classCache( className, function( elem ) { return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" ); }); }, "ATTR": function( name, operator, check ) { return function( elem ) { var result = Sizzle.attr( elem, name ); if ( result == null ) { return operator === "!="; } if ( !operator ) { return true; } result += ""; return operator === "=" ? result === check : operator === "!=" ? result !== check : operator === "^=" ? check && result.indexOf( check ) === 0 : operator === "*=" ? check && result.indexOf( check ) > -1 : operator === "$=" ? check && result.slice( -check.length ) === check : operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 : operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" : false; }; }, "CHILD": function( type, what, argument, first, last ) { var simple = type.slice( 0, 3 ) !== "nth", forward = type.slice( -4 ) !== "last", ofType = what === "of-type"; return first === 1 && last === 0 ? // Shortcut for :nth-*(n) function( elem ) { return !!elem.parentNode; } : function( elem, context, xml ) { var cache, uniqueCache, outerCache, node, nodeIndex, start, dir = simple !== forward ? "nextSibling" : "previousSibling", parent = elem.parentNode, name = ofType && elem.nodeName.toLowerCase(), useCache = !xml && !ofType, diff = false; if ( parent ) { // :(first|last|only)-(child|of-type) if ( simple ) { while ( dir ) { node = elem; while ( (node = node[ dir ]) ) { if ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) { return false; } } // Reverse direction for :only-* (if we haven't yet done so) start = dir = type === "only" && !start && "nextSibling"; } return true; } start = [ forward ? parent.firstChild : parent.lastChild ]; // non-xml :nth-child(...) stores cache data on `parent` if ( forward && useCache ) { // Seek `elem` from a previously-cached index // ...in a gzip-friendly way node = parent; outerCache = node[ expando ] || (node[ expando ] = {}); // Support: IE <9 only // Defend against cloned attroperties (jQuery gh-1709) uniqueCache = outerCache[ node.uniqueID ] || (outerCache[ node.uniqueID ] = {}); cache = uniqueCache[ type ] || []; nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; diff = nodeIndex && cache[ 2 ]; node = nodeIndex && parent.childNodes[ nodeIndex ]; while ( (node = ++nodeIndex && node && node[ dir ] || // Fallback to seeking `elem` from the start (diff = nodeIndex = 0) || start.pop()) ) { // When found, cache indexes on `parent` and break if ( node.nodeType === 1 && ++diff && node === elem ) { uniqueCache[ type ] = [ dirruns, nodeIndex, diff ]; break; } } } else { // Use previously-cached element index if available if ( useCache ) { // ...in a gzip-friendly way node = elem; outerCache = node[ expando ] || (node[ expando ] = {}); // Support: IE <9 only // Defend against cloned attroperties (jQuery gh-1709) uniqueCache = outerCache[ node.uniqueID ] || (outerCache[ node.uniqueID ] = {}); cache = uniqueCache[ type ] || []; nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; diff = nodeIndex; } // xml :nth-child(...) // or :nth-last-child(...) or :nth(-last)?-of-type(...) if ( diff === false ) { // Use the same loop as above to seek `elem` from the start while ( (node = ++nodeIndex && node && node[ dir ] || (diff = nodeIndex = 0) || start.pop()) ) { if ( ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) { // Cache the index of each encountered element if ( useCache ) { outerCache = node[ expando ] || (node[ expando ] = {}); // Support: IE <9 only // Defend against cloned attroperties (jQuery gh-1709) uniqueCache = outerCache[ node.uniqueID ] || (outerCache[ node.uniqueID ] = {}); uniqueCache[ type ] = [ dirruns, diff ]; } if ( node === elem ) { break; } } } } } // Incorporate the offset, then check against cycle size diff -= last; return diff === first || ( diff % first === 0 && diff / first >= 0 ); } }; }, "PSEUDO": function( pseudo, argument ) { // pseudo-class names are case-insensitive // http://www.w3.org/TR/selectors/#pseudo-classes // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters // Remember that setFilters inherits from pseudos var args, fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] || Sizzle.error( "unsupported pseudo: " + pseudo ); // The user may use createPseudo to indicate that // arguments are needed to create the filter function // just as Sizzle does if ( fn[ expando ] ) { return fn( argument ); } // But maintain support for old signatures if ( fn.length > 1 ) { args = [ pseudo, pseudo, "", argument ]; return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ? markFunction(function( seed, matches ) { var idx, matched = fn( seed, argument ), i = matched.length; while ( i-- ) { idx = indexOf( seed, matched[i] ); seed[ idx ] = !( matches[ idx ] = matched[i] ); } }) : function( elem ) { return fn( elem, 0, args ); }; } return fn; } }, pseudos: { // Potentially complex pseudos "not": markFunction(function( selector ) { // Trim the selector passed to compile // to avoid treating leading and trailing // spaces as combinators var input = [], results = [], matcher = compile( selector.replace( rtrim, "$1" ) ); return matcher[ expando ] ? markFunction(function( seed, matches, context, xml ) { var elem, unmatched = matcher( seed, null, xml, [] ), i = seed.length; // Match elements unmatched by `matcher` while ( i-- ) { if ( (elem = unmatched[i]) ) { seed[i] = !(matches[i] = elem); } } }) : function( elem, context, xml ) { input[0] = elem; matcher( input, null, xml, results ); // Don't keep the element (issue #299) input[0] = null; return !results.pop(); }; }), "has": markFunction(function( selector ) { return function( elem ) { return Sizzle( selector, elem ).length > 0; }; }), "contains": markFunction(function( text ) { text = text.replace( runescape, funescape ); return function( elem ) { return ( elem.textContent || getText( elem ) ).indexOf( text ) > -1; }; }), // "Whether an element is represented by a :lang() selector // is based solely on the element's language value // being equal to the identifier C, // or beginning with the identifier C immediately followed by "-". // The matching of C against the element's language value is performed case-insensitively. // The identifier C does not have to be a valid language name." // http://www.w3.org/TR/selectors/#lang-pseudo "lang": markFunction( function( lang ) { // lang value must be a valid identifier if ( !ridentifier.test(lang || "") ) { Sizzle.error( "unsupported lang: " + lang ); } lang = lang.replace( runescape, funescape ).toLowerCase(); return function( elem ) { var elemLang; do { if ( (elemLang = documentIsHTML ? elem.lang : elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) { elemLang = elemLang.toLowerCase(); return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0; } } while ( (elem = elem.parentNode) && elem.nodeType === 1 ); return false; }; }), // Miscellaneous "target": function( elem ) { var hash = window.location && window.location.hash; return hash && hash.slice( 1 ) === elem.id; }, "root": function( elem ) { return elem === docElem; }, "focus": function( elem ) { return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex); }, // Boolean properties "enabled": createDisabledPseudo( false ), "disabled": createDisabledPseudo( true ), "checked": function( elem ) { // In CSS3, :checked should return both checked and selected elements // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked var nodeName = elem.nodeName.toLowerCase(); return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected); }, "selected": function( elem ) { // Accessing this property makes selected-by-default // options in Safari work properly if ( elem.parentNode ) { elem.parentNode.selectedIndex; } return elem.selected === true; }, // Contents "empty": function( elem ) { // http://www.w3.org/TR/selectors/#empty-pseudo // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5), // but not by others (comment: 8; processing instruction: 7; etc.) // nodeType < 6 works because attributes (2) do not appear as children for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { if ( elem.nodeType < 6 ) { return false; } } return true; }, "parent": function( elem ) { return !Expr.pseudos["empty"]( elem ); }, // Element/input types "header": function( elem ) { return rheader.test( elem.nodeName ); }, "input": function( elem ) { return rinputs.test( elem.nodeName ); }, "button": function( elem ) { var name = elem.nodeName.toLowerCase(); return name === "input" && elem.type === "button" || name === "button"; }, "text": function( elem ) { var attr; return elem.nodeName.toLowerCase() === "input" && elem.type === "text" && // Support: IE<8 // New HTML5 attribute values (e.g., "search") appear with elem.type === "text" ( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" ); }, // Position-in-collection "first": createPositionalPseudo(function() { return [ 0 ]; }), "last": createPositionalPseudo(function( matchIndexes, length ) { return [ length - 1 ]; }), "eq": createPositionalPseudo(function( matchIndexes, length, argument ) { return [ argument < 0 ? argument + length : argument ]; }), "even": createPositionalPseudo(function( matchIndexes, length ) { var i = 0; for ( ; i < length; i += 2 ) { matchIndexes.push( i ); } return matchIndexes; }), "odd": createPositionalPseudo(function( matchIndexes, length ) { var i = 1; for ( ; i < length; i += 2 ) { matchIndexes.push( i ); } return matchIndexes; }), "lt": createPositionalPseudo(function( matchIndexes, length, argument ) { var i = argument < 0 ? argument + length : argument > length ? length : argument; for ( ; --i >= 0; ) { matchIndexes.push( i ); } return matchIndexes; }), "gt": createPositionalPseudo(function( matchIndexes, length, argument ) { var i = argument < 0 ? argument + length : argument; for ( ; ++i < length; ) { matchIndexes.push( i ); } return matchIndexes; }) } }; Expr.pseudos["nth"] = Expr.pseudos["eq"]; // Add button/input type pseudos for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) { Expr.pseudos[ i ] = createInputPseudo( i ); } for ( i in { submit: true, reset: true } ) { Expr.pseudos[ i ] = createButtonPseudo( i ); } // Easy API for creating new setFilters function setFilters() {} setFilters.prototype = Expr.filters = Expr.pseudos; Expr.setFilters = new setFilters(); tokenize = Sizzle.tokenize = function( selector, parseOnly ) { var matched, match, tokens, type, soFar, groups, preFilters, cached = tokenCache[ selector + " " ]; if ( cached ) { return parseOnly ? 0 : cached.slice( 0 ); } soFar = selector; groups = []; preFilters = Expr.preFilter; while ( soFar ) { // Comma and first run if ( !matched || (match = rcomma.exec( soFar )) ) { if ( match ) { // Don't consume trailing commas as valid soFar = soFar.slice( match[0].length ) || soFar; } groups.push( (tokens = []) ); } matched = false; // Combinators if ( (match = rcombinators.exec( soFar )) ) { matched = match.shift(); tokens.push({ value: matched, // Cast descendant combinators to space type: match[0].replace( rtrim, " " ) }); soFar = soFar.slice( matched.length ); } // Filters for ( type in Expr.filter ) { if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] || (match = preFilters[ type ]( match ))) ) { matched = match.shift(); tokens.push({ value: matched, type: type, matches: match }); soFar = soFar.slice( matched.length ); } } if ( !matched ) { break; } } // Return the length of the invalid excess // if we're just parsing // Otherwise, throw an error or return tokens return parseOnly ? soFar.length : soFar ? Sizzle.error( selector ) : // Cache the tokens tokenCache( selector, groups ).slice( 0 ); }; function toSelector( tokens ) { var i = 0, len = tokens.length, selector = ""; for ( ; i < len; i++ ) { selector += tokens[i].value; } return selector; } function addCombinator( matcher, combinator, base ) { var dir = combinator.dir, skip = combinator.next, key = skip || dir, checkNonElements = base && key === "parentNode", doneName = done++; return combinator.first ? // Check against closest ancestor/preceding element function( elem, context, xml ) { while ( (elem = elem[ dir ]) ) { if ( elem.nodeType === 1 || checkNonElements ) { return matcher( elem, context, xml ); } } return false; } : // Check against all ancestor/preceding elements function( elem, context, xml ) { var oldCache, uniqueCache, outerCache, newCache = [ dirruns, doneName ]; // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching if ( xml ) { while ( (elem = elem[ dir ]) ) { if ( elem.nodeType === 1 || checkNonElements ) { if ( matcher( elem, context, xml ) ) { return true; } } } } else { while ( (elem = elem[ dir ]) ) { if ( elem.nodeType === 1 || checkNonElements ) { outerCache = elem[ expando ] || (elem[ expando ] = {}); // Support: IE <9 only // Defend against cloned attroperties (jQuery gh-1709) uniqueCache = outerCache[ elem.uniqueID ] || (outerCache[ elem.uniqueID ] = {}); if ( skip && skip === elem.nodeName.toLowerCase() ) { elem = elem[ dir ] || elem; } else if ( (oldCache = uniqueCache[ key ]) && oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) { // Assign to newCache so results back-propagate to previous elements return (newCache[ 2 ] = oldCache[ 2 ]); } else { // Reuse newcache so results back-propagate to previous elements uniqueCache[ key ] = newCache; // A match means we're done; a fail means we have to keep checking if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) { return true; } } } } } return false; }; } function elementMatcher( matchers ) { return matchers.length > 1 ? function( elem, context, xml ) { var i = matchers.length; while ( i-- ) { if ( !matchers[i]( elem, context, xml ) ) { return false; } } return true; } : matchers[0]; } function multipleContexts( selector, contexts, results ) { var i = 0, len = contexts.length; for ( ; i < len; i++ ) { Sizzle( selector, contexts[i], results ); } return results; } function condense( unmatched, map, filter, context, xml ) { var elem, newUnmatched = [], i = 0, len = unmatched.length, mapped = map != null; for ( ; i < len; i++ ) { if ( (elem = unmatched[i]) ) { if ( !filter || filter( elem, context, xml ) ) { newUnmatched.push( elem ); if ( mapped ) { map.push( i ); } } } } return newUnmatched; } function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) { if ( postFilter && !postFilter[ expando ] ) { postFilter = setMatcher( postFilter ); } if ( postFinder && !postFinder[ expando ] ) { postFinder = setMatcher( postFinder, postSelector ); } return markFunction(function( seed, results, context, xml ) { var temp, i, elem, preMap = [], postMap = [], preexisting = results.length, // Get initial elements from seed or context elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ), // Prefilter to get matcher input, preserving a map for seed-results synchronization matcherIn = preFilter && ( seed || !selector ) ? condense( elems, preMap, preFilter, context, xml ) : elems, matcherOut = matcher ? // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results, postFinder || ( seed ? preFilter : preexisting || postFilter ) ? // ...intermediate processing is necessary [] : // ...otherwise use results directly results : matcherIn; // Find primary matches if ( matcher ) { matcher( matcherIn, matcherOut, context, xml ); } // Apply postFilter if ( postFilter ) { temp = condense( matcherOut, postMap ); postFilter( temp, [], context, xml ); // Un-match failing elements by moving them back to matcherIn i = temp.length; while ( i-- ) { if ( (elem = temp[i]) ) { matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem); } } } if ( seed ) { if ( postFinder || preFilter ) { if ( postFinder ) { // Get the final matcherOut by condensing this intermediate into postFinder contexts temp = []; i = matcherOut.length; while ( i-- ) { if ( (elem = matcherOut[i]) ) { // Restore matcherIn since elem is not yet a final match temp.push( (matcherIn[i] = elem) ); } } postFinder( null, (matcherOut = []), temp, xml ); } // Move matched elements from seed to results to keep them synchronized i = matcherOut.length; while ( i-- ) { if ( (elem = matcherOut[i]) && (temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) { seed[temp] = !(results[temp] = elem); } } } // Add elements to results, through postFinder if defined } else { matcherOut = condense( matcherOut === results ? matcherOut.splice( preexisting, matcherOut.length ) : matcherOut ); if ( postFinder ) { postFinder( null, results, matcherOut, xml ); } else { push.apply( results, matcherOut ); } } }); } function matcherFromTokens( tokens ) { var checkContext, matcher, j, len = tokens.length, leadingRelative = Expr.relative[ tokens[0].type ], implicitRelative = leadingRelative || Expr.relative[" "], i = leadingRelative ? 1 : 0, // The foundational matcher ensures that elements are reachable from top-level context(s) matchContext = addCombinator( function( elem ) { return elem === checkContext; }, implicitRelative, true ), matchAnyContext = addCombinator( function( elem ) { return indexOf( checkContext, elem ) > -1; }, implicitRelative, true ), matchers = [ function( elem, context, xml ) { var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || ( (checkContext = context).nodeType ? matchContext( elem, context, xml ) : matchAnyContext( elem, context, xml ) ); // Avoid hanging onto element (issue #299) checkContext = null; return ret; } ]; for ( ; i < len; i++ ) { if ( (matcher = Expr.relative[ tokens[i].type ]) ) { matchers = [ addCombinator(elementMatcher( matchers ), matcher) ]; } else { matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches ); // Return special upon seeing a positional matcher if ( matcher[ expando ] ) { // Find the next relative operator (if any) for proper handling j = ++i; for ( ; j < len; j++ ) { if ( Expr.relative[ tokens[j].type ] ) { break; } } return setMatcher( i > 1 && elementMatcher( matchers ), i > 1 && toSelector( // If the preceding token was a descendant combinator, insert an implicit any-element `*` tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" }) ).replace( rtrim, "$1" ), matcher, i < j && matcherFromTokens( tokens.slice( i, j ) ), j < len && matcherFromTokens( (tokens = tokens.slice( j )) ), j < len && toSelector( tokens ) ); } matchers.push( matcher ); } } return elementMatcher( matchers ); } function matcherFromGroupMatchers( elementMatchers, setMatchers ) { var bySet = setMatchers.length > 0, byElement = elementMatchers.length > 0, superMatcher = function( seed, context, xml, results, outermost ) { var elem, j, matcher, matchedCount = 0, i = "0", unmatched = seed && [], setMatched = [], contextBackup = outermostContext, // We must always have either seed elements or outermost context elems = seed || byElement && Expr.find["TAG"]( "*", outermost ), // Use integer dirruns iff this is the outermost matcher dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1), len = elems.length; if ( outermost ) { outermostContext = context === document || context || outermost; } // Add elements passing elementMatchers directly to results // Support: IE<9, Safari // Tolerate NodeList properties (IE: "length"; Safari: ) matching elements by id for ( ; i !== len && (elem = elems[i]) != null; i++ ) { if ( byElement && elem ) { j = 0; if ( !context && elem.ownerDocument !== document ) { setDocument( elem ); xml = !documentIsHTML; } while ( (matcher = elementMatchers[j++]) ) { if ( matcher( elem, context || document, xml) ) { results.push( elem ); break; } } if ( outermost ) { dirruns = dirrunsUnique; } } // Track unmatched elements for set filters if ( bySet ) { // They will have gone through all possible matchers if ( (elem = !matcher && elem) ) { matchedCount--; } // Lengthen the array for every element, matched or not if ( seed ) { unmatched.push( elem ); } } } // `i` is now the count of elements visited above, and adding it to `matchedCount` // makes the latter nonnegative. matchedCount += i; // Apply set filters to unmatched elements // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount` // equals `i`), unless we didn't visit _any_ elements in the above loop because we have // no element matchers and no seed. // Incrementing an initially-string "0" `i` allows `i` to remain a string only in that // case, which will result in a "00" `matchedCount` that differs from `i` but is also // numerically zero. if ( bySet && i !== matchedCount ) { j = 0; while ( (matcher = setMatchers[j++]) ) { matcher( unmatched, setMatched, context, xml ); } if ( seed ) { // Reintegrate element matches to eliminate the need for sorting if ( matchedCount > 0 ) { while ( i-- ) { if ( !(unmatched[i] || setMatched[i]) ) { setMatched[i] = pop.call( results ); } } } // Discard index placeholder values to get only actual matches setMatched = condense( setMatched ); } // Add matches to results push.apply( results, setMatched ); // Seedless set matches succeeding multiple successful matchers stipulate sorting if ( outermost && !seed && setMatched.length > 0 && ( matchedCount + setMatchers.length ) > 1 ) { Sizzle.uniqueSort( results ); } } // Override manipulation of globals by nested matchers if ( outermost ) { dirruns = dirrunsUnique; outermostContext = contextBackup; } return unmatched; }; return bySet ? markFunction( superMatcher ) : superMatcher; } compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) { var i, setMatchers = [], elementMatchers = [], cached = compilerCache[ selector + " " ]; if ( !cached ) { // Generate a function of recursive functions that can be used to check each element if ( !match ) { match = tokenize( selector ); } i = match.length; while ( i-- ) { cached = matcherFromTokens( match[i] ); if ( cached[ expando ] ) { setMatchers.push( cached ); } else { elementMatchers.push( cached ); } } // Cache the compiled function cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) ); // Save selector and tokenization cached.selector = selector; } return cached; }; /** * A low-level selection function that works with Sizzle's compiled * selector functions * @param {String|Function} selector A selector or a pre-compiled * selector function built with Sizzle.compile * @param {Element} context * @param {Array} [results] * @param {Array} [seed] A set of elements to match against */ select = Sizzle.select = function( selector, context, results, seed ) { var i, tokens, token, type, find, compiled = typeof selector === "function" && selector, match = !seed && tokenize( (selector = compiled.selector || selector) ); results = results || []; // Try to minimize operations if there is only one selector in the list and no seed // (the latter of which guarantees us context) if ( match.length === 1 ) { // Reduce context if the leading compound selector is an ID tokens = match[0] = match[0].slice( 0 ); if ( tokens.length > 2 && (token = tokens[0]).type === "ID" && context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[1].type ] ) { context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0]; if ( !context ) { return results; // Precompiled matchers will still verify ancestry, so step up a level } else if ( compiled ) { context = context.parentNode; } selector = selector.slice( tokens.shift().value.length ); } // Fetch a seed set for right-to-left matching i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length; while ( i-- ) { token = tokens[i]; // Abort if we hit a combinator if ( Expr.relative[ (type = token.type) ] ) { break; } if ( (find = Expr.find[ type ]) ) { // Search, expanding context for leading sibling combinators if ( (seed = find( token.matches[0].replace( runescape, funescape ), rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context )) ) { // If seed is empty or no tokens remain, we can return early tokens.splice( i, 1 ); selector = seed.length && toSelector( tokens ); if ( !selector ) { push.apply( results, seed ); return results; } break; } } } } // Compile and execute a filtering function if one is not provided // Provide `match` to avoid retokenization if we modified the selector above ( compiled || compile( selector, match ) )( seed, context, !documentIsHTML, results, !context || rsibling.test( selector ) && testContext( context.parentNode ) || context ); return results; }; // One-time assignments // Sort stability support.sortStable = expando.split("").sort( sortOrder ).join("") === expando; // Support: Chrome 14-35+ // Always assume duplicates if they aren't passed to the comparison function support.detectDuplicates = !!hasDuplicate; // Initialize against the default document setDocument(); // Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27) // Detached nodes confoundingly follow *each other* support.sortDetached = assert(function( el ) { // Should return 1, but returns 4 (following) return el.compareDocumentPosition( document.createElement("fieldset") ) & 1; }); // Support: IE<8 // Prevent attribute/property "interpolation" // https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx if ( !assert(function( el ) { el.innerHTML = ""; return el.firstChild.getAttribute("href") === "#" ; }) ) { addHandle( "type|href|height|width", function( elem, name, isXML ) { if ( !isXML ) { return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 ); } }); } // Support: IE<9 // Use defaultValue in place of getAttribute("value") if ( !support.attributes || !assert(function( el ) { el.innerHTML = ""; el.firstChild.setAttribute( "value", "" ); return el.firstChild.getAttribute( "value" ) === ""; }) ) { addHandle( "value", function( elem, name, isXML ) { if ( !isXML && elem.nodeName.toLowerCase() === "input" ) { return elem.defaultValue; } }); } // Support: IE<9 // Use getAttributeNode to fetch booleans when getAttribute lies if ( !assert(function( el ) { return el.getAttribute("disabled") == null; }) ) { addHandle( booleans, function( elem, name, isXML ) { var val; if ( !isXML ) { return elem[ name ] === true ? name.toLowerCase() : (val = elem.getAttributeNode( name )) && val.specified ? val.value : null; } }); } return Sizzle; })( window ); jQuery.find = Sizzle; jQuery.expr = Sizzle.selectors; // Deprecated jQuery.expr[ ":" ] = jQuery.expr.pseudos; jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort; jQuery.text = Sizzle.getText; jQuery.isXMLDoc = Sizzle.isXML; jQuery.contains = Sizzle.contains; jQuery.escapeSelector = Sizzle.escape; var dir = function( elem, dir, until ) { var matched = [], truncate = until !== undefined; while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) { if ( elem.nodeType === 1 ) { if ( truncate && jQuery( elem ).is( until ) ) { break; } matched.push( elem ); } } return matched; }; var siblings = function( n, elem ) { var matched = []; for ( ; n; n = n.nextSibling ) { if ( n.nodeType === 1 && n !== elem ) { matched.push( n ); } } return matched; }; var rneedsContext = jQuery.expr.match.needsContext; function nodeName( elem, name ) { return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase(); }; var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i ); // Implement the identical functionality for filter and not function winnow( elements, qualifier, not ) { if ( isFunction( qualifier ) ) { return jQuery.grep( elements, function( elem, i ) { return !!qualifier.call( elem, i, elem ) !== not; } ); } // Single element if ( qualifier.nodeType ) { return jQuery.grep( elements, function( elem ) { return ( elem === qualifier ) !== not; } ); } // Arraylike of elements (jQuery, arguments, Array) if ( typeof qualifier !== "string" ) { return jQuery.grep( elements, function( elem ) { return ( indexOf.call( qualifier, elem ) > -1 ) !== not; } ); } // Filtered directly for both simple and complex selectors return jQuery.filter( qualifier, elements, not ); } jQuery.filter = function( expr, elems, not ) { var elem = elems[ 0 ]; if ( not ) { expr = ":not(" + expr + ")"; } if ( elems.length === 1 && elem.nodeType === 1 ) { return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : []; } return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) { return elem.nodeType === 1; } ) ); }; jQuery.fn.extend( { find: function( selector ) { var i, ret, len = this.length, self = this; if ( typeof selector !== "string" ) { return this.pushStack( jQuery( selector ).filter( function() { for ( i = 0; i < len; i++ ) { if ( jQuery.contains( self[ i ], this ) ) { return true; } } } ) ); } ret = this.pushStack( [] ); for ( i = 0; i < len; i++ ) { jQuery.find( selector, self[ i ], ret ); } return len > 1 ? jQuery.uniqueSort( ret ) : ret; }, filter: function( selector ) { return this.pushStack( winnow( this, selector || [], false ) ); }, not: function( selector ) { return this.pushStack( winnow( this, selector || [], true ) ); }, is: function( selector ) { return !!winnow( this, // If this is a positional/relative selector, check membership in the returned set // so $("p:first").is("p:last") won't return true for a doc with two "p". typeof selector === "string" && rneedsContext.test( selector ) ? jQuery( selector ) : selector || [], false ).length; } } ); // Initialize a jQuery object // A central reference to the root jQuery(document) var rootjQuery, // A simple way to check for HTML strings // Prioritize #id over to avoid XSS via location.hash (#9521) // Strict HTML recognition (#11290: must start with <) // Shortcut simple #id case for speed rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/, init = jQuery.fn.init = function( selector, context, root ) { var match, elem; // HANDLE: $(""), $(null), $(undefined), $(false) if ( !selector ) { return this; } // Method init() accepts an alternate rootjQuery // so migrate can support jQuery.sub (gh-2101) root = root || rootjQuery; // Handle HTML strings if ( typeof selector === "string" ) { if ( selector[ 0 ] === "<" && selector[ selector.length - 1 ] === ">" && selector.length >= 3 ) { // Assume that strings that start and end with <> are HTML and skip the regex check match = [ null, selector, null ]; } else { match = rquickExpr.exec( selector ); } // Match html or make sure no context is specified for #id if ( match && ( match[ 1 ] || !context ) ) { // HANDLE: $(html) -> $(array) if ( match[ 1 ] ) { context = context instanceof jQuery ? context[ 0 ] : context; // Option to run scripts is true for back-compat // Intentionally let the error be thrown if parseHTML is not present jQuery.merge( this, jQuery.parseHTML( match[ 1 ], context && context.nodeType ? context.ownerDocument || context : document, true ) ); // HANDLE: $(html, props) if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) { for ( match in context ) { // Properties of context are called as methods if possible if ( isFunction( this[ match ] ) ) { this[ match ]( context[ match ] ); // ...and otherwise set as attributes } else { this.attr( match, context[ match ] ); } } } return this; // HANDLE: $(#id) } else { elem = document.getElementById( match[ 2 ] ); if ( elem ) { // Inject the element directly into the jQuery object this[ 0 ] = elem; this.length = 1; } return this; } // HANDLE: $(expr, $(...)) } else if ( !context || context.jquery ) { return ( context || root ).find( selector ); // HANDLE: $(expr, context) // (which is just equivalent to: $(context).find(expr) } else { return this.constructor( context ).find( selector ); } // HANDLE: $(DOMElement) } else if ( selector.nodeType ) { this[ 0 ] = selector; this.length = 1; return this; // HANDLE: $(function) // Shortcut for document ready } else if ( isFunction( selector ) ) { return root.ready !== undefined ? root.ready( selector ) : // Execute immediately if ready is not present selector( jQuery ); } return jQuery.makeArray( selector, this ); }; // Give the init function the jQuery prototype for later instantiation init.prototype = jQuery.fn; // Initialize central reference rootjQuery = jQuery( document ); var rparentsprev = /^(?:parents|prev(?:Until|All))/, // Methods guaranteed to produce a unique set when starting from a unique set guaranteedUnique = { children: true, contents: true, next: true, prev: true }; jQuery.fn.extend( { has: function( target ) { var targets = jQuery( target, this ), l = targets.length; return this.filter( function() { var i = 0; for ( ; i < l; i++ ) { if ( jQuery.contains( this, targets[ i ] ) ) { return true; } } } ); }, closest: function( selectors, context ) { var cur, i = 0, l = this.length, matched = [], targets = typeof selectors !== "string" && jQuery( selectors ); // Positional selectors never match, since there's no _selection_ context if ( !rneedsContext.test( selectors ) ) { for ( ; i < l; i++ ) { for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) { // Always skip document fragments if ( cur.nodeType < 11 && ( targets ? targets.index( cur ) > -1 : // Don't pass non-elements to Sizzle cur.nodeType === 1 && jQuery.find.matchesSelector( cur, selectors ) ) ) { matched.push( cur ); break; } } } } return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched ); }, // Determine the position of an element within the set index: function( elem ) { // No argument, return index in parent if ( !elem ) { return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1; } // Index in selector if ( typeof elem === "string" ) { return indexOf.call( jQuery( elem ), this[ 0 ] ); } // Locate the position of the desired element return indexOf.call( this, // If it receives a jQuery object, the first element is used elem.jquery ? elem[ 0 ] : elem ); }, add: function( selector, context ) { return this.pushStack( jQuery.uniqueSort( jQuery.merge( this.get(), jQuery( selector, context ) ) ) ); }, addBack: function( selector ) { return this.add( selector == null ? this.prevObject : this.prevObject.filter( selector ) ); } } ); function sibling( cur, dir ) { while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {} return cur; } jQuery.each( { parent: function( elem ) { var parent = elem.parentNode; return parent && parent.nodeType !== 11 ? parent : null; }, parents: function( elem ) { return dir( elem, "parentNode" ); }, parentsUntil: function( elem, i, until ) { return dir( elem, "parentNode", until ); }, next: function( elem ) { return sibling( elem, "nextSibling" ); }, prev: function( elem ) { return sibling( elem, "previousSibling" ); }, nextAll: function( elem ) { return dir( elem, "nextSibling" ); }, prevAll: function( elem ) { return dir( elem, "previousSibling" ); }, nextUntil: function( elem, i, until ) { return dir( elem, "nextSibling", until ); }, prevUntil: function( elem, i, until ) { return dir( elem, "previousSibling", until ); }, siblings: function( elem ) { return siblings( ( elem.parentNode || {} ).firstChild, elem ); }, children: function( elem ) { return siblings( elem.firstChild ); }, contents: function( elem ) { if ( typeof elem.contentDocument !== "undefined" ) { return elem.contentDocument; } // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only // Treat the template element as a regular one in browsers that // don't support it. if ( nodeName( elem, "template" ) ) { elem = elem.content || elem; } return jQuery.merge( [], elem.childNodes ); } }, function( name, fn ) { jQuery.fn[ name ] = function( until, selector ) { var matched = jQuery.map( this, fn, until ); if ( name.slice( -5 ) !== "Until" ) { selector = until; } if ( selector && typeof selector === "string" ) { matched = jQuery.filter( selector, matched ); } if ( this.length > 1 ) { // Remove duplicates if ( !guaranteedUnique[ name ] ) { jQuery.uniqueSort( matched ); } // Reverse order for parents* and prev-derivatives if ( rparentsprev.test( name ) ) { matched.reverse(); } } return this.pushStack( matched ); }; } ); var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g ); // Convert String-formatted options into Object-formatted ones function createOptions( options ) { var object = {}; jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) { object[ flag ] = true; } ); return object; } /* * Create a callback list using the following parameters: * * options: an optional list of space-separated options that will change how * the callback list behaves or a more traditional option object * * By default a callback list will act like an event callback list and can be * "fired" multiple times. * * Possible options: * * once: will ensure the callback list can only be fired once (like a Deferred) * * memory: will keep track of previous values and will call any callback added * after the list has been fired right away with the latest "memorized" * values (like a Deferred) * * unique: will ensure a callback can only be added once (no duplicate in the list) * * stopOnFalse: interrupt callings when a callback returns false * */ jQuery.Callbacks = function( options ) { // Convert options from String-formatted to Object-formatted if needed // (we check in cache first) options = typeof options === "string" ? createOptions( options ) : jQuery.extend( {}, options ); var // Flag to know if list is currently firing firing, // Last fire value for non-forgettable lists memory, // Flag to know if list was already fired fired, // Flag to prevent firing locked, // Actual callback list list = [], // Queue of execution data for repeatable lists queue = [], // Index of currently firing callback (modified by add/remove as needed) firingIndex = -1, // Fire callbacks fire = function() { // Enforce single-firing locked = locked || options.once; // Execute callbacks for all pending executions, // respecting firingIndex overrides and runtime changes fired = firing = true; for ( ; queue.length; firingIndex = -1 ) { memory = queue.shift(); while ( ++firingIndex < list.length ) { // Run callback and check for early termination if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false && options.stopOnFalse ) { // Jump to end and forget the data so .add doesn't re-fire firingIndex = list.length; memory = false; } } } // Forget the data if we're done with it if ( !options.memory ) { memory = false; } firing = false; // Clean up if we're done firing for good if ( locked ) { // Keep an empty list if we have data for future add calls if ( memory ) { list = []; // Otherwise, this object is spent } else { list = ""; } } }, // Actual Callbacks object self = { // Add a callback or a collection of callbacks to the list add: function() { if ( list ) { // If we have memory from a past run, we should fire after adding if ( memory && !firing ) { firingIndex = list.length - 1; queue.push( memory ); } ( function add( args ) { jQuery.each( args, function( _, arg ) { if ( isFunction( arg ) ) { if ( !options.unique || !self.has( arg ) ) { list.push( arg ); } } else if ( arg && arg.length && toType( arg ) !== "string" ) { // Inspect recursively add( arg ); } } ); } )( arguments ); if ( memory && !firing ) { fire(); } } return this; }, // Remove a callback from the list remove: function() { jQuery.each( arguments, function( _, arg ) { var index; while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) { list.splice( index, 1 ); // Handle firing indexes if ( index <= firingIndex ) { firingIndex--; } } } ); return this; }, // Check if a given callback is in the list. // If no argument is given, return whether or not list has callbacks attached. has: function( fn ) { return fn ? jQuery.inArray( fn, list ) > -1 : list.length > 0; }, // Remove all callbacks from the list empty: function() { if ( list ) { list = []; } return this; }, // Disable .fire and .add // Abort any current/pending executions // Clear all callbacks and values disable: function() { locked = queue = []; list = memory = ""; return this; }, disabled: function() { return !list; }, // Disable .fire // Also disable .add unless we have memory (since it would have no effect) // Abort any pending executions lock: function() { locked = queue = []; if ( !memory && !firing ) { list = memory = ""; } return this; }, locked: function() { return !!locked; }, // Call all callbacks with the given context and arguments fireWith: function( context, args ) { if ( !locked ) { args = args || []; args = [ context, args.slice ? args.slice() : args ]; queue.push( args ); if ( !firing ) { fire(); } } return this; }, // Call all the callbacks with the given arguments fire: function() { self.fireWith( this, arguments ); return this; }, // To know if the callbacks have already been called at least once fired: function() { return !!fired; } }; return self; }; function Identity( v ) { return v; } function Thrower( ex ) { throw ex; } function adoptValue( value, resolve, reject, noValue ) { var method; try { // Check for promise aspect first to privilege synchronous behavior if ( value && isFunction( ( method = value.promise ) ) ) { method.call( value ).done( resolve ).fail( reject ); // Other thenables } else if ( value && isFunction( ( method = value.then ) ) ) { method.call( value, resolve, reject ); // Other non-thenables } else { // Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer: // * false: [ value ].slice( 0 ) => resolve( value ) // * true: [ value ].slice( 1 ) => resolve() resolve.apply( undefined, [ value ].slice( noValue ) ); } // For Promises/A+, convert exceptions into rejections // Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in // Deferred#then to conditionally suppress rejection. } catch ( value ) { // Support: Android 4.0 only // Strict mode functions invoked without .call/.apply get global-object context reject.apply( undefined, [ value ] ); } } jQuery.extend( { Deferred: function( func ) { var tuples = [ // action, add listener, callbacks, // ... .then handlers, argument index, [final state] [ "notify", "progress", jQuery.Callbacks( "memory" ), jQuery.Callbacks( "memory" ), 2 ], [ "resolve", "done", jQuery.Callbacks( "once memory" ), jQuery.Callbacks( "once memory" ), 0, "resolved" ], [ "reject", "fail", jQuery.Callbacks( "once memory" ), jQuery.Callbacks( "once memory" ), 1, "rejected" ] ], state = "pending", promise = { state: function() { return state; }, always: function() { deferred.done( arguments ).fail( arguments ); return this; }, "catch": function( fn ) { return promise.then( null, fn ); }, // Keep pipe for back-compat pipe: function( /* fnDone, fnFail, fnProgress */ ) { var fns = arguments; return jQuery.Deferred( function( newDefer ) { jQuery.each( tuples, function( i, tuple ) { // Map tuples (progress, done, fail) to arguments (done, fail, progress) var fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ]; // deferred.progress(function() { bind to newDefer or newDefer.notify }) // deferred.done(function() { bind to newDefer or newDefer.resolve }) // deferred.fail(function() { bind to newDefer or newDefer.reject }) deferred[ tuple[ 1 ] ]( function() { var returned = fn && fn.apply( this, arguments ); if ( returned && isFunction( returned.promise ) ) { returned.promise() .progress( newDefer.notify ) .done( newDefer.resolve ) .fail( newDefer.reject ); } else { newDefer[ tuple[ 0 ] + "With" ]( this, fn ? [ returned ] : arguments ); } } ); } ); fns = null; } ).promise(); }, then: function( onFulfilled, onRejected, onProgress ) { var maxDepth = 0; function resolve( depth, deferred, handler, special ) { return function() { var that = this, args = arguments, mightThrow = function() { var returned, then; // Support: Promises/A+ section 2.3.3.3.3 // https://promisesaplus.com/#point-59 // Ignore double-resolution attempts if ( depth < maxDepth ) { return; } returned = handler.apply( that, args ); // Support: Promises/A+ section 2.3.1 // https://promisesaplus.com/#point-48 if ( returned === deferred.promise() ) { throw new TypeError( "Thenable self-resolution" ); } // Support: Promises/A+ sections 2.3.3.1, 3.5 // https://promisesaplus.com/#point-54 // https://promisesaplus.com/#point-75 // Retrieve `then` only once then = returned && // Support: Promises/A+ section 2.3.4 // https://promisesaplus.com/#point-64 // Only check objects and functions for thenability ( typeof returned === "object" || typeof returned === "function" ) && returned.then; // Handle a returned thenable if ( isFunction( then ) ) { // Special processors (notify) just wait for resolution if ( special ) { then.call( returned, resolve( maxDepth, deferred, Identity, special ), resolve( maxDepth, deferred, Thrower, special ) ); // Normal processors (resolve) also hook into progress } else { // ...and disregard older resolution values maxDepth++; then.call( returned, resolve( maxDepth, deferred, Identity, special ), resolve( maxDepth, deferred, Thrower, special ), resolve( maxDepth, deferred, Identity, deferred.notifyWith ) ); } // Handle all other returned values } else { // Only substitute handlers pass on context // and multiple values (non-spec behavior) if ( handler !== Identity ) { that = undefined; args = [ returned ]; } // Process the value(s) // Default process is resolve ( special || deferred.resolveWith )( that, args ); } }, // Only normal processors (resolve) catch and reject exceptions process = special ? mightThrow : function() { try { mightThrow(); } catch ( e ) { if ( jQuery.Deferred.exceptionHook ) { jQuery.Deferred.exceptionHook( e, process.stackTrace ); } // Support: Promises/A+ section 2.3.3.3.4.1 // https://promisesaplus.com/#point-61 // Ignore post-resolution exceptions if ( depth + 1 >= maxDepth ) { // Only substitute handlers pass on context // and multiple values (non-spec behavior) if ( handler !== Thrower ) { that = undefined; args = [ e ]; } deferred.rejectWith( that, args ); } } }; // Support: Promises/A+ section 2.3.3.3.1 // https://promisesaplus.com/#point-57 // Re-resolve promises immediately to dodge false rejection from // subsequent errors if ( depth ) { process(); } else { // Call an optional hook to record the stack, in case of exception // since it's otherwise lost when execution goes async if ( jQuery.Deferred.getStackHook ) { process.stackTrace = jQuery.Deferred.getStackHook(); } window.setTimeout( process ); } }; } return jQuery.Deferred( function( newDefer ) { // progress_handlers.add( ... ) tuples[ 0 ][ 3 ].add( resolve( 0, newDefer, isFunction( onProgress ) ? onProgress : Identity, newDefer.notifyWith ) ); // fulfilled_handlers.add( ... ) tuples[ 1 ][ 3 ].add( resolve( 0, newDefer, isFunction( onFulfilled ) ? onFulfilled : Identity ) ); // rejected_handlers.add( ... ) tuples[ 2 ][ 3 ].add( resolve( 0, newDefer, isFunction( onRejected ) ? onRejected : Thrower ) ); } ).promise(); }, // Get a promise for this deferred // If obj is provided, the promise aspect is added to the object promise: function( obj ) { return obj != null ? jQuery.extend( obj, promise ) : promise; } }, deferred = {}; // Add list-specific methods jQuery.each( tuples, function( i, tuple ) { var list = tuple[ 2 ], stateString = tuple[ 5 ]; // promise.progress = list.add // promise.done = list.add // promise.fail = list.add promise[ tuple[ 1 ] ] = list.add; // Handle state if ( stateString ) { list.add( function() { // state = "resolved" (i.e., fulfilled) // state = "rejected" state = stateString; }, // rejected_callbacks.disable // fulfilled_callbacks.disable tuples[ 3 - i ][ 2 ].disable, // rejected_handlers.disable // fulfilled_handlers.disable tuples[ 3 - i ][ 3 ].disable, // progress_callbacks.lock tuples[ 0 ][ 2 ].lock, // progress_handlers.lock tuples[ 0 ][ 3 ].lock ); } // progress_handlers.fire // fulfilled_handlers.fire // rejected_handlers.fire list.add( tuple[ 3 ].fire ); // deferred.notify = function() { deferred.notifyWith(...) } // deferred.resolve = function() { deferred.resolveWith(...) } // deferred.reject = function() { deferred.rejectWith(...) } deferred[ tuple[ 0 ] ] = function() { deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments ); return this; }; // deferred.notifyWith = list.fireWith // deferred.resolveWith = list.fireWith // deferred.rejectWith = list.fireWith deferred[ tuple[ 0 ] + "With" ] = list.fireWith; } ); // Make the deferred a promise promise.promise( deferred ); // Call given func if any if ( func ) { func.call( deferred, deferred ); } // All done! return deferred; }, // Deferred helper when: function( singleValue ) { var // count of uncompleted subordinates remaining = arguments.length, // count of unprocessed arguments i = remaining, // subordinate fulfillment data resolveContexts = Array( i ), resolveValues = slice.call( arguments ), // the master Deferred master = jQuery.Deferred(), // subordinate callback factory updateFunc = function( i ) { return function( value ) { resolveContexts[ i ] = this; resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value; if ( !( --remaining ) ) { master.resolveWith( resolveContexts, resolveValues ); } }; }; // Single- and empty arguments are adopted like Promise.resolve if ( remaining <= 1 ) { adoptValue( singleValue, master.done( updateFunc( i ) ).resolve, master.reject, !remaining ); // Use .then() to unwrap secondary thenables (cf. gh-3000) if ( master.state() === "pending" || isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) { return master.then(); } } // Multiple arguments are aggregated like Promise.all array elements while ( i-- ) { adoptValue( resolveValues[ i ], updateFunc( i ), master.reject ); } return master.promise(); } } ); // These usually indicate a programmer mistake during development, // warn about them ASAP rather than swallowing them by default. var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/; jQuery.Deferred.exceptionHook = function( error, stack ) { // Support: IE 8 - 9 only // Console exists when dev tools are open, which can happen at any time if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) { window.console.warn( "jQuery.Deferred exception: " + error.message, error.stack, stack ); } }; jQuery.readyException = function( error ) { window.setTimeout( function() { throw error; } ); }; // The deferred used on DOM ready var readyList = jQuery.Deferred(); jQuery.fn.ready = function( fn ) { readyList .then( fn ) // Wrap jQuery.readyException in a function so that the lookup // happens at the time of error handling instead of callback // registration. .catch( function( error ) { jQuery.readyException( error ); } ); return this; }; jQuery.extend( { // Is the DOM ready to be used? Set to true once it occurs. isReady: false, // A counter to track how many items to wait for before // the ready event fires. See #6781 readyWait: 1, // Handle when the DOM is ready ready: function( wait ) { // Abort if there are pending holds or we're already ready if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) { return; } // Remember that the DOM is ready jQuery.isReady = true; // If a normal DOM Ready event fired, decrement, and wait if need be if ( wait !== true && --jQuery.readyWait > 0 ) { return; } // If there are functions bound, to execute readyList.resolveWith( document, [ jQuery ] ); } } ); jQuery.ready.then = readyList.then; // The ready event handler and self cleanup method function completed() { document.removeEventListener( "DOMContentLoaded", completed ); window.removeEventListener( "load", completed ); jQuery.ready(); } // Catch cases where $(document).ready() is called // after the browser event has already occurred. // Support: IE <=9 - 10 only // Older IE sometimes signals "interactive" too soon if ( document.readyState === "complete" || ( document.readyState !== "loading" && !document.documentElement.doScroll ) ) { // Handle it asynchronously to allow scripts the opportunity to delay ready window.setTimeout( jQuery.ready ); } else { // Use the handy event callback document.addEventListener( "DOMContentLoaded", completed ); // A fallback to window.onload, that will always work window.addEventListener( "load", completed ); } // Multifunctional method to get and set values of a collection // The value/s can optionally be executed if it's a function var access = function( elems, fn, key, value, chainable, emptyGet, raw ) { var i = 0, len = elems.length, bulk = key == null; // Sets many values if ( toType( key ) === "object" ) { chainable = true; for ( i in key ) { access( elems, fn, i, key[ i ], true, emptyGet, raw ); } // Sets one value } else if ( value !== undefined ) { chainable = true; if ( !isFunction( value ) ) { raw = true; } if ( bulk ) { // Bulk operations run against the entire set if ( raw ) { fn.call( elems, value ); fn = null; // ...except when executing function values } else { bulk = fn; fn = function( elem, key, value ) { return bulk.call( jQuery( elem ), value ); }; } } if ( fn ) { for ( ; i < len; i++ ) { fn( elems[ i ], key, raw ? value : value.call( elems[ i ], i, fn( elems[ i ], key ) ) ); } } } if ( chainable ) { return elems; } // Gets if ( bulk ) { return fn.call( elems ); } return len ? fn( elems[ 0 ], key ) : emptyGet; }; // Matches dashed string for camelizing var rmsPrefix = /^-ms-/, rdashAlpha = /-([a-z])/g; // Used by camelCase as callback to replace() function fcamelCase( all, letter ) { return letter.toUpperCase(); } // Convert dashed to camelCase; used by the css and data modules // Support: IE <=9 - 11, Edge 12 - 15 // Microsoft forgot to hump their vendor prefix (#9572) function camelCase( string ) { return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase ); } var acceptData = function( owner ) { // Accepts only: // - Node // - Node.ELEMENT_NODE // - Node.DOCUMENT_NODE // - Object // - Any return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType ); }; function Data() { this.expando = jQuery.expando + Data.uid++; } Data.uid = 1; Data.prototype = { cache: function( owner ) { // Check if the owner object already has a cache var value = owner[ this.expando ]; // If not, create one if ( !value ) { value = {}; // We can accept data for non-element nodes in modern browsers, // but we should not, see #8335. // Always return an empty object. if ( acceptData( owner ) ) { // If it is a node unlikely to be stringify-ed or looped over // use plain assignment if ( owner.nodeType ) { owner[ this.expando ] = value; // Otherwise secure it in a non-enumerable property // configurable must be true to allow the property to be // deleted when data is removed } else { Object.defineProperty( owner, this.expando, { value: value, configurable: true } ); } } } return value; }, set: function( owner, data, value ) { var prop, cache = this.cache( owner ); // Handle: [ owner, key, value ] args // Always use camelCase key (gh-2257) if ( typeof data === "string" ) { cache[ camelCase( data ) ] = value; // Handle: [ owner, { properties } ] args } else { // Copy the properties one-by-one to the cache object for ( prop in data ) { cache[ camelCase( prop ) ] = data[ prop ]; } } return cache; }, get: function( owner, key ) { return key === undefined ? this.cache( owner ) : // Always use camelCase key (gh-2257) owner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ]; }, access: function( owner, key, value ) { // In cases where either: // // 1. No key was specified // 2. A string key was specified, but no value provided // // Take the "read" path and allow the get method to determine // which value to return, respectively either: // // 1. The entire cache object // 2. The data stored at the key // if ( key === undefined || ( ( key && typeof key === "string" ) && value === undefined ) ) { return this.get( owner, key ); } // When the key is not a string, or both a key and value // are specified, set or extend (existing objects) with either: // // 1. An object of properties // 2. A key and value // this.set( owner, key, value ); // Since the "set" path can have two possible entry points // return the expected data based on which path was taken[*] return value !== undefined ? value : key; }, remove: function( owner, key ) { var i, cache = owner[ this.expando ]; if ( cache === undefined ) { return; } if ( key !== undefined ) { // Support array or space separated string of keys if ( Array.isArray( key ) ) { // If key is an array of keys... // We always set camelCase keys, so remove that. key = key.map( camelCase ); } else { key = camelCase( key ); // If a key with the spaces exists, use it. // Otherwise, create an array by matching non-whitespace key = key in cache ? [ key ] : ( key.match( rnothtmlwhite ) || [] ); } i = key.length; while ( i-- ) { delete cache[ key[ i ] ]; } } // Remove the expando if there's no more data if ( key === undefined || jQuery.isEmptyObject( cache ) ) { // Support: Chrome <=35 - 45 // Webkit & Blink performance suffers when deleting properties // from DOM nodes, so set to undefined instead // https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted) if ( owner.nodeType ) { owner[ this.expando ] = undefined; } else { delete owner[ this.expando ]; } } }, hasData: function( owner ) { var cache = owner[ this.expando ]; return cache !== undefined && !jQuery.isEmptyObject( cache ); } }; var dataPriv = new Data(); var dataUser = new Data(); // Implementation Summary // // 1. Enforce API surface and semantic compatibility with 1.9.x branch // 2. Improve the module's maintainability by reducing the storage // paths to a single mechanism. // 3. Use the same single mechanism to support "private" and "user" data. // 4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData) // 5. Avoid exposing implementation details on user objects (eg. expando properties) // 6. Provide a clear path for implementation upgrade to WeakMap in 2014 var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/, rmultiDash = /[A-Z]/g; function getData( data ) { if ( data === "true" ) { return true; } if ( data === "false" ) { return false; } if ( data === "null" ) { return null; } // Only convert to a number if it doesn't change the string if ( data === +data + "" ) { return +data; } if ( rbrace.test( data ) ) { return JSON.parse( data ); } return data; } function dataAttr( elem, key, data ) { var name; // If nothing was found internally, try to fetch any // data from the HTML5 data-* attribute if ( data === undefined && elem.nodeType === 1 ) { name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase(); data = elem.getAttribute( name ); if ( typeof data === "string" ) { try { data = getData( data ); } catch ( e ) {} // Make sure we set the data so it isn't changed later dataUser.set( elem, key, data ); } else { data = undefined; } } return data; } jQuery.extend( { hasData: function( elem ) { return dataUser.hasData( elem ) || dataPriv.hasData( elem ); }, data: function( elem, name, data ) { return dataUser.access( elem, name, data ); }, removeData: function( elem, name ) { dataUser.remove( elem, name ); }, // TODO: Now that all calls to _data and _removeData have been replaced // with direct calls to dataPriv methods, these can be deprecated. _data: function( elem, name, data ) { return dataPriv.access( elem, name, data ); }, _removeData: function( elem, name ) { dataPriv.remove( elem, name ); } } ); jQuery.fn.extend( { data: function( key, value ) { var i, name, data, elem = this[ 0 ], attrs = elem && elem.attributes; // Gets all values if ( key === undefined ) { if ( this.length ) { data = dataUser.get( elem ); if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) { i = attrs.length; while ( i-- ) { // Support: IE 11 only // The attrs elements can be null (#14894) if ( attrs[ i ] ) { name = attrs[ i ].name; if ( name.indexOf( "data-" ) === 0 ) { name = camelCase( name.slice( 5 ) ); dataAttr( elem, name, data[ name ] ); } } } dataPriv.set( elem, "hasDataAttrs", true ); } } return data; } // Sets multiple values if ( typeof key === "object" ) { return this.each( function() { dataUser.set( this, key ); } ); } return access( this, function( value ) { var data; // The calling jQuery object (element matches) is not empty // (and therefore has an element appears at this[ 0 ]) and the // `value` parameter was not undefined. An empty jQuery object // will result in `undefined` for elem = this[ 0 ] which will // throw an exception if an attempt to read a data cache is made. if ( elem && value === undefined ) { // Attempt to get data from the cache // The key will always be camelCased in Data data = dataUser.get( elem, key ); if ( data !== undefined ) { return data; } // Attempt to "discover" the data in // HTML5 custom data-* attrs data = dataAttr( elem, key ); if ( data !== undefined ) { return data; } // We tried really hard, but the data doesn't exist. return; } // Set the data... this.each( function() { // We always store the camelCased key dataUser.set( this, key, value ); } ); }, null, value, arguments.length > 1, null, true ); }, removeData: function( key ) { return this.each( function() { dataUser.remove( this, key ); } ); } } ); jQuery.extend( { queue: function( elem, type, data ) { var queue; if ( elem ) { type = ( type || "fx" ) + "queue"; queue = dataPriv.get( elem, type ); // Speed up dequeue by getting out quickly if this is just a lookup if ( data ) { if ( !queue || Array.isArray( data ) ) { queue = dataPriv.access( elem, type, jQuery.makeArray( data ) ); } else { queue.push( data ); } } return queue || []; } }, dequeue: function( elem, type ) { type = type || "fx"; var queue = jQuery.queue( elem, type ), startLength = queue.length, fn = queue.shift(), hooks = jQuery._queueHooks( elem, type ), next = function() { jQuery.dequeue( elem, type ); }; // If the fx queue is dequeued, always remove the progress sentinel if ( fn === "inprogress" ) { fn = queue.shift(); startLength--; } if ( fn ) { // Add a progress sentinel to prevent the fx queue from being // automatically dequeued if ( type === "fx" ) { queue.unshift( "inprogress" ); } // Clear up the last queue stop function delete hooks.stop; fn.call( elem, next, hooks ); } if ( !startLength && hooks ) { hooks.empty.fire(); } }, // Not public - generate a queueHooks object, or return the current one _queueHooks: function( elem, type ) { var key = type + "queueHooks"; return dataPriv.get( elem, key ) || dataPriv.access( elem, key, { empty: jQuery.Callbacks( "once memory" ).add( function() { dataPriv.remove( elem, [ type + "queue", key ] ); } ) } ); } } ); jQuery.fn.extend( { queue: function( type, data ) { var setter = 2; if ( typeof type !== "string" ) { data = type; type = "fx"; setter--; } if ( arguments.length < setter ) { return jQuery.queue( this[ 0 ], type ); } return data === undefined ? this : this.each( function() { var queue = jQuery.queue( this, type, data ); // Ensure a hooks for this queue jQuery._queueHooks( this, type ); if ( type === "fx" && queue[ 0 ] !== "inprogress" ) { jQuery.dequeue( this, type ); } } ); }, dequeue: function( type ) { return this.each( function() { jQuery.dequeue( this, type ); } ); }, clearQueue: function( type ) { return this.queue( type || "fx", [] ); }, // Get a promise resolved when queues of a certain type // are emptied (fx is the type by default) promise: function( type, obj ) { var tmp, count = 1, defer = jQuery.Deferred(), elements = this, i = this.length, resolve = function() { if ( !( --count ) ) { defer.resolveWith( elements, [ elements ] ); } }; if ( typeof type !== "string" ) { obj = type; type = undefined; } type = type || "fx"; while ( i-- ) { tmp = dataPriv.get( elements[ i ], type + "queueHooks" ); if ( tmp && tmp.empty ) { count++; tmp.empty.add( resolve ); } } resolve(); return defer.promise( obj ); } } ); var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source; var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" ); var cssExpand = [ "Top", "Right", "Bottom", "Left" ]; var documentElement = document.documentElement; var isAttached = function( elem ) { return jQuery.contains( elem.ownerDocument, elem ); }, composed = { composed: true }; // Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only // Check attachment across shadow DOM boundaries when possible (gh-3504) // Support: iOS 10.0-10.2 only // Early iOS 10 versions support `attachShadow` but not `getRootNode`, // leading to errors. We need to check for `getRootNode`. if ( documentElement.getRootNode ) { isAttached = function( elem ) { return jQuery.contains( elem.ownerDocument, elem ) || elem.getRootNode( composed ) === elem.ownerDocument; }; } var isHiddenWithinTree = function( elem, el ) { // isHiddenWithinTree might be called from jQuery#filter function; // in that case, element will be second argument elem = el || elem; // Inline style trumps all return elem.style.display === "none" || elem.style.display === "" && // Otherwise, check computed style // Support: Firefox <=43 - 45 // Disconnected elements can have computed display: none, so first confirm that elem is // in the document. isAttached( elem ) && jQuery.css( elem, "display" ) === "none"; }; var swap = function( elem, options, callback, args ) { var ret, name, old = {}; // Remember the old values, and insert the new ones for ( name in options ) { old[ name ] = elem.style[ name ]; elem.style[ name ] = options[ name ]; } ret = callback.apply( elem, args || [] ); // Revert the old values for ( name in options ) { elem.style[ name ] = old[ name ]; } return ret; }; function adjustCSS( elem, prop, valueParts, tween ) { var adjusted, scale, maxIterations = 20, currentValue = tween ? function() { return tween.cur(); } : function() { return jQuery.css( elem, prop, "" ); }, initial = currentValue(), unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ), // Starting value computation is required for potential unit mismatches initialInUnit = elem.nodeType && ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) && rcssNum.exec( jQuery.css( elem, prop ) ); if ( initialInUnit && initialInUnit[ 3 ] !== unit ) { // Support: Firefox <=54 // Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144) initial = initial / 2; // Trust units reported by jQuery.css unit = unit || initialInUnit[ 3 ]; // Iteratively approximate from a nonzero starting point initialInUnit = +initial || 1; while ( maxIterations-- ) { // Evaluate and update our best guess (doubling guesses that zero out). // Finish if the scale equals or crosses 1 (making the old*new product non-positive). jQuery.style( elem, prop, initialInUnit + unit ); if ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) { maxIterations = 0; } initialInUnit = initialInUnit / scale; } initialInUnit = initialInUnit * 2; jQuery.style( elem, prop, initialInUnit + unit ); // Make sure we update the tween properties later on valueParts = valueParts || []; } if ( valueParts ) { initialInUnit = +initialInUnit || +initial || 0; // Apply relative offset (+=/-=) if specified adjusted = valueParts[ 1 ] ? initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] : +valueParts[ 2 ]; if ( tween ) { tween.unit = unit; tween.start = initialInUnit; tween.end = adjusted; } } return adjusted; } var defaultDisplayMap = {}; function getDefaultDisplay( elem ) { var temp, doc = elem.ownerDocument, nodeName = elem.nodeName, display = defaultDisplayMap[ nodeName ]; if ( display ) { return display; } temp = doc.body.appendChild( doc.createElement( nodeName ) ); display = jQuery.css( temp, "display" ); temp.parentNode.removeChild( temp ); if ( display === "none" ) { display = "block"; } defaultDisplayMap[ nodeName ] = display; return display; } function showHide( elements, show ) { var display, elem, values = [], index = 0, length = elements.length; // Determine new display value for elements that need to change for ( ; index < length; index++ ) { elem = elements[ index ]; if ( !elem.style ) { continue; } display = elem.style.display; if ( show ) { // Since we force visibility upon cascade-hidden elements, an immediate (and slow) // check is required in this first loop unless we have a nonempty display value (either // inline or about-to-be-restored) if ( display === "none" ) { values[ index ] = dataPriv.get( elem, "display" ) || null; if ( !values[ index ] ) { elem.style.display = ""; } } if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) { values[ index ] = getDefaultDisplay( elem ); } } else { if ( display !== "none" ) { values[ index ] = "none"; // Remember what we're overwriting dataPriv.set( elem, "display", display ); } } } // Set the display of the elements in a second loop to avoid constant reflow for ( index = 0; index < length; index++ ) { if ( values[ index ] != null ) { elements[ index ].style.display = values[ index ]; } } return elements; } jQuery.fn.extend( { show: function() { return showHide( this, true ); }, hide: function() { return showHide( this ); }, toggle: function( state ) { if ( typeof state === "boolean" ) { return state ? this.show() : this.hide(); } return this.each( function() { if ( isHiddenWithinTree( this ) ) { jQuery( this ).show(); } else { jQuery( this ).hide(); } } ); } } ); var rcheckableType = ( /^(?:checkbox|radio)$/i ); var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]*)/i ); var rscriptType = ( /^$|^module$|\/(?:java|ecma)script/i ); // We have to close these tags to support XHTML (#13200) var wrapMap = { // Support: IE <=9 only option: [ 1, "" ], // XHTML parsers do not magically insert elements in the // same way that tag soup parsers do. So we cannot shorten // this by omitting or other required elements. thead: [ 1, "", "
    " ], col: [ 2, "", "
    " ], tr: [ 2, "", "
    " ], td: [ 3, "", "
    " ], _default: [ 0, "", "" ] }; // Support: IE <=9 only wrapMap.optgroup = wrapMap.option; wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; wrapMap.th = wrapMap.td; function getAll( context, tag ) { // Support: IE <=9 - 11 only // Use typeof to avoid zero-argument method invocation on host objects (#15151) var ret; if ( typeof context.getElementsByTagName !== "undefined" ) { ret = context.getElementsByTagName( tag || "*" ); } else if ( typeof context.querySelectorAll !== "undefined" ) { ret = context.querySelectorAll( tag || "*" ); } else { ret = []; } if ( tag === undefined || tag && nodeName( context, tag ) ) { return jQuery.merge( [ context ], ret ); } return ret; } // Mark scripts as having already been evaluated function setGlobalEval( elems, refElements ) { var i = 0, l = elems.length; for ( ; i < l; i++ ) { dataPriv.set( elems[ i ], "globalEval", !refElements || dataPriv.get( refElements[ i ], "globalEval" ) ); } } var rhtml = /<|&#?\w+;/; function buildFragment( elems, context, scripts, selection, ignored ) { var elem, tmp, tag, wrap, attached, j, fragment = context.createDocumentFragment(), nodes = [], i = 0, l = elems.length; for ( ; i < l; i++ ) { elem = elems[ i ]; if ( elem || elem === 0 ) { // Add nodes directly if ( toType( elem ) === "object" ) { // Support: Android <=4.0 only, PhantomJS 1 only // push.apply(_, arraylike) throws on ancient WebKit jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem ); // Convert non-html into a text node } else if ( !rhtml.test( elem ) ) { nodes.push( context.createTextNode( elem ) ); // Convert html into DOM nodes } else { tmp = tmp || fragment.appendChild( context.createElement( "div" ) ); // Deserialize a standard representation tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase(); wrap = wrapMap[ tag ] || wrapMap._default; tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ]; // Descend through wrappers to the right content j = wrap[ 0 ]; while ( j-- ) { tmp = tmp.lastChild; } // Support: Android <=4.0 only, PhantomJS 1 only // push.apply(_, arraylike) throws on ancient WebKit jQuery.merge( nodes, tmp.childNodes ); // Remember the top-level container tmp = fragment.firstChild; // Ensure the created nodes are orphaned (#12392) tmp.textContent = ""; } } } // Remove wrapper from fragment fragment.textContent = ""; i = 0; while ( ( elem = nodes[ i++ ] ) ) { // Skip elements already in the context collection (trac-4087) if ( selection && jQuery.inArray( elem, selection ) > -1 ) { if ( ignored ) { ignored.push( elem ); } continue; } attached = isAttached( elem ); // Append to fragment tmp = getAll( fragment.appendChild( elem ), "script" ); // Preserve script evaluation history if ( attached ) { setGlobalEval( tmp ); } // Capture executables if ( scripts ) { j = 0; while ( ( elem = tmp[ j++ ] ) ) { if ( rscriptType.test( elem.type || "" ) ) { scripts.push( elem ); } } } } return fragment; } ( function() { var fragment = document.createDocumentFragment(), div = fragment.appendChild( document.createElement( "div" ) ), input = document.createElement( "input" ); // Support: Android 4.0 - 4.3 only // Check state lost if the name is set (#11217) // Support: Windows Web Apps (WWA) // `name` and `type` must use .setAttribute for WWA (#14901) input.setAttribute( "type", "radio" ); input.setAttribute( "checked", "checked" ); input.setAttribute( "name", "t" ); div.appendChild( input ); // Support: Android <=4.1 only // Older WebKit doesn't clone checked state correctly in fragments support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked; // Support: IE <=11 only // Make sure textarea (and checkbox) defaultValue is properly cloned div.innerHTML = ""; support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue; } )(); var rkeyEvent = /^key/, rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/, rtypenamespace = /^([^.]*)(?:\.(.+)|)/; function returnTrue() { return true; } function returnFalse() { return false; } // Support: IE <=9 - 11+ // focus() and blur() are asynchronous, except when they are no-op. // So expect focus to be synchronous when the element is already active, // and blur to be synchronous when the element is not already active. // (focus and blur are always synchronous in other supported browsers, // this just defines when we can count on it). function expectSync( elem, type ) { return ( elem === safeActiveElement() ) === ( type === "focus" ); } // Support: IE <=9 only // Accessing document.activeElement can throw unexpectedly // https://bugs.jquery.com/ticket/13393 function safeActiveElement() { try { return document.activeElement; } catch ( err ) { } } function on( elem, types, selector, data, fn, one ) { var origFn, type; // Types can be a map of types/handlers if ( typeof types === "object" ) { // ( types-Object, selector, data ) if ( typeof selector !== "string" ) { // ( types-Object, data ) data = data || selector; selector = undefined; } for ( type in types ) { on( elem, type, selector, data, types[ type ], one ); } return elem; } if ( data == null && fn == null ) { // ( types, fn ) fn = selector; data = selector = undefined; } else if ( fn == null ) { if ( typeof selector === "string" ) { // ( types, selector, fn ) fn = data; data = undefined; } else { // ( types, data, fn ) fn = data; data = selector; selector = undefined; } } if ( fn === false ) { fn = returnFalse; } else if ( !fn ) { return elem; } if ( one === 1 ) { origFn = fn; fn = function( event ) { // Can use an empty set, since event contains the info jQuery().off( event ); return origFn.apply( this, arguments ); }; // Use same guid so caller can remove using origFn fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ ); } return elem.each( function() { jQuery.event.add( this, types, fn, data, selector ); } ); } /* * Helper functions for managing events -- not part of the public interface. * Props to Dean Edwards' addEvent library for many of the ideas. */ jQuery.event = { global: {}, add: function( elem, types, handler, data, selector ) { var handleObjIn, eventHandle, tmp, events, t, handleObj, special, handlers, type, namespaces, origType, elemData = dataPriv.get( elem ); // Don't attach events to noData or text/comment nodes (but allow plain objects) if ( !elemData ) { return; } // Caller can pass in an object of custom data in lieu of the handler if ( handler.handler ) { handleObjIn = handler; handler = handleObjIn.handler; selector = handleObjIn.selector; } // Ensure that invalid selectors throw exceptions at attach time // Evaluate against documentElement in case elem is a non-element node (e.g., document) if ( selector ) { jQuery.find.matchesSelector( documentElement, selector ); } // Make sure that the handler has a unique ID, used to find/remove it later if ( !handler.guid ) { handler.guid = jQuery.guid++; } // Init the element's event structure and main handler, if this is the first if ( !( events = elemData.events ) ) { events = elemData.events = {}; } if ( !( eventHandle = elemData.handle ) ) { eventHandle = elemData.handle = function( e ) { // Discard the second event of a jQuery.event.trigger() and // when an event is called after a page has unloaded return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ? jQuery.event.dispatch.apply( elem, arguments ) : undefined; }; } // Handle multiple events separated by a space types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; t = types.length; while ( t-- ) { tmp = rtypenamespace.exec( types[ t ] ) || []; type = origType = tmp[ 1 ]; namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort(); // There *must* be a type, no attaching namespace-only handlers if ( !type ) { continue; } // If event changes its type, use the special event handlers for the changed type special = jQuery.event.special[ type ] || {}; // If selector defined, determine special event api type, otherwise given type type = ( selector ? special.delegateType : special.bindType ) || type; // Update special based on newly reset type special = jQuery.event.special[ type ] || {}; // handleObj is passed to all event handlers handleObj = jQuery.extend( { type: type, origType: origType, data: data, handler: handler, guid: handler.guid, selector: selector, needsContext: selector && jQuery.expr.match.needsContext.test( selector ), namespace: namespaces.join( "." ) }, handleObjIn ); // Init the event handler queue if we're the first if ( !( handlers = events[ type ] ) ) { handlers = events[ type ] = []; handlers.delegateCount = 0; // Only use addEventListener if the special events handler returns false if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) { if ( elem.addEventListener ) { elem.addEventListener( type, eventHandle ); } } } if ( special.add ) { special.add.call( elem, handleObj ); if ( !handleObj.handler.guid ) { handleObj.handler.guid = handler.guid; } } // Add to the element's handler list, delegates in front if ( selector ) { handlers.splice( handlers.delegateCount++, 0, handleObj ); } else { handlers.push( handleObj ); } // Keep track of which events have ever been used, for event optimization jQuery.event.global[ type ] = true; } }, // Detach an event or set of events from an element remove: function( elem, types, handler, selector, mappedTypes ) { var j, origCount, tmp, events, t, handleObj, special, handlers, type, namespaces, origType, elemData = dataPriv.hasData( elem ) && dataPriv.get( elem ); if ( !elemData || !( events = elemData.events ) ) { return; } // Once for each type.namespace in types; type may be omitted types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; t = types.length; while ( t-- ) { tmp = rtypenamespace.exec( types[ t ] ) || []; type = origType = tmp[ 1 ]; namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort(); // Unbind all events (on this namespace, if provided) for the element if ( !type ) { for ( type in events ) { jQuery.event.remove( elem, type + types[ t ], handler, selector, true ); } continue; } special = jQuery.event.special[ type ] || {}; type = ( selector ? special.delegateType : special.bindType ) || type; handlers = events[ type ] || []; tmp = tmp[ 2 ] && new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ); // Remove matching events origCount = j = handlers.length; while ( j-- ) { handleObj = handlers[ j ]; if ( ( mappedTypes || origType === handleObj.origType ) && ( !handler || handler.guid === handleObj.guid ) && ( !tmp || tmp.test( handleObj.namespace ) ) && ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) { handlers.splice( j, 1 ); if ( handleObj.selector ) { handlers.delegateCount--; } if ( special.remove ) { special.remove.call( elem, handleObj ); } } } // Remove generic event handler if we removed something and no more handlers exist // (avoids potential for endless recursion during removal of special event handlers) if ( origCount && !handlers.length ) { if ( !special.teardown || special.teardown.call( elem, namespaces, elemData.handle ) === false ) { jQuery.removeEvent( elem, type, elemData.handle ); } delete events[ type ]; } } // Remove data and the expando if it's no longer used if ( jQuery.isEmptyObject( events ) ) { dataPriv.remove( elem, "handle events" ); } }, dispatch: function( nativeEvent ) { // Make a writable jQuery.Event from the native event object var event = jQuery.event.fix( nativeEvent ); var i, j, ret, matched, handleObj, handlerQueue, args = new Array( arguments.length ), handlers = ( dataPriv.get( this, "events" ) || {} )[ event.type ] || [], special = jQuery.event.special[ event.type ] || {}; // Use the fix-ed jQuery.Event rather than the (read-only) native event args[ 0 ] = event; for ( i = 1; i < arguments.length; i++ ) { args[ i ] = arguments[ i ]; } event.delegateTarget = this; // Call the preDispatch hook for the mapped type, and let it bail if desired if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) { return; } // Determine handlers handlerQueue = jQuery.event.handlers.call( this, event, handlers ); // Run delegates first; they may want to stop propagation beneath us i = 0; while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) { event.currentTarget = matched.elem; j = 0; while ( ( handleObj = matched.handlers[ j++ ] ) && !event.isImmediatePropagationStopped() ) { // If the event is namespaced, then each handler is only invoked if it is // specially universal or its namespaces are a superset of the event's. if ( !event.rnamespace || handleObj.namespace === false || event.rnamespace.test( handleObj.namespace ) ) { event.handleObj = handleObj; event.data = handleObj.data; ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle || handleObj.handler ).apply( matched.elem, args ); if ( ret !== undefined ) { if ( ( event.result = ret ) === false ) { event.preventDefault(); event.stopPropagation(); } } } } } // Call the postDispatch hook for the mapped type if ( special.postDispatch ) { special.postDispatch.call( this, event ); } return event.result; }, handlers: function( event, handlers ) { var i, handleObj, sel, matchedHandlers, matchedSelectors, handlerQueue = [], delegateCount = handlers.delegateCount, cur = event.target; // Find delegate handlers if ( delegateCount && // Support: IE <=9 // Black-hole SVG instance trees (trac-13180) cur.nodeType && // Support: Firefox <=42 // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861) // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click // Support: IE 11 only // ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343) !( event.type === "click" && event.button >= 1 ) ) { for ( ; cur !== this; cur = cur.parentNode || this ) { // Don't check non-elements (#13208) // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764) if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) { matchedHandlers = []; matchedSelectors = {}; for ( i = 0; i < delegateCount; i++ ) { handleObj = handlers[ i ]; // Don't conflict with Object.prototype properties (#13203) sel = handleObj.selector + " "; if ( matchedSelectors[ sel ] === undefined ) { matchedSelectors[ sel ] = handleObj.needsContext ? jQuery( sel, this ).index( cur ) > -1 : jQuery.find( sel, this, null, [ cur ] ).length; } if ( matchedSelectors[ sel ] ) { matchedHandlers.push( handleObj ); } } if ( matchedHandlers.length ) { handlerQueue.push( { elem: cur, handlers: matchedHandlers } ); } } } } // Add the remaining (directly-bound) handlers cur = this; if ( delegateCount < handlers.length ) { handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } ); } return handlerQueue; }, addProp: function( name, hook ) { Object.defineProperty( jQuery.Event.prototype, name, { enumerable: true, configurable: true, get: isFunction( hook ) ? function() { if ( this.originalEvent ) { return hook( this.originalEvent ); } } : function() { if ( this.originalEvent ) { return this.originalEvent[ name ]; } }, set: function( value ) { Object.defineProperty( this, name, { enumerable: true, configurable: true, writable: true, value: value } ); } } ); }, fix: function( originalEvent ) { return originalEvent[ jQuery.expando ] ? originalEvent : new jQuery.Event( originalEvent ); }, special: { load: { // Prevent triggered image.load events from bubbling to window.load noBubble: true }, click: { // Utilize native event to ensure correct state for checkable inputs setup: function( data ) { // For mutual compressibility with _default, replace `this` access with a local var. // `|| data` is dead code meant only to preserve the variable through minification. var el = this || data; // Claim the first handler if ( rcheckableType.test( el.type ) && el.click && nodeName( el, "input" ) ) { // dataPriv.set( el, "click", ... ) leverageNative( el, "click", returnTrue ); } // Return false to allow normal processing in the caller return false; }, trigger: function( data ) { // For mutual compressibility with _default, replace `this` access with a local var. // `|| data` is dead code meant only to preserve the variable through minification. var el = this || data; // Force setup before triggering a click if ( rcheckableType.test( el.type ) && el.click && nodeName( el, "input" ) ) { leverageNative( el, "click" ); } // Return non-false to allow normal event-path propagation return true; }, // For cross-browser consistency, suppress native .click() on links // Also prevent it if we're currently inside a leveraged native-event stack _default: function( event ) { var target = event.target; return rcheckableType.test( target.type ) && target.click && nodeName( target, "input" ) && dataPriv.get( target, "click" ) || nodeName( target, "a" ); } }, beforeunload: { postDispatch: function( event ) { // Support: Firefox 20+ // Firefox doesn't alert if the returnValue field is not set. if ( event.result !== undefined && event.originalEvent ) { event.originalEvent.returnValue = event.result; } } } } }; // Ensure the presence of an event listener that handles manually-triggered // synthetic events by interrupting progress until reinvoked in response to // *native* events that it fires directly, ensuring that state changes have // already occurred before other listeners are invoked. function leverageNative( el, type, expectSync ) { // Missing expectSync indicates a trigger call, which must force setup through jQuery.event.add if ( !expectSync ) { if ( dataPriv.get( el, type ) === undefined ) { jQuery.event.add( el, type, returnTrue ); } return; } // Register the controller as a special universal handler for all event namespaces dataPriv.set( el, type, false ); jQuery.event.add( el, type, { namespace: false, handler: function( event ) { var notAsync, result, saved = dataPriv.get( this, type ); if ( ( event.isTrigger & 1 ) && this[ type ] ) { // Interrupt processing of the outer synthetic .trigger()ed event // Saved data should be false in such cases, but might be a leftover capture object // from an async native handler (gh-4350) if ( !saved.length ) { // Store arguments for use when handling the inner native event // There will always be at least one argument (an event object), so this array // will not be confused with a leftover capture object. saved = slice.call( arguments ); dataPriv.set( this, type, saved ); // Trigger the native event and capture its result // Support: IE <=9 - 11+ // focus() and blur() are asynchronous notAsync = expectSync( this, type ); this[ type ](); result = dataPriv.get( this, type ); if ( saved !== result || notAsync ) { dataPriv.set( this, type, false ); } else { result = {}; } if ( saved !== result ) { // Cancel the outer synthetic event event.stopImmediatePropagation(); event.preventDefault(); return result.value; } // If this is an inner synthetic event for an event with a bubbling surrogate // (focus or blur), assume that the surrogate already propagated from triggering the // native event and prevent that from happening again here. // This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the // bubbling surrogate propagates *after* the non-bubbling base), but that seems // less bad than duplication. } else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) { event.stopPropagation(); } // If this is a native event triggered above, everything is now in order // Fire an inner synthetic event with the original arguments } else if ( saved.length ) { // ...and capture the result dataPriv.set( this, type, { value: jQuery.event.trigger( // Support: IE <=9 - 11+ // Extend with the prototype to reset the above stopImmediatePropagation() jQuery.extend( saved[ 0 ], jQuery.Event.prototype ), saved.slice( 1 ), this ) } ); // Abort handling of the native event event.stopImmediatePropagation(); } } } ); } jQuery.removeEvent = function( elem, type, handle ) { // This "if" is needed for plain objects if ( elem.removeEventListener ) { elem.removeEventListener( type, handle ); } }; jQuery.Event = function( src, props ) { // Allow instantiation without the 'new' keyword if ( !( this instanceof jQuery.Event ) ) { return new jQuery.Event( src, props ); } // Event object if ( src && src.type ) { this.originalEvent = src; this.type = src.type; // Events bubbling up the document may have been marked as prevented // by a handler lower down the tree; reflect the correct value. this.isDefaultPrevented = src.defaultPrevented || src.defaultPrevented === undefined && // Support: Android <=2.3 only src.returnValue === false ? returnTrue : returnFalse; // Create target properties // Support: Safari <=6 - 7 only // Target should not be a text node (#504, #13143) this.target = ( src.target && src.target.nodeType === 3 ) ? src.target.parentNode : src.target; this.currentTarget = src.currentTarget; this.relatedTarget = src.relatedTarget; // Event type } else { this.type = src; } // Put explicitly provided properties onto the event object if ( props ) { jQuery.extend( this, props ); } // Create a timestamp if incoming event doesn't have one this.timeStamp = src && src.timeStamp || Date.now(); // Mark it as fixed this[ jQuery.expando ] = true; }; // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding // https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html jQuery.Event.prototype = { constructor: jQuery.Event, isDefaultPrevented: returnFalse, isPropagationStopped: returnFalse, isImmediatePropagationStopped: returnFalse, isSimulated: false, preventDefault: function() { var e = this.originalEvent; this.isDefaultPrevented = returnTrue; if ( e && !this.isSimulated ) { e.preventDefault(); } }, stopPropagation: function() { var e = this.originalEvent; this.isPropagationStopped = returnTrue; if ( e && !this.isSimulated ) { e.stopPropagation(); } }, stopImmediatePropagation: function() { var e = this.originalEvent; this.isImmediatePropagationStopped = returnTrue; if ( e && !this.isSimulated ) { e.stopImmediatePropagation(); } this.stopPropagation(); } }; // Includes all common event props including KeyEvent and MouseEvent specific props jQuery.each( { altKey: true, bubbles: true, cancelable: true, changedTouches: true, ctrlKey: true, detail: true, eventPhase: true, metaKey: true, pageX: true, pageY: true, shiftKey: true, view: true, "char": true, code: true, charCode: true, key: true, keyCode: true, button: true, buttons: true, clientX: true, clientY: true, offsetX: true, offsetY: true, pointerId: true, pointerType: true, screenX: true, screenY: true, targetTouches: true, toElement: true, touches: true, which: function( event ) { var button = event.button; // Add which for key events if ( event.which == null && rkeyEvent.test( event.type ) ) { return event.charCode != null ? event.charCode : event.keyCode; } // Add which for click: 1 === left; 2 === middle; 3 === right if ( !event.which && button !== undefined && rmouseEvent.test( event.type ) ) { if ( button & 1 ) { return 1; } if ( button & 2 ) { return 3; } if ( button & 4 ) { return 2; } return 0; } return event.which; } }, jQuery.event.addProp ); jQuery.each( { focus: "focusin", blur: "focusout" }, function( type, delegateType ) { jQuery.event.special[ type ] = { // Utilize native event if possible so blur/focus sequence is correct setup: function() { // Claim the first handler // dataPriv.set( this, "focus", ... ) // dataPriv.set( this, "blur", ... ) leverageNative( this, type, expectSync ); // Return false to allow normal processing in the caller return false; }, trigger: function() { // Force setup before trigger leverageNative( this, type ); // Return non-false to allow normal event-path propagation return true; }, delegateType: delegateType }; } ); // Create mouseenter/leave events using mouseover/out and event-time checks // so that event delegation works in jQuery. // Do the same for pointerenter/pointerleave and pointerover/pointerout // // Support: Safari 7 only // Safari sends mouseenter too often; see: // https://bugs.chromium.org/p/chromium/issues/detail?id=470258 // for the description of the bug (it existed in older Chrome versions as well). jQuery.each( { mouseenter: "mouseover", mouseleave: "mouseout", pointerenter: "pointerover", pointerleave: "pointerout" }, function( orig, fix ) { jQuery.event.special[ orig ] = { delegateType: fix, bindType: fix, handle: function( event ) { var ret, target = this, related = event.relatedTarget, handleObj = event.handleObj; // For mouseenter/leave call the handler if related is outside the target. // NB: No relatedTarget if the mouse left/entered the browser window if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) { event.type = handleObj.origType; ret = handleObj.handler.apply( this, arguments ); event.type = fix; } return ret; } }; } ); jQuery.fn.extend( { on: function( types, selector, data, fn ) { return on( this, types, selector, data, fn ); }, one: function( types, selector, data, fn ) { return on( this, types, selector, data, fn, 1 ); }, off: function( types, selector, fn ) { var handleObj, type; if ( types && types.preventDefault && types.handleObj ) { // ( event ) dispatched jQuery.Event handleObj = types.handleObj; jQuery( types.delegateTarget ).off( handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType, handleObj.selector, handleObj.handler ); return this; } if ( typeof types === "object" ) { // ( types-object [, selector] ) for ( type in types ) { this.off( type, selector, types[ type ] ); } return this; } if ( selector === false || typeof selector === "function" ) { // ( types [, fn] ) fn = selector; selector = undefined; } if ( fn === false ) { fn = returnFalse; } return this.each( function() { jQuery.event.remove( this, types, fn, selector ); } ); } } ); var /* eslint-disable max-len */ // See https://github.com/eslint/eslint/issues/3229 rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi, /* eslint-enable */ // Support: IE <=10 - 11, Edge 12 - 13 only // In IE/Edge using regex groups here causes severe slowdowns. // See https://connect.microsoft.com/IE/feedback/details/1736512/ rnoInnerhtml = /\s*$/g; // Prefer a tbody over its parent table for containing new rows function manipulationTarget( elem, content ) { if ( nodeName( elem, "table" ) && nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) { return jQuery( elem ).children( "tbody" )[ 0 ] || elem; } return elem; } // Replace/restore the type attribute of script elements for safe DOM manipulation function disableScript( elem ) { elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type; return elem; } function restoreScript( elem ) { if ( ( elem.type || "" ).slice( 0, 5 ) === "true/" ) { elem.type = elem.type.slice( 5 ); } else { elem.removeAttribute( "type" ); } return elem; } function cloneCopyEvent( src, dest ) { var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events; if ( dest.nodeType !== 1 ) { return; } // 1. Copy private data: events, handlers, etc. if ( dataPriv.hasData( src ) ) { pdataOld = dataPriv.access( src ); pdataCur = dataPriv.set( dest, pdataOld ); events = pdataOld.events; if ( events ) { delete pdataCur.handle; pdataCur.events = {}; for ( type in events ) { for ( i = 0, l = events[ type ].length; i < l; i++ ) { jQuery.event.add( dest, type, events[ type ][ i ] ); } } } } // 2. Copy user data if ( dataUser.hasData( src ) ) { udataOld = dataUser.access( src ); udataCur = jQuery.extend( {}, udataOld ); dataUser.set( dest, udataCur ); } } // Fix IE bugs, see support tests function fixInput( src, dest ) { var nodeName = dest.nodeName.toLowerCase(); // Fails to persist the checked state of a cloned checkbox or radio button. if ( nodeName === "input" && rcheckableType.test( src.type ) ) { dest.checked = src.checked; // Fails to return the selected option to the default selected state when cloning options } else if ( nodeName === "input" || nodeName === "textarea" ) { dest.defaultValue = src.defaultValue; } } function domManip( collection, args, callback, ignored ) { // Flatten any nested arrays args = concat.apply( [], args ); var fragment, first, scripts, hasScripts, node, doc, i = 0, l = collection.length, iNoClone = l - 1, value = args[ 0 ], valueIsFunction = isFunction( value ); // We can't cloneNode fragments that contain checked, in WebKit if ( valueIsFunction || ( l > 1 && typeof value === "string" && !support.checkClone && rchecked.test( value ) ) ) { return collection.each( function( index ) { var self = collection.eq( index ); if ( valueIsFunction ) { args[ 0 ] = value.call( this, index, self.html() ); } domManip( self, args, callback, ignored ); } ); } if ( l ) { fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored ); first = fragment.firstChild; if ( fragment.childNodes.length === 1 ) { fragment = first; } // Require either new content or an interest in ignored elements to invoke the callback if ( first || ignored ) { scripts = jQuery.map( getAll( fragment, "script" ), disableScript ); hasScripts = scripts.length; // Use the original fragment for the last item // instead of the first because it can end up // being emptied incorrectly in certain situations (#8070). for ( ; i < l; i++ ) { node = fragment; if ( i !== iNoClone ) { node = jQuery.clone( node, true, true ); // Keep references to cloned scripts for later restoration if ( hasScripts ) { // Support: Android <=4.0 only, PhantomJS 1 only // push.apply(_, arraylike) throws on ancient WebKit jQuery.merge( scripts, getAll( node, "script" ) ); } } callback.call( collection[ i ], node, i ); } if ( hasScripts ) { doc = scripts[ scripts.length - 1 ].ownerDocument; // Reenable scripts jQuery.map( scripts, restoreScript ); // Evaluate executable scripts on first document insertion for ( i = 0; i < hasScripts; i++ ) { node = scripts[ i ]; if ( rscriptType.test( node.type || "" ) && !dataPriv.access( node, "globalEval" ) && jQuery.contains( doc, node ) ) { if ( node.src && ( node.type || "" ).toLowerCase() !== "module" ) { // Optional AJAX dependency, but won't run scripts if not present if ( jQuery._evalUrl && !node.noModule ) { jQuery._evalUrl( node.src, { nonce: node.nonce || node.getAttribute( "nonce" ) } ); } } else { DOMEval( node.textContent.replace( rcleanScript, "" ), node, doc ); } } } } } } return collection; } function remove( elem, selector, keepData ) { var node, nodes = selector ? jQuery.filter( selector, elem ) : elem, i = 0; for ( ; ( node = nodes[ i ] ) != null; i++ ) { if ( !keepData && node.nodeType === 1 ) { jQuery.cleanData( getAll( node ) ); } if ( node.parentNode ) { if ( keepData && isAttached( node ) ) { setGlobalEval( getAll( node, "script" ) ); } node.parentNode.removeChild( node ); } } return elem; } jQuery.extend( { htmlPrefilter: function( html ) { return html.replace( rxhtmlTag, "<$1>" ); }, clone: function( elem, dataAndEvents, deepDataAndEvents ) { var i, l, srcElements, destElements, clone = elem.cloneNode( true ), inPage = isAttached( elem ); // Fix IE cloning issues if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) && !jQuery.isXMLDoc( elem ) ) { // We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2 destElements = getAll( clone ); srcElements = getAll( elem ); for ( i = 0, l = srcElements.length; i < l; i++ ) { fixInput( srcElements[ i ], destElements[ i ] ); } } // Copy the events from the original to the clone if ( dataAndEvents ) { if ( deepDataAndEvents ) { srcElements = srcElements || getAll( elem ); destElements = destElements || getAll( clone ); for ( i = 0, l = srcElements.length; i < l; i++ ) { cloneCopyEvent( srcElements[ i ], destElements[ i ] ); } } else { cloneCopyEvent( elem, clone ); } } // Preserve script evaluation history destElements = getAll( clone, "script" ); if ( destElements.length > 0 ) { setGlobalEval( destElements, !inPage && getAll( elem, "script" ) ); } // Return the cloned set return clone; }, cleanData: function( elems ) { var data, elem, type, special = jQuery.event.special, i = 0; for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) { if ( acceptData( elem ) ) { if ( ( data = elem[ dataPriv.expando ] ) ) { if ( data.events ) { for ( type in data.events ) { if ( special[ type ] ) { jQuery.event.remove( elem, type ); // This is a shortcut to avoid jQuery.event.remove's overhead } else { jQuery.removeEvent( elem, type, data.handle ); } } } // Support: Chrome <=35 - 45+ // Assign undefined instead of using delete, see Data#remove elem[ dataPriv.expando ] = undefined; } if ( elem[ dataUser.expando ] ) { // Support: Chrome <=35 - 45+ // Assign undefined instead of using delete, see Data#remove elem[ dataUser.expando ] = undefined; } } } } } ); jQuery.fn.extend( { detach: function( selector ) { return remove( this, selector, true ); }, remove: function( selector ) { return remove( this, selector ); }, text: function( value ) { return access( this, function( value ) { return value === undefined ? jQuery.text( this ) : this.empty().each( function() { if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { this.textContent = value; } } ); }, null, value, arguments.length ); }, append: function() { return domManip( this, arguments, function( elem ) { if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { var target = manipulationTarget( this, elem ); target.appendChild( elem ); } } ); }, prepend: function() { return domManip( this, arguments, function( elem ) { if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { var target = manipulationTarget( this, elem ); target.insertBefore( elem, target.firstChild ); } } ); }, before: function() { return domManip( this, arguments, function( elem ) { if ( this.parentNode ) { this.parentNode.insertBefore( elem, this ); } } ); }, after: function() { return domManip( this, arguments, function( elem ) { if ( this.parentNode ) { this.parentNode.insertBefore( elem, this.nextSibling ); } } ); }, empty: function() { var elem, i = 0; for ( ; ( elem = this[ i ] ) != null; i++ ) { if ( elem.nodeType === 1 ) { // Prevent memory leaks jQuery.cleanData( getAll( elem, false ) ); // Remove any remaining nodes elem.textContent = ""; } } return this; }, clone: function( dataAndEvents, deepDataAndEvents ) { dataAndEvents = dataAndEvents == null ? false : dataAndEvents; deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents; return this.map( function() { return jQuery.clone( this, dataAndEvents, deepDataAndEvents ); } ); }, html: function( value ) { return access( this, function( value ) { var elem = this[ 0 ] || {}, i = 0, l = this.length; if ( value === undefined && elem.nodeType === 1 ) { return elem.innerHTML; } // See if we can take a shortcut and just use innerHTML if ( typeof value === "string" && !rnoInnerhtml.test( value ) && !wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) { value = jQuery.htmlPrefilter( value ); try { for ( ; i < l; i++ ) { elem = this[ i ] || {}; // Remove element nodes and prevent memory leaks if ( elem.nodeType === 1 ) { jQuery.cleanData( getAll( elem, false ) ); elem.innerHTML = value; } } elem = 0; // If using innerHTML throws an exception, use the fallback method } catch ( e ) {} } if ( elem ) { this.empty().append( value ); } }, null, value, arguments.length ); }, replaceWith: function() { var ignored = []; // Make the changes, replacing each non-ignored context element with the new content return domManip( this, arguments, function( elem ) { var parent = this.parentNode; if ( jQuery.inArray( this, ignored ) < 0 ) { jQuery.cleanData( getAll( this ) ); if ( parent ) { parent.replaceChild( elem, this ); } } // Force callback invocation }, ignored ); } } ); jQuery.each( { appendTo: "append", prependTo: "prepend", insertBefore: "before", insertAfter: "after", replaceAll: "replaceWith" }, function( name, original ) { jQuery.fn[ name ] = function( selector ) { var elems, ret = [], insert = jQuery( selector ), last = insert.length - 1, i = 0; for ( ; i <= last; i++ ) { elems = i === last ? this : this.clone( true ); jQuery( insert[ i ] )[ original ]( elems ); // Support: Android <=4.0 only, PhantomJS 1 only // .get() because push.apply(_, arraylike) throws on ancient WebKit push.apply( ret, elems.get() ); } return this.pushStack( ret ); }; } ); var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" ); var getStyles = function( elem ) { // Support: IE <=11 only, Firefox <=30 (#15098, #14150) // IE throws on elements created in popups // FF meanwhile throws on frame elements through "defaultView.getComputedStyle" var view = elem.ownerDocument.defaultView; if ( !view || !view.opener ) { view = window; } return view.getComputedStyle( elem ); }; var rboxStyle = new RegExp( cssExpand.join( "|" ), "i" ); ( function() { // Executing both pixelPosition & boxSizingReliable tests require only one layout // so they're executed at the same time to save the second computation. function computeStyleTests() { // This is a singleton, we need to execute it only once if ( !div ) { return; } container.style.cssText = "position:absolute;left:-11111px;width:60px;" + "margin-top:1px;padding:0;border:0"; div.style.cssText = "position:relative;display:block;box-sizing:border-box;overflow:scroll;" + "margin:auto;border:1px;padding:1px;" + "width:60%;top:1%"; documentElement.appendChild( container ).appendChild( div ); var divStyle = window.getComputedStyle( div ); pixelPositionVal = divStyle.top !== "1%"; // Support: Android 4.0 - 4.3 only, Firefox <=3 - 44 reliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12; // Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3 // Some styles come back with percentage values, even though they shouldn't div.style.right = "60%"; pixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36; // Support: IE 9 - 11 only // Detect misreporting of content dimensions for box-sizing:border-box elements boxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36; // Support: IE 9 only // Detect overflow:scroll screwiness (gh-3699) // Support: Chrome <=64 // Don't get tricked when zoom affects offsetWidth (gh-4029) div.style.position = "absolute"; scrollboxSizeVal = roundPixelMeasures( div.offsetWidth / 3 ) === 12; documentElement.removeChild( container ); // Nullify the div so it wouldn't be stored in the memory and // it will also be a sign that checks already performed div = null; } function roundPixelMeasures( measure ) { return Math.round( parseFloat( measure ) ); } var pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal, reliableMarginLeftVal, container = document.createElement( "div" ), div = document.createElement( "div" ); // Finish early in limited (non-browser) environments if ( !div.style ) { return; } // Support: IE <=9 - 11 only // Style of cloned element affects source element cloned (#8908) div.style.backgroundClip = "content-box"; div.cloneNode( true ).style.backgroundClip = ""; support.clearCloneStyle = div.style.backgroundClip === "content-box"; jQuery.extend( support, { boxSizingReliable: function() { computeStyleTests(); return boxSizingReliableVal; }, pixelBoxStyles: function() { computeStyleTests(); return pixelBoxStylesVal; }, pixelPosition: function() { computeStyleTests(); return pixelPositionVal; }, reliableMarginLeft: function() { computeStyleTests(); return reliableMarginLeftVal; }, scrollboxSize: function() { computeStyleTests(); return scrollboxSizeVal; } } ); } )(); function curCSS( elem, name, computed ) { var width, minWidth, maxWidth, ret, // Support: Firefox 51+ // Retrieving style before computed somehow // fixes an issue with getting wrong values // on detached elements style = elem.style; computed = computed || getStyles( elem ); // getPropertyValue is needed for: // .css('filter') (IE 9 only, #12537) // .css('--customProperty) (#3144) if ( computed ) { ret = computed.getPropertyValue( name ) || computed[ name ]; if ( ret === "" && !isAttached( elem ) ) { ret = jQuery.style( elem, name ); } // A tribute to the "awesome hack by Dean Edwards" // Android Browser returns percentage for some values, // but width seems to be reliably pixels. // This is against the CSSOM draft spec: // https://drafts.csswg.org/cssom/#resolved-values if ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) { // Remember the original values width = style.width; minWidth = style.minWidth; maxWidth = style.maxWidth; // Put in the new values to get a computed value out style.minWidth = style.maxWidth = style.width = ret; ret = computed.width; // Revert the changed values style.width = width; style.minWidth = minWidth; style.maxWidth = maxWidth; } } return ret !== undefined ? // Support: IE <=9 - 11 only // IE returns zIndex value as an integer. ret + "" : ret; } function addGetHookIf( conditionFn, hookFn ) { // Define the hook, we'll check on the first run if it's really needed. return { get: function() { if ( conditionFn() ) { // Hook not needed (or it's not possible to use it due // to missing dependency), remove it. delete this.get; return; } // Hook needed; redefine it so that the support test is not executed again. return ( this.get = hookFn ).apply( this, arguments ); } }; } var cssPrefixes = [ "Webkit", "Moz", "ms" ], emptyStyle = document.createElement( "div" ).style, vendorProps = {}; // Return a vendor-prefixed property or undefined function vendorPropName( name ) { // Check for vendor prefixed names var capName = name[ 0 ].toUpperCase() + name.slice( 1 ), i = cssPrefixes.length; while ( i-- ) { name = cssPrefixes[ i ] + capName; if ( name in emptyStyle ) { return name; } } } // Return a potentially-mapped jQuery.cssProps or vendor prefixed property function finalPropName( name ) { var final = jQuery.cssProps[ name ] || vendorProps[ name ]; if ( final ) { return final; } if ( name in emptyStyle ) { return name; } return vendorProps[ name ] = vendorPropName( name ) || name; } var // Swappable if display is none or starts with table // except "table", "table-cell", or "table-caption" // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display rdisplayswap = /^(none|table(?!-c[ea]).+)/, rcustomProp = /^--/, cssShow = { position: "absolute", visibility: "hidden", display: "block" }, cssNormalTransform = { letterSpacing: "0", fontWeight: "400" }; function setPositiveNumber( elem, value, subtract ) { // Any relative (+/-) values have already been // normalized at this point var matches = rcssNum.exec( value ); return matches ? // Guard against undefined "subtract", e.g., when used as in cssHooks Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) : value; } function boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) { var i = dimension === "width" ? 1 : 0, extra = 0, delta = 0; // Adjustment may not be necessary if ( box === ( isBorderBox ? "border" : "content" ) ) { return 0; } for ( ; i < 4; i += 2 ) { // Both box models exclude margin if ( box === "margin" ) { delta += jQuery.css( elem, box + cssExpand[ i ], true, styles ); } // If we get here with a content-box, we're seeking "padding" or "border" or "margin" if ( !isBorderBox ) { // Add padding delta += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); // For "border" or "margin", add border if ( box !== "padding" ) { delta += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); // But still keep track of it otherwise } else { extra += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); } // If we get here with a border-box (content + padding + border), we're seeking "content" or // "padding" or "margin" } else { // For "content", subtract padding if ( box === "content" ) { delta -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); } // For "content" or "padding", subtract border if ( box !== "margin" ) { delta -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); } } } // Account for positive content-box scroll gutter when requested by providing computedVal if ( !isBorderBox && computedVal >= 0 ) { // offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border // Assuming integer scroll gutter, subtract the rest and round down delta += Math.max( 0, Math.ceil( elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] - computedVal - delta - extra - 0.5 // If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter // Use an explicit zero to avoid NaN (gh-3964) ) ) || 0; } return delta; } function getWidthOrHeight( elem, dimension, extra ) { // Start with computed style var styles = getStyles( elem ), // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322). // Fake content-box until we know it's needed to know the true value. boxSizingNeeded = !support.boxSizingReliable() || extra, isBorderBox = boxSizingNeeded && jQuery.css( elem, "boxSizing", false, styles ) === "border-box", valueIsBorderBox = isBorderBox, val = curCSS( elem, dimension, styles ), offsetProp = "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ); // Support: Firefox <=54 // Return a confounding non-pixel value or feign ignorance, as appropriate. if ( rnumnonpx.test( val ) ) { if ( !extra ) { return val; } val = "auto"; } // Fall back to offsetWidth/offsetHeight when value is "auto" // This happens for inline elements with no explicit setting (gh-3571) // Support: Android <=4.1 - 4.3 only // Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602) // Support: IE 9-11 only // Also use offsetWidth/offsetHeight for when box sizing is unreliable // We use getClientRects() to check for hidden/disconnected. // In those cases, the computed value can be trusted to be border-box if ( ( !support.boxSizingReliable() && isBorderBox || val === "auto" || !parseFloat( val ) && jQuery.css( elem, "display", false, styles ) === "inline" ) && elem.getClientRects().length ) { isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box"; // Where available, offsetWidth/offsetHeight approximate border box dimensions. // Where not available (e.g., SVG), assume unreliable box-sizing and interpret the // retrieved value as a content box dimension. valueIsBorderBox = offsetProp in elem; if ( valueIsBorderBox ) { val = elem[ offsetProp ]; } } // Normalize "" and auto val = parseFloat( val ) || 0; // Adjust for the element's box model return ( val + boxModelAdjustment( elem, dimension, extra || ( isBorderBox ? "border" : "content" ), valueIsBorderBox, styles, // Provide the current computed size to request scroll gutter calculation (gh-3589) val ) ) + "px"; } jQuery.extend( { // Add in style property hooks for overriding the default // behavior of getting and setting a style property cssHooks: { opacity: { get: function( elem, computed ) { if ( computed ) { // We should always get a number back from opacity var ret = curCSS( elem, "opacity" ); return ret === "" ? "1" : ret; } } } }, // Don't automatically add "px" to these possibly-unitless properties cssNumber: { "animationIterationCount": true, "columnCount": true, "fillOpacity": true, "flexGrow": true, "flexShrink": true, "fontWeight": true, "gridArea": true, "gridColumn": true, "gridColumnEnd": true, "gridColumnStart": true, "gridRow": true, "gridRowEnd": true, "gridRowStart": true, "lineHeight": true, "opacity": true, "order": true, "orphans": true, "widows": true, "zIndex": true, "zoom": true }, // Add in properties whose names you wish to fix before // setting or getting the value cssProps: {}, // Get and set the style property on a DOM Node style: function( elem, name, value, extra ) { // Don't set styles on text and comment nodes if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) { return; } // Make sure that we're working with the right name var ret, type, hooks, origName = camelCase( name ), isCustomProp = rcustomProp.test( name ), style = elem.style; // Make sure that we're working with the right name. We don't // want to query the value if it is a CSS custom property // since they are user-defined. if ( !isCustomProp ) { name = finalPropName( origName ); } // Gets hook for the prefixed version, then unprefixed version hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; // Check if we're setting a value if ( value !== undefined ) { type = typeof value; // Convert "+=" or "-=" to relative numbers (#7345) if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) { value = adjustCSS( elem, name, ret ); // Fixes bug #9237 type = "number"; } // Make sure that null and NaN values aren't set (#7116) if ( value == null || value !== value ) { return; } // If a number was passed in, add the unit (except for certain CSS properties) // The isCustomProp check can be removed in jQuery 4.0 when we only auto-append // "px" to a few hardcoded values. if ( type === "number" && !isCustomProp ) { value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" ); } // background-* props affect original clone's values if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) { style[ name ] = "inherit"; } // If a hook was provided, use that value, otherwise just set the specified value if ( !hooks || !( "set" in hooks ) || ( value = hooks.set( elem, value, extra ) ) !== undefined ) { if ( isCustomProp ) { style.setProperty( name, value ); } else { style[ name ] = value; } } } else { // If a hook was provided get the non-computed value from there if ( hooks && "get" in hooks && ( ret = hooks.get( elem, false, extra ) ) !== undefined ) { return ret; } // Otherwise just get the value from the style object return style[ name ]; } }, css: function( elem, name, extra, styles ) { var val, num, hooks, origName = camelCase( name ), isCustomProp = rcustomProp.test( name ); // Make sure that we're working with the right name. We don't // want to modify the value if it is a CSS custom property // since they are user-defined. if ( !isCustomProp ) { name = finalPropName( origName ); } // Try prefixed name followed by the unprefixed name hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; // If a hook was provided get the computed value from there if ( hooks && "get" in hooks ) { val = hooks.get( elem, true, extra ); } // Otherwise, if a way to get the computed value exists, use that if ( val === undefined ) { val = curCSS( elem, name, styles ); } // Convert "normal" to computed value if ( val === "normal" && name in cssNormalTransform ) { val = cssNormalTransform[ name ]; } // Make numeric if forced or a qualifier was provided and val looks numeric if ( extra === "" || extra ) { num = parseFloat( val ); return extra === true || isFinite( num ) ? num || 0 : val; } return val; } } ); jQuery.each( [ "height", "width" ], function( i, dimension ) { jQuery.cssHooks[ dimension ] = { get: function( elem, computed, extra ) { if ( computed ) { // Certain elements can have dimension info if we invisibly show them // but it must have a current display style that would benefit return rdisplayswap.test( jQuery.css( elem, "display" ) ) && // Support: Safari 8+ // Table columns in Safari have non-zero offsetWidth & zero // getBoundingClientRect().width unless display is changed. // Support: IE <=11 only // Running getBoundingClientRect on a disconnected node // in IE throws an error. ( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ? swap( elem, cssShow, function() { return getWidthOrHeight( elem, dimension, extra ); } ) : getWidthOrHeight( elem, dimension, extra ); } }, set: function( elem, value, extra ) { var matches, styles = getStyles( elem ), // Only read styles.position if the test has a chance to fail // to avoid forcing a reflow. scrollboxSizeBuggy = !support.scrollboxSize() && styles.position === "absolute", // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991) boxSizingNeeded = scrollboxSizeBuggy || extra, isBorderBox = boxSizingNeeded && jQuery.css( elem, "boxSizing", false, styles ) === "border-box", subtract = extra ? boxModelAdjustment( elem, dimension, extra, isBorderBox, styles ) : 0; // Account for unreliable border-box dimensions by comparing offset* to computed and // faking a content-box to get border and padding (gh-3699) if ( isBorderBox && scrollboxSizeBuggy ) { subtract -= Math.ceil( elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] - parseFloat( styles[ dimension ] ) - boxModelAdjustment( elem, dimension, "border", false, styles ) - 0.5 ); } // Convert to pixels if value adjustment is needed if ( subtract && ( matches = rcssNum.exec( value ) ) && ( matches[ 3 ] || "px" ) !== "px" ) { elem.style[ dimension ] = value; value = jQuery.css( elem, dimension ); } return setPositiveNumber( elem, value, subtract ); } }; } ); jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft, function( elem, computed ) { if ( computed ) { return ( parseFloat( curCSS( elem, "marginLeft" ) ) || elem.getBoundingClientRect().left - swap( elem, { marginLeft: 0 }, function() { return elem.getBoundingClientRect().left; } ) ) + "px"; } } ); // These hooks are used by animate to expand properties jQuery.each( { margin: "", padding: "", border: "Width" }, function( prefix, suffix ) { jQuery.cssHooks[ prefix + suffix ] = { expand: function( value ) { var i = 0, expanded = {}, // Assumes a single number if not a string parts = typeof value === "string" ? value.split( " " ) : [ value ]; for ( ; i < 4; i++ ) { expanded[ prefix + cssExpand[ i ] + suffix ] = parts[ i ] || parts[ i - 2 ] || parts[ 0 ]; } return expanded; } }; if ( prefix !== "margin" ) { jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber; } } ); jQuery.fn.extend( { css: function( name, value ) { return access( this, function( elem, name, value ) { var styles, len, map = {}, i = 0; if ( Array.isArray( name ) ) { styles = getStyles( elem ); len = name.length; for ( ; i < len; i++ ) { map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles ); } return map; } return value !== undefined ? jQuery.style( elem, name, value ) : jQuery.css( elem, name ); }, name, value, arguments.length > 1 ); } } ); function Tween( elem, options, prop, end, easing ) { return new Tween.prototype.init( elem, options, prop, end, easing ); } jQuery.Tween = Tween; Tween.prototype = { constructor: Tween, init: function( elem, options, prop, end, easing, unit ) { this.elem = elem; this.prop = prop; this.easing = easing || jQuery.easing._default; this.options = options; this.start = this.now = this.cur(); this.end = end; this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" ); }, cur: function() { var hooks = Tween.propHooks[ this.prop ]; return hooks && hooks.get ? hooks.get( this ) : Tween.propHooks._default.get( this ); }, run: function( percent ) { var eased, hooks = Tween.propHooks[ this.prop ]; if ( this.options.duration ) { this.pos = eased = jQuery.easing[ this.easing ]( percent, this.options.duration * percent, 0, 1, this.options.duration ); } else { this.pos = eased = percent; } this.now = ( this.end - this.start ) * eased + this.start; if ( this.options.step ) { this.options.step.call( this.elem, this.now, this ); } if ( hooks && hooks.set ) { hooks.set( this ); } else { Tween.propHooks._default.set( this ); } return this; } }; Tween.prototype.init.prototype = Tween.prototype; Tween.propHooks = { _default: { get: function( tween ) { var result; // Use a property on the element directly when it is not a DOM element, // or when there is no matching style property that exists. if ( tween.elem.nodeType !== 1 || tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) { return tween.elem[ tween.prop ]; } // Passing an empty string as a 3rd parameter to .css will automatically // attempt a parseFloat and fallback to a string if the parse fails. // Simple values such as "10px" are parsed to Float; // complex values such as "rotate(1rad)" are returned as-is. result = jQuery.css( tween.elem, tween.prop, "" ); // Empty strings, null, undefined and "auto" are converted to 0. return !result || result === "auto" ? 0 : result; }, set: function( tween ) { // Use step hook for back compat. // Use cssHook if its there. // Use .style if available and use plain properties where available. if ( jQuery.fx.step[ tween.prop ] ) { jQuery.fx.step[ tween.prop ]( tween ); } else if ( tween.elem.nodeType === 1 && ( jQuery.cssHooks[ tween.prop ] || tween.elem.style[ finalPropName( tween.prop ) ] != null ) ) { jQuery.style( tween.elem, tween.prop, tween.now + tween.unit ); } else { tween.elem[ tween.prop ] = tween.now; } } } }; // Support: IE <=9 only // Panic based approach to setting things on disconnected nodes Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = { set: function( tween ) { if ( tween.elem.nodeType && tween.elem.parentNode ) { tween.elem[ tween.prop ] = tween.now; } } }; jQuery.easing = { linear: function( p ) { return p; }, swing: function( p ) { return 0.5 - Math.cos( p * Math.PI ) / 2; }, _default: "swing" }; jQuery.fx = Tween.prototype.init; // Back compat <1.8 extension point jQuery.fx.step = {}; var fxNow, inProgress, rfxtypes = /^(?:toggle|show|hide)$/, rrun = /queueHooks$/; function schedule() { if ( inProgress ) { if ( document.hidden === false && window.requestAnimationFrame ) { window.requestAnimationFrame( schedule ); } else { window.setTimeout( schedule, jQuery.fx.interval ); } jQuery.fx.tick(); } } // Animations created synchronously will run synchronously function createFxNow() { window.setTimeout( function() { fxNow = undefined; } ); return ( fxNow = Date.now() ); } // Generate parameters to create a standard animation function genFx( type, includeWidth ) { var which, i = 0, attrs = { height: type }; // If we include width, step value is 1 to do all cssExpand values, // otherwise step value is 2 to skip over Left and Right includeWidth = includeWidth ? 1 : 0; for ( ; i < 4; i += 2 - includeWidth ) { which = cssExpand[ i ]; attrs[ "margin" + which ] = attrs[ "padding" + which ] = type; } if ( includeWidth ) { attrs.opacity = attrs.width = type; } return attrs; } function createTween( value, prop, animation ) { var tween, collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ), index = 0, length = collection.length; for ( ; index < length; index++ ) { if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) { // We're done with this property return tween; } } } function defaultPrefilter( elem, props, opts ) { var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display, isBox = "width" in props || "height" in props, anim = this, orig = {}, style = elem.style, hidden = elem.nodeType && isHiddenWithinTree( elem ), dataShow = dataPriv.get( elem, "fxshow" ); // Queue-skipping animations hijack the fx hooks if ( !opts.queue ) { hooks = jQuery._queueHooks( elem, "fx" ); if ( hooks.unqueued == null ) { hooks.unqueued = 0; oldfire = hooks.empty.fire; hooks.empty.fire = function() { if ( !hooks.unqueued ) { oldfire(); } }; } hooks.unqueued++; anim.always( function() { // Ensure the complete handler is called before this completes anim.always( function() { hooks.unqueued--; if ( !jQuery.queue( elem, "fx" ).length ) { hooks.empty.fire(); } } ); } ); } // Detect show/hide animations for ( prop in props ) { value = props[ prop ]; if ( rfxtypes.test( value ) ) { delete props[ prop ]; toggle = toggle || value === "toggle"; if ( value === ( hidden ? "hide" : "show" ) ) { // Pretend to be hidden if this is a "show" and // there is still data from a stopped show/hide if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) { hidden = true; // Ignore all other no-op show/hide data } else { continue; } } orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop ); } } // Bail out if this is a no-op like .hide().hide() propTween = !jQuery.isEmptyObject( props ); if ( !propTween && jQuery.isEmptyObject( orig ) ) { return; } // Restrict "overflow" and "display" styles during box animations if ( isBox && elem.nodeType === 1 ) { // Support: IE <=9 - 11, Edge 12 - 15 // Record all 3 overflow attributes because IE does not infer the shorthand // from identically-valued overflowX and overflowY and Edge just mirrors // the overflowX value there. opts.overflow = [ style.overflow, style.overflowX, style.overflowY ]; // Identify a display type, preferring old show/hide data over the CSS cascade restoreDisplay = dataShow && dataShow.display; if ( restoreDisplay == null ) { restoreDisplay = dataPriv.get( elem, "display" ); } display = jQuery.css( elem, "display" ); if ( display === "none" ) { if ( restoreDisplay ) { display = restoreDisplay; } else { // Get nonempty value(s) by temporarily forcing visibility showHide( [ elem ], true ); restoreDisplay = elem.style.display || restoreDisplay; display = jQuery.css( elem, "display" ); showHide( [ elem ] ); } } // Animate inline elements as inline-block if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) { if ( jQuery.css( elem, "float" ) === "none" ) { // Restore the original display value at the end of pure show/hide animations if ( !propTween ) { anim.done( function() { style.display = restoreDisplay; } ); if ( restoreDisplay == null ) { display = style.display; restoreDisplay = display === "none" ? "" : display; } } style.display = "inline-block"; } } } if ( opts.overflow ) { style.overflow = "hidden"; anim.always( function() { style.overflow = opts.overflow[ 0 ]; style.overflowX = opts.overflow[ 1 ]; style.overflowY = opts.overflow[ 2 ]; } ); } // Implement show/hide animations propTween = false; for ( prop in orig ) { // General show/hide setup for this element animation if ( !propTween ) { if ( dataShow ) { if ( "hidden" in dataShow ) { hidden = dataShow.hidden; } } else { dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } ); } // Store hidden/visible for toggle so `.stop().toggle()` "reverses" if ( toggle ) { dataShow.hidden = !hidden; } // Show elements before animating them if ( hidden ) { showHide( [ elem ], true ); } /* eslint-disable no-loop-func */ anim.done( function() { /* eslint-enable no-loop-func */ // The final step of a "hide" animation is actually hiding the element if ( !hidden ) { showHide( [ elem ] ); } dataPriv.remove( elem, "fxshow" ); for ( prop in orig ) { jQuery.style( elem, prop, orig[ prop ] ); } } ); } // Per-property setup propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim ); if ( !( prop in dataShow ) ) { dataShow[ prop ] = propTween.start; if ( hidden ) { propTween.end = propTween.start; propTween.start = 0; } } } } function propFilter( props, specialEasing ) { var index, name, easing, value, hooks; // camelCase, specialEasing and expand cssHook pass for ( index in props ) { name = camelCase( index ); easing = specialEasing[ name ]; value = props[ index ]; if ( Array.isArray( value ) ) { easing = value[ 1 ]; value = props[ index ] = value[ 0 ]; } if ( index !== name ) { props[ name ] = value; delete props[ index ]; } hooks = jQuery.cssHooks[ name ]; if ( hooks && "expand" in hooks ) { value = hooks.expand( value ); delete props[ name ]; // Not quite $.extend, this won't overwrite existing keys. // Reusing 'index' because we have the correct "name" for ( index in value ) { if ( !( index in props ) ) { props[ index ] = value[ index ]; specialEasing[ index ] = easing; } } } else { specialEasing[ name ] = easing; } } } function Animation( elem, properties, options ) { var result, stopped, index = 0, length = Animation.prefilters.length, deferred = jQuery.Deferred().always( function() { // Don't match elem in the :animated selector delete tick.elem; } ), tick = function() { if ( stopped ) { return false; } var currentTime = fxNow || createFxNow(), remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ), // Support: Android 2.3 only // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497) temp = remaining / animation.duration || 0, percent = 1 - temp, index = 0, length = animation.tweens.length; for ( ; index < length; index++ ) { animation.tweens[ index ].run( percent ); } deferred.notifyWith( elem, [ animation, percent, remaining ] ); // If there's more to do, yield if ( percent < 1 && length ) { return remaining; } // If this was an empty animation, synthesize a final progress notification if ( !length ) { deferred.notifyWith( elem, [ animation, 1, 0 ] ); } // Resolve the animation and report its conclusion deferred.resolveWith( elem, [ animation ] ); return false; }, animation = deferred.promise( { elem: elem, props: jQuery.extend( {}, properties ), opts: jQuery.extend( true, { specialEasing: {}, easing: jQuery.easing._default }, options ), originalProperties: properties, originalOptions: options, startTime: fxNow || createFxNow(), duration: options.duration, tweens: [], createTween: function( prop, end ) { var tween = jQuery.Tween( elem, animation.opts, prop, end, animation.opts.specialEasing[ prop ] || animation.opts.easing ); animation.tweens.push( tween ); return tween; }, stop: function( gotoEnd ) { var index = 0, // If we are going to the end, we want to run all the tweens // otherwise we skip this part length = gotoEnd ? animation.tweens.length : 0; if ( stopped ) { return this; } stopped = true; for ( ; index < length; index++ ) { animation.tweens[ index ].run( 1 ); } // Resolve when we played the last frame; otherwise, reject if ( gotoEnd ) { deferred.notifyWith( elem, [ animation, 1, 0 ] ); deferred.resolveWith( elem, [ animation, gotoEnd ] ); } else { deferred.rejectWith( elem, [ animation, gotoEnd ] ); } return this; } } ), props = animation.props; propFilter( props, animation.opts.specialEasing ); for ( ; index < length; index++ ) { result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts ); if ( result ) { if ( isFunction( result.stop ) ) { jQuery._queueHooks( animation.elem, animation.opts.queue ).stop = result.stop.bind( result ); } return result; } } jQuery.map( props, createTween, animation ); if ( isFunction( animation.opts.start ) ) { animation.opts.start.call( elem, animation ); } // Attach callbacks from options animation .progress( animation.opts.progress ) .done( animation.opts.done, animation.opts.complete ) .fail( animation.opts.fail ) .always( animation.opts.always ); jQuery.fx.timer( jQuery.extend( tick, { elem: elem, anim: animation, queue: animation.opts.queue } ) ); return animation; } jQuery.Animation = jQuery.extend( Animation, { tweeners: { "*": [ function( prop, value ) { var tween = this.createTween( prop, value ); adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween ); return tween; } ] }, tweener: function( props, callback ) { if ( isFunction( props ) ) { callback = props; props = [ "*" ]; } else { props = props.match( rnothtmlwhite ); } var prop, index = 0, length = props.length; for ( ; index < length; index++ ) { prop = props[ index ]; Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || []; Animation.tweeners[ prop ].unshift( callback ); } }, prefilters: [ defaultPrefilter ], prefilter: function( callback, prepend ) { if ( prepend ) { Animation.prefilters.unshift( callback ); } else { Animation.prefilters.push( callback ); } } } ); jQuery.speed = function( speed, easing, fn ) { var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : { complete: fn || !fn && easing || isFunction( speed ) && speed, duration: speed, easing: fn && easing || easing && !isFunction( easing ) && easing }; // Go to the end state if fx are off if ( jQuery.fx.off ) { opt.duration = 0; } else { if ( typeof opt.duration !== "number" ) { if ( opt.duration in jQuery.fx.speeds ) { opt.duration = jQuery.fx.speeds[ opt.duration ]; } else { opt.duration = jQuery.fx.speeds._default; } } } // Normalize opt.queue - true/undefined/null -> "fx" if ( opt.queue == null || opt.queue === true ) { opt.queue = "fx"; } // Queueing opt.old = opt.complete; opt.complete = function() { if ( isFunction( opt.old ) ) { opt.old.call( this ); } if ( opt.queue ) { jQuery.dequeue( this, opt.queue ); } }; return opt; }; jQuery.fn.extend( { fadeTo: function( speed, to, easing, callback ) { // Show any hidden elements after setting opacity to 0 return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show() // Animate to the value specified .end().animate( { opacity: to }, speed, easing, callback ); }, animate: function( prop, speed, easing, callback ) { var empty = jQuery.isEmptyObject( prop ), optall = jQuery.speed( speed, easing, callback ), doAnimation = function() { // Operate on a copy of prop so per-property easing won't be lost var anim = Animation( this, jQuery.extend( {}, prop ), optall ); // Empty animations, or finishing resolves immediately if ( empty || dataPriv.get( this, "finish" ) ) { anim.stop( true ); } }; doAnimation.finish = doAnimation; return empty || optall.queue === false ? this.each( doAnimation ) : this.queue( optall.queue, doAnimation ); }, stop: function( type, clearQueue, gotoEnd ) { var stopQueue = function( hooks ) { var stop = hooks.stop; delete hooks.stop; stop( gotoEnd ); }; if ( typeof type !== "string" ) { gotoEnd = clearQueue; clearQueue = type; type = undefined; } if ( clearQueue && type !== false ) { this.queue( type || "fx", [] ); } return this.each( function() { var dequeue = true, index = type != null && type + "queueHooks", timers = jQuery.timers, data = dataPriv.get( this ); if ( index ) { if ( data[ index ] && data[ index ].stop ) { stopQueue( data[ index ] ); } } else { for ( index in data ) { if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) { stopQueue( data[ index ] ); } } } for ( index = timers.length; index--; ) { if ( timers[ index ].elem === this && ( type == null || timers[ index ].queue === type ) ) { timers[ index ].anim.stop( gotoEnd ); dequeue = false; timers.splice( index, 1 ); } } // Start the next in the queue if the last step wasn't forced. // Timers currently will call their complete callbacks, which // will dequeue but only if they were gotoEnd. if ( dequeue || !gotoEnd ) { jQuery.dequeue( this, type ); } } ); }, finish: function( type ) { if ( type !== false ) { type = type || "fx"; } return this.each( function() { var index, data = dataPriv.get( this ), queue = data[ type + "queue" ], hooks = data[ type + "queueHooks" ], timers = jQuery.timers, length = queue ? queue.length : 0; // Enable finishing flag on private data data.finish = true; // Empty the queue first jQuery.queue( this, type, [] ); if ( hooks && hooks.stop ) { hooks.stop.call( this, true ); } // Look for any active animations, and finish them for ( index = timers.length; index--; ) { if ( timers[ index ].elem === this && timers[ index ].queue === type ) { timers[ index ].anim.stop( true ); timers.splice( index, 1 ); } } // Look for any animations in the old queue and finish them for ( index = 0; index < length; index++ ) { if ( queue[ index ] && queue[ index ].finish ) { queue[ index ].finish.call( this ); } } // Turn off finishing flag delete data.finish; } ); } } ); jQuery.each( [ "toggle", "show", "hide" ], function( i, name ) { var cssFn = jQuery.fn[ name ]; jQuery.fn[ name ] = function( speed, easing, callback ) { return speed == null || typeof speed === "boolean" ? cssFn.apply( this, arguments ) : this.animate( genFx( name, true ), speed, easing, callback ); }; } ); // Generate shortcuts for custom animations jQuery.each( { slideDown: genFx( "show" ), slideUp: genFx( "hide" ), slideToggle: genFx( "toggle" ), fadeIn: { opacity: "show" }, fadeOut: { opacity: "hide" }, fadeToggle: { opacity: "toggle" } }, function( name, props ) { jQuery.fn[ name ] = function( speed, easing, callback ) { return this.animate( props, speed, easing, callback ); }; } ); jQuery.timers = []; jQuery.fx.tick = function() { var timer, i = 0, timers = jQuery.timers; fxNow = Date.now(); for ( ; i < timers.length; i++ ) { timer = timers[ i ]; // Run the timer and safely remove it when done (allowing for external removal) if ( !timer() && timers[ i ] === timer ) { timers.splice( i--, 1 ); } } if ( !timers.length ) { jQuery.fx.stop(); } fxNow = undefined; }; jQuery.fx.timer = function( timer ) { jQuery.timers.push( timer ); jQuery.fx.start(); }; jQuery.fx.interval = 13; jQuery.fx.start = function() { if ( inProgress ) { return; } inProgress = true; schedule(); }; jQuery.fx.stop = function() { inProgress = null; }; jQuery.fx.speeds = { slow: 600, fast: 200, // Default speed _default: 400 }; // Based off of the plugin by Clint Helfers, with permission. // https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/ jQuery.fn.delay = function( time, type ) { time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time; type = type || "fx"; return this.queue( type, function( next, hooks ) { var timeout = window.setTimeout( next, time ); hooks.stop = function() { window.clearTimeout( timeout ); }; } ); }; ( function() { var input = document.createElement( "input" ), select = document.createElement( "select" ), opt = select.appendChild( document.createElement( "option" ) ); input.type = "checkbox"; // Support: Android <=4.3 only // Default value for a checkbox should be "on" support.checkOn = input.value !== ""; // Support: IE <=11 only // Must access selectedIndex to make default options select support.optSelected = opt.selected; // Support: IE <=11 only // An input loses its value after becoming a radio input = document.createElement( "input" ); input.value = "t"; input.type = "radio"; support.radioValue = input.value === "t"; } )(); var boolHook, attrHandle = jQuery.expr.attrHandle; jQuery.fn.extend( { attr: function( name, value ) { return access( this, jQuery.attr, name, value, arguments.length > 1 ); }, removeAttr: function( name ) { return this.each( function() { jQuery.removeAttr( this, name ); } ); } } ); jQuery.extend( { attr: function( elem, name, value ) { var ret, hooks, nType = elem.nodeType; // Don't get/set attributes on text, comment and attribute nodes if ( nType === 3 || nType === 8 || nType === 2 ) { return; } // Fallback to prop when attributes are not supported if ( typeof elem.getAttribute === "undefined" ) { return jQuery.prop( elem, name, value ); } // Attribute hooks are determined by the lowercase version // Grab necessary hook if one is defined if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { hooks = jQuery.attrHooks[ name.toLowerCase() ] || ( jQuery.expr.match.bool.test( name ) ? boolHook : undefined ); } if ( value !== undefined ) { if ( value === null ) { jQuery.removeAttr( elem, name ); return; } if ( hooks && "set" in hooks && ( ret = hooks.set( elem, value, name ) ) !== undefined ) { return ret; } elem.setAttribute( name, value + "" ); return value; } if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { return ret; } ret = jQuery.find.attr( elem, name ); // Non-existent attributes return null, we normalize to undefined return ret == null ? undefined : ret; }, attrHooks: { type: { set: function( elem, value ) { if ( !support.radioValue && value === "radio" && nodeName( elem, "input" ) ) { var val = elem.value; elem.setAttribute( "type", value ); if ( val ) { elem.value = val; } return value; } } } }, removeAttr: function( elem, value ) { var name, i = 0, // Attribute names can contain non-HTML whitespace characters // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2 attrNames = value && value.match( rnothtmlwhite ); if ( attrNames && elem.nodeType === 1 ) { while ( ( name = attrNames[ i++ ] ) ) { elem.removeAttribute( name ); } } } } ); // Hooks for boolean attributes boolHook = { set: function( elem, value, name ) { if ( value === false ) { // Remove boolean attributes when set to false jQuery.removeAttr( elem, name ); } else { elem.setAttribute( name, name ); } return name; } }; jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) { var getter = attrHandle[ name ] || jQuery.find.attr; attrHandle[ name ] = function( elem, name, isXML ) { var ret, handle, lowercaseName = name.toLowerCase(); if ( !isXML ) { // Avoid an infinite loop by temporarily removing this function from the getter handle = attrHandle[ lowercaseName ]; attrHandle[ lowercaseName ] = ret; ret = getter( elem, name, isXML ) != null ? lowercaseName : null; attrHandle[ lowercaseName ] = handle; } return ret; }; } ); var rfocusable = /^(?:input|select|textarea|button)$/i, rclickable = /^(?:a|area)$/i; jQuery.fn.extend( { prop: function( name, value ) { return access( this, jQuery.prop, name, value, arguments.length > 1 ); }, removeProp: function( name ) { return this.each( function() { delete this[ jQuery.propFix[ name ] || name ]; } ); } } ); jQuery.extend( { prop: function( elem, name, value ) { var ret, hooks, nType = elem.nodeType; // Don't get/set properties on text, comment and attribute nodes if ( nType === 3 || nType === 8 || nType === 2 ) { return; } if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { // Fix name and attach hooks name = jQuery.propFix[ name ] || name; hooks = jQuery.propHooks[ name ]; } if ( value !== undefined ) { if ( hooks && "set" in hooks && ( ret = hooks.set( elem, value, name ) ) !== undefined ) { return ret; } return ( elem[ name ] = value ); } if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { return ret; } return elem[ name ]; }, propHooks: { tabIndex: { get: function( elem ) { // Support: IE <=9 - 11 only // elem.tabIndex doesn't always return the // correct value when it hasn't been explicitly set // https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/ // Use proper attribute retrieval(#12072) var tabindex = jQuery.find.attr( elem, "tabindex" ); if ( tabindex ) { return parseInt( tabindex, 10 ); } if ( rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ) { return 0; } return -1; } } }, propFix: { "for": "htmlFor", "class": "className" } } ); // Support: IE <=11 only // Accessing the selectedIndex property // forces the browser to respect setting selected // on the option // The getter ensures a default option is selected // when in an optgroup // eslint rule "no-unused-expressions" is disabled for this code // since it considers such accessions noop if ( !support.optSelected ) { jQuery.propHooks.selected = { get: function( elem ) { /* eslint no-unused-expressions: "off" */ var parent = elem.parentNode; if ( parent && parent.parentNode ) { parent.parentNode.selectedIndex; } return null; }, set: function( elem ) { /* eslint no-unused-expressions: "off" */ var parent = elem.parentNode; if ( parent ) { parent.selectedIndex; if ( parent.parentNode ) { parent.parentNode.selectedIndex; } } } }; } jQuery.each( [ "tabIndex", "readOnly", "maxLength", "cellSpacing", "cellPadding", "rowSpan", "colSpan", "useMap", "frameBorder", "contentEditable" ], function() { jQuery.propFix[ this.toLowerCase() ] = this; } ); // Strip and collapse whitespace according to HTML spec // https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace function stripAndCollapse( value ) { var tokens = value.match( rnothtmlwhite ) || []; return tokens.join( " " ); } function getClass( elem ) { return elem.getAttribute && elem.getAttribute( "class" ) || ""; } function classesToArray( value ) { if ( Array.isArray( value ) ) { return value; } if ( typeof value === "string" ) { return value.match( rnothtmlwhite ) || []; } return []; } jQuery.fn.extend( { addClass: function( value ) { var classes, elem, cur, curValue, clazz, j, finalValue, i = 0; if ( isFunction( value ) ) { return this.each( function( j ) { jQuery( this ).addClass( value.call( this, j, getClass( this ) ) ); } ); } classes = classesToArray( value ); if ( classes.length ) { while ( ( elem = this[ i++ ] ) ) { curValue = getClass( elem ); cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " ); if ( cur ) { j = 0; while ( ( clazz = classes[ j++ ] ) ) { if ( cur.indexOf( " " + clazz + " " ) < 0 ) { cur += clazz + " "; } } // Only assign if different to avoid unneeded rendering. finalValue = stripAndCollapse( cur ); if ( curValue !== finalValue ) { elem.setAttribute( "class", finalValue ); } } } } return this; }, removeClass: function( value ) { var classes, elem, cur, curValue, clazz, j, finalValue, i = 0; if ( isFunction( value ) ) { return this.each( function( j ) { jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) ); } ); } if ( !arguments.length ) { return this.attr( "class", "" ); } classes = classesToArray( value ); if ( classes.length ) { while ( ( elem = this[ i++ ] ) ) { curValue = getClass( elem ); // This expression is here for better compressibility (see addClass) cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " ); if ( cur ) { j = 0; while ( ( clazz = classes[ j++ ] ) ) { // Remove *all* instances while ( cur.indexOf( " " + clazz + " " ) > -1 ) { cur = cur.replace( " " + clazz + " ", " " ); } } // Only assign if different to avoid unneeded rendering. finalValue = stripAndCollapse( cur ); if ( curValue !== finalValue ) { elem.setAttribute( "class", finalValue ); } } } } return this; }, toggleClass: function( value, stateVal ) { var type = typeof value, isValidValue = type === "string" || Array.isArray( value ); if ( typeof stateVal === "boolean" && isValidValue ) { return stateVal ? this.addClass( value ) : this.removeClass( value ); } if ( isFunction( value ) ) { return this.each( function( i ) { jQuery( this ).toggleClass( value.call( this, i, getClass( this ), stateVal ), stateVal ); } ); } return this.each( function() { var className, i, self, classNames; if ( isValidValue ) { // Toggle individual class names i = 0; self = jQuery( this ); classNames = classesToArray( value ); while ( ( className = classNames[ i++ ] ) ) { // Check each className given, space separated list if ( self.hasClass( className ) ) { self.removeClass( className ); } else { self.addClass( className ); } } // Toggle whole class name } else if ( value === undefined || type === "boolean" ) { className = getClass( this ); if ( className ) { // Store className if set dataPriv.set( this, "__className__", className ); } // If the element has a class name or if we're passed `false`, // then remove the whole classname (if there was one, the above saved it). // Otherwise bring back whatever was previously saved (if anything), // falling back to the empty string if nothing was stored. if ( this.setAttribute ) { this.setAttribute( "class", className || value === false ? "" : dataPriv.get( this, "__className__" ) || "" ); } } } ); }, hasClass: function( selector ) { var className, elem, i = 0; className = " " + selector + " "; while ( ( elem = this[ i++ ] ) ) { if ( elem.nodeType === 1 && ( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) { return true; } } return false; } } ); var rreturn = /\r/g; jQuery.fn.extend( { val: function( value ) { var hooks, ret, valueIsFunction, elem = this[ 0 ]; if ( !arguments.length ) { if ( elem ) { hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase() ]; if ( hooks && "get" in hooks && ( ret = hooks.get( elem, "value" ) ) !== undefined ) { return ret; } ret = elem.value; // Handle most common string cases if ( typeof ret === "string" ) { return ret.replace( rreturn, "" ); } // Handle cases where value is null/undef or number return ret == null ? "" : ret; } return; } valueIsFunction = isFunction( value ); return this.each( function( i ) { var val; if ( this.nodeType !== 1 ) { return; } if ( valueIsFunction ) { val = value.call( this, i, jQuery( this ).val() ); } else { val = value; } // Treat null/undefined as ""; convert numbers to string if ( val == null ) { val = ""; } else if ( typeof val === "number" ) { val += ""; } else if ( Array.isArray( val ) ) { val = jQuery.map( val, function( value ) { return value == null ? "" : value + ""; } ); } hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ]; // If set returns undefined, fall back to normal setting if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) { this.value = val; } } ); } } ); jQuery.extend( { valHooks: { option: { get: function( elem ) { var val = jQuery.find.attr( elem, "value" ); return val != null ? val : // Support: IE <=10 - 11 only // option.text throws exceptions (#14686, #14858) // Strip and collapse whitespace // https://html.spec.whatwg.org/#strip-and-collapse-whitespace stripAndCollapse( jQuery.text( elem ) ); } }, select: { get: function( elem ) { var value, option, i, options = elem.options, index = elem.selectedIndex, one = elem.type === "select-one", values = one ? null : [], max = one ? index + 1 : options.length; if ( index < 0 ) { i = max; } else { i = one ? index : 0; } // Loop through all the selected options for ( ; i < max; i++ ) { option = options[ i ]; // Support: IE <=9 only // IE8-9 doesn't update selected after form reset (#2551) if ( ( option.selected || i === index ) && // Don't return options that are disabled or in a disabled optgroup !option.disabled && ( !option.parentNode.disabled || !nodeName( option.parentNode, "optgroup" ) ) ) { // Get the specific value for the option value = jQuery( option ).val(); // We don't need an array for one selects if ( one ) { return value; } // Multi-Selects return an array values.push( value ); } } return values; }, set: function( elem, value ) { var optionSet, option, options = elem.options, values = jQuery.makeArray( value ), i = options.length; while ( i-- ) { option = options[ i ]; /* eslint-disable no-cond-assign */ if ( option.selected = jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1 ) { optionSet = true; } /* eslint-enable no-cond-assign */ } // Force browsers to behave consistently when non-matching value is set if ( !optionSet ) { elem.selectedIndex = -1; } return values; } } } } ); // Radios and checkboxes getter/setter jQuery.each( [ "radio", "checkbox" ], function() { jQuery.valHooks[ this ] = { set: function( elem, value ) { if ( Array.isArray( value ) ) { return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 ); } } }; if ( !support.checkOn ) { jQuery.valHooks[ this ].get = function( elem ) { return elem.getAttribute( "value" ) === null ? "on" : elem.value; }; } } ); // Return jQuery for attributes-only inclusion support.focusin = "onfocusin" in window; var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, stopPropagationCallback = function( e ) { e.stopPropagation(); }; jQuery.extend( jQuery.event, { trigger: function( event, data, elem, onlyHandlers ) { var i, cur, tmp, bubbleType, ontype, handle, special, lastElement, eventPath = [ elem || document ], type = hasOwn.call( event, "type" ) ? event.type : event, namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : []; cur = lastElement = tmp = elem = elem || document; // Don't do events on text and comment nodes if ( elem.nodeType === 3 || elem.nodeType === 8 ) { return; } // focus/blur morphs to focusin/out; ensure we're not firing them right now if ( rfocusMorph.test( type + jQuery.event.triggered ) ) { return; } if ( type.indexOf( "." ) > -1 ) { // Namespaced trigger; create a regexp to match event type in handle() namespaces = type.split( "." ); type = namespaces.shift(); namespaces.sort(); } ontype = type.indexOf( ":" ) < 0 && "on" + type; // Caller can pass in a jQuery.Event object, Object, or just an event type string event = event[ jQuery.expando ] ? event : new jQuery.Event( type, typeof event === "object" && event ); // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true) event.isTrigger = onlyHandlers ? 2 : 3; event.namespace = namespaces.join( "." ); event.rnamespace = event.namespace ? new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) : null; // Clean up the event in case it is being reused event.result = undefined; if ( !event.target ) { event.target = elem; } // Clone any incoming data and prepend the event, creating the handler arg list data = data == null ? [ event ] : jQuery.makeArray( data, [ event ] ); // Allow special events to draw outside the lines special = jQuery.event.special[ type ] || {}; if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) { return; } // Determine event propagation path in advance, per W3C events spec (#9951) // Bubble up to document, then to window; watch for a global ownerDocument var (#9724) if ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) { bubbleType = special.delegateType || type; if ( !rfocusMorph.test( bubbleType + type ) ) { cur = cur.parentNode; } for ( ; cur; cur = cur.parentNode ) { eventPath.push( cur ); tmp = cur; } // Only add window if we got to document (e.g., not plain obj or detached DOM) if ( tmp === ( elem.ownerDocument || document ) ) { eventPath.push( tmp.defaultView || tmp.parentWindow || window ); } } // Fire handlers on the event path i = 0; while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) { lastElement = cur; event.type = i > 1 ? bubbleType : special.bindType || type; // jQuery handler handle = ( dataPriv.get( cur, "events" ) || {} )[ event.type ] && dataPriv.get( cur, "handle" ); if ( handle ) { handle.apply( cur, data ); } // Native handler handle = ontype && cur[ ontype ]; if ( handle && handle.apply && acceptData( cur ) ) { event.result = handle.apply( cur, data ); if ( event.result === false ) { event.preventDefault(); } } } event.type = type; // If nobody prevented the default action, do it now if ( !onlyHandlers && !event.isDefaultPrevented() ) { if ( ( !special._default || special._default.apply( eventPath.pop(), data ) === false ) && acceptData( elem ) ) { // Call a native DOM method on the target with the same name as the event. // Don't do default actions on window, that's where global variables be (#6170) if ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) { // Don't re-trigger an onFOO event when we call its FOO() method tmp = elem[ ontype ]; if ( tmp ) { elem[ ontype ] = null; } // Prevent re-triggering of the same event, since we already bubbled it above jQuery.event.triggered = type; if ( event.isPropagationStopped() ) { lastElement.addEventListener( type, stopPropagationCallback ); } elem[ type ](); if ( event.isPropagationStopped() ) { lastElement.removeEventListener( type, stopPropagationCallback ); } jQuery.event.triggered = undefined; if ( tmp ) { elem[ ontype ] = tmp; } } } } return event.result; }, // Piggyback on a donor event to simulate a different one // Used only for `focus(in | out)` events simulate: function( type, elem, event ) { var e = jQuery.extend( new jQuery.Event(), event, { type: type, isSimulated: true } ); jQuery.event.trigger( e, null, elem ); } } ); jQuery.fn.extend( { trigger: function( type, data ) { return this.each( function() { jQuery.event.trigger( type, data, this ); } ); }, triggerHandler: function( type, data ) { var elem = this[ 0 ]; if ( elem ) { return jQuery.event.trigger( type, data, elem, true ); } } } ); // Support: Firefox <=44 // Firefox doesn't have focus(in | out) events // Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787 // // Support: Chrome <=48 - 49, Safari <=9.0 - 9.1 // focus(in | out) events fire after focus & blur events, // which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order // Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857 if ( !support.focusin ) { jQuery.each( { focus: "focusin", blur: "focusout" }, function( orig, fix ) { // Attach a single capturing handler on the document while someone wants focusin/focusout var handler = function( event ) { jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) ); }; jQuery.event.special[ fix ] = { setup: function() { var doc = this.ownerDocument || this, attaches = dataPriv.access( doc, fix ); if ( !attaches ) { doc.addEventListener( orig, handler, true ); } dataPriv.access( doc, fix, ( attaches || 0 ) + 1 ); }, teardown: function() { var doc = this.ownerDocument || this, attaches = dataPriv.access( doc, fix ) - 1; if ( !attaches ) { doc.removeEventListener( orig, handler, true ); dataPriv.remove( doc, fix ); } else { dataPriv.access( doc, fix, attaches ); } } }; } ); } var location = window.location; var nonce = Date.now(); var rquery = ( /\?/ ); // Cross-browser xml parsing jQuery.parseXML = function( data ) { var xml; if ( !data || typeof data !== "string" ) { return null; } // Support: IE 9 - 11 only // IE throws on parseFromString with invalid input. try { xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" ); } catch ( e ) { xml = undefined; } if ( !xml || xml.getElementsByTagName( "parsererror" ).length ) { jQuery.error( "Invalid XML: " + data ); } return xml; }; var rbracket = /\[\]$/, rCRLF = /\r?\n/g, rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i, rsubmittable = /^(?:input|select|textarea|keygen)/i; function buildParams( prefix, obj, traditional, add ) { var name; if ( Array.isArray( obj ) ) { // Serialize array item. jQuery.each( obj, function( i, v ) { if ( traditional || rbracket.test( prefix ) ) { // Treat each array item as a scalar. add( prefix, v ); } else { // Item is non-scalar (array or object), encode its numeric index. buildParams( prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]", v, traditional, add ); } } ); } else if ( !traditional && toType( obj ) === "object" ) { // Serialize object item. for ( name in obj ) { buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add ); } } else { // Serialize scalar item. add( prefix, obj ); } } // Serialize an array of form elements or a set of // key/values into a query string jQuery.param = function( a, traditional ) { var prefix, s = [], add = function( key, valueOrFunction ) { // If value is a function, invoke it and use its return value var value = isFunction( valueOrFunction ) ? valueOrFunction() : valueOrFunction; s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value == null ? "" : value ); }; if ( a == null ) { return ""; } // If an array was passed in, assume that it is an array of form elements. if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) { // Serialize the form elements jQuery.each( a, function() { add( this.name, this.value ); } ); } else { // If traditional, encode the "old" way (the way 1.3.2 or older // did it), otherwise encode params recursively. for ( prefix in a ) { buildParams( prefix, a[ prefix ], traditional, add ); } } // Return the resulting serialization return s.join( "&" ); }; jQuery.fn.extend( { serialize: function() { return jQuery.param( this.serializeArray() ); }, serializeArray: function() { return this.map( function() { // Can add propHook for "elements" to filter or add form elements var elements = jQuery.prop( this, "elements" ); return elements ? jQuery.makeArray( elements ) : this; } ) .filter( function() { var type = this.type; // Use .is( ":disabled" ) so that fieldset[disabled] works return this.name && !jQuery( this ).is( ":disabled" ) && rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) && ( this.checked || !rcheckableType.test( type ) ); } ) .map( function( i, elem ) { var val = jQuery( this ).val(); if ( val == null ) { return null; } if ( Array.isArray( val ) ) { return jQuery.map( val, function( val ) { return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; } ); } return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; } ).get(); } } ); var r20 = /%20/g, rhash = /#.*$/, rantiCache = /([?&])_=[^&]*/, rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg, // #7653, #8125, #8152: local protocol detection rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/, rnoContent = /^(?:GET|HEAD)$/, rprotocol = /^\/\//, /* Prefilters * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example) * 2) These are called: * - BEFORE asking for a transport * - AFTER param serialization (s.data is a string if s.processData is true) * 3) key is the dataType * 4) the catchall symbol "*" can be used * 5) execution will start with transport dataType and THEN continue down to "*" if needed */ prefilters = {}, /* Transports bindings * 1) key is the dataType * 2) the catchall symbol "*" can be used * 3) selection will start with transport dataType and THEN go to "*" if needed */ transports = {}, // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression allTypes = "*/".concat( "*" ), // Anchor tag for parsing the document origin originAnchor = document.createElement( "a" ); originAnchor.href = location.href; // Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport function addToPrefiltersOrTransports( structure ) { // dataTypeExpression is optional and defaults to "*" return function( dataTypeExpression, func ) { if ( typeof dataTypeExpression !== "string" ) { func = dataTypeExpression; dataTypeExpression = "*"; } var dataType, i = 0, dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || []; if ( isFunction( func ) ) { // For each dataType in the dataTypeExpression while ( ( dataType = dataTypes[ i++ ] ) ) { // Prepend if requested if ( dataType[ 0 ] === "+" ) { dataType = dataType.slice( 1 ) || "*"; ( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func ); // Otherwise append } else { ( structure[ dataType ] = structure[ dataType ] || [] ).push( func ); } } } }; } // Base inspection function for prefilters and transports function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) { var inspected = {}, seekingTransport = ( structure === transports ); function inspect( dataType ) { var selected; inspected[ dataType ] = true; jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) { var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR ); if ( typeof dataTypeOrTransport === "string" && !seekingTransport && !inspected[ dataTypeOrTransport ] ) { options.dataTypes.unshift( dataTypeOrTransport ); inspect( dataTypeOrTransport ); return false; } else if ( seekingTransport ) { return !( selected = dataTypeOrTransport ); } } ); return selected; } return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" ); } // A special extend for ajax options // that takes "flat" options (not to be deep extended) // Fixes #9887 function ajaxExtend( target, src ) { var key, deep, flatOptions = jQuery.ajaxSettings.flatOptions || {}; for ( key in src ) { if ( src[ key ] !== undefined ) { ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ]; } } if ( deep ) { jQuery.extend( true, target, deep ); } return target; } /* Handles responses to an ajax request: * - finds the right dataType (mediates between content-type and expected dataType) * - returns the corresponding response */ function ajaxHandleResponses( s, jqXHR, responses ) { var ct, type, finalDataType, firstDataType, contents = s.contents, dataTypes = s.dataTypes; // Remove auto dataType and get content-type in the process while ( dataTypes[ 0 ] === "*" ) { dataTypes.shift(); if ( ct === undefined ) { ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" ); } } // Check if we're dealing with a known content-type if ( ct ) { for ( type in contents ) { if ( contents[ type ] && contents[ type ].test( ct ) ) { dataTypes.unshift( type ); break; } } } // Check to see if we have a response for the expected dataType if ( dataTypes[ 0 ] in responses ) { finalDataType = dataTypes[ 0 ]; } else { // Try convertible dataTypes for ( type in responses ) { if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) { finalDataType = type; break; } if ( !firstDataType ) { firstDataType = type; } } // Or just use first one finalDataType = finalDataType || firstDataType; } // If we found a dataType // We add the dataType to the list if needed // and return the corresponding response if ( finalDataType ) { if ( finalDataType !== dataTypes[ 0 ] ) { dataTypes.unshift( finalDataType ); } return responses[ finalDataType ]; } } /* Chain conversions given the request and the original response * Also sets the responseXXX fields on the jqXHR instance */ function ajaxConvert( s, response, jqXHR, isSuccess ) { var conv2, current, conv, tmp, prev, converters = {}, // Work with a copy of dataTypes in case we need to modify it for conversion dataTypes = s.dataTypes.slice(); // Create converters map with lowercased keys if ( dataTypes[ 1 ] ) { for ( conv in s.converters ) { converters[ conv.toLowerCase() ] = s.converters[ conv ]; } } current = dataTypes.shift(); // Convert to each sequential dataType while ( current ) { if ( s.responseFields[ current ] ) { jqXHR[ s.responseFields[ current ] ] = response; } // Apply the dataFilter if provided if ( !prev && isSuccess && s.dataFilter ) { response = s.dataFilter( response, s.dataType ); } prev = current; current = dataTypes.shift(); if ( current ) { // There's only work to do if current dataType is non-auto if ( current === "*" ) { current = prev; // Convert response if prev dataType is non-auto and differs from current } else if ( prev !== "*" && prev !== current ) { // Seek a direct converter conv = converters[ prev + " " + current ] || converters[ "* " + current ]; // If none found, seek a pair if ( !conv ) { for ( conv2 in converters ) { // If conv2 outputs current tmp = conv2.split( " " ); if ( tmp[ 1 ] === current ) { // If prev can be converted to accepted input conv = converters[ prev + " " + tmp[ 0 ] ] || converters[ "* " + tmp[ 0 ] ]; if ( conv ) { // Condense equivalence converters if ( conv === true ) { conv = converters[ conv2 ]; // Otherwise, insert the intermediate dataType } else if ( converters[ conv2 ] !== true ) { current = tmp[ 0 ]; dataTypes.unshift( tmp[ 1 ] ); } break; } } } } // Apply converter (if not an equivalence) if ( conv !== true ) { // Unless errors are allowed to bubble, catch and return them if ( conv && s.throws ) { response = conv( response ); } else { try { response = conv( response ); } catch ( e ) { return { state: "parsererror", error: conv ? e : "No conversion from " + prev + " to " + current }; } } } } } } return { state: "success", data: response }; } jQuery.extend( { // Counter for holding the number of active queries active: 0, // Last-Modified header cache for next request lastModified: {}, etag: {}, ajaxSettings: { url: location.href, type: "GET", isLocal: rlocalProtocol.test( location.protocol ), global: true, processData: true, async: true, contentType: "application/x-www-form-urlencoded; charset=UTF-8", /* timeout: 0, data: null, dataType: null, username: null, password: null, cache: null, throws: false, traditional: false, headers: {}, */ accepts: { "*": allTypes, text: "text/plain", html: "text/html", xml: "application/xml, text/xml", json: "application/json, text/javascript" }, contents: { xml: /\bxml\b/, html: /\bhtml/, json: /\bjson\b/ }, responseFields: { xml: "responseXML", text: "responseText", json: "responseJSON" }, // Data converters // Keys separate source (or catchall "*") and destination types with a single space converters: { // Convert anything to text "* text": String, // Text to html (true = no transformation) "text html": true, // Evaluate text as a json expression "text json": JSON.parse, // Parse text as xml "text xml": jQuery.parseXML }, // For options that shouldn't be deep extended: // you can add your own custom options here if // and when you create one that shouldn't be // deep extended (see ajaxExtend) flatOptions: { url: true, context: true } }, // Creates a full fledged settings object into target // with both ajaxSettings and settings fields. // If target is omitted, writes into ajaxSettings. ajaxSetup: function( target, settings ) { return settings ? // Building a settings object ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) : // Extending ajaxSettings ajaxExtend( jQuery.ajaxSettings, target ); }, ajaxPrefilter: addToPrefiltersOrTransports( prefilters ), ajaxTransport: addToPrefiltersOrTransports( transports ), // Main method ajax: function( url, options ) { // If url is an object, simulate pre-1.5 signature if ( typeof url === "object" ) { options = url; url = undefined; } // Force options to be an object options = options || {}; var transport, // URL without anti-cache param cacheURL, // Response headers responseHeadersString, responseHeaders, // timeout handle timeoutTimer, // Url cleanup var urlAnchor, // Request state (becomes false upon send and true upon completion) completed, // To know if global events are to be dispatched fireGlobals, // Loop variable i, // uncached part of the url uncached, // Create the final options object s = jQuery.ajaxSetup( {}, options ), // Callbacks context callbackContext = s.context || s, // Context for global events is callbackContext if it is a DOM node or jQuery collection globalEventContext = s.context && ( callbackContext.nodeType || callbackContext.jquery ) ? jQuery( callbackContext ) : jQuery.event, // Deferreds deferred = jQuery.Deferred(), completeDeferred = jQuery.Callbacks( "once memory" ), // Status-dependent callbacks statusCode = s.statusCode || {}, // Headers (they are sent all at once) requestHeaders = {}, requestHeadersNames = {}, // Default abort message strAbort = "canceled", // Fake xhr jqXHR = { readyState: 0, // Builds headers hashtable if needed getResponseHeader: function( key ) { var match; if ( completed ) { if ( !responseHeaders ) { responseHeaders = {}; while ( ( match = rheaders.exec( responseHeadersString ) ) ) { responseHeaders[ match[ 1 ].toLowerCase() + " " ] = ( responseHeaders[ match[ 1 ].toLowerCase() + " " ] || [] ) .concat( match[ 2 ] ); } } match = responseHeaders[ key.toLowerCase() + " " ]; } return match == null ? null : match.join( ", " ); }, // Raw string getAllResponseHeaders: function() { return completed ? responseHeadersString : null; }, // Caches the header setRequestHeader: function( name, value ) { if ( completed == null ) { name = requestHeadersNames[ name.toLowerCase() ] = requestHeadersNames[ name.toLowerCase() ] || name; requestHeaders[ name ] = value; } return this; }, // Overrides response content-type header overrideMimeType: function( type ) { if ( completed == null ) { s.mimeType = type; } return this; }, // Status-dependent callbacks statusCode: function( map ) { var code; if ( map ) { if ( completed ) { // Execute the appropriate callbacks jqXHR.always( map[ jqXHR.status ] ); } else { // Lazy-add the new callbacks in a way that preserves old ones for ( code in map ) { statusCode[ code ] = [ statusCode[ code ], map[ code ] ]; } } } return this; }, // Cancel the request abort: function( statusText ) { var finalText = statusText || strAbort; if ( transport ) { transport.abort( finalText ); } done( 0, finalText ); return this; } }; // Attach deferreds deferred.promise( jqXHR ); // Add protocol if not provided (prefilters might expect it) // Handle falsy url in the settings object (#10093: consistency with old signature) // We also use the url parameter if available s.url = ( ( url || s.url || location.href ) + "" ) .replace( rprotocol, location.protocol + "//" ); // Alias method option to type as per ticket #12004 s.type = options.method || options.type || s.method || s.type; // Extract dataTypes list s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ]; // A cross-domain request is in order when the origin doesn't match the current origin. if ( s.crossDomain == null ) { urlAnchor = document.createElement( "a" ); // Support: IE <=8 - 11, Edge 12 - 15 // IE throws exception on accessing the href property if url is malformed, // e.g. http://example.com:80x/ try { urlAnchor.href = s.url; // Support: IE <=8 - 11 only // Anchor's host property isn't correctly set when s.url is relative urlAnchor.href = urlAnchor.href; s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !== urlAnchor.protocol + "//" + urlAnchor.host; } catch ( e ) { // If there is an error parsing the URL, assume it is crossDomain, // it can be rejected by the transport if it is invalid s.crossDomain = true; } } // Convert data if not already a string if ( s.data && s.processData && typeof s.data !== "string" ) { s.data = jQuery.param( s.data, s.traditional ); } // Apply prefilters inspectPrefiltersOrTransports( prefilters, s, options, jqXHR ); // If request was aborted inside a prefilter, stop there if ( completed ) { return jqXHR; } // We can fire global events as of now if asked to // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118) fireGlobals = jQuery.event && s.global; // Watch for a new set of requests if ( fireGlobals && jQuery.active++ === 0 ) { jQuery.event.trigger( "ajaxStart" ); } // Uppercase the type s.type = s.type.toUpperCase(); // Determine if request has content s.hasContent = !rnoContent.test( s.type ); // Save the URL in case we're toying with the If-Modified-Since // and/or If-None-Match header later on // Remove hash to simplify url manipulation cacheURL = s.url.replace( rhash, "" ); // More options handling for requests with no content if ( !s.hasContent ) { // Remember the hash so we can put it back uncached = s.url.slice( cacheURL.length ); // If data is available and should be processed, append data to url if ( s.data && ( s.processData || typeof s.data === "string" ) ) { cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data; // #9682: remove data so that it's not used in an eventual retry delete s.data; } // Add or update anti-cache param if needed if ( s.cache === false ) { cacheURL = cacheURL.replace( rantiCache, "$1" ); uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce++ ) + uncached; } // Put hash and anti-cache on the URL that will be requested (gh-1732) s.url = cacheURL + uncached; // Change '%20' to '+' if this is encoded form body content (gh-2658) } else if ( s.data && s.processData && ( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) { s.data = s.data.replace( r20, "+" ); } // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. if ( s.ifModified ) { if ( jQuery.lastModified[ cacheURL ] ) { jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] ); } if ( jQuery.etag[ cacheURL ] ) { jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] ); } } // Set the correct header, if data is being sent if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) { jqXHR.setRequestHeader( "Content-Type", s.contentType ); } // Set the Accepts header for the server, depending on the dataType jqXHR.setRequestHeader( "Accept", s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ? s.accepts[ s.dataTypes[ 0 ] ] + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) : s.accepts[ "*" ] ); // Check for headers option for ( i in s.headers ) { jqXHR.setRequestHeader( i, s.headers[ i ] ); } // Allow custom headers/mimetypes and early abort if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) { // Abort if not done already and return return jqXHR.abort(); } // Aborting is no longer a cancellation strAbort = "abort"; // Install callbacks on deferreds completeDeferred.add( s.complete ); jqXHR.done( s.success ); jqXHR.fail( s.error ); // Get transport transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR ); // If no transport, we auto-abort if ( !transport ) { done( -1, "No Transport" ); } else { jqXHR.readyState = 1; // Send global event if ( fireGlobals ) { globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] ); } // If request was aborted inside ajaxSend, stop there if ( completed ) { return jqXHR; } // Timeout if ( s.async && s.timeout > 0 ) { timeoutTimer = window.setTimeout( function() { jqXHR.abort( "timeout" ); }, s.timeout ); } try { completed = false; transport.send( requestHeaders, done ); } catch ( e ) { // Rethrow post-completion exceptions if ( completed ) { throw e; } // Propagate others as results done( -1, e ); } } // Callback for when everything is done function done( status, nativeStatusText, responses, headers ) { var isSuccess, success, error, response, modified, statusText = nativeStatusText; // Ignore repeat invocations if ( completed ) { return; } completed = true; // Clear timeout if it exists if ( timeoutTimer ) { window.clearTimeout( timeoutTimer ); } // Dereference transport for early garbage collection // (no matter how long the jqXHR object will be used) transport = undefined; // Cache response headers responseHeadersString = headers || ""; // Set readyState jqXHR.readyState = status > 0 ? 4 : 0; // Determine if successful isSuccess = status >= 200 && status < 300 || status === 304; // Get response data if ( responses ) { response = ajaxHandleResponses( s, jqXHR, responses ); } // Convert no matter what (that way responseXXX fields are always set) response = ajaxConvert( s, response, jqXHR, isSuccess ); // If successful, handle type chaining if ( isSuccess ) { // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. if ( s.ifModified ) { modified = jqXHR.getResponseHeader( "Last-Modified" ); if ( modified ) { jQuery.lastModified[ cacheURL ] = modified; } modified = jqXHR.getResponseHeader( "etag" ); if ( modified ) { jQuery.etag[ cacheURL ] = modified; } } // if no content if ( status === 204 || s.type === "HEAD" ) { statusText = "nocontent"; // if not modified } else if ( status === 304 ) { statusText = "notmodified"; // If we have data, let's convert it } else { statusText = response.state; success = response.data; error = response.error; isSuccess = !error; } } else { // Extract error from statusText and normalize for non-aborts error = statusText; if ( status || !statusText ) { statusText = "error"; if ( status < 0 ) { status = 0; } } } // Set data for the fake xhr object jqXHR.status = status; jqXHR.statusText = ( nativeStatusText || statusText ) + ""; // Success/Error if ( isSuccess ) { deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] ); } else { deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] ); } // Status-dependent callbacks jqXHR.statusCode( statusCode ); statusCode = undefined; if ( fireGlobals ) { globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError", [ jqXHR, s, isSuccess ? success : error ] ); } // Complete completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] ); if ( fireGlobals ) { globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] ); // Handle the global AJAX counter if ( !( --jQuery.active ) ) { jQuery.event.trigger( "ajaxStop" ); } } } return jqXHR; }, getJSON: function( url, data, callback ) { return jQuery.get( url, data, callback, "json" ); }, getScript: function( url, callback ) { return jQuery.get( url, undefined, callback, "script" ); } } ); jQuery.each( [ "get", "post" ], function( i, method ) { jQuery[ method ] = function( url, data, callback, type ) { // Shift arguments if data argument was omitted if ( isFunction( data ) ) { type = type || callback; callback = data; data = undefined; } // The url can be an options object (which then must have .url) return jQuery.ajax( jQuery.extend( { url: url, type: method, dataType: type, data: data, success: callback }, jQuery.isPlainObject( url ) && url ) ); }; } ); jQuery._evalUrl = function( url, options ) { return jQuery.ajax( { url: url, // Make this explicit, since user can override this through ajaxSetup (#11264) type: "GET", dataType: "script", cache: true, async: false, global: false, // Only evaluate the response if it is successful (gh-4126) // dataFilter is not invoked for failure responses, so using it instead // of the default converter is kludgy but it works. converters: { "text script": function() {} }, dataFilter: function( response ) { jQuery.globalEval( response, options ); } } ); }; jQuery.fn.extend( { wrapAll: function( html ) { var wrap; if ( this[ 0 ] ) { if ( isFunction( html ) ) { html = html.call( this[ 0 ] ); } // The elements to wrap the target around wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true ); if ( this[ 0 ].parentNode ) { wrap.insertBefore( this[ 0 ] ); } wrap.map( function() { var elem = this; while ( elem.firstElementChild ) { elem = elem.firstElementChild; } return elem; } ).append( this ); } return this; }, wrapInner: function( html ) { if ( isFunction( html ) ) { return this.each( function( i ) { jQuery( this ).wrapInner( html.call( this, i ) ); } ); } return this.each( function() { var self = jQuery( this ), contents = self.contents(); if ( contents.length ) { contents.wrapAll( html ); } else { self.append( html ); } } ); }, wrap: function( html ) { var htmlIsFunction = isFunction( html ); return this.each( function( i ) { jQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html ); } ); }, unwrap: function( selector ) { this.parent( selector ).not( "body" ).each( function() { jQuery( this ).replaceWith( this.childNodes ); } ); return this; } } ); jQuery.expr.pseudos.hidden = function( elem ) { return !jQuery.expr.pseudos.visible( elem ); }; jQuery.expr.pseudos.visible = function( elem ) { return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length ); }; jQuery.ajaxSettings.xhr = function() { try { return new window.XMLHttpRequest(); } catch ( e ) {} }; var xhrSuccessStatus = { // File protocol always yields status code 0, assume 200 0: 200, // Support: IE <=9 only // #1450: sometimes IE returns 1223 when it should be 204 1223: 204 }, xhrSupported = jQuery.ajaxSettings.xhr(); support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported ); support.ajax = xhrSupported = !!xhrSupported; jQuery.ajaxTransport( function( options ) { var callback, errorCallback; // Cross domain only allowed if supported through XMLHttpRequest if ( support.cors || xhrSupported && !options.crossDomain ) { return { send: function( headers, complete ) { var i, xhr = options.xhr(); xhr.open( options.type, options.url, options.async, options.username, options.password ); // Apply custom fields if provided if ( options.xhrFields ) { for ( i in options.xhrFields ) { xhr[ i ] = options.xhrFields[ i ]; } } // Override mime type if needed if ( options.mimeType && xhr.overrideMimeType ) { xhr.overrideMimeType( options.mimeType ); } // X-Requested-With header // For cross-domain requests, seeing as conditions for a preflight are // akin to a jigsaw puzzle, we simply never set it to be sure. // (it can always be set on a per-request basis or even using ajaxSetup) // For same-domain requests, won't change header if already provided. if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) { headers[ "X-Requested-With" ] = "XMLHttpRequest"; } // Set headers for ( i in headers ) { xhr.setRequestHeader( i, headers[ i ] ); } // Callback callback = function( type ) { return function() { if ( callback ) { callback = errorCallback = xhr.onload = xhr.onerror = xhr.onabort = xhr.ontimeout = xhr.onreadystatechange = null; if ( type === "abort" ) { xhr.abort(); } else if ( type === "error" ) { // Support: IE <=9 only // On a manual native abort, IE9 throws // errors on any property access that is not readyState if ( typeof xhr.status !== "number" ) { complete( 0, "error" ); } else { complete( // File: protocol always yields status 0; see #8605, #14207 xhr.status, xhr.statusText ); } } else { complete( xhrSuccessStatus[ xhr.status ] || xhr.status, xhr.statusText, // Support: IE <=9 only // IE9 has no XHR2 but throws on binary (trac-11426) // For XHR2 non-text, let the caller handle it (gh-2498) ( xhr.responseType || "text" ) !== "text" || typeof xhr.responseText !== "string" ? { binary: xhr.response } : { text: xhr.responseText }, xhr.getAllResponseHeaders() ); } } }; }; // Listen to events xhr.onload = callback(); errorCallback = xhr.onerror = xhr.ontimeout = callback( "error" ); // Support: IE 9 only // Use onreadystatechange to replace onabort // to handle uncaught aborts if ( xhr.onabort !== undefined ) { xhr.onabort = errorCallback; } else { xhr.onreadystatechange = function() { // Check readyState before timeout as it changes if ( xhr.readyState === 4 ) { // Allow onerror to be called first, // but that will not handle a native abort // Also, save errorCallback to a variable // as xhr.onerror cannot be accessed window.setTimeout( function() { if ( callback ) { errorCallback(); } } ); } }; } // Create the abort callback callback = callback( "abort" ); try { // Do send the request (this may raise an exception) xhr.send( options.hasContent && options.data || null ); } catch ( e ) { // #14683: Only rethrow if this hasn't been notified as an error yet if ( callback ) { throw e; } } }, abort: function() { if ( callback ) { callback(); } } }; } } ); // Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432) jQuery.ajaxPrefilter( function( s ) { if ( s.crossDomain ) { s.contents.script = false; } } ); // Install script dataType jQuery.ajaxSetup( { accepts: { script: "text/javascript, application/javascript, " + "application/ecmascript, application/x-ecmascript" }, contents: { script: /\b(?:java|ecma)script\b/ }, converters: { "text script": function( text ) { jQuery.globalEval( text ); return text; } } } ); // Handle cache's special case and crossDomain jQuery.ajaxPrefilter( "script", function( s ) { if ( s.cache === undefined ) { s.cache = false; } if ( s.crossDomain ) { s.type = "GET"; } } ); // Bind script tag hack transport jQuery.ajaxTransport( "script", function( s ) { // This transport only deals with cross domain or forced-by-attrs requests if ( s.crossDomain || s.scriptAttrs ) { var script, callback; return { send: function( _, complete ) { script = jQuery( "

    Berkeley DB 4.7, 4.8, 5.1, 5.3, 6.1 and 6.2 Python Extension Package

    Introduction

    This is a simple bit of documentation for the bsddb3.db Python extension module which wraps the Berkeley DB C library. The extension module is located in a Python package along with a few pure python modules.

    It is expected that this module will be used in the following general ways by different programmers in different situations. The goals of this module are to allow all of these methods without making things too complex for the simple cases, and without leaving out funtionality needed by the complex cases.

    1. Backwards compatibility: It is desirable for this package to be a near drop-in replacement for the bsddb module shipped with Python which is designed to wrap either DB 1.85, or the 1.85 compatibility interface. This means that there will need to be equivalent object creation functions available, (btopen(), hashopen(), and rnopen()) and the objects returned will need to have the same or at least similar methods available, (specifically, first(), last(), next(), and prev() will need to be available without the user needing to explicitly use a cursor.) All of these have been implemented in Python code in the bsddb3.__init__.py module.

    2. Simple persistent dictionary: One small step beyond the above. The programmer may be aware of and use the new DB object type directly, but only needs it from a single process and thread. The programmer should not have to be bothered with using a DBEnv, and the DB object should behave as much like a dictionary as possible.

    3. Concurrent access dictionaries: This refers to the ability to simultaneously have one writer and multiple readers of a DB (either in multiple threads or processes) and is implemented simply by creating a DBEnv with certain flags. No extra work is required to allow this access mode in bsddb3.

    4. Advanced transactional data store: This mode of use is where the full capabilities of the Berkeley DB library are called into action. The programmer will probably not use the dictionary access methods as much as the regular methods of the DB object, so he can pass transaction objects to the methods. Again, most of this advanced functionality is activated simply by opening a DBEnv with the proper flags, and also by using transactions and being aware of and reacting to deadlock exceptions, etc.

    Types Provided

    The bsddb3.db extension module provides the following object types:

    • DB: The basic database object, capable of Hash, BTree, Recno, and Queue access methods.

    • DBEnv: Provides a Database Environment for more advanced database use. Apps using transactions, logging, concurrent access, etc. will need to have an environment object.

    • DBCursor: A pointer-like object used to traverse a database.

    • DBTxn: A database transaction. Allows for multi-file commit, abort and checkpoint of database modifications.

    • DBLock: An opaque handle for a lock. See DBEnv.lock_get() and DBEnv.lock_put(). Locks are not necessarily associated with anything in the database, but can be used for any syncronization task across all threads and processes that have the DBEnv open.

    • DBSequence: Sequences provide an arbitrary number of persistent objects that return an increasing or decreasing sequence of integers. Opening a sequence handle associates it with a record in a database.

    • DBSite: Site object for Replication Manager.

    Top level functions

    version()

    Returns a tuple with major, minor and patch level. More info…

    full_version()

    Returns a tuple with the full version string, family, release, major, minor and patch level. More info…

    Exceptions Provided

    The Berkeley DB C API uses function return codes to signal various errors. The bsddb3.db module checks for these error codes and turns them into Python exceptions, allowing you to use familiar try:… except:… constructs and not have to bother with checking every method’s return value.

    Each of the error codes is turned into an exception specific to that error code, as outlined in the table below. If you are using the C API documentation then it is very easy to map the error return codes specified there to the name of the Python exception that will be raised. Simply refer to the table below.

    Each exception derives from the DBError exception class so if you just want to catch generic errors you can use DBError to do it. Since DBNotFoundError is raised when a given key is not found in the database, DBNotFoundError also derives from the standard KeyError exception to help make a DB look and act like a dictionary. We do the same trick with DBKeyEmptyError.

    When any of these exceptions is raised, the associated value is a tuple containing an integer representing the error code and a string for the error message itself.

    DBError

    Base class, all others derive from this

    DBCursorClosedError

    When trying to use a closed cursor

    DBForeignConflictError

    DB_FOREIGN_CONFLICT

    DBKeyEmptyError

    DB_KEYEMPTY (also derives from KeyError)

    DBKeyExistError

    DB_KEYEXIST

    DBLockDeadlockError

    DB_LOCK_DEADLOCK

    DBLockNotGrantedError

    DB_LOCK_NOTGRANTED

    DBNotFoundError

    DB_NOTFOUND (also derives from KeyError)

    DBOldVersionError

    DB_OLD_VERSION

    DBPageNotFoundError

    DB_PAGE_NOTFOUND

    DBRepHandleDeadError

    DB_REP_HANDLE_DEAD

    DBRepLeaseExpiredError

    DB_REP_LEASE_EXPIRED

    DBRepLockoutError

    DB_REP_LOCKOUT

    DBRepUnavailError

    DB_REP_UNAVAIL

    DBRunRecoveryError

    DB_RUNRECOVERY

    DBSecondaryBadError

    DB_SECONDARY_BAD

    DBVerifyBadError

    DB_VERIFY_BAD

    DBNoServerError

    DB_NOSERVER

    DBNoServerHomeError

    DB_NOSERVER_HOME

    DBNoServerIDError

    DB_NOSERVER_ID

    DBInvalidArgError

    EINVAL

    DBAccessError

    EACCES

    DBNoSpaceError

    ENOSPC

    DBNoMemoryError

    DB_BUFFER_SMALL

    DBAgainError

    EAGAIN

    DBBusyError

    EBUSY

    DBFileExistsError

    EEXIST

    DBNoSuchFileError

    ENOENT

    DBPermissionsError

    EPERM

    Other Package Modules

    • dbshelve.py: This is an implementation of the standard Python shelve concept for storing objects that uses bsddb3 specifically, and also exposes some of the more advanced methods and capabilities of the underlying DB.

    • dbtables.py: This is a module by Gregory Smith that implements a simplistic table structure on top of a DB.

    • dbutils.py: A catch-all for python code that is generally useful when working with DB’s

    • dbobj.py: Contains subclassable versions of DB and DBEnv.

    • dbrecio.py: Contains the DBRecIO class that can be used to do partial reads and writes from a DB record using a file-like interface. Contributed by Itamar Shtull-Trauring.

    Testing

    A full unit test suite is being developed to exercise the various object types, their methods and the various usage modes described in the introduction. PyUnit is used and the tests are structured such that they can be run unattended and automated. There are currently 482 test cases! (March 2010)

    Reference

    See the C language API online documentation on Oracle’s website for more details of the functionality of each of these methods. The names of all the Python methods should be the same or similar to the names in the C API.

    Berkeley DB is very powerful and versatile, but it is complex to use correctly. Oracle documentation is very complete. Please, review it.

    NOTE: All the methods shown below having more than one keyword argument are actually implemented using keyword argument parsing, so you can use keywords to provide optional parameters as desired. Those that have only a single optional argument are implemented without keyword parsing to help keep the implementation simple. If this is too confusing let me know and I’ll think about using keywords for everything.

    ©2008-2020 Jesus Cea Avion. | Powered by Sphinx 2.3.1 & Alabaster 0.7.12
    bsddb3-6.2.7/docs/html/dblock.html0000664000175000017500000001027613617125467016561 0ustar jceajcea00000000000000 DBLock — PyBSDDB 6.2.7 documentation

    DBLock

    Read Oracle documentation for better understanding.

    The DBLock objects have no methods or attributes. They are just opaque handles to the lock in question.

    They are managed via DBEnv methods.

    ©2008-2020 Jesus Cea Avion. | Powered by Sphinx 2.3.1 & Alabaster 0.7.12
    bsddb3-6.2.7/docs/html/history.html0000664000175000017500000001126113617125467017017 0ustar jceajcea00000000000000 History — PyBSDDB 6.2.7 documentation

    History

    This module was started by Andrew Kuchling (amk) to remove the dependency on SWIG in a package by Gregory P. Smith who based his work on a similar package by Robin Dunn which wrapped Berkeley DB 2.7.x.

    Development then returned full circle back to Robin Dunn working in behalf of Digital Creations to complete the SWIG-less wrapping of the DB 3.x API and to build a solid unit test suite. Having completed that, Robin was now busy with another project (wxPython) and Greg returned as maintainer.

    Jesus Cea Avion is the maintainer of this code since February 2008, and ported it to Python 3.x.

    ©2008-2020 Jesus Cea Avion. | Powered by Sphinx 2.3.1 & Alabaster 0.7.12
    bsddb3-6.2.7/docs/html/donate.html0000664000175000017500000001756613617125467016606 0ustar jceajcea00000000000000 DONATE! — PyBSDDB 6.2.7 documentation
    ©2008-2020 Jesus Cea Avion. | Powered by Sphinx 2.3.1 & Alabaster 0.7.12
    bsddb3-6.2.7/docs/html/dbenv.html0000664000175000017500000032675613617125467016436 0ustar jceajcea00000000000000 DBEnv — PyBSDDB 6.2.7 documentation

    DBEnv

    Read Oracle documentation for better understanding.

    More info…

    DBEnv Attributes

    DBEnv(flags=0)

    database home directory (read-only)

    DBEnv Methods

    DBEnv(flags=0)

    Constructor. More info…

    set_rpc_server(host, cl_timeout=0, sv_timeout=0)

    Establishes a connection for this dbenv to a RPC server. This function is not available if linked to Berkeley DB 4.8 or up. More info…

    close(flags=0)

    Close the database environment, freeing resources. More info…

    open(homedir, flags=0, mode=0660)

    Prepare the database environment for use. More info…

    log_cursor()

    Returns a created log cursor. More info…

    memp_stat(flags=0)

    Returns the memory pool (that is, the buffer cache) subsystem statistics.

    The returning value is a tuple. The first element is a dictionary with the general stats. The second element is another dictionary, keyed by filename, and the values are the stats for each file.

    The first dictionary contains these data:

    gbytes

    Gigabytes of cache (total cache size is st_gbytes + st_bytes).

    bytes

    Bytes of cache (total cache size is st_gbytes + st_bytes).

    ncache

    Number of caches.

    max_ncache

    Maximum number of caches, as configured with the DB_ENV->set_cache_max() method.

    regsize

    Individual cache size, in bytes.

    mmapsize

    Maximum memory-mapped file size.

    maxopenfd

    Maximum open file descriptors.

    maxwrite

    Maximum sequential buffer writes.

    maxwrite_sleep

    Microseconds to pause after writing maximum sequential buffers.

    map

    Requested pages mapped into the process’ address space (there is no available information about whether or not this request caused disk I/O, although examining the application page fault rate may be helpful).

    cache_hit

    Requested pages found in the cache.

    cache_miss

    Requested pages not found in the cache.

    page_create

    Pages created in the cache.

    page_in

    Pages read into the cache.

    page_out

    Pages written from the cache to the backing file.

    ro_evict

    Clean pages forced from the cache.

    rw_evict

    Dirty pages forced from the cache.

    page_trickle

    Dirty pages written using the DB_ENV->memp_trickle() method.

    pages

    Pages in the cache.

    page_clean

    Clean pages currently in the cache.

    page_dirty

    Dirty pages currently in the cache.

    hash_buckets

    Number of hash buckets in buffer hash table.

    hash_searches

    Total number of buffer hash table lookups.

    hash_longest

    Longest chain ever encountered in buffer hash table lookups.

    hash_examined

    Total number of hash elements traversed during hash table lookups.

    hash_nowait

    Number of times that a thread of control was able to obtain a hash bucket lock without waiting.

    hash_wait

    Number of times that a thread of control was forced to wait before obtaining a hash bucket lock.

    hash_max_nowait

    The number of times a thread of control was able to obtain the hash bucket lock without waiting on the bucket which had the maximum number of times that a thread of control needed to wait.

    hash_max_wait

    Maximum number of times any hash bucket lock was waited for by a thread of control.

    region_wait

    Number of times that a thread of control was forced to wait before obtaining a cache region mutex.

    region_nowait

    Number of times that a thread of control was able to obtain a cache region mutex without waiting.

    mvcc_frozen

    Number of buffers frozen.

    mvcc_thawed

    Number of buffers thawed.

    mvcc_freed

    Number of frozen buffers freed.

    alloc

    Number of page allocations.

    alloc_buckets

    Number of hash buckets checked during allocation.

    alloc_max_buckets

    Maximum number of hash buckets checked during an allocation.

    alloc_pages

    Number of pages checked during allocation.

    alloc_max_pages

    Maximum number of pages checked during an allocation.

    io_wait

    Number of operations blocked waiting for I/O to complete.

    sync_interrupted

    Number of mpool sync operations interrupted.

    The second dictionary contains these data:

    pagesize

    Page size in bytes.

    cache_hit

    Requested pages found in the cache.

    cache_miss

    Requested pages not found in the cache.

    map

    Requested pages mapped into the process’ address space.

    page_create

    Pages created in the cache.

    page_in

    Pages read into the cache.

    page_out

    Pages written from the cache to the backing file.

    More info…

    memp_stat_print(flags=0)

    Displays cache subsystem statistical information. More info…

    memp_sync(lsn=None)

    Flushes modified pages in the cache to their backing files. If provided, lsn is a tuple: (file, offset). More info…

    memp_trickle(percent)

    Ensures that a specified percent of the pages in the cache are clean, by writing dirty pages to their backing files. More info…

    remove(homedir, flags=0)

    Remove a database environment. More info…

    dbremove(file, database=None, txn=None, flags=0)

    Removes the database specified by the file and database parameters. If no database is specified, the underlying file represented by file is removed, incidentally removing all of the databases it contained. More info…

    dbrename(file, database=None, newname, txn=None, flags=0)

    Renames the database specified by the file and database parameters to newname. If no database is specified, the underlying file represented by file is renamed, incidentally renaming all of the databases it contained. More info…

    fileid_reset(file, flags=0)

    All databases contain an ID string used to identify the database in the database environment cache. If a physical database file is copied, and used in the same environment as another file with the same ID strings, corruption can occur. The DB_ENV->fileid_reset method creates new ID strings for all of the databases in the physical file. More info…

    get_thread_count()

    Returns the thread count as set by the DB_ENV->set_thread_count() method. More info…

    set_thread_count(count)

    Declare an approximate number of threads in the database environment. The DB_ENV->set_thread_count() method must be called prior to opening the database environment if the DB_ENV->failchk() method will be used. The DB_ENV->set_thread_count() method does not set the maximum number of threads but is used to determine memory sizing and the thread control block reclamation policy. More info…

    set_encrypt(passwd, flags=0)

    Set the password used by the Berkeley DB library to perform encryption and decryption. More info…

    get_encrypt_flags()

    Returns the encryption flags. More info…

    get_intermediate_dir_mode()

    Returns the intermediate directory permissions.

    Intermediate directories are directories needed for recovery. Normally, Berkeley DB does not create these directories and will do so only if the DB_ENV->set_intermediate_dir_mode() method is called.

    More info…

    set_intermediate_dir_mode(mode)

    By default, Berkeley DB does not create intermediate directories needed for recovery, that is, if the file /a/b/c/mydatabase is being recovered, and the directory path b/c does not exist, recovery will fail. This default behavior is because Berkeley DB does not know what permissions are appropriate for intermediate directory creation, and creating the directory might result in a security problem.

    The DB_ENV->set_intermediate_dir_mode() method causes Berkeley DB to create any intermediate directories needed during recovery, using the specified permissions.

    More info…

    get_timeout(flags)

    Returns a timeout value, in microseconds. More info…

    set_timeout(timeout, flags)

    Sets timeout values for locks or transactions in the database environment. More info…

    get_mp_max_openfd()

    Returns the maximum number of file descriptors the library will open concurrently when flushing dirty pages from the cache. More info…

    set_mp_max_openfd(max_open_fd)

    Limits the number of file descriptors the library will open concurrently when flushing dirty pages from the cache. More info…

    get_mp_max_write()

    Returns a tuple with the current maximum number of sequential write operations and microseconds to pause that the library can schedule when flushing dirty pages from the cache. More info…

    set_mp_max_write(maxwrite, maxwrite_sleep)

    Limits the number of sequential write operations scheduled by the library when flushing dirty pages from the cache. More info…

    set_shm_key(key)

    Specify a base segment ID for Berkeley DB environment shared memory regions created in system memory on VxWorks or systems supporting X/Open-style shared memory interfaces; for example, UNIX systems supporting shmget(2) and related System V IPC interfaces. More info…

    get_shm_key()

    Returns the base segment ID. More info…

    set_cache_max(gbytes, bytes)

    Sets the maximum cache size, in bytes. The specified size is rounded to the nearest multiple of the cache region size, which is the initial cache size divided by the number of regions specified to the DB_ENV->set_cachesize() method. If no value is specified, it defaults to the initial cache size. More info…

    get_cache_max()

    Returns the maximum size of the cache as set using the DB_ENV->set_cache_max() method. More info…

    set_cachesize(gbytes, bytes, ncache=0)

    Set the size of the shared memory buffer pool. More info…

    get_cachesize()

    Returns a tuple with the current size and composition of the cache. More info…

    set_data_dir(dir)

    Set the environment data directory. You can call this function multiple times, adding new directories. More info…

    get_data_dirs()

    Return a tuple with the directories. More info…

    get_flags()

    Returns the configuration flags set for a DB_ENV handle. More info…

    set_flags(flags, onoff)

    Set additional flags for the DBEnv. The onoff parameter specifes if the flag is set or cleared. More info…

    set_tmp_dir(dir)

    Set the directory to be used for temporary files. More info…

    get_tmp_dir()

    Returns the database environment temporary file directory. More info…

    set_get_returns_none(flag)

    By default when DB.get or DBCursor.get, get_both, first, last, next or prev encounter a DB_NOTFOUND error they return None instead of raising DBNotFoundError. This behaviour emulates Python dictionaries and is convenient for looping.

    You can use this method to toggle that behaviour for all of the aformentioned methods or extend it to also apply to the DBCursor.set, set_both, set_range, and set_recno methods. Supported values of flag:

    • 0 all DB and DBCursor get and set methods will raise a DBNotFoundError rather than returning None.

    • 1 Default in module version <4.2.4 The DB.get and DBCursor.get, get_both, first, last, next and prev methods return None.

    • 2 Default in module version >=4.2.4 Extends the behaviour of 1 to the DBCursor set, set_both, set_range and set_recno methods.

    The default of returning None makes it easy to do things like this without having to catch DBNotFoundError (KeyError):

    data = mydb.get(key)
if data:
    doSomething(data)

    or this:

    rec = cursor.first()
while rec:
    print rec
    rec = cursor.next()

    Making the cursor set methods return None is useful in order to do this:

    rec = mydb.set()
while rec:
    key, val = rec
    doSomething(key, val)
    rec = mydb.next()

    The downside to this it that it is inconsistent with the rest of the package and noticeably diverges from the Oracle Berkeley DB API. If you prefer to have the get and set methods raise an exception when a key is not found, use this method to tell them to do so.

    Calling this method on a DBEnv object will set the default for all DB’s later created within that environment. Calling it on a DB object sets the behaviour for that DB only.

    The previous setting is returned.

    set_private(object)

    Link an object to the DBEnv object. This allows to pass around an arbitrary object. For instance, for callback context.

    get_private()

    Give the object linked to the DBEnv.

    get_open_flags()

    Returns the current open method flags. That is, this method returns the flags that were specified when DB_ENV->open() was called. More info…

    get_lg_filemode()

    Returns the log file mode. More info…

    set_lg_filemode(filemode)

    Set the absolute file mode for created log files. More info…

    get_lg_bsize()

    Returns the size of the log buffer, in bytes. More info…

    set_lg_bsize(size)

    Set the size of the in-memory log buffer, in bytes. More info…

    get_lg_dir()

    Returns the log directory, which is the location for logging files. More info…

    set_lg_dir(dir)

    The path of a directory to be used as the location of logging files. Log files created by the Log Manager subsystem will be created in this directory. More info…

    set_lg_max(size)

    Set the maximum size of a single file in the log, in bytes. More info…

    get_lg_max(size)

    Returns the maximum log file size. More info…

    get_lg_regionmax()

    Returns the size of the underlying logging subsystem region. More info…

    set_lg_regionmax(size)

    Set the maximum size of a single region in the log, in bytes. More info…

    get_lk_partitions()

    Returns the number of lock table partitions used in the Berkeley DB environment. More info…

    set_lk_partitions(partitions)

    Set the number of lock table partitions in the Berkeley DB environment. More info…

    get_lk_detect()

    Returns the deadlock detector configuration. More info…

    set_lk_detect(mode)

    Set the automatic deadlock detection mode. More info…

    set_lk_max(max)

    Set the maximum number of locks. (This method is deprecated.) More info…

    get_lk_max_locks()

    Returns the maximum number of potential locks. More info…

    set_lk_max_locks(max)

    Set the maximum number of locks supported by the Berkeley DB lock subsystem. More info…

    get_lk_max_lockers()

    Returns the maximum number of potential lockers. More info…

    set_lk_max_lockers(max)

    Set the maximum number of simultaneous locking entities supported by the Berkeley DB lock subsystem. More info…

    get_lk_max_objects()

    Returns the maximum number of locked objects. More info…

    set_lk_max_objects(max)

    Set the maximum number of simultaneously locked objects supported by the Berkeley DB lock subsystem. More info…

    get_mp_mmapsize()

    Returns the the maximum file size, in bytes, for a file to be mapped into the process address space. More info…

    set_mp_mmapsize(size)

    Files that are opened read-only in the memory pool (and that satisfy a few other criteria) are, by default, mapped into the process address space instead of being copied into the local cache. This can result in better-than-usual performance, as available virtual memory is normally much larger than the local cache, and page faults are faster than page copying on many systems. However, in the presence of limited virtual memory it can cause resource starvation, and in the presence of large databases, it can result in immense process sizes.

    This method sets the maximum file size, in bytes, for a file to be mapped into the process address space. If no value is specified, it defaults to 10MB. More info…

    stat_print(flags=0)

    Displays the default subsystem statistical information. More info…

    log_file(lsn)

    Maps lsn to filenames, returning the name of the file containing the named record. More info…

    log_printf(string, txn=None)

    Appends an informational message to the Berkeley DB database environment log files. More info…

    log_archive(flags=0)

    Returns a list of log or database file names. By default, log_archive returns the names of all of the log files that are no longer in use (e.g., no longer involved in active transactions), and that may safely be archived for catastrophic recovery and then removed from the system. More info…

    log_flush()

    Force log records to disk. Useful if the environment, database or transactions are used as ACI, instead of ACID. For example, if the environment is opened as DB_TXN_NOSYNC. More info…

    log_get_config(which)

    Returns whether the specified which parameter is currently set or not. You can manage this value using the DB_ENV->log_set_config() method. More info…

    log_set_config(flags, onoff)

    Configures the Berkeley DB logging subsystem. More info…

    lock_detect(atype, flags=0)

    Run one iteration of the deadlock detector, returns the number of transactions aborted. More info…

    lock_get(locker, obj, lock_mode, flags=0)

    Acquires a lock and returns a handle to it as a DBLock object. The locker parameter is an integer representing the entity doing the locking, and obj is an object representing the item to be locked. More info…

    lock_id()

    Acquires a locker id, guaranteed to be unique across all threads and processes that have the DBEnv open. More info…

    lock_id_free(id)

    Frees a locker ID allocated by the “dbenv.lock_id()” method. More info…

    lock_put(lock)

    Release the lock. More info…

    lock_stat(flags=0)

    Returns a dictionary of locking subsystem statistics with the following keys:

    id

    Last allocated lock ID.

    cur_maxid

    The current maximum unused locker ID.

    nmodes

    Number of lock modes.

    maxlocks

    Maximum number of locks possible.

    maxlockers

    Maximum number of lockers possible.

    maxobjects

    Maximum number of objects possible.

    nlocks

    Number of current locks.

    maxnlocks

    Maximum number of locks at once.

    nlockers

    Number of current lockers.

    nobjects

    Number of current lock objects.

    maxnobjects

    Maximum number of lock objects at once.

    maxnlockers

    Maximum number of lockers at once.

    nrequests

    Total number of locks requested.

    nreleases

    Total number of locks released.

    nupgrade

    Total number of locks upgraded.

    ndowngrade

    Total number of locks downgraded.

    lock_wait

    The number of lock requests not immediately available due to conflicts, for which the thread of control waited.

    lock_nowait

    The number of lock requests not immediately available due to conflicts, for which the thread of control did not wait.

    ndeadlocks

    Number of deadlocks.

    locktimeout

    Lock timeout value.

    nlocktimeouts

    The number of lock requests that have timed out.

    txntimeout

    Transaction timeout value.

    ntxntimeouts

    The number of transactions that have timed out. This value is also a component of ndeadlocks, the total number of deadlocks detected.

    objs_wait

    The number of requests to allocate or deallocate an object for which the thread of control waited.

    objs_nowait

    The number of requests to allocate or deallocate an object for which the thread of control did not wait.

    lockers_wait

    The number of requests to allocate or deallocate a locker for which the thread of control waited.

    lockers_nowait

    The number of requests to allocate or deallocate a locker for which the thread of control did not wait.

    locks_wait

    The number of requests to allocate or deallocate a lock structure for which the thread of control waited.

    locks_nowait

    The number of requests to allocate or deallocate a lock structure for which the thread of control did not wait.

    hash_len

    Maximum length of a lock hash bucket.

    regsize

    Size of the region.

    region_wait

    Number of times a thread of control was forced to wait before obtaining the region lock.

    region_nowait

    Number of times a thread of control was able to obtain the region lock without waiting.

    More info…

    lock_stat_print(flags=0)

    Displays the locking subsystem statistical information. More info…

    get_tx_max()

    Returns the number of active transactions. More info…

    set_tx_max(max)

    Set the maximum number of active transactions. More info…

    get_tx_timestamp()

    Returns the recovery timestamp. More info…

    set_tx_timestamp(timestamp)

    Recover to the time specified by timestamp rather than to the most current possible date. More info…

    txn_begin(parent=None, flags=0)

    Creates and begins a new transaction. A DBTxn object is returned. More info…

    txn_checkpoint(kbyte=0, min=0, flag=0)

    Flushes the underlying memory pool, writes a checkpoint record to the log and then flushes the log. More info…

    txn_stat(flags=0)

    Return a dictionary of transaction statistics with the following keys:

    last_ckp

    The LSN of the last checkpoint.

    time_ckp

    Time the last completed checkpoint finished (as the number of seconds since the Epoch, returned by the IEEE/ANSI Std 1003.1 POSIX time interface).

    last_txnid

    Last transaction ID allocated.

    maxtxns

    Max number of active transactions possible.

    nactive

    Number of transactions currently active.

    maxnactive

    Max number of active transactions at once.

    nsnapshot

    The number of transactions on the snapshot list. These are transactions which modified a database opened with DB_MULTIVERSION, and which have committed or aborted, but the copies of pages they created are still in the cache.

    maxnsnapshot

    The maximum number of transactions on the snapshot list at any one time.

    nbegins

    Number of transactions that have begun.

    naborts

    Number of transactions that have aborted.

    ncommits

    Number of transactions that have committed.

    nrestores

    Number of transactions that have been restored.

    regsize

    Size of the region.

    region_wait

    Number of times that a thread of control was forced to wait before obtaining the region lock.

    region_nowait

    Number of times that a thread of control was able to obtain the region lock without waiting.

    More info…

    txn_stat_print(flags=0)

    Displays the transaction subsystem statistical information. More info…

    lsn_reset(file=None, flags=0)

    This method allows database files to be moved from one transactional database environment to another. More info…

    log_stat(flags=0)

    Returns a dictionary of logging subsystem statistics with the following keys:

    magic

    The magic number that identifies a file as a log file.

    version

    The version of the log file type.

    mode

    The mode of any created log files.

    lg_bsize

    The in-memory log record cache size.

    lg_size

    The log file size.

    record

    The number of records written to this log.

    w_mbytes

    The number of megabytes written to this log.

    w_bytes

    The number of bytes over and above w_mbytes written to this log.

    wc_mbytes

    The number of megabytes written to this log since the last checkpoint.

    wc_bytes

    The number of bytes over and above wc_mbytes written to this log since the last checkpoint.

    wcount

    The number of times the log has been written to disk.

    wcount_fill

    The number of times the log has been written to disk because the in-memory log record cache filled up.

    rcount

    The number of times the log has been read from disk.

    scount

    The number of times the log has been flushed to disk.

    cur_file

    The current log file number.

    cur_offset

    The byte offset in the current log file.

    disk_file

    The log file number of the last record known to be on disk.

    disk_offset

    The byte offset of the last record known to be on disk.

    maxcommitperflush

    The maximum number of commits contained in a single log flush.

    mincommitperflush

    The minimum number of commits contained in a single log flush that contained a commit.

    regsize

    The size of the log region, in bytes.

    region_wait

    The number of times that a thread of control was forced to wait before obtaining the log region mutex.

    region_nowait

    The number of times that a thread of control was able to obtain the log region mutex without waiting.

    More info…

    log_stat_print(flags=0)

    Displays the logging subsystem statistical information. More info…

    txn_recover()

    Returns a list of tuples (GID, TXN) of transactions prepared but still unresolved. This is used while doing environment recovery in an application using distributed transactions.

    This method must be called only from a single thread at a time. It should be called after DBEnv recovery. More info…

    set_verbose(which, onoff)

    Turns specific additional informational and debugging messages in the Berkeley DB message output on and off. To see the additional messages, verbose messages must also be configured for the application. More info…

    get_verbose(which)

    Returns whether the specified which parameter is currently set or not. More info…

    set_event_notify(eventFunc)

    Configures a callback function which is called to notify the process of specific Berkeley DB events. More info…

    mutex_stat(flags=0)

    Returns a dictionary of mutex subsystem statistics with the following keys:

    mutex_align

    The mutex alignment, in bytes.

    mutex_tas_spins

    The number of times test-and-set mutexes will spin without blocking.

    mutex_cnt

    The total number of mutexes configured.

    mutex_free

    The number of mutexes currently available.

    mutex_inuse

    The number of mutexes currently in use.

    mutex_inuse_max

    The maximum number of mutexes ever in use.

    regsize

    The size of the mutex region, in bytes.

    region_wait

    The number of times that a thread of control was forced to wait before obtaining the mutex region mutex.

    region_nowait

    The number of times that a thread of control was able to obtain the mutex region mutex without waiting.

    More info…

    mutex_stat_print(flags=0)

    Displays the mutex subsystem statistical information. More info…

    mutex_set_max(value)

    Configure the total number of mutexes to allocate. More info…

    mutex_get_max()

    Returns the total number of mutexes allocated. More info…

    mutex_set_increment(value)

    Configure the number of additional mutexes to allocate. More info…

    mutex_get_increment()

    Returns the number of additional mutexes to allocate. More info…

    mutex_set_align(align)

    Set the mutex alignment, in bytes. More info…

    mutex_get_align()

    Returns the mutex alignment, in bytes. More info…

    mutex_set_tas_spins(tas_spins)

    Specify that test-and-set mutexes should spin tas_spins times without blocking. Check the default values in the Oracle webpage. More info…

    mutex_get_tas_spins()

    Returns the test-and-set spin count. More info…

    DBEnv Replication Manager Methods

    This module automates many of the tasks needed to provide replication abilities in a Berkeley DB system. The module is fairly limited, but enough in many cases. Users more demanding must use the full Base Replication API.

    This module requires pthread support (in Unix), so you must compile Berkeley DB with it if you want to be able to use the Replication Manager.

    repmgr_start(nthreads, flags)

    Starts the replication manager. More info…

    repmgr_site(host, port)

    Returns a DB_SITE handle that defines a site’s host/port network address. You use the DB_SITE handle to configure and manage replication sites. More info…

    repmgr_site_by_eid(eid)

    Returns a DB_SITE handle based on the site’s Environment ID value. You use the DB_SITE handle to configure and manage replication sites. More info…

    repmgr_set_ack_policy(ack_policy)

    Specifies how master and client sites will handle acknowledgment of replication messages which are necessary for “permanent” records. More info…

    repmgr_get_ack_policy()

    Returns the replication manager’s client acknowledgment policy. More info…

    repmgr_site_list()

    Returns a dictionary with the status of the sites currently known by the replication manager.

    The keys are the Environment ID assigned by the replication manager. This is the same value that is passed to the application’s event notification function for the DB_EVENT_REP_NEWMASTER event.

    The values are tuples containing the hostname, the TCP/IP port number and the link status.

    More info…

    repmgr_stat(flags=0)

    Returns a dictionary with the replication manager statistics. Keys are:

    perm_failed

    The number of times a message critical for maintaining database integrity (for example, a transaction commit), originating at this site, did not receive sufficient acknowledgement from clients, according to the configured acknowledgement policy and acknowledgement timeout.

    msgs_queued

    The number of outgoing messages which could not be transmitted immediately, due to a full network buffer, and had to be queued for later delivery.

    msgs_dropped

    The number of outgoing messages that were completely dropped, because the outgoing message queue was full. (Berkeley DB replication is tolerant of dropped messages, and will automatically request retransmission of any missing messages as needed.)

    connection_drop

    The number of times an existing TCP/IP connection failed.

    connect_fail

    The number of times an attempt to open a new TCP/IP connection failed.

    More info…

    repmgr_stat_print(flags=0)

    Displays the replication manager statistical information. More info…

    DBEnv Replication Methods

    This section provides the raw methods for replication. If possible, it is recommended to use the Replication Manager.

    rep_elect(nsites, nvotes)

    Holds an election for the master of a replication group. More info…

    rep_set_transport(envid, transportFunc)

    Initializes the communication infrastructure for a database environment participating in a replicated application. More info…

    rep_process_messsage(control, rec, envid)

    Processes an incoming replication message sent by a member of the replication group to the local database environment.

    Returns a two element tuple.

    More info…

    rep_start(flags, cdata=None)

    Configures the database environment as a client or master in a group of replicated database environments.

    The DB_ENV->rep_start method is not called by most replication applications. It should only be called by applications implementing their own network transport layer, explicitly holding replication group elections and handling replication messages outside of the replication manager framework.

    More info…

    rep_sync()

    Forces master synchronization to begin for this client. This method is the other half of setting the DB_REP_CONF_DELAYCLIENT flag via the DB_ENV->rep_set_config method. More info…

    rep_set_config(which, onoff)

    Configures the Berkeley DB replication subsystem. More info…

    rep_get_config(which)

    Returns whether the specified which parameter is currently set or not. More info…

    rep_set_limit(bytes)

    Sets a byte-count limit on the amount of data that will be transmitted from a site in response to a single message processed by the DB_ENV->rep_process_message method. The limit is not a hard limit, and the record that exceeds the limit is the last record to be sent. More info…

    rep_get_limit()

    Gets a byte-count limit on the amount of data that will be transmitted from a site in response to a single message processed by the DB_ENV->rep_process_message method. The limit is not a hard limit, and the record that exceeds the limit is the last record to be sent. More info…

    rep_set_request(minimum, maximum)

    Sets a threshold for the minimum and maximum time that a client waits before requesting retransmission of a missing message. Specifically, if the client detects a gap in the sequence of incoming log records or database pages, Berkeley DB will wait for at least min microseconds before requesting retransmission of the missing record. Berkeley DB will double that amount before requesting the same missing record again, and so on, up to a maximum threshold of max microseconds. More info…

    rep_get_request()

    Returns a tuple with the minimum and maximum number of microseconds a client waits before requesting retransmission. More info…

    rep_set_nsites(nsites)

    Specifies the total number of sites in a replication group. More info…

    rep_get_nsites()

    Returns the total number of sites in the replication group. More info…

    rep_set_priority(priority)

    Specifies the database environment’s priority in replication group elections. The priority must be a positive integer, or 0 if this environment cannot be a replication group master. More info…

    rep_get_priority()

    Returns the database environment priority. More info…

    rep_set_timeout(which, timeout)

    Specifies a variety of replication timeout values. More info…

    rep_get_timeout(which)

    Returns the timeout value for the specified which parameter. More info…

    rep_set_clockskew(fast, slow)

    Sets the clock skew ratio among replication group members based on the fastest and slowest measurements among the group for use with master leases. More info…

    rep_get_clockskew()

    Returns a tuple with the current clock skew values. More info…

    rep_stat(flags=0)

    Returns a dictionary with the replication subsystem statistics. Keys are:

    st_bulk_fills

    The number of times the bulk buffer filled up, forcing the buffer content to be sent.

    bulk_overflows

    The number of times a record was bigger than the entire bulk buffer, and therefore had to be sent as a singleton.

    bulk_records

    The number of records added to a bulk buffer.

    bulk_transfers

    The number of bulk buffers transferred (via a call to the application’s send function).

    client_rerequests

    The number of times this client site received a “re-request” message, indicating that a request it previously sent to another client could not be serviced by that client. (Compare to client_svc_miss.)

    client_svc_miss

    The number of “request” type messages received by this client that could not be processed, forcing the originating requester to try sending the request to the master (or another client).

    client_svc_req

    The number of “request” type messages received by this client. (“Request” messages are usually sent from a client to the master, but a message marked with the DB_REP_ANYWHERE flag in the invocation of the application’s send function may be sent to another client instead.)

    dupmasters

    The number of duplicate master conditions originally detected at this site.

    egen

    The current election generation number.

    election_cur_winner

    The election winner.

    election_gen

    The election generation number.

    election_lsn

    The maximum LSN of election winner.

    election_nsites

    The number sites responding to this site during the last election.

    election_nvotes

    The number of votes required in the last election.

    election_priority

    The election priority.

    election_sec

    The number of seconds the last election took (the total election time is election_sec plus election_usec).

    election_status

    The current election phase (0 if no election is in progress).

    election_tiebreaker

    The election tiebreaker value.

    election_usec

    The number of microseconds the last election took (the total election time is election_sec plus election_usec).

    election_votes

    The number of votes received in the last election.

    elections

    The number of elections held.

    elections_won

    The number of elections won.

    env_id

    The current environment ID.

    env_priority

    The current environment priority.

    gen

    The current generation number.

    log_duplicated

    The number of duplicate log records received.

    log_queued

    The number of log records currently queued.

    log_queued_max

    The maximum number of log records ever queued at once.

    log_queued_total

    The total number of log records queued.

    log_records

    The number of log records received and appended to the log.

    log_requested

    The number of times log records were missed and requested.

    master

    The current master environment ID.

    master_changes

    The number of times the master has changed.

    max_lease_sec

    The number of seconds of the longest lease (the total lease time is max_lease_sec plus max_lease_usec).

    max_lease_usec

    The number of microseconds of the longest lease (the total lease time is max_lease_sec plus max_lease_usec).

    max_perm_lsn

    The LSN of the maximum permanent log record, or 0 if there are no permanent log records.

    msgs_badgen

    The number of messages received with a bad generation number.

    msgs_processed

    The number of messages received and processed.

    msgs_recover

    The number of messages ignored due to pending recovery.

    msgs_send_failures

    The number of failed message sends.

    msgs_sent

    The number of messages sent.

    newsites

    The number of new site messages received.

    next_lsn

    In replication environments configured as masters, the next LSN expected. In replication environments configured as clients, the next LSN to be used.

    next_pg

    The next page number we expect to receive.

    nsites

    The number of sites used in the last election.

    nthrottles

    Transmission limited. This indicates the number of times that data transmission was stopped to limit the amount of data sent in response to a single call to DB_ENV->rep_process_message.

    outdated

    The number of outdated conditions detected.

    pg_duplicated

    The number of duplicate pages received.

    pg_records

    The number of pages received and stored.

    pg_requested

    The number of pages missed and requested from the master.

    startsync_delayed

    The number of times the client had to delay the start of a cache flush operation (initiated by the master for an impending checkpoint) because it was missing some previous log record(s).

    startup_complete

    The client site has completed its startup procedures and is now handling live records from the master.

    status
    The current replication mode. Set to

    DB_REP_MASTER if the environment is a replication master, DB_REP_CLIENT if the environment is a replication client, or 0 if replication is not configured.

    txns_applied

    The number of transactions applied.

    waiting_lsn

    The LSN of the first log record we have after missing log records being waited for, or 0 if no log records are currently missing.

    waiting_pg

    The page number of the first page we have after missing pages being waited for, or 0 if no pages are currently missing.

    More info…

    rep_stat_print(flags=0)

    Displays the replication subsystem statistical information. More info…

    ©2008-2020 Jesus Cea Avion. | Powered by Sphinx 2.3.1 & Alabaster 0.7.12
    bsddb3-6.2.7/docs/html/license.html0000664000175000017500000002147213617125467016745 0ustar jceajcea00000000000000 LICENSE — PyBSDDB 6.2.7 documentation

    LICENSE

    Except when noted in individual files, this project is distributed under BSD 3-Clause License.

    Note

    If this file is changed, “LICENSE.txt” and “licenses.txt” must be updated too.

    License Text (BSD 3-Clause License)

    Copyright (c) 2008-2020, Jesus Cea Avion <jcea@jcea.es> All rights reserved.

    Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

    1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.

    2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

    3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    License of individual files

    The history of this project is long and complicated, and so are their copyrights and licenses. I (Jesus Cea) wrote this document in orden to clarify the situation.

    This code was integrated once in Python 2.x, so I guess somebody did the paperwork related to contributor agreement. This code is derived from that version, so that could be a license checkpoint/blank sheet. I must verify that.

    New files will be covered by the 3-clause BSD license.

    License of Python files

    • Except the following files, license is 3-clause BSD license. Jesus Cea Avion.

    • test2.py, test3.py: Zope Public License, version 2.0. Zope Corporation and contributors.

    • Lib*/bsddb/dbrecio.py: Itamar Shtull-Trauring <itamar@maxnm.com>.

    • Lib*/bsddb/__init__.py: 3-clause BSD license. Digital Creations and Andrew Kuchling.

    • Lib*/bsddb/db.py: 3-clause BSD license. Digital Creations and Andrew Kuchling.

    • Lib*/bsddb/dbobj.py, dbutils.py: Free software. Autonomous Zone Industries, Gregory P. Smith.

    • Lib*/bsddb/dbtables.py: Free software. Autonomous Zone Industries, Gregory P. Smith.

    • Lib*/bsddb/test/test_dbtables.py: Free software. Autonomous Zone Industries, Gregory P. Smith.

    • Lib*/bsddb/dbshelve.py: Free software. Total Control Software.

    License of C files

    • Modules/bsddb.h, _bsddb.c: 3-clause BSD license. Digital Creations, Andrew Kuchling, Robin Dunn, Gregory P. Smith, Duncan Grisby, Jesus Cea Avion.

    ©2008-2020 Jesus Cea Avion. | Powered by Sphinx 2.3.1 & Alabaster 0.7.12
    bsddb3-6.2.7/setup3.py0000664000175000017500000005431513617133012014321 0ustar jceajcea00000000000000#!/usr/bin/env python """ Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ import os import re import sys import glob if (sys.version_info[0] < 3) and (sys.version_info >= (2, 6)) : # Silence deprecation warnings during "setup" import warnings warnings.filterwarnings('ignore', message='in 3.x, bsddb has been removed; ' \ 'please use the pybsddb project instead', category=DeprecationWarning) warnings.filterwarnings('ignore', message='in 3.x, the bsddb module has been removed; ' \ 'please use the pybsddb project instead', category=DeprecationWarning) if sys.version_info[:2] == (2, 7) : with warnings.catch_warnings() : # Python 2.7.0 warnings.filterwarnings('ignore', message='The CObject type is marked Pending Deprecation ' \ 'in Python 2.7. Please use capsule objects instead.', category=PendingDeprecationWarning) # Python 2.7.1 warnings.filterwarnings('ignore', message='CObject type is not supported in 3.x. ' \ 'Please use capsule objects instead.', category=DeprecationWarning) try : # 'bsddb' library could be not available import bsddb # Import the 2.7 version, that uses CObject except ImportError : pass # setuptools warnings warnings.filterwarnings('ignore', message='tuple parameter unpacking has been removed in 3.x', category=SyntaxWarning) warnings.filterwarnings('ignore', message='the dl module has been removed in Python 3.0; ' \ 'use the ctypes module instead', category=DeprecationWarning) try : from setuptools import setup, Extension except : from distutils.core import setup, Extension from distutils.dep_util import newer import distutils.ccompiler # read the module version number out of the .c file VERSION = None _ver_re = re.compile('^#\s*define\s+PY_BSDDB_VERSION\s+"(\d+\.\d+\.\d+.*)"') try: _srcFile = open('Modules/bsddb.h', 'r') except IOError: print("Could not open module source to read the version number.") raise for line in _srcFile.readlines(): m = _ver_re.match(line) if m: VERSION = m.group(1) continue # We close first, to avoid a "ResourceWarning" _srcFile.close() del _srcFile del _ver_re del m if not VERSION: raise RuntimeError("could not find PY_BSDDB_VERSION in Modules/bsddb.h") #---------------------------------------------------------------------- debug = '--debug' in sys.argv or '-g' in sys.argv lflags_arg = [] if os.name == 'posix': # Allow setting the DB dir and additional link flags either in # the environment or on the command line. # First check the environment... BERKELEYDB_INCDIR = os.environ.get('BERKELEYDB_INCDIR', '') BERKELEYDB_LIBDIR = os.environ.get('BERKELEYDB_LIBDIR', '') BERKELEYDB_DIR = os.environ.get('BERKELEYDB_DIR', '') LFLAGS = os.environ.get('LFLAGS', []) LIBS = os.environ.get('LIBS', []) # ...then the command line. # Handle --berkeley-db=[PATH] and --lflags=[FLAGS] args = sys.argv[:] for arg in args: if arg.startswith('--berkeley-db-incdir='): BERKELEYDB_INCDIR = arg.split('=')[1] sys.argv.remove(arg) if arg.startswith('--berkeley-db-libdir='): BERKELEYDB_LIBDIR = arg.split('=')[1] sys.argv.remove(arg) if arg.startswith('--berkeley-db='): BERKELEYDB_DIR = arg.split('=')[1] sys.argv.remove(arg) elif arg.startswith('--lflags='): LFLAGS = arg.split('=')[1].split() sys.argv.remove(arg) elif arg.startswith('--libs='): LIBS = arg.split('=')[1].split() sys.argv.remove(arg) if LFLAGS or LIBS: lflags_arg = LFLAGS + LIBS # Supported Berkeley DB versions, in order of preference. db_ver_list = ((6, 2), (6, 1), (5, 3), (5, 1), (4, 8), (4, 7)) db_ver = None # If we were not told where it is, go looking for it. dblib = 'db' incdir = libdir = None if not BERKELEYDB_DIR and not BERKELEYDB_LIBDIR and not BERKELEYDB_INCDIR: # construct a list of paths to look for the header file in on # top of the normal inc_dirs. db_inc_paths = [] db_major = set() bitness = "" import platform if (platform.architecture()[0] == "64bit") and \ (platform.platform(True, True).startswith("Solaris-")) and \ (not platform.uname()[3].startswith('joyent_')): bitness = "/64" for major, minor in db_ver_list : if major not in db_major : db_major.add(major) db_inc_paths.extend([ '/usr/include/db%d%s' %(major, bitness), '/usr/local/include/db%d%s' %(major, bitness), '/opt/local/include/db%d%s' %(major, bitness), '/opt/sfw/include/db%d%s' %(major, bitness), '/sw/include/db%d%s' %(major, bitness), '/usr/local/opt/berkeley-db@%s/include' % (major), ]) db_inc_paths.append('/usr/include/db%d%d%s' % \ (major, minor, bitness)) db_inc_paths.append('/usr/local/BerkeleyDB.%d.%d%s/include' % \ (major, minor, bitness)) db_inc_paths.append('/usr/local/include/db%d%d%s' % \ (major, minor, bitness)) db_inc_paths.append('/pkg/db-%d.%d%s/include' % \ (major, minor, bitness)) db_inc_paths.append('/opt/db-%d.%d%s/include' % \ (major, minor, bitness)) db_ver_inc_map = {} class db_found(Exception): pass try: # this CCompiler object is only used to locate include files compiler = distutils.ccompiler.new_compiler() lib_dirs = compiler.library_dirs + [ '/lib64', '/usr/lib64', '/lib', '/usr/lib', '/usr/lib/x86_64-linux-gnu/', ] inc_dirs = compiler.include_dirs + [ '/usr/include', '/usr/local/opt/berkeley-db/include', ] # See whether there is a Oracle or Sleepycat header in the standard # search path. for d in inc_dirs + db_inc_paths: f = os.path.join(d, "db.h") if debug: print("db: looking for db.h in", f) if os.path.exists(f): with open(f) as fichero : f = fichero.read() m = re.search(r"#define\WDB_VERSION_MAJOR\W(\d+)", f) if m: db_major = int(m.group(1)) m = re.search(r"#define\WDB_VERSION_MINOR\W(\d+)", f) db_minor = int(m.group(1)) db_ver = (db_major, db_minor) if ( (db_ver not in db_ver_inc_map) and (db_ver in db_ver_list) ): # save the include directory with the db.h version # (first occurrance only) db_ver_inc_map[db_ver] = d if debug: print("db.h: found", db_ver, "in", d) else: # we already found a header for this library version if debug: print("db.h: ignoring", d) else: # ignore this header, it didn't contain a version number if debug: print("db.h: unsupported version", db_ver, "in", d) db_found_vers = list(db_ver_inc_map.keys()) db_found_vers.sort() while db_found_vers: db_ver = db_found_vers.pop() db_incdir = db_ver_inc_map[db_ver] # check lib directories parallel to the location of the header db_dirs_to_check = [ os.path.join(db_incdir, '..', 'lib64'), os.path.join(db_incdir, '..', 'lib'), os.path.join(db_incdir, '..', '..', 'lib64'), os.path.join(db_incdir, '..', '..', 'lib'), ] db_dirs_to_check = list(filter(os.path.isdir, db_dirs_to_check)) # Look for a version specific db-X.Y before an ambiguoius dbX # XXX should we -ever- look for a dbX name? Do any # systems really not name their library by version and # symlink to more general names? for dblib in ( ('db%d-%d.%d' % (db_ver[0], db_ver[0], db_ver[1])), ('db-%d.%d' % db_ver), ('db%d' % db_ver[0]) ): dblib_file = compiler.find_library_file( db_dirs_to_check + lib_dirs, dblib ) if dblib_file: db_libdir = os.path.abspath(os.path.dirname(dblib_file)) raise db_found else: if debug: print("db lib: ", dblib, "not found") except db_found: print("Found Berkeley DB %d.%d installation." % db_ver) print(" include files in", db_incdir) print(" library files in", db_libdir) print(" library name is lib"+dblib) if debug: print("db: lib dir", db_libdir, "inc dir", db_incdir) incdir = db_incdir libdir = db_libdir else: # this means Berkeley DB could not be found pass if BERKELEYDB_LIBDIR or BERKELEYDB_INCDIR: libdir = BERKELEYDB_LIBDIR or None incdir = BERKELEYDB_INCDIR or None if not BERKELEYDB_DIR and not incdir and not libdir: print("Can't find a local Berkeley DB installation.") print("(suggestion: try the --berkeley-db=/path/to/bsddb option)") sys.exit(1) # figure out from the base setting where the lib and .h are if not incdir: incdir = os.path.join(BERKELEYDB_DIR, 'include') if not libdir: libdir = os.path.join(BERKELEYDB_DIR, 'lib') if not '-ldb' in LIBS: libname = [dblib] else: if debug: print("LIBS already contains '-ldb' not adding our own", "'-l"+dblib+"'") libname = [] utils = [] # Test if the old bsddb is built-in static = 0 try: # Possibly already imported in the "warning" section (python 2.7) import bsddb if str(bsddb).find('built-in') >= 0: static = 1 except ImportError: pass # On Un*x, double check that no other built-in module pulls libdb in as a # side-effect. TBD: how/what to do on other platforms? fp = os.popen('ldd %s 2>&1' % sys.executable) results = fp.read() status = fp.close() if not status and results.find('libdb.') >= 0: static = 1 if static: print("""\ \aWARNING: \tIt appears that the old bsddb module is staticly linked in the \tPython executable. This will cause various random problems for \tbsddb3, up to and including segfaults. Please rebuild your \tPython either with bsddb disabled, or with it built as a shared \tdynamic extension. Watch out for other modules (e.g. dbm) that create \tdependencies in the python executable to libdb as a side effect.""") st = input("Build anyway? (yes/[no]) ") if st != "yes": sys.exit(1) # read db.h to figure out what version of Berkeley DB this is ver = None with open(os.path.join(incdir, 'db.h'), 'r') as f : db_h_lines = f.readlines() db_ver_re = re.compile( r'^#define\s+DB_VERSION_STRING\s.*Berkeley DB (\d+\.\d+).*') db_ver2 = db_ver if db_ver is None : print("Trying to use the Berkeley DB you specified...") for line in db_h_lines: match = db_ver_re.match(line) if not match: continue fullverstr = match.group(1) ver = fullverstr[0] + fullverstr[2] # 31 == 3.1, 32 == 3.2, etc. db_ver = (int(fullverstr[0]), int(fullverstr[2])) if (db_ver2 is not None) and (db_ver != db_ver2) : raise AssertionError("Detected Berkeley DB version is inconsistent") if db_ver not in db_ver_list: raise AssertionError("pybsddb untested with this Berkeley DB " "version %d.%d" %db_ver) print('Detected Berkeley DB version %d.%d from db.h' %db_ver) elif os.name == 'nt': # The default build of Berkeley DB for windows just leaves # everything in the build dirs in the db source tree. That means # that we either have to hunt around to find it, (which would be # even more difficult than the mess above for Unix...) or we make # the builder specify everything here. Compounding the problem is # version numbers in default path names, and different library # names for debug/release or dll/static. # # So to make things easier, I'm just going to expect that the DB stuff # has been moved to the ./db directory. There's an updatedb.bat file to # help. # # You'll need to edit the project file that comes with Berkeley DB so it # uses "Multithreaded DLL" and "Debug Multithreaded DLL" (/MD and /MDd) # settings as appropriate to build .lib file (the db_static project). incdir = 'db/include' libdir = 'db/lib' # read db.h to figure out what version of Berkeley DB this is ver = None with open(os.path.join(incdir, 'db.h'), 'r') as f : db_h_lines = f.readlines() db_ver_re = re.compile( r'^#define\s+DB_VERSION_STRING\s.*Berkeley DB (\d+\.\d+).*') for line in db_h_lines: match = db_ver_re.match(line) if not match: continue fullverstr = match.group(1) ver = fullverstr[0] + fullverstr[2] # 31 == 3.1, 32 == 3.2, etc. db_ver = (int(fullverstr[0]), int(fullverstr[2])) if db_ver not in db_ver_list: raise AssertionError("pybsddb untested with this Berkeley DB " "version %d.%d" %db_ver) print('Detected Berkeley DB version %d.%d from db.h' %db_ver) if debug: libname = ['libdb%ssd' % ver] # Debug, static else: libname = ['libdb%ss' % ver] # Release, static utils = [("bsddb3/utils", ["db/bin/db_archive.exe", "db/bin/db_checkpoint.exe", "db/bin/db_deadlock.exe", "db/bin/db_dump.exe", "db/bin/db_load.exe", "db/bin/db_printlog.exe", "db/bin/db_recover.exe", "db/bin/db_stat.exe", "db/bin/db_upgrade.exe", "db/bin/db_verify.exe", "db/bin/libdb%s.dll" % ver, ]), ("bsddb3/test", glob.glob("test/*.py")) ] if (db_ver in ((6, 0), (6, 1), (6, 2))) and \ ("YES_I_HAVE_THE_RIGHT_TO_USE_THIS_BERKELEY_DB_VERSION" not in os.environ) : print ( "\n" "******* COMPILATION ABORTED *******\n" "\n" "You are linking a Berkeley DB version licensed under " "AGPL3 or have a commercial license.\n" "\n" "AGPL3 is a strong copyleft license and derivative " "works must be equivalently licensed.\n" "\n" "You have two choices:\n" "\n" " 1. If your code is AGPL3 or you have a commercial Berkeley DB " "license from Oracle, please, define the environment variable " "'YES_I_HAVE_THE_RIGHT_TO_USE_THIS_BERKELEY_DB_VERSION' to " "any value, and try to install this python library again.\n" "\n" " 2. In any other case, you have to link to a previous version " "of Berkeley DB. Remove Berlekey DB version 6.x and let this " "python library try to locate an older version of the " "Berkeley DB library in your system. Alternatively, you can " "define the environment variable 'BERKELEYDB_DIR', or " "'BERKELEYDB_INCDIR' and 'BERKELEYDB_LIBDIR', with the path of " "the Berkeley DB you want to use and try to install this " "python library again.\n" "\n" "Sorry for the inconvenience. I am trying to protect you.\n" "\n" "More details:\n" "\n" " https://forums.oracle.com/message/11184885\n" " http://lists.debian.org/debian-legal/2013/07/\n" "\n" "******* COMPILATION ABORTED *******\n" ) sys.exit(1) version_suffix = "" if sys.version_info[0] > 2 : version_suffix = "3" # ############################# # Delete pkgsrc stale info # This is something that eventually should be not necesary. # XXX - jcea@jcea.es - 20170125 from distutils import sysconfig # The same dictionary is always returned, so we abuse it # and modify it in place. config_vars = sysconfig.get_config_vars() for k, v in list(config_vars.items()): if isinstance(v, str) and ('/db4' in v): j = ' '.join([i for i in v.split() if not i.endswith('/db4')]) config_vars[k] = j del config_vars # ############################# # do the actual build, install, whatever... setup(name = 'bsddb3', version = VERSION, description = 'Python bindings for Oracle Berkeley DB', long_description = """\ This module provides a nearly complete wrapping of the Oracle/Sleepycat C API for the Database Environment, Database, Cursor, Log Cursor, Sequence and Transaction objects, and each of these is exposed as a Python type in the bsddb3.db module. The database objects can use various access methods: btree, hash, recno, and queue. Complete support of Berkeley DB distributed transactions. Complete support for Berkeley DB Replication Manager. Complete support for Berkeley DB Base Replication. Support for RPC. Please see the documents in the docs directory of the source distribution or at the website for more details on the types and methods provided. The goal is to mirror most of the real Berkeley DB API so fall back to the Oracle Berkeley DB documentation as appropriate. If you need to support ancient versiones of Python and/or Berkeley DB , you can use old releases of this bindings. `Homepage `__ -- `Releases (changelog) `__ -- `Documentation `__ -- `Mailing List `__ -- `Donation `__ """, long_description_content_type = 'text/x-rst', author = 'Jesus Cea, Robin Dunn, Gregory P. Smith, Andrew Kuchling, Barry Warsaw', author_email = 'pybsddb@jcea.es', url = 'https://www.jcea.es/programacion/pybsddb.htm', license = "3-clause BSD License", packages = ['bsddb3', 'bsddb3/tests'], package_dir = {'bsddb3': 'Lib%s/bsddb' %version_suffix, 'bsddb3/tests': 'Lib%s/bsddb/test' %version_suffix}, ext_modules = [Extension('bsddb3._pybsddb', sources = ['Modules/_bsddb.c'], depends = ['Modules/bsddb.h'], include_dirs = [ incdir ], library_dirs = [ libdir ], runtime_library_dirs = [ libdir ], libraries = libname, extra_link_args = lflags_arg, )], headers = ['Modules/bsddb.h'], data_files = utils, classifiers = [ 'License :: OSI Approved :: BSD License', 'Development Status :: 5 - Production/Stable', 'Intended Audience :: Developers', 'Intended Audience :: Information Technology', 'Natural Language :: English', 'Natural Language :: Spanish', 'Operating System :: OS Independent', 'Programming Language :: Python', 'Topic :: Database', 'Topic :: Software Development', 'Topic :: System :: Clustering', 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 2.6', 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.3', 'Programming Language :: Python :: 3.4', 'Programming Language :: Python :: 3.5', 'Programming Language :: Python :: 3.6', 'Programming Language :: Python :: 3.7', 'Programming Language :: Python :: 3.8', 'Programming Language :: Python :: 3.9', ], ) bsddb3-6.2.7/MANIFEST.in0000644000175000017500000000117213316226203014252 0ustar jceajcea00000000000000include test-full_prerelease.py include setup2.py include setup3.py include test2.py include test3.py include make3.py recursive-include Lib3 *.py include *.txt include updatedb.bat include MANIFEST.in include setup.py include setup.cfg include ChangeLog include test.py recursive-include bsddb3 *.py recursive-include docs *.rst *.html *.css *.gif *.jpg *.png *.js *.json *.txt recursive-include patches *.txt *.patch recursive-include Modules _bsddb.c bsddb.h recursive-include test *.py prune docs/build prune docs/tools/docutils prune docs/tools/sphinx prune docs/tools/pygments prune old prune test/db_home prune test/bsddb3 bsddb3-6.2.7/Lib/0000775000175000017500000000000013617133044013227 5ustar jceajcea00000000000000bsddb3-6.2.7/Lib/bsddb/0000775000175000017500000000000013617133044014305 5ustar jceajcea00000000000000bsddb3-6.2.7/Lib/bsddb/dbutils.py0000644000175000017500000000552113316226203016322 0ustar jceajcea00000000000000#------------------------------------------------------------------------ # # Copyright (C) 2000 Autonomous Zone Industries # # License: This is free software. You may use this software for any # purpose including modification/redistribution, so long as # this header remains intact and that you do not claim any # rights of ownership or authorship of this software. This # software has been tested, but no warranty is expressed or # implied. # # Author: Gregory P. Smith # # Note: I don't know how useful this is in reality since when a # DBLockDeadlockError happens the current transaction is supposed to be # aborted. If it doesn't then when the operation is attempted again # the deadlock is still happening... # --Robin # #------------------------------------------------------------------------ # # import the time.sleep function in a namespace safe way to allow # "from bsddb.dbutils import *" # from time import sleep as _sleep import sys absolute_import = (sys.version_info[0] >= 3) if absolute_import : from . import db else : import db # always sleep at least N seconds between retrys _deadlock_MinSleepTime = 1.0/128 # never sleep more than N seconds between retrys _deadlock_MaxSleepTime = 3.14159 # Assign a file object to this for a "sleeping" message to be written to it # each retry _deadlock_VerboseFile = None def DeadlockWrap(function, *_args, **_kwargs): """DeadlockWrap(function, *_args, **_kwargs) - automatically retries function in case of a database deadlock. This is a function intended to be used to wrap database calls such that they perform retrys with exponentially backing off sleeps in between when a DBLockDeadlockError exception is raised. A 'max_retries' parameter may optionally be passed to prevent it from retrying forever (in which case the exception will be reraised). d = DB(...) d.open(...) DeadlockWrap(d.put, "foo", data="bar") # set key "foo" to "bar" """ sleeptime = _deadlock_MinSleepTime max_retries = _kwargs.get('max_retries', -1) if 'max_retries' in _kwargs: del _kwargs['max_retries'] while True: try: return function(*_args, **_kwargs) except db.DBLockDeadlockError: if _deadlock_VerboseFile: _deadlock_VerboseFile.write( 'dbutils.DeadlockWrap: sleeping %1.3f\n' % sleeptime) _sleep(sleeptime) # exponential backoff in the sleep time sleeptime *= 2 if sleeptime > _deadlock_MaxSleepTime: sleeptime = _deadlock_MaxSleepTime max_retries -= 1 if max_retries == -1: raise #------------------------------------------------------------------------ bsddb3-6.2.7/Lib/bsddb/test/0000775000175000017500000000000013617133044015264 5ustar jceajcea00000000000000bsddb3-6.2.7/Lib/bsddb/test/test_join.py0000664000175000017500000001126213617051124017634 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """TestCases for using the DB.join and DBCursor.join_item methods. """ import os import unittest from test_all import db, dbshelve, test_support, verbose, \ get_new_environment_path, get_new_database_path #---------------------------------------------------------------------- ProductIndex = [ ('apple', "Convenience Store"), ('blueberry', "Farmer's Market"), ('shotgun', "S-Mart"), # Aisle 12 ('pear', "Farmer's Market"), ('chainsaw', "S-Mart"), # "Shop smart. Shop S-Mart!" ('strawberry', "Farmer's Market"), ] ColorIndex = [ ('blue', "blueberry"), ('red', "apple"), ('red', "chainsaw"), ('red', "strawberry"), ('yellow', "peach"), ('yellow', "pear"), ('black', "shotgun"), ] class JoinTestCase(unittest.TestCase): keytype = '' def setUp(self): self.filename = self.__class__.__name__ + '.db' self.homeDir = get_new_environment_path() self.env = db.DBEnv() self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL | db.DB_INIT_LOCK ) def tearDown(self): self.env.close() test_support.rmtree(self.homeDir) def test01_join(self): if verbose: print '\n', '-=' * 30 print "Running %s.test01_join..." % \ self.__class__.__name__ # create and populate primary index priDB = db.DB(self.env) priDB.open(self.filename, "primary", db.DB_BTREE, db.DB_CREATE) map(lambda t, priDB=priDB: priDB.put(*t), ProductIndex) # create and populate secondary index secDB = db.DB(self.env) secDB.set_flags(db.DB_DUP | db.DB_DUPSORT) secDB.open(self.filename, "secondary", db.DB_BTREE, db.DB_CREATE) map(lambda t, secDB=secDB: secDB.put(*t), ColorIndex) sCursor = None jCursor = None try: # lets look up all of the red Products sCursor = secDB.cursor() # Don't do the .set() in an assert, or you can get a bogus failure # when running python -O tmp = sCursor.set('red') self.assertTrue(tmp) # FIXME: jCursor doesn't properly hold a reference to its # cursors, if they are closed before jcursor is used it # can cause a crash. jCursor = priDB.join([sCursor]) if jCursor.get(0) != ('apple', "Convenience Store"): self.fail("join cursor positioned wrong") if jCursor.join_item() != 'chainsaw': self.fail("DBCursor.join_item returned wrong item") if jCursor.get(0)[0] != 'strawberry': self.fail("join cursor returned wrong thing") if jCursor.get(0): # there were only three red items to return self.fail("join cursor returned too many items") finally: if jCursor: jCursor.close() if sCursor: sCursor.close() priDB.close() secDB.close() def test_suite(): suite = unittest.TestSuite() suite.addTest(unittest.makeSuite(JoinTestCase)) return suite bsddb3-6.2.7/Lib/bsddb/test/test_dbtables.py0000644000175000017500000003577713316226203020472 0ustar jceajcea00000000000000#!/usr/bin/env python # #----------------------------------------------------------------------- # A test suite for the table interface built on bsddb.db #----------------------------------------------------------------------- # # Copyright (C) 2000, 2001 by Autonomous Zone Industries # Copyright (C) 2002 Gregory P. Smith # # March 20, 2000 # # License: This is free software. You may use this software for any # purpose including modification/redistribution, so long as # this header remains intact and that you do not claim any # rights of ownership or authorship of this software. This # software has been tested, but no warranty is expressed or # implied. # # -- Gregory P. Smith # import os, re, sys if sys.version_info[0] < 3 : try: import cPickle pickle = cPickle except ImportError: import pickle else : import pickle import unittest from test_all import db, dbtables, test_support, verbose, \ get_new_environment_path, get_new_database_path #---------------------------------------------------------------------- class TableDBTestCase(unittest.TestCase): db_name = 'test-table.db' def setUp(self): import sys if sys.version_info[0] >= 3 : from test_all import do_proxy_db_py3k self._flag_proxy_db_py3k = do_proxy_db_py3k(False) self.testHomeDir = get_new_environment_path() self.tdb = dbtables.bsdTableDB( filename='tabletest.db', dbhome=self.testHomeDir, create=1) def tearDown(self): self.tdb.close() import sys if sys.version_info[0] >= 3 : from test_all import do_proxy_db_py3k do_proxy_db_py3k(self._flag_proxy_db_py3k) test_support.rmtree(self.testHomeDir) def test01(self): tabname = "test01" colname = 'cool numbers' try: self.tdb.Drop(tabname) except dbtables.TableDBError: pass self.tdb.CreateTable(tabname, [colname]) import sys if sys.version_info[0] < 3 : self.tdb.Insert(tabname, {colname: pickle.dumps(3.14159, 1)}) else : self.tdb.Insert(tabname, {colname: pickle.dumps(3.14159, 1).decode("iso8859-1")}) # 8 bits if verbose: self.tdb._db_print() values = self.tdb.Select( tabname, [colname], conditions={colname: None}) import sys if sys.version_info[0] < 3 : colval = pickle.loads(values[0][colname]) else : colval = pickle.loads(bytes(values[0][colname], "iso8859-1")) self.assertTrue(colval > 3.141) self.assertTrue(colval < 3.142) def test02(self): tabname = "test02" col0 = 'coolness factor' col1 = 'but can it fly?' col2 = 'Species' import sys if sys.version_info[0] < 3 : testinfo = [ {col0: pickle.dumps(8, 1), col1: 'no', col2: 'Penguin'}, {col0: pickle.dumps(-1, 1), col1: 'no', col2: 'Turkey'}, {col0: pickle.dumps(9, 1), col1: 'yes', col2: 'SR-71A Blackbird'} ] else : testinfo = [ {col0: pickle.dumps(8, 1).decode("iso8859-1"), col1: 'no', col2: 'Penguin'}, {col0: pickle.dumps(-1, 1).decode("iso8859-1"), col1: 'no', col2: 'Turkey'}, {col0: pickle.dumps(9, 1).decode("iso8859-1"), col1: 'yes', col2: 'SR-71A Blackbird'} ] try: self.tdb.Drop(tabname) except dbtables.TableDBError: pass self.tdb.CreateTable(tabname, [col0, col1, col2]) for row in testinfo : self.tdb.Insert(tabname, row) import sys if sys.version_info[0] < 3 : values = self.tdb.Select(tabname, [col2], conditions={col0: lambda x: pickle.loads(x) >= 8}) else : values = self.tdb.Select(tabname, [col2], conditions={col0: lambda x: pickle.loads(bytes(x, "iso8859-1")) >= 8}) self.assertEqual(len(values), 2) if values[0]['Species'] == 'Penguin' : self.assertEqual(values[1]['Species'], 'SR-71A Blackbird') elif values[0]['Species'] == 'SR-71A Blackbird' : self.assertEqual(values[1]['Species'], 'Penguin') else : if verbose: print "values= %r" % (values,) raise RuntimeError("Wrong values returned!") def test03(self): tabname = "test03" try: self.tdb.Drop(tabname) except dbtables.TableDBError: pass if verbose: print '...before CreateTable...' self.tdb._db_print() self.tdb.CreateTable(tabname, ['a', 'b', 'c', 'd', 'e']) if verbose: print '...after CreateTable...' self.tdb._db_print() self.tdb.Drop(tabname) if verbose: print '...after Drop...' self.tdb._db_print() self.tdb.CreateTable(tabname, ['a', 'b', 'c', 'd', 'e']) try: self.tdb.Insert(tabname, {'a': "", 'e': pickle.dumps([{4:5, 6:7}, 'foo'], 1), 'f': "Zero"}) self.fail('Expected an exception') except dbtables.TableDBError: pass try: self.tdb.Select(tabname, [], conditions={'foo': '123'}) self.fail('Expected an exception') except dbtables.TableDBError: pass self.tdb.Insert(tabname, {'a': '42', 'b': "bad", 'c': "meep", 'e': 'Fuzzy wuzzy was a bear'}) self.tdb.Insert(tabname, {'a': '581750', 'b': "good", 'd': "bla", 'c': "black", 'e': 'fuzzy was here'}) self.tdb.Insert(tabname, {'a': '800000', 'b': "good", 'd': "bla", 'c': "black", 'e': 'Fuzzy wuzzy is a bear'}) if verbose: self.tdb._db_print() # this should return two rows values = self.tdb.Select(tabname, ['b', 'a', 'd'], conditions={'e': re.compile('wuzzy').search, 'a': re.compile('^[0-9]+$').match}) self.assertEqual(len(values), 2) # now lets delete one of them and try again self.tdb.Delete(tabname, conditions={'b': dbtables.ExactCond('good')}) values = self.tdb.Select( tabname, ['a', 'd', 'b'], conditions={'e': dbtables.PrefixCond('Fuzzy')}) self.assertEqual(len(values), 1) self.assertEqual(values[0]['d'], None) values = self.tdb.Select(tabname, ['b'], conditions={'c': lambda c: c == 'meep'}) self.assertEqual(len(values), 1) self.assertEqual(values[0]['b'], "bad") def test04_MultiCondSelect(self): tabname = "test04_MultiCondSelect" try: self.tdb.Drop(tabname) except dbtables.TableDBError: pass self.tdb.CreateTable(tabname, ['a', 'b', 'c', 'd', 'e']) try: self.tdb.Insert(tabname, {'a': "", 'e': pickle.dumps([{4:5, 6:7}, 'foo'], 1), 'f': "Zero"}) self.fail('Expected an exception') except dbtables.TableDBError: pass self.tdb.Insert(tabname, {'a': "A", 'b': "B", 'c': "C", 'd': "D", 'e': "E"}) self.tdb.Insert(tabname, {'a': "-A", 'b': "-B", 'c': "-C", 'd': "-D", 'e': "-E"}) self.tdb.Insert(tabname, {'a': "A-", 'b': "B-", 'c': "C-", 'd': "D-", 'e': "E-"}) if verbose: self.tdb._db_print() # This select should return 0 rows. it is designed to test # the bug identified and fixed in sourceforge bug # 590449 # (Big Thanks to "Rob Tillotson (n9mtb)" for tracking this down # and supplying a fix!! This one caused many headaches to say # the least...) values = self.tdb.Select(tabname, ['b', 'a', 'd'], conditions={'e': dbtables.ExactCond('E'), 'a': dbtables.ExactCond('A'), 'd': dbtables.PrefixCond('-') } ) self.assertEqual(len(values), 0, values) def test_CreateOrExtend(self): tabname = "test_CreateOrExtend" self.tdb.CreateOrExtendTable( tabname, ['name', 'taste', 'filling', 'alcohol content', 'price']) try: self.tdb.Insert(tabname, {'taste': 'crap', 'filling': 'no', 'is it Guinness?': 'no'}) self.fail("Insert should've failed due to bad column name") except: pass self.tdb.CreateOrExtendTable(tabname, ['name', 'taste', 'is it Guinness?']) # these should both succeed as the table should contain the union of both sets of columns. self.tdb.Insert(tabname, {'taste': 'crap', 'filling': 'no', 'is it Guinness?': 'no'}) self.tdb.Insert(tabname, {'taste': 'great', 'filling': 'yes', 'is it Guinness?': 'yes', 'name': 'Guinness'}) def test_CondObjs(self): tabname = "test_CondObjs" self.tdb.CreateTable(tabname, ['a', 'b', 'c', 'd', 'e', 'p']) self.tdb.Insert(tabname, {'a': "the letter A", 'b': "the letter B", 'c': "is for cookie"}) self.tdb.Insert(tabname, {'a': "is for aardvark", 'e': "the letter E", 'c': "is for cookie", 'd': "is for dog"}) self.tdb.Insert(tabname, {'a': "the letter A", 'e': "the letter E", 'c': "is for cookie", 'p': "is for Python"}) values = self.tdb.Select( tabname, ['p', 'e'], conditions={'e': dbtables.PrefixCond('the l')}) self.assertEqual(len(values), 2, values) self.assertEqual(values[0]['e'], values[1]['e'], values) self.assertNotEqual(values[0]['p'], values[1]['p'], values) values = self.tdb.Select( tabname, ['d', 'a'], conditions={'a': dbtables.LikeCond('%aardvark%')}) self.assertEqual(len(values), 1, values) self.assertEqual(values[0]['d'], "is for dog", values) self.assertEqual(values[0]['a'], "is for aardvark", values) values = self.tdb.Select(tabname, None, {'b': dbtables.Cond(), 'e':dbtables.LikeCond('%letter%'), 'a':dbtables.PrefixCond('is'), 'd':dbtables.ExactCond('is for dog'), 'c':dbtables.PrefixCond('is for'), 'p':lambda s: not s}) self.assertEqual(len(values), 1, values) self.assertEqual(values[0]['d'], "is for dog", values) self.assertEqual(values[0]['a'], "is for aardvark", values) def test_Delete(self): tabname = "test_Delete" self.tdb.CreateTable(tabname, ['x', 'y', 'z']) # prior to 2001-05-09 there was a bug where Delete() would # fail if it encountered any rows that did not have values in # every column. # Hunted and Squashed by (Jukka Santala - donwulff@nic.fi) self.tdb.Insert(tabname, {'x': 'X1', 'y':'Y1'}) self.tdb.Insert(tabname, {'x': 'X2', 'y':'Y2', 'z': 'Z2'}) self.tdb.Delete(tabname, conditions={'x': dbtables.PrefixCond('X')}) values = self.tdb.Select(tabname, ['y'], conditions={'x': dbtables.PrefixCond('X')}) self.assertEqual(len(values), 0) def test_Modify(self): tabname = "test_Modify" self.tdb.CreateTable(tabname, ['Name', 'Type', 'Access']) self.tdb.Insert(tabname, {'Name': 'Index to MP3 files.doc', 'Type': 'Word', 'Access': '8'}) self.tdb.Insert(tabname, {'Name': 'Nifty.MP3', 'Access': '1'}) self.tdb.Insert(tabname, {'Type': 'Unknown', 'Access': '0'}) def set_type(type): if type is None: return 'MP3' return type def increment_access(count): return str(int(count)+1) def remove_value(value): return None self.tdb.Modify(tabname, conditions={'Access': dbtables.ExactCond('0')}, mappings={'Access': remove_value}) self.tdb.Modify(tabname, conditions={'Name': dbtables.LikeCond('%MP3%')}, mappings={'Type': set_type}) self.tdb.Modify(tabname, conditions={'Name': dbtables.LikeCond('%')}, mappings={'Access': increment_access}) try: self.tdb.Modify(tabname, conditions={'Name': dbtables.LikeCond('%')}, mappings={'Access': 'What is your quest?'}) except TypeError: # success, the string value in mappings isn't callable pass else: raise RuntimeError, "why was TypeError not raised for bad callable?" # Delete key in select conditions values = self.tdb.Select( tabname, None, conditions={'Type': dbtables.ExactCond('Unknown')}) self.assertEqual(len(values), 1, values) self.assertEqual(values[0]['Name'], None, values) self.assertEqual(values[0]['Access'], None, values) # Modify value by select conditions values = self.tdb.Select( tabname, None, conditions={'Name': dbtables.ExactCond('Nifty.MP3')}) self.assertEqual(len(values), 1, values) self.assertEqual(values[0]['Type'], "MP3", values) self.assertEqual(values[0]['Access'], "2", values) # Make sure change applied only to select conditions values = self.tdb.Select( tabname, None, conditions={'Name': dbtables.LikeCond('%doc%')}) self.assertEqual(len(values), 1, values) self.assertEqual(values[0]['Type'], "Word", values) self.assertEqual(values[0]['Access'], "9", values) def test_suite(): suite = unittest.TestSuite() suite.addTest(unittest.makeSuite(TableDBTestCase)) return suite if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib/bsddb/test/test_all.py0000664000175000017500000005062713617051124017455 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """Run all test cases. """ import sys import os import unittest import bsddb3 as bsddb if sys.version_info[0] >= 3 : charset = "iso8859-1" # Full 8 bit class logcursor_py3k(object) : def __init__(self, env) : self._logcursor = env.log_cursor() def __getattr__(self, v) : return getattr(self._logcursor, v) def __next__(self) : v = getattr(self._logcursor, "next")() if v is not None : v = (v[0], v[1].decode(charset)) return v next = __next__ def first(self) : v = self._logcursor.first() if v is not None : v = (v[0], v[1].decode(charset)) return v def last(self) : v = self._logcursor.last() if v is not None : v = (v[0], v[1].decode(charset)) return v def prev(self) : v = self._logcursor.prev() if v is not None : v = (v[0], v[1].decode(charset)) return v def current(self) : v = self._logcursor.current() if v is not None : v = (v[0], v[1].decode(charset)) return v def set(self, lsn) : v = self._logcursor.set(lsn) if v is not None : v = (v[0], v[1].decode(charset)) return v class cursor_py3k(object) : def __init__(self, db, *args, **kwargs) : self._dbcursor = db.cursor(*args, **kwargs) def __getattr__(self, v) : return getattr(self._dbcursor, v) def _fix(self, v) : if v is None : return None key, value = v if isinstance(key, bytes) : key = key.decode(charset) return (key, value.decode(charset)) def __next__(self, flags=0, dlen=-1, doff=-1) : v = getattr(self._dbcursor, "next")(flags=flags, dlen=dlen, doff=doff) return self._fix(v) next = __next__ def previous(self) : v = self._dbcursor.previous() return self._fix(v) def last(self) : v = self._dbcursor.last() return self._fix(v) def set(self, k) : if isinstance(k, str) : k = bytes(k, charset) v = self._dbcursor.set(k) return self._fix(v) def set_recno(self, num) : v = self._dbcursor.set_recno(num) return self._fix(v) def set_range(self, k, dlen=-1, doff=-1) : if isinstance(k, str) : k = bytes(k, charset) v = self._dbcursor.set_range(k, dlen=dlen, doff=doff) return self._fix(v) def dup(self, flags=0) : cursor = self._dbcursor.dup(flags) return dup_cursor_py3k(cursor) def next_dup(self) : v = self._dbcursor.next_dup() return self._fix(v) def next_nodup(self) : v = self._dbcursor.next_nodup() return self._fix(v) def put(self, key, data, flags=0, dlen=-1, doff=-1) : if isinstance(key, str) : key = bytes(key, charset) if isinstance(data, str) : value = bytes(data, charset) return self._dbcursor.put(key, data, flags=flags, dlen=dlen, doff=doff) def current(self, flags=0, dlen=-1, doff=-1) : v = self._dbcursor.current(flags=flags, dlen=dlen, doff=doff) return self._fix(v) def first(self, flags=0, dlen=-1, doff=-1) : v = self._dbcursor.first(flags=flags, dlen=dlen, doff=doff) return self._fix(v) def pget(self, key=None, data=None, flags=0) : # Incorrect because key can be a bare number, # but enough to pass testsuite if isinstance(key, int) and (data is None) and (flags == 0) : flags = key key = None if isinstance(key, str) : key = bytes(key, charset) if isinstance(data, int) and (flags==0) : flags = data data = None if isinstance(data, str) : data = bytes(data, charset) v=self._dbcursor.pget(key=key, data=data, flags=flags) if v is not None : v1, v2, v3 = v if isinstance(v1, bytes) : v1 = v1.decode(charset) if isinstance(v2, bytes) : v2 = v2.decode(charset) v = (v1, v2, v3.decode(charset)) return v def join_item(self) : v = self._dbcursor.join_item() if v is not None : v = v.decode(charset) return v def get(self, *args, **kwargs) : l = len(args) if l == 2 : k, f = args if isinstance(k, str) : k = bytes(k, "iso8859-1") args = (k, f) elif l == 3 : k, d, f = args if isinstance(k, str) : k = bytes(k, charset) if isinstance(d, str) : d = bytes(d, charset) args =(k, d, f) v = self._dbcursor.get(*args, **kwargs) if v is not None : k, v = v if isinstance(k, bytes) : k = k.decode(charset) v = (k, v.decode(charset)) return v def get_both(self, key, value) : if isinstance(key, str) : key = bytes(key, charset) if isinstance(value, str) : value = bytes(value, charset) v=self._dbcursor.get_both(key, value) return self._fix(v) class dup_cursor_py3k(cursor_py3k) : def __init__(self, dbcursor) : self._dbcursor = dbcursor class DB_py3k(object) : def __init__(self, *args, **kwargs) : args2=[] for i in args : if isinstance(i, DBEnv_py3k) : i = i._dbenv args2.append(i) args = tuple(args2) for k, v in kwargs.items() : if isinstance(v, DBEnv_py3k) : kwargs[k] = v._dbenv self._db = bsddb._db.DB_orig(*args, **kwargs) def __contains__(self, k) : if isinstance(k, str) : k = bytes(k, charset) return getattr(self._db, "has_key")(k) def __getitem__(self, k) : if isinstance(k, str) : k = bytes(k, charset) v = self._db[k] if v is not None : v = v.decode(charset) return v def __setitem__(self, k, v) : if isinstance(k, str) : k = bytes(k, charset) if isinstance(v, str) : v = bytes(v, charset) self._db[k] = v def __delitem__(self, k) : if isinstance(k, str) : k = bytes(k, charset) del self._db[k] def __getattr__(self, v) : return getattr(self._db, v) def __len__(self) : return len(self._db) def has_key(self, k, txn=None) : if isinstance(k, str) : k = bytes(k, charset) return self._db.has_key(k, txn=txn) def set_re_delim(self, c) : if isinstance(c, str) : # We can use a numeric value byte too c = bytes(c, charset) return self._db.set_re_delim(c) def set_re_pad(self, c) : if isinstance(c, str) : # We can use a numeric value byte too c = bytes(c, charset) return self._db.set_re_pad(c) def get_re_source(self) : source = self._db.get_re_source() return source.decode(charset) def put(self, key, data, txn=None, flags=0, dlen=-1, doff=-1) : if isinstance(key, str) : key = bytes(key, charset) if isinstance(data, str) : value = bytes(data, charset) return self._db.put(key, data, flags=flags, txn=txn, dlen=dlen, doff=doff) def append(self, value, txn=None) : if isinstance(value, str) : value = bytes(value, charset) return self._db.append(value, txn=txn) def get_size(self, key) : if isinstance(key, str) : key = bytes(key, charset) return self._db.get_size(key) def exists(self, key, *args, **kwargs) : if isinstance(key, str) : key = bytes(key, charset) return self._db.exists(key, *args, **kwargs) def get(self, key, default="MagicCookie", txn=None, flags=0, dlen=-1, doff=-1) : if isinstance(key, str) : key = bytes(key, charset) if default != "MagicCookie" : # Magic for 'test_get_none.py' v=self._db.get(key, default=default, txn=txn, flags=flags, dlen=dlen, doff=doff) else : v=self._db.get(key, txn=txn, flags=flags, dlen=dlen, doff=doff) if (v is not None) and isinstance(v, bytes) : v = v.decode(charset) return v def pget(self, key, txn=None) : if isinstance(key, str) : key = bytes(key, charset) v=self._db.pget(key, txn=txn) if v is not None : v1, v2 = v if isinstance(v1, bytes) : v1 = v1.decode(charset) v = (v1, v2.decode(charset)) return v def get_both(self, key, value, txn=None, flags=0) : if isinstance(key, str) : key = bytes(key, charset) if isinstance(value, str) : value = bytes(value, charset) v=self._db.get_both(key, value, txn=txn, flags=flags) if v is not None : v = v.decode(charset) return v def delete(self, key, txn=None) : if isinstance(key, str) : key = bytes(key, charset) return self._db.delete(key, txn=txn) def compact(self, **kwargs) : if isinstance(kwargs.get('start'), str) : kwargs['start'] = bytes(kwargs['start'], charset) if isinstance(kwargs.get('stop'), str) : kwargs['stop'] = bytes(kwargs['stop'], charset) return self._db.compact(**kwargs) def keys(self) : k = self._db.keys() if len(k) and isinstance(k[0], bytes) : return [i.decode(charset) for i in self._db.keys()] else : return k def items(self) : data = self._db.items() if not len(data) : return data data2 = [] for k, v in data : if isinstance(k, bytes) : k = k.decode(charset) data2.append((k, v.decode(charset))) return data2 def associate(self, secondarydb, callback, flags=0, txn=None) : class associate_callback(object) : def __init__(self, callback) : self._callback = callback def callback(self, key, data) : if isinstance(key, str) : key = key.decode(charset) data = data.decode(charset) key = self._callback(key, data) if (key != bsddb._db.DB_DONOTINDEX) : if isinstance(key, str) : key = bytes(key, charset) elif isinstance(key, list) : key2 = [] for i in key : if isinstance(i, str) : i = bytes(i, charset) key2.append(i) key = key2 return key return self._db.associate(secondarydb._db, associate_callback(callback).callback, flags=flags, txn=txn) def cursor(self, txn=None, flags=0) : return cursor_py3k(self._db, txn=txn, flags=flags) def join(self, cursor_list) : cursor_list = [i._dbcursor for i in cursor_list] return dup_cursor_py3k(self._db.join(cursor_list)) class DBEnv_py3k(object) : def __init__(self, *args, **kwargs) : self._dbenv = bsddb._db.DBEnv_orig(*args, **kwargs) def __getattr__(self, v) : return getattr(self._dbenv, v) def log_cursor(self, flags=0) : return logcursor_py3k(self._dbenv) def get_lg_dir(self) : return self._dbenv.get_lg_dir().decode(charset) def get_tmp_dir(self) : return self._dbenv.get_tmp_dir().decode(charset) def get_data_dirs(self) : return tuple( (i.decode(charset) for i in self._dbenv.get_data_dirs())) class DBSequence_py3k(object) : def __init__(self, db, *args, **kwargs) : self._db=db self._dbsequence = bsddb._db.DBSequence_orig(db._db, *args, **kwargs) def __getattr__(self, v) : return getattr(self._dbsequence, v) def open(self, key, *args, **kwargs) : return self._dbsequence.open(bytes(key, charset), *args, **kwargs) def get_key(self) : return self._dbsequence.get_key().decode(charset) def get_dbp(self) : return self._db bsddb._db.DBEnv_orig = bsddb._db.DBEnv bsddb._db.DB_orig = bsddb._db.DB bsddb._db.DBSequence_orig = bsddb._db.DBSequence def do_proxy_db_py3k(flag) : flag2 = do_proxy_db_py3k.flag do_proxy_db_py3k.flag = flag if flag : bsddb.DBEnv = bsddb.db.DBEnv = bsddb._db.DBEnv = DBEnv_py3k bsddb.DB = bsddb.db.DB = bsddb._db.DB = DB_py3k bsddb._db.DBSequence = DBSequence_py3k else : bsddb.DBEnv = bsddb.db.DBEnv = bsddb._db.DBEnv = bsddb._db.DBEnv_orig bsddb.DB = bsddb.db.DB = bsddb._db.DB = bsddb._db.DB_orig bsddb._db.DBSequence = bsddb._db.DBSequence_orig return flag2 do_proxy_db_py3k.flag = False do_proxy_db_py3k(True) from bsddb3 import db, dbtables, dbutils, dbshelve, \ hashopen, btopen, rnopen, dbobj if sys.version_info[0] < 3 : from test import test_support else : from test import support as test_support try: if sys.version_info[0] < 3 : from threading import Thread, currentThread del Thread, currentThread else : from threading import Thread, current_thread del Thread, current_thread have_threads = True except ImportError: have_threads = False verbose = 0 if 'verbose' in sys.argv: verbose = 1 sys.argv.remove('verbose') if 'silent' in sys.argv: # take care of old flag, just in case verbose = 0 sys.argv.remove('silent') def print_versions(): print print '-=' * 38 print db.DB_VERSION_STRING print 'bsddb.db.version(): %s' % (db.version(), ) if db.version() >= (5, 0) : print 'bsddb.db.full_version(): %s' %repr(db.full_version()) print 'bsddb.db.__version__: %s' % db.__version__ # Workaround for allowing generating an EGGs as a ZIP files. suffix="__" print 'py module: %s' % getattr(bsddb, "__file"+suffix) print 'extension module: %s' % getattr(bsddb, "__file"+suffix) print 'Test working dir: %s' % get_test_path_prefix() import platform print 'python version: %s %s' % \ (sys.version.replace("\r", "").replace("\n", ""), \ platform.architecture()[0]) print 'My pid: %s' % os.getpid() print '-=' * 38 def get_new_path(name) : get_new_path.mutex.acquire() try : import os path=os.path.join(get_new_path.prefix, name+"_"+str(os.getpid())+"_"+str(get_new_path.num)) get_new_path.num+=1 finally : get_new_path.mutex.release() return path def get_new_environment_path() : path=get_new_path("environment") import os try: os.makedirs(path,mode=0700) except os.error: test_support.rmtree(path) os.makedirs(path) return path def get_new_database_path() : path=get_new_path("database") import os if os.path.exists(path) : os.remove(path) return path # This path can be overriden via "set_test_path_prefix()". import os, os.path get_new_path.prefix=os.path.join(os.environ.get("TMPDIR", os.path.join(os.sep,"tmp")), "z-Berkeley_DB") get_new_path.num=0 def get_test_path_prefix() : return get_new_path.prefix def set_test_path_prefix(path) : get_new_path.prefix=path def remove_test_path_directory() : test_support.rmtree(get_new_path.prefix) if have_threads : import threading get_new_path.mutex=threading.Lock() del threading else : class Lock(object) : def acquire(self) : pass def release(self) : pass get_new_path.mutex=Lock() del Lock class PrintInfoFakeTest(unittest.TestCase): def testPrintVersions(self): print_versions() # This little hack is for when this module is run as main and all the # other modules import it so they will still be able to get the right # verbose setting. It's confusing but it works. if sys.version_info[0] < 3 : import test_all test_all.verbose = verbose else : import sys print >>sys.stderr, "Work to do!" def suite(module_prefix='', timing_check=None): test_modules = [ 'test_associate', 'test_basics', 'test_dbenv', 'test_db', 'test_compare', 'test_compat', 'test_cursor_pget_bug', 'test_dbobj', 'test_dbshelve', 'test_dbtables', 'test_distributed_transactions', 'test_early_close', 'test_fileid', 'test_get_none', 'test_join', 'test_lock', 'test_misc', 'test_pickle', 'test_queue', 'test_recno', 'test_replication', 'test_sequence', 'test_thread', ] alltests = unittest.TestSuite() for name in test_modules: #module = __import__(name) # Do it this way so that suite may be called externally via # python's Lib/test/test_bsddb3. module = __import__(module_prefix+name, globals(), locals(), name) alltests.addTest(module.test_suite()) if timing_check: alltests.addTest(unittest.makeSuite(timing_check)) return alltests def test_suite(): suite = unittest.TestSuite() suite.addTest(unittest.makeSuite(PrintInfoFakeTest)) return suite if __name__ == '__main__': print_versions() unittest.main(defaultTest='suite') bsddb3-6.2.7/Lib/bsddb/test/test_associate.py0000664000175000017500000004033413617051124020652 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """ TestCases for DB.associate. """ import sys, os, string import time from pprint import pprint import unittest from test_all import db, dbshelve, test_support, verbose, have_threads, \ get_new_environment_path #---------------------------------------------------------------------- musicdata = { 1 : ("Bad English", "The Price Of Love", "Rock"), 2 : ("DNA featuring Suzanne Vega", "Tom's Diner", "Rock"), 3 : ("George Michael", "Praying For Time", "Rock"), 4 : ("Gloria Estefan", "Here We Are", "Rock"), 5 : ("Linda Ronstadt", "Don't Know Much", "Rock"), 6 : ("Michael Bolton", "How Am I Supposed To Live Without You", "Blues"), 7 : ("Paul Young", "Oh Girl", "Rock"), 8 : ("Paula Abdul", "Opposites Attract", "Rock"), 9 : ("Richard Marx", "Should've Known Better", "Rock"), 10: ("Rod Stewart", "Forever Young", "Rock"), 11: ("Roxette", "Dangerous", "Rock"), 12: ("Sheena Easton", "The Lover In Me", "Rock"), 13: ("Sinead O'Connor", "Nothing Compares 2 U", "Rock"), 14: ("Stevie B.", "Because I Love You", "Rock"), 15: ("Taylor Dayne", "Love Will Lead You Back", "Rock"), 16: ("The Bangles", "Eternal Flame", "Rock"), 17: ("Wilson Phillips", "Release Me", "Rock"), 18: ("Billy Joel", "Blonde Over Blue", "Rock"), 19: ("Billy Joel", "Famous Last Words", "Rock"), 20: ("Billy Joel", "Lullabye (Goodnight, My Angel)", "Rock"), 21: ("Billy Joel", "The River Of Dreams", "Rock"), 22: ("Billy Joel", "Two Thousand Years", "Rock"), 23: ("Janet Jackson", "Alright", "Rock"), 24: ("Janet Jackson", "Black Cat", "Rock"), 25: ("Janet Jackson", "Come Back To Me", "Rock"), 26: ("Janet Jackson", "Escapade", "Rock"), 27: ("Janet Jackson", "Love Will Never Do (Without You)", "Rock"), 28: ("Janet Jackson", "Miss You Much", "Rock"), 29: ("Janet Jackson", "Rhythm Nation", "Rock"), 30: ("Janet Jackson", "State Of The World", "Rock"), 31: ("Janet Jackson", "The Knowledge", "Rock"), 32: ("Spyro Gyra", "End of Romanticism", "Jazz"), 33: ("Spyro Gyra", "Heliopolis", "Jazz"), 34: ("Spyro Gyra", "Jubilee", "Jazz"), 35: ("Spyro Gyra", "Little Linda", "Jazz"), 36: ("Spyro Gyra", "Morning Dance", "Jazz"), 37: ("Spyro Gyra", "Song for Lorraine", "Jazz"), 38: ("Yes", "Owner Of A Lonely Heart", "Rock"), 39: ("Yes", "Rhythm Of Love", "Rock"), 40: ("Cusco", "Dream Catcher", "New Age"), 41: ("Cusco", "Geronimos Laughter", "New Age"), 42: ("Cusco", "Ghost Dance", "New Age"), 43: ("Blue Man Group", "Drumbone", "New Age"), 44: ("Blue Man Group", "Endless Column", "New Age"), 45: ("Blue Man Group", "Klein Mandelbrot", "New Age"), 46: ("Kenny G", "Silhouette", "Jazz"), 47: ("Sade", "Smooth Operator", "Jazz"), 48: ("David Arkenstone", "Papillon (On The Wings Of The Butterfly)", "New Age"), 49: ("David Arkenstone", "Stepping Stars", "New Age"), 50: ("David Arkenstone", "Carnation Lily Lily Rose", "New Age"), 51: ("David Lanz", "Behind The Waterfall", "New Age"), 52: ("David Lanz", "Cristofori's Dream", "New Age"), 53: ("David Lanz", "Heartsounds", "New Age"), 54: ("David Lanz", "Leaves on the Seine", "New Age"), 99: ("unknown artist", "Unnamed song", "Unknown"), } #---------------------------------------------------------------------- class AssociateErrorTestCase(unittest.TestCase): def setUp(self): self.filename = self.__class__.__name__ + '.db' self.homeDir = get_new_environment_path() self.env = db.DBEnv() self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL) def tearDown(self): self.env.close() self.env = None test_support.rmtree(self.homeDir) def test00_associateDBError(self): if verbose: print '\n', '-=' * 30 print "Running %s.test00_associateDBError..." % \ self.__class__.__name__ dupDB = db.DB(self.env) dupDB.set_flags(db.DB_DUP) dupDB.open(self.filename, "primary", db.DB_BTREE, db.DB_CREATE) secDB = db.DB(self.env) secDB.open(self.filename, "secondary", db.DB_BTREE, db.DB_CREATE) # dupDB has been configured to allow duplicates, it can't # associate with a secondary. Berkeley DB will return an error. try: def f(a,b): return a+b dupDB.associate(secDB, f) except db.DBError: # good secDB.close() dupDB.close() else: secDB.close() dupDB.close() self.fail("DBError exception was expected") #---------------------------------------------------------------------- class AssociateTestCase(unittest.TestCase): keytype = '' envFlags = 0 dbFlags = 0 def setUp(self): self.filename = self.__class__.__name__ + '.db' self.homeDir = get_new_environment_path() self.env = db.DBEnv() self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL | db.DB_INIT_LOCK | db.DB_THREAD | self.envFlags) def tearDown(self): self.closeDB() self.env.close() self.env = None test_support.rmtree(self.homeDir) def addDataToDB(self, d, txn=None): for key, value in musicdata.items(): if type(self.keytype) == type(''): key = "%02d" % key d.put(key, '|'.join(value), txn=txn) def createDB(self, txn=None): self.cur = None self.secDB = None self.primary = db.DB(self.env) self.primary.set_get_returns_none(2) self.primary.open(self.filename, "primary", self.dbtype, db.DB_CREATE | db.DB_THREAD | self.dbFlags, txn=txn) def closeDB(self): if self.cur: self.cur.close() self.cur = None if self.secDB: self.secDB.close() self.secDB = None self.primary.close() self.primary = None def getDB(self): return self.primary def _associateWithDB(self, getGenre): self.createDB() self.secDB = db.DB(self.env) self.secDB.set_flags(db.DB_DUP) self.secDB.set_get_returns_none(2) self.secDB.open(self.filename, "secondary", db.DB_BTREE, db.DB_CREATE | db.DB_THREAD | self.dbFlags) self.getDB().associate(self.secDB, getGenre) self.addDataToDB(self.getDB()) self.finish_test(self.secDB) def test01_associateWithDB(self): if verbose: print '\n', '-=' * 30 print "Running %s.test01_associateWithDB..." % \ self.__class__.__name__ return self._associateWithDB(self.getGenre) def _associateAfterDB(self, getGenre) : self.createDB() self.addDataToDB(self.getDB()) self.secDB = db.DB(self.env) self.secDB.set_flags(db.DB_DUP) self.secDB.open(self.filename, "secondary", db.DB_BTREE, db.DB_CREATE | db.DB_THREAD | self.dbFlags) # adding the DB_CREATE flag will cause it to index existing records self.getDB().associate(self.secDB, getGenre, db.DB_CREATE) self.finish_test(self.secDB) def test02_associateAfterDB(self): if verbose: print '\n', '-=' * 30 print "Running %s.test02_associateAfterDB..." % \ self.__class__.__name__ return self._associateAfterDB(self.getGenre) def test03_associateWithDB(self): if verbose: print '\n', '-=' * 30 print "Running %s.test03_associateWithDB..." % \ self.__class__.__name__ return self._associateWithDB(self.getGenreList) def test04_associateAfterDB(self): if verbose: print '\n', '-=' * 30 print "Running %s.test04_associateAfterDB..." % \ self.__class__.__name__ return self._associateAfterDB(self.getGenreList) def finish_test(self, secDB, txn=None): # 'Blues' should not be in the secondary database vals = secDB.pget('Blues', txn=txn) self.assertEqual(vals, None, vals) vals = secDB.pget('Unknown', txn=txn) self.assertTrue(vals[0] == 99 or vals[0] == '99', vals) vals[1].index('Unknown') vals[1].index('Unnamed') vals[1].index('unknown') if verbose: print "Primary key traversal:" self.cur = self.getDB().cursor(txn) count = 0 rec = self.cur.first() while rec is not None: if type(self.keytype) == type(''): self.assertTrue(int(rec[0])) # for primary db, key is a number else: self.assertTrue(rec[0] and type(rec[0]) == type(0)) count = count + 1 if verbose: print rec rec = getattr(self.cur, "next")() self.assertEqual(count, len(musicdata)) # all items accounted for if verbose: print "Secondary key traversal:" self.cur = secDB.cursor(txn) count = 0 # test cursor pget vals = self.cur.pget('Unknown', flags=db.DB_LAST) self.assertTrue(vals[1] == 99 or vals[1] == '99', vals) self.assertEqual(vals[0], 'Unknown') vals[2].index('Unknown') vals[2].index('Unnamed') vals[2].index('unknown') vals = self.cur.pget('Unknown', data='wrong value', flags=db.DB_GET_BOTH) self.assertEqual(vals, None, vals) rec = self.cur.first() self.assertEqual(rec[0], "Jazz") while rec is not None: count = count + 1 if verbose: print rec rec = getattr(self.cur, "next")() # all items accounted for EXCEPT for 1 with "Blues" genre self.assertEqual(count, len(musicdata)-1) self.cur = None def getGenre(self, priKey, priData): self.assertEqual(type(priData), type("")) genre = priData.split('|')[2] if verbose: print 'getGenre key: %r data: %r' % (priKey, priData) if genre == 'Blues': return db.DB_DONOTINDEX else: return genre def getGenreList(self, priKey, PriData) : v = self.getGenre(priKey, PriData) if type(v) == type("") : v = [v] return v #---------------------------------------------------------------------- class AssociateHashTestCase(AssociateTestCase): dbtype = db.DB_HASH class AssociateBTreeTestCase(AssociateTestCase): dbtype = db.DB_BTREE class AssociateRecnoTestCase(AssociateTestCase): dbtype = db.DB_RECNO keytype = 0 #---------------------------------------------------------------------- class AssociateBTreeTxnTestCase(AssociateBTreeTestCase): envFlags = db.DB_INIT_TXN dbFlags = 0 def txn_finish_test(self, sDB, txn): try: self.finish_test(sDB, txn=txn) finally: if self.cur: self.cur.close() self.cur = None if txn: txn.commit() def test13_associate_in_transaction(self): if verbose: print '\n', '-=' * 30 print "Running %s.test13_associateAutoCommit..." % \ self.__class__.__name__ txn = self.env.txn_begin() try: self.createDB(txn=txn) self.secDB = db.DB(self.env) self.secDB.set_flags(db.DB_DUP) self.secDB.set_get_returns_none(2) self.secDB.open(self.filename, "secondary", db.DB_BTREE, db.DB_CREATE | db.DB_THREAD, txn=txn) self.getDB().associate(self.secDB, self.getGenre, txn=txn) self.addDataToDB(self.getDB(), txn=txn) except: txn.abort() raise self.txn_finish_test(self.secDB, txn=txn) #---------------------------------------------------------------------- class ShelveAssociateTestCase(AssociateTestCase): def createDB(self): self.primary = dbshelve.open(self.filename, dbname="primary", dbenv=self.env, filetype=self.dbtype) def addDataToDB(self, d): for key, value in musicdata.items(): if type(self.keytype) == type(''): key = "%02d" % key d.put(key, value) # save the value as is this time def getGenre(self, priKey, priData): self.assertEqual(type(priData), type(())) if verbose: print 'getGenre key: %r data: %r' % (priKey, priData) genre = priData[2] if genre == 'Blues': return db.DB_DONOTINDEX else: return genre class ShelveAssociateHashTestCase(ShelveAssociateTestCase): dbtype = db.DB_HASH class ShelveAssociateBTreeTestCase(ShelveAssociateTestCase): dbtype = db.DB_BTREE class ShelveAssociateRecnoTestCase(ShelveAssociateTestCase): dbtype = db.DB_RECNO keytype = 0 #---------------------------------------------------------------------- class ThreadedAssociateTestCase(AssociateTestCase): def addDataToDB(self, d): t1 = Thread(target = self.writer1, args = (d, )) t2 = Thread(target = self.writer2, args = (d, )) t1.setDaemon(True) t2.setDaemon(True) t1.start() t2.start() t1.join() t2.join() def writer1(self, d): for key, value in musicdata.items(): if type(self.keytype) == type(''): key = "%02d" % key d.put(key, '|'.join(value)) def writer2(self, d): for x in range(100, 600): key = 'z%2d' % x value = [key] * 4 d.put(key, '|'.join(value)) class ThreadedAssociateHashTestCase(ShelveAssociateTestCase): dbtype = db.DB_HASH class ThreadedAssociateBTreeTestCase(ShelveAssociateTestCase): dbtype = db.DB_BTREE class ThreadedAssociateRecnoTestCase(ShelveAssociateTestCase): dbtype = db.DB_RECNO keytype = 0 #---------------------------------------------------------------------- def test_suite(): suite = unittest.TestSuite() suite.addTest(unittest.makeSuite(AssociateErrorTestCase)) suite.addTest(unittest.makeSuite(AssociateHashTestCase)) suite.addTest(unittest.makeSuite(AssociateBTreeTestCase)) suite.addTest(unittest.makeSuite(AssociateRecnoTestCase)) suite.addTest(unittest.makeSuite(AssociateBTreeTxnTestCase)) suite.addTest(unittest.makeSuite(ShelveAssociateHashTestCase)) suite.addTest(unittest.makeSuite(ShelveAssociateBTreeTestCase)) suite.addTest(unittest.makeSuite(ShelveAssociateRecnoTestCase)) if have_threads: suite.addTest(unittest.makeSuite(ThreadedAssociateHashTestCase)) suite.addTest(unittest.makeSuite(ThreadedAssociateBTreeTestCase)) suite.addTest(unittest.makeSuite(ThreadedAssociateRecnoTestCase)) return suite if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib/bsddb/test/test_compare.py0000664000175000017500000004013513617051124020324 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """ TestCases for python DB duplicate and Btree key comparison function. """ import sys, os, re import test_all from cStringIO import StringIO import unittest from test_all import db, dbshelve, test_support, \ get_new_environment_path, get_new_database_path # Needed for python 3. "cmp" vanished in 3.0.1 def cmp(a, b) : if a==b : return 0 if a All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """TestCase for reseting File ID. """ import os import shutil import unittest from test_all import db, test_support, get_new_environment_path, get_new_database_path class FileidResetTestCase(unittest.TestCase): def setUp(self): self.db_path_1 = get_new_database_path() self.db_path_2 = get_new_database_path() self.db_env_path = get_new_environment_path() def test_fileid_reset(self): # create DB 1 self.db1 = db.DB() self.db1.open(self.db_path_1, dbtype=db.DB_HASH, flags=(db.DB_CREATE|db.DB_EXCL)) self.db1.put('spam', 'eggs') self.db1.close() shutil.copy(self.db_path_1, self.db_path_2) self.db2 = db.DB() self.db2.open(self.db_path_2, dbtype=db.DB_HASH) self.db2.put('spam', 'spam') self.db2.close() self.db_env = db.DBEnv() self.db_env.open(self.db_env_path, db.DB_CREATE|db.DB_INIT_MPOOL) # use fileid_reset() here self.db_env.fileid_reset(self.db_path_2) self.db1 = db.DB(self.db_env) self.db1.open(self.db_path_1, dbtype=db.DB_HASH, flags=db.DB_RDONLY) self.assertEqual(self.db1.get('spam'), 'eggs') self.db2 = db.DB(self.db_env) self.db2.open(self.db_path_2, dbtype=db.DB_HASH, flags=db.DB_RDONLY) self.assertEqual(self.db2.get('spam'), 'spam') self.db1.close() self.db2.close() self.db_env.close() def tearDown(self): test_support.unlink(self.db_path_1) test_support.unlink(self.db_path_2) test_support.rmtree(self.db_env_path) def test_suite(): suite = unittest.TestSuite() suite.addTest(unittest.makeSuite(FileidResetTestCase)) return suite if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib/bsddb/test/test_compat.py0000664000175000017500000001400613617051124020157 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """ Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import os, string import unittest from test_all import db, hashopen, btopen, rnopen, verbose, \ get_new_database_path class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = get_new_database_path() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = "The quick brown fox jumped over the lazy dog.".split() if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest self.assertEqual(getTest[1], 'quick', 'data mismatch!') rv = f.set_location(3) if rv != (3, 'brown'): self.fail('recno database set_location failed: '+repr(rv)) f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' # 'e' intentionally left out f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' start = f.set_location(f.first()[0]) if start != ('0', ''): self.fail("incorrect first() result: "+repr(start)) while 1: try: rec = f.next() except KeyError: self.assertEqual(rec, f.last(), 'Error, last <> last!') f.previous() break if verbose: print rec self.assertTrue(f.has_key('f'), 'Error, missing key!') # test that set_location() returns the next nearest key, value # on btree databases and raises KeyError on others. if factory == btopen: e = f.set_location('e') if e != ('f', 'Python'): self.fail('wrong key,value returned: '+repr(e)) else: try: e = f.set_location('e') except KeyError: pass else: self.fail("set_location on non-existent key did not raise KeyError") f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib/bsddb/test/test_db.py0000664000175000017500000001623213617051124017264 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ import unittest import os, glob from test_all import db, test_support, get_new_environment_path, \ get_new_database_path #---------------------------------------------------------------------- class DB(unittest.TestCase): def setUp(self): self.path = get_new_database_path() self.db = db.DB() def tearDown(self): self.db.close() del self.db test_support.unlink(self.path) class DB_general(DB) : def test_get_open_flags(self) : self.db.open(self.path, dbtype=db.DB_HASH, flags = db.DB_CREATE) self.assertEqual(db.DB_CREATE, self.db.get_open_flags()) def test_get_open_flags2(self) : self.db.open(self.path, dbtype=db.DB_HASH, flags = db.DB_CREATE | db.DB_THREAD) self.assertEqual(db.DB_CREATE | db.DB_THREAD, self.db.get_open_flags()) def test_get_dbname_filename(self) : self.db.open(self.path, dbtype=db.DB_HASH, flags = db.DB_CREATE) self.assertEqual((self.path, None), self.db.get_dbname()) def test_get_dbname_filename_database(self) : name = "jcea-random-name" self.db.open(self.path, dbname=name, dbtype=db.DB_HASH, flags = db.DB_CREATE) self.assertEqual((self.path, name), self.db.get_dbname()) def test_bt_minkey(self) : for i in [17, 108, 1030] : self.db.set_bt_minkey(i) self.assertEqual(i, self.db.get_bt_minkey()) def test_lorder(self) : self.db.set_lorder(1234) self.assertEqual(1234, self.db.get_lorder()) self.db.set_lorder(4321) self.assertEqual(4321, self.db.get_lorder()) self.assertRaises(db.DBInvalidArgError, self.db.set_lorder, 9182) def test_priority(self) : flags = [db.DB_PRIORITY_VERY_LOW, db.DB_PRIORITY_LOW, db.DB_PRIORITY_DEFAULT, db.DB_PRIORITY_HIGH, db.DB_PRIORITY_VERY_HIGH] for flag in flags : self.db.set_priority(flag) self.assertEqual(flag, self.db.get_priority()) def test_get_transactional(self) : self.assertFalse(self.db.get_transactional()) self.db.open(self.path, dbtype=db.DB_HASH, flags = db.DB_CREATE) self.assertFalse(self.db.get_transactional()) class DB_hash(DB) : def test_h_ffactor(self) : for ffactor in [4, 16, 256] : self.db.set_h_ffactor(ffactor) self.assertEqual(ffactor, self.db.get_h_ffactor()) def test_h_nelem(self) : for nelem in [1, 2, 4] : nelem = nelem*1024*1024 # Millions self.db.set_h_nelem(nelem) self.assertEqual(nelem, self.db.get_h_nelem()) def test_pagesize(self) : for i in xrange(9, 17) : # From 512 to 65536 i = 1< All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """ TestCases for checking dbShelve objects. """ import os, string, sys import random import unittest from test_all import db, dbshelve, test_support, verbose, \ get_new_environment_path, get_new_database_path #---------------------------------------------------------------------- # We want the objects to be comparable so we can test dbshelve.values # later on. class DataClass: def __init__(self): self.value = random.random() def __repr__(self) : # For Python 3.0 comparison return "DataClass %f" %self.value def __cmp__(self, other): # For Python 2.x comparison return cmp(self.value, other) class DBShelveTestCase(unittest.TestCase): if sys.version_info < (2, 7) : def assertIn(self, a, b, msg=None) : return self.assertTrue(a in b, msg=msg) def setUp(self): if sys.version_info[0] >= 3 : from test_all import do_proxy_db_py3k self._flag_proxy_db_py3k = do_proxy_db_py3k(False) self.filename = get_new_database_path() self.do_open() def tearDown(self): if sys.version_info[0] >= 3 : from test_all import do_proxy_db_py3k do_proxy_db_py3k(self._flag_proxy_db_py3k) self.do_close() test_support.unlink(self.filename) def mk(self, key): """Turn key into an appropriate key type for this db""" # override in child class for RECNO if sys.version_info[0] < 3 : return key else : return bytes(key, "iso8859-1") # 8 bits def populateDB(self, d): for x in string.ascii_letters: d[self.mk('S' + x)] = 10 * x # add a string d[self.mk('I' + x)] = ord(x) # add an integer d[self.mk('L' + x)] = [x] * 10 # add a list inst = DataClass() # add an instance inst.S = 10 * x inst.I = ord(x) inst.L = [x] * 10 d[self.mk('O' + x)] = inst # overridable in derived classes to affect how the shelf is created/opened def do_open(self): self.d = dbshelve.open(self.filename) # and closed... def do_close(self): self.d.close() def test01_basics(self): if verbose: print '\n', '-=' * 30 print "Running %s.test01_basics..." % self.__class__.__name__ self.populateDB(self.d) self.d.sync() self.do_close() self.do_open() d = self.d l = len(d) k = d.keys() s = d.stat() f = d.fd() if verbose: print "length:", l print "keys:", k print "stats:", s self.assertEqual(0, d.has_key(self.mk('bad key'))) self.assertEqual(1, d.has_key(self.mk('IA'))) self.assertEqual(1, d.has_key(self.mk('OA'))) d.delete(self.mk('IA')) del d[self.mk('OA')] self.assertEqual(0, d.has_key(self.mk('IA'))) self.assertEqual(0, d.has_key(self.mk('OA'))) self.assertEqual(len(d), l-2) values = [] for key in d.keys(): value = d[key] values.append(value) if verbose: print "%s: %s" % (key, value) self.checkrec(key, value) dbvalues = d.values() self.assertEqual(len(dbvalues), len(d.keys())) # XXX: Convert all to strings. Please, improve values.sort(key=lambda x : str(x)) dbvalues.sort(key=lambda x : str(x)) self.assertEqual(repr(values), repr(dbvalues)) items = d.items() self.assertEqual(len(items), len(values)) for key, value in items: self.checkrec(key, value) self.assertEqual(d.get(self.mk('bad key')), None) self.assertEqual(d.get(self.mk('bad key'), None), None) self.assertEqual(d.get(self.mk('bad key'), 'a string'), 'a string') self.assertEqual(d.get(self.mk('bad key'), [1, 2, 3]), [1, 2, 3]) d.set_get_returns_none(0) self.assertRaises(db.DBNotFoundError, d.get, self.mk('bad key')) d.set_get_returns_none(1) d.put(self.mk('new key'), 'new data') self.assertEqual(d.get(self.mk('new key')), 'new data') self.assertEqual(d[self.mk('new key')], 'new data') def test02_cursors(self): if verbose: print '\n', '-=' * 30 print "Running %s.test02_cursors..." % self.__class__.__name__ self.populateDB(self.d) d = self.d count = 0 c = d.cursor() rec = c.first() while rec is not None: count = count + 1 if verbose: print rec key, value = rec self.checkrec(key, value) # Hack to avoid conversion by 2to3 tool rec = getattr(c, "next")() del c self.assertEqual(count, len(d)) count = 0 c = d.cursor() rec = c.last() while rec is not None: count = count + 1 if verbose: print rec key, value = rec self.checkrec(key, value) rec = c.prev() self.assertEqual(count, len(d)) c.set(self.mk('SS')) key, value = c.current() self.checkrec(key, value) del c def test03_append(self): # NOTE: this is overridden in RECNO subclass, don't change its name. if verbose: print '\n', '-=' * 30 print "Running %s.test03_append..." % self.__class__.__name__ self.assertRaises(dbshelve.DBShelveError, self.d.append, 'unit test was here') def test04_iterable(self) : self.populateDB(self.d) d = self.d keys = d.keys() keyset = set(keys) self.assertEqual(len(keyset), len(keys)) for key in d : self.assertIn(key, keyset) keyset.remove(key) self.assertEqual(len(keyset), 0) def checkrec(self, key, value): # override this in a subclass if the key type is different if sys.version_info[0] >= 3 : if isinstance(key, bytes) : key = key.decode("iso8859-1") # 8 bits x = key[1] if key[0] == 'S': self.assertEqual(type(value), str) self.assertEqual(value, 10 * x) elif key[0] == 'I': self.assertEqual(type(value), int) self.assertEqual(value, ord(x)) elif key[0] == 'L': self.assertEqual(type(value), list) self.assertEqual(value, [x] * 10) elif key[0] == 'O': if sys.version_info[0] < 3 : from types import InstanceType self.assertEqual(type(value), InstanceType) else : self.assertEqual(type(value), DataClass) self.assertEqual(value.S, 10 * x) self.assertEqual(value.I, ord(x)) self.assertEqual(value.L, [x] * 10) else: self.assertTrue(0, 'Unknown key type, fix the test') #---------------------------------------------------------------------- class BasicShelveTestCase(DBShelveTestCase): def do_open(self): self.d = dbshelve.DBShelf() self.d.open(self.filename, self.dbtype, self.dbflags) def do_close(self): self.d.close() class BTreeShelveTestCase(BasicShelveTestCase): dbtype = db.DB_BTREE dbflags = db.DB_CREATE class HashShelveTestCase(BasicShelveTestCase): dbtype = db.DB_HASH dbflags = db.DB_CREATE class ThreadBTreeShelveTestCase(BasicShelveTestCase): dbtype = db.DB_BTREE dbflags = db.DB_CREATE | db.DB_THREAD class ThreadHashShelveTestCase(BasicShelveTestCase): dbtype = db.DB_HASH dbflags = db.DB_CREATE | db.DB_THREAD #---------------------------------------------------------------------- class BasicEnvShelveTestCase(DBShelveTestCase): def do_open(self): self.env = db.DBEnv() self.env.open(self.homeDir, self.envflags | db.DB_INIT_MPOOL | db.DB_CREATE) self.filename = os.path.split(self.filename)[1] self.d = dbshelve.DBShelf(self.env) self.d.open(self.filename, self.dbtype, self.dbflags) def do_close(self): self.d.close() self.env.close() def setUp(self) : self.homeDir = get_new_environment_path() DBShelveTestCase.setUp(self) def tearDown(self): if sys.version_info[0] >= 3 : from test_all import do_proxy_db_py3k do_proxy_db_py3k(self._flag_proxy_db_py3k) self.do_close() test_support.rmtree(self.homeDir) class EnvBTreeShelveTestCase(BasicEnvShelveTestCase): envflags = 0 dbtype = db.DB_BTREE dbflags = db.DB_CREATE class EnvHashShelveTestCase(BasicEnvShelveTestCase): envflags = 0 dbtype = db.DB_HASH dbflags = db.DB_CREATE class EnvThreadBTreeShelveTestCase(BasicEnvShelveTestCase): envflags = db.DB_THREAD dbtype = db.DB_BTREE dbflags = db.DB_CREATE | db.DB_THREAD class EnvThreadHashShelveTestCase(BasicEnvShelveTestCase): envflags = db.DB_THREAD dbtype = db.DB_HASH dbflags = db.DB_CREATE | db.DB_THREAD #---------------------------------------------------------------------- # test cases for a DBShelf in a RECNO DB. class RecNoShelveTestCase(BasicShelveTestCase): dbtype = db.DB_RECNO dbflags = db.DB_CREATE def setUp(self): BasicShelveTestCase.setUp(self) # pool to assign integer key values out of self.key_pool = list(range(1, 5000)) self.key_map = {} # map string keys to the number we gave them self.intkey_map = {} # reverse map of above def mk(self, key): if key not in self.key_map: self.key_map[key] = self.key_pool.pop(0) self.intkey_map[self.key_map[key]] = key return self.key_map[key] def checkrec(self, intkey, value): key = self.intkey_map[intkey] BasicShelveTestCase.checkrec(self, key, value) def test03_append(self): if verbose: print '\n', '-=' * 30 print "Running %s.test03_append..." % self.__class__.__name__ self.d[1] = 'spam' self.d[5] = 'eggs' self.assertEqual(6, self.d.append('spam')) self.assertEqual(7, self.d.append('baked beans')) self.assertEqual('spam', self.d.get(6)) self.assertEqual('spam', self.d.get(1)) self.assertEqual('baked beans', self.d.get(7)) self.assertEqual('eggs', self.d.get(5)) #---------------------------------------------------------------------- def test_suite(): suite = unittest.TestSuite() suite.addTest(unittest.makeSuite(DBShelveTestCase)) suite.addTest(unittest.makeSuite(BTreeShelveTestCase)) suite.addTest(unittest.makeSuite(HashShelveTestCase)) suite.addTest(unittest.makeSuite(ThreadBTreeShelveTestCase)) suite.addTest(unittest.makeSuite(ThreadHashShelveTestCase)) suite.addTest(unittest.makeSuite(EnvBTreeShelveTestCase)) suite.addTest(unittest.makeSuite(EnvHashShelveTestCase)) suite.addTest(unittest.makeSuite(EnvThreadBTreeShelveTestCase)) suite.addTest(unittest.makeSuite(EnvThreadHashShelveTestCase)) suite.addTest(unittest.makeSuite(RecNoShelveTestCase)) return suite if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib/bsddb/test/test_lock.py0000664000175000017500000001720613617051124017631 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """ TestCases for testing the locking sub-system. """ import time import unittest from test_all import db, test_support, verbose, have_threads, \ get_new_environment_path, get_new_database_path if have_threads : from threading import Thread import sys if sys.version_info[0] < 3 : from threading import currentThread else : from threading import current_thread as currentThread #---------------------------------------------------------------------- class LockingTestCase(unittest.TestCase): def setUp(self): self.homeDir = get_new_environment_path() self.env = db.DBEnv() self.env.open(self.homeDir, db.DB_THREAD | db.DB_INIT_MPOOL | db.DB_INIT_LOCK | db.DB_CREATE) def tearDown(self): self.env.close() test_support.rmtree(self.homeDir) def test01_simple(self): if verbose: print '\n', '-=' * 30 print "Running %s.test01_simple..." % self.__class__.__name__ anID = self.env.lock_id() if verbose: print "locker ID: %s" % anID lock = self.env.lock_get(anID, "some locked thing", db.DB_LOCK_WRITE) if verbose: print "Aquired lock: %s" % lock self.env.lock_put(lock) if verbose: print "Released lock: %s" % lock self.env.lock_id_free(anID) def test02_threaded(self): if verbose: print '\n', '-=' * 30 print "Running %s.test02_threaded..." % self.__class__.__name__ threads = [] threads.append(Thread(target = self.theThread, args=(db.DB_LOCK_WRITE,))) threads.append(Thread(target = self.theThread, args=(db.DB_LOCK_READ,))) threads.append(Thread(target = self.theThread, args=(db.DB_LOCK_READ,))) threads.append(Thread(target = self.theThread, args=(db.DB_LOCK_WRITE,))) threads.append(Thread(target = self.theThread, args=(db.DB_LOCK_READ,))) threads.append(Thread(target = self.theThread, args=(db.DB_LOCK_READ,))) threads.append(Thread(target = self.theThread, args=(db.DB_LOCK_WRITE,))) threads.append(Thread(target = self.theThread, args=(db.DB_LOCK_WRITE,))) threads.append(Thread(target = self.theThread, args=(db.DB_LOCK_WRITE,))) for t in threads: import sys if sys.version_info[0] < 3 : t.setDaemon(True) else : t.daemon = True t.start() for t in threads: t.join() def test03_lock_timeout(self): self.env.set_timeout(0, db.DB_SET_LOCK_TIMEOUT) self.assertEqual(self.env.get_timeout(db.DB_SET_LOCK_TIMEOUT), 0) self.env.set_timeout(0, db.DB_SET_TXN_TIMEOUT) self.assertEqual(self.env.get_timeout(db.DB_SET_TXN_TIMEOUT), 0) self.env.set_timeout(123456, db.DB_SET_LOCK_TIMEOUT) self.assertEqual(self.env.get_timeout(db.DB_SET_LOCK_TIMEOUT), 123456) self.env.set_timeout(7890123, db.DB_SET_TXN_TIMEOUT) self.assertEqual(self.env.get_timeout(db.DB_SET_TXN_TIMEOUT), 7890123) def test04_lock_timeout2(self): self.env.set_timeout(0, db.DB_SET_LOCK_TIMEOUT) self.env.set_timeout(0, db.DB_SET_TXN_TIMEOUT) self.env.set_timeout(123456, db.DB_SET_LOCK_TIMEOUT) self.env.set_timeout(7890123, db.DB_SET_TXN_TIMEOUT) def deadlock_detection() : while not deadlock_detection.end : deadlock_detection.count = \ self.env.lock_detect(db.DB_LOCK_EXPIRE) if deadlock_detection.count : while not deadlock_detection.end : pass break time.sleep(0.01) deadlock_detection.end=False deadlock_detection.count=0 t=Thread(target=deadlock_detection) import sys if sys.version_info[0] < 3 : t.setDaemon(True) else : t.daemon = True t.start() self.env.set_timeout(100000, db.DB_SET_LOCK_TIMEOUT) anID = self.env.lock_id() anID2 = self.env.lock_id() self.assertNotEqual(anID, anID2) lock = self.env.lock_get(anID, "shared lock", db.DB_LOCK_WRITE) start_time=time.time() self.assertRaises(db.DBLockNotGrantedError, self.env.lock_get,anID2, "shared lock", db.DB_LOCK_READ) end_time=time.time() deadlock_detection.end=True # Floating point rounding self.assertTrue((end_time-start_time) >= 0.0999) self.env.lock_put(lock) t.join() self.env.lock_id_free(anID) self.env.lock_id_free(anID2) self.assertTrue(deadlock_detection.count>0) def theThread(self, lockType): import sys if sys.version_info[0] < 3 : name = currentThread().getName() else : name = currentThread().name if lockType == db.DB_LOCK_WRITE: lt = "write" else: lt = "read" anID = self.env.lock_id() if verbose: print "%s: locker ID: %s" % (name, anID) for i in xrange(1000) : lock = self.env.lock_get(anID, "some locked thing", lockType) if verbose: print "%s: Aquired %s lock: %s" % (name, lt, lock) self.env.lock_put(lock) if verbose: print "%s: Released %s lock: %s" % (name, lt, lock) self.env.lock_id_free(anID) #---------------------------------------------------------------------- def test_suite(): suite = unittest.TestSuite() if have_threads: suite.addTest(unittest.makeSuite(LockingTestCase)) else: suite.addTest(unittest.makeSuite(LockingTestCase, 'test01')) return suite if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib/bsddb/test/test_early_close.py0000664000175000017500000001767413617051124021213 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """TestCases for checking that it does not segfault when a DBEnv object is closed before its DB objects. """ import os, sys import unittest from test_all import db, test_support, verbose, get_new_environment_path, get_new_database_path # We're going to get warnings in this module about trying to close the db when # its env is already closed. Let's just ignore those. try: import warnings except ImportError: pass else: warnings.filterwarnings('ignore', message='DB could not be closed in', category=RuntimeWarning) #---------------------------------------------------------------------- class DBEnvClosedEarlyCrash(unittest.TestCase): def setUp(self): self.homeDir = get_new_environment_path() self.filename = "test" def tearDown(self): test_support.rmtree(self.homeDir) def test01_close_dbenv_before_db(self): dbenv = db.DBEnv() dbenv.open(self.homeDir, db.DB_INIT_CDB| db.DB_CREATE |db.DB_THREAD|db.DB_INIT_MPOOL, 0666) d = db.DB(dbenv) d2 = db.DB(dbenv) d.open(self.filename, db.DB_BTREE, db.DB_CREATE | db.DB_THREAD, 0666) self.assertRaises(db.DBNoSuchFileError, d2.open, self.filename+"2", db.DB_BTREE, db.DB_THREAD, 0666) d.put("test","this is a test") self.assertEqual(d.get("test"), "this is a test", "put!=get") dbenv.close() # This "close" should close the child db handle also self.assertRaises(db.DBError, d.get, "test") def test02_close_dbenv_before_dbcursor(self): dbenv = db.DBEnv() dbenv.open(self.homeDir, db.DB_INIT_CDB| db.DB_CREATE |db.DB_THREAD|db.DB_INIT_MPOOL, 0666) d = db.DB(dbenv) d.open(self.filename, db.DB_BTREE, db.DB_CREATE | db.DB_THREAD, 0666) d.put("test","this is a test") d.put("test2","another test") d.put("test3","another one") self.assertEqual(d.get("test"), "this is a test", "put!=get") c=d.cursor() c.first() c.next() d.close() # This "close" should close the child db handle also # db.close should close the child cursor self.assertRaises(db.DBError,c.next) d = db.DB(dbenv) d.open(self.filename, db.DB_BTREE, db.DB_CREATE | db.DB_THREAD, 0666) c=d.cursor() c.first() c.next() dbenv.close() # The "close" should close the child db handle also, with cursors self.assertRaises(db.DBError, c.next) def test03_close_db_before_dbcursor_without_env(self): import os.path path=os.path.join(self.homeDir,self.filename) d = db.DB() d.open(path, db.DB_BTREE, db.DB_CREATE | db.DB_THREAD, 0666) d.put("test","this is a test") d.put("test2","another test") d.put("test3","another one") self.assertEqual(d.get("test"), "this is a test", "put!=get") c=d.cursor() c.first() c.next() d.close() # The "close" should close the child db handle also self.assertRaises(db.DBError, c.next) def test04_close_massive(self): dbenv = db.DBEnv() dbenv.open(self.homeDir, db.DB_INIT_CDB| db.DB_CREATE |db.DB_THREAD|db.DB_INIT_MPOOL, 0666) dbs=[db.DB(dbenv) for i in xrange(16)] cursors=[] for i in dbs : i.open(self.filename, db.DB_BTREE, db.DB_CREATE | db.DB_THREAD, 0666) dbs[10].put("test","this is a test") dbs[10].put("test2","another test") dbs[10].put("test3","another one") self.assertEqual(dbs[4].get("test"), "this is a test", "put!=get") for i in dbs : cursors.extend([i.cursor() for j in xrange(32)]) for i in dbs[::3] : i.close() for i in cursors[::3] : i.close() # Check for missing exception in DB! (after DB close) self.assertRaises(db.DBError, dbs[9].get, "test") # Check for missing exception in DBCursor! (after DB close) self.assertRaises(db.DBError, cursors[101].first) cursors[80].first() cursors[80].next() dbenv.close() # This "close" should close the child db handle also # Check for missing exception! (after DBEnv close) self.assertRaises(db.DBError, cursors[80].next) def test05_close_dbenv_delete_db_success(self): dbenv = db.DBEnv() dbenv.open(self.homeDir, db.DB_INIT_CDB| db.DB_CREATE |db.DB_THREAD|db.DB_INIT_MPOOL, 0666) d = db.DB(dbenv) d.open(self.filename, db.DB_BTREE, db.DB_CREATE | db.DB_THREAD, 0666) dbenv.close() # This "close" should close the child db handle also del d try: import gc except ImportError: gc = None if gc: # force d.__del__ [DB_dealloc] to be called gc.collect() def test06_close_txn_before_dup_cursor(self) : dbenv = db.DBEnv() dbenv.open(self.homeDir,db.DB_INIT_TXN | db.DB_INIT_MPOOL | db.DB_INIT_LOG | db.DB_CREATE) d = db.DB(dbenv) txn = dbenv.txn_begin() d.open(self.filename, dbtype = db.DB_HASH, flags = db.DB_CREATE, txn=txn) d.put("XXX", "yyy", txn=txn) txn.commit() txn = dbenv.txn_begin() c1 = d.cursor(txn) c2 = c1.dup() self.assertEqual(("XXX", "yyy"), c1.first()) # Not interested in warnings about implicit close. import warnings with warnings.catch_warnings() : warnings.filterwarnings("ignore") txn.commit() self.assertRaises(db.DBCursorClosedError, c2.first) def test07_close_db_before_sequence(self): import os.path path=os.path.join(self.homeDir,self.filename) d = db.DB() d.open(path, db.DB_BTREE, db.DB_CREATE | db.DB_THREAD, 0666) dbs=db.DBSequence(d) d.close() # This "close" should close the child DBSequence also dbs.close() # If not closed, core dump (in Berkeley DB 4.6.*) #---------------------------------------------------------------------- def test_suite(): suite = unittest.TestSuite() suite.addTest(unittest.makeSuite(DBEnvClosedEarlyCrash)) return suite if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib/bsddb/test/test_dbobj.py0000664000175000017500000000767113617051124017766 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ import os, string import unittest from test_all import db, dbobj, test_support, get_new_environment_path, \ get_new_database_path #---------------------------------------------------------------------- class dbobjTestCase(unittest.TestCase): """Verify that dbobj.DB and dbobj.DBEnv work properly""" db_name = 'test-dbobj.db' def setUp(self): self.homeDir = get_new_environment_path() def tearDown(self): if hasattr(self, 'db'): del self.db if hasattr(self, 'env'): del self.env test_support.rmtree(self.homeDir) def test01_both(self): class TestDBEnv(dbobj.DBEnv): pass class TestDB(dbobj.DB): def put(self, key, *args, **kwargs): key = key.upper() # call our parent classes put method with an upper case key return dbobj.DB.put(self, key, *args, **kwargs) self.env = TestDBEnv() self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL) self.db = TestDB(self.env) self.db.open(self.db_name, db.DB_HASH, db.DB_CREATE) self.db.put('spam', 'eggs') self.assertEqual(self.db.get('spam'), None, "overridden dbobj.DB.put() method failed [1]") self.assertEqual(self.db.get('SPAM'), 'eggs', "overridden dbobj.DB.put() method failed [2]") self.db.close() self.env.close() def test02_dbobj_dict_interface(self): self.env = dbobj.DBEnv() self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL) self.db = dbobj.DB(self.env) self.db.open(self.db_name+'02', db.DB_HASH, db.DB_CREATE) # __setitem__ self.db['spam'] = 'eggs' # __len__ self.assertEqual(len(self.db), 1) # __getitem__ self.assertEqual(self.db['spam'], 'eggs') # __del__ del self.db['spam'] self.assertEqual(self.db.get('spam'), None, "dbobj __del__ failed") self.db.close() self.env.close() def test03_dbobj_type_before_open(self): # Ensure this doesn't cause a segfault. self.assertRaises(db.DBInvalidArgError, db.DB().type) #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(dbobjTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib/bsddb/test/test_sequence.py0000664000175000017500000001525113617051124020507 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ import unittest import os from test_all import db, test_support, get_new_environment_path, get_new_database_path class DBSequenceTest(unittest.TestCase): def setUp(self): self.int_32_max = 0x100000000 self.homeDir = get_new_environment_path() self.filename = "test" self.dbenv = db.DBEnv() self.dbenv.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL, 0666) self.d = db.DB(self.dbenv) self.d.open(self.filename, db.DB_BTREE, db.DB_CREATE, 0666) def tearDown(self): if hasattr(self, 'seq'): self.seq.close() del self.seq if hasattr(self, 'd'): self.d.close() del self.d if hasattr(self, 'dbenv'): self.dbenv.close() del self.dbenv test_support.rmtree(self.homeDir) def test_get(self): self.seq = db.DBSequence(self.d, flags=0) start_value = 10 * self.int_32_max self.assertEqual(0xA00000000, start_value) self.assertEqual(None, self.seq.initial_value(start_value)) self.assertEqual(None, self.seq.open(key='id', txn=None, flags=db.DB_CREATE)) self.assertEqual(start_value, self.seq.get(5)) self.assertEqual(start_value + 5, self.seq.get()) def test_remove(self): self.seq = db.DBSequence(self.d, flags=0) self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE)) self.assertEqual(None, self.seq.remove(txn=None, flags=0)) del self.seq def test_get_key(self): self.seq = db.DBSequence(self.d, flags=0) key = 'foo' self.assertEqual(None, self.seq.open(key=key, txn=None, flags=db.DB_CREATE)) self.assertEqual(key, self.seq.get_key()) def test_get_dbp(self): self.seq = db.DBSequence(self.d, flags=0) self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE)) self.assertEqual(self.d, self.seq.get_dbp()) def test_cachesize(self): self.seq = db.DBSequence(self.d, flags=0) cashe_size = 10 self.assertEqual(None, self.seq.set_cachesize(cashe_size)) self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE)) self.assertEqual(cashe_size, self.seq.get_cachesize()) def test_flags(self): self.seq = db.DBSequence(self.d, flags=0) flag = db.DB_SEQ_WRAP; self.assertEqual(None, self.seq.set_flags(flag)) self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE)) self.assertEqual(flag, self.seq.get_flags() & flag) def test_range(self): self.seq = db.DBSequence(self.d, flags=0) seq_range = (10 * self.int_32_max, 11 * self.int_32_max - 1) self.assertEqual(None, self.seq.set_range(seq_range)) self.seq.initial_value(seq_range[0]) self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE)) self.assertEqual(seq_range, self.seq.get_range()) def test_stat(self): self.seq = db.DBSequence(self.d, flags=0) self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE)) stat = self.seq.stat() for param in ('nowait', 'min', 'max', 'value', 'current', 'flags', 'cache_size', 'last_value', 'wait'): self.assertTrue(param in stat, "parameter %s isn't in stat info" % param) # This code checks a crash solved in Berkeley DB 4.7 def test_stat_crash(self) : d=db.DB() d.open(None,dbtype=db.DB_HASH,flags=db.DB_CREATE) # In RAM seq = db.DBSequence(d, flags=0) self.assertRaises(db.DBNotFoundError, seq.open, key='id', txn=None, flags=0) self.assertRaises(db.DBInvalidArgError, seq.stat) d.close() def test_64bits(self) : # We don't use both extremes because they are problematic value_plus=(1L<<63)-2 self.assertEqual(9223372036854775806L,value_plus) value_minus=(-1L<<63)+1 # Two complement self.assertEqual(-9223372036854775807L,value_minus) self.seq = db.DBSequence(self.d, flags=0) self.assertEqual(None, self.seq.initial_value(value_plus-1)) self.assertEqual(None, self.seq.open(key='id', txn=None, flags=db.DB_CREATE)) self.assertEqual(value_plus-1, self.seq.get(1)) self.assertEqual(value_plus, self.seq.get(1)) self.seq.remove(txn=None, flags=0) self.seq = db.DBSequence(self.d, flags=0) self.assertEqual(None, self.seq.initial_value(value_minus)) self.assertEqual(None, self.seq.open(key='id', txn=None, flags=db.DB_CREATE)) self.assertEqual(value_minus, self.seq.get(1)) self.assertEqual(value_minus+1, self.seq.get(1)) def test_multiple_close(self): self.seq = db.DBSequence(self.d) self.seq.close() # You can close a Sequence multiple times self.seq.close() self.seq.close() def test_suite(): suite = unittest.TestSuite() suite.addTest(unittest.makeSuite(DBSequenceTest)) return suite if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib/bsddb/test/test_cursor_pget_bug.py0000664000175000017500000000664713617051124022101 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ import unittest import os, glob from test_all import db, test_support, get_new_environment_path, \ get_new_database_path #---------------------------------------------------------------------- class pget_bugTestCase(unittest.TestCase): """Verify that cursor.pget works properly""" db_name = 'test-cursor_pget.db' def setUp(self): self.homeDir = get_new_environment_path() self.env = db.DBEnv() self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL) self.primary_db = db.DB(self.env) self.primary_db.open(self.db_name, 'primary', db.DB_BTREE, db.DB_CREATE) self.secondary_db = db.DB(self.env) self.secondary_db.set_flags(db.DB_DUP) self.secondary_db.open(self.db_name, 'secondary', db.DB_BTREE, db.DB_CREATE) self.primary_db.associate(self.secondary_db, lambda key, data: data) self.primary_db.put('salad', 'eggs') self.primary_db.put('spam', 'ham') self.primary_db.put('omelet', 'eggs') def tearDown(self): self.secondary_db.close() self.primary_db.close() self.env.close() del self.secondary_db del self.primary_db del self.env test_support.rmtree(self.homeDir) def test_pget(self): cursor = self.secondary_db.cursor() self.assertEqual(('eggs', 'salad', 'eggs'), cursor.pget(key='eggs', flags=db.DB_SET)) self.assertEqual(('eggs', 'omelet', 'eggs'), cursor.pget(db.DB_NEXT_DUP)) self.assertEqual(None, cursor.pget(db.DB_NEXT_DUP)) self.assertEqual(('ham', 'spam', 'ham'), cursor.pget('ham', 'spam', flags=db.DB_SET)) self.assertEqual(None, cursor.pget(db.DB_NEXT_DUP)) cursor.close() def test_suite(): return unittest.makeSuite(pget_bugTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib/bsddb/test/test_basics.py0000664000175000017500000010701713617051124020145 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """ Basic TestCases for BTree and hash DBs, with and without a DBEnv, with various DB flags, etc. """ import os import errno import string from pprint import pprint import unittest import time import sys from test_all import db, test_support, verbose, get_new_environment_path, \ get_new_database_path DASH = '-' #---------------------------------------------------------------------- class VersionTestCase(unittest.TestCase): def test00_version(self): info = db.version() if verbose: print '\n', '-=' * 20 print 'bsddb.db.version(): %s' % (info, ) print db.DB_VERSION_STRING print '-=' * 20 self.assertEqual(info, (db.DB_VERSION_MAJOR, db.DB_VERSION_MINOR, db.DB_VERSION_PATCH)) #---------------------------------------------------------------------- class BasicTestCase(unittest.TestCase): dbtype = db.DB_UNKNOWN # must be set in derived class cachesize = (0, 1024*1024, 1) dbopenflags = 0 dbsetflags = 0 dbmode = 0660 dbname = None useEnv = 0 envflags = 0 envsetflags = 0 _numKeys = 1002 # PRIVATE. NOTE: must be an even value def setUp(self): if self.useEnv: self.homeDir=get_new_environment_path() try: self.env = db.DBEnv() self.env.set_lg_max(1024*1024) self.env.set_tx_max(30) self._t = int(time.time()) self.env.set_tx_timestamp(self._t) self.env.set_flags(self.envsetflags, 1) self.env.open(self.homeDir, self.envflags | db.DB_CREATE) self.filename = "test" # Yes, a bare except is intended, since we're re-raising the exc. except: test_support.rmtree(self.homeDir) raise else: self.env = None self.filename = get_new_database_path() # create and open the DB self.d = db.DB(self.env) if not self.useEnv : self.d.set_cachesize(*self.cachesize) cachesize = self.d.get_cachesize() self.assertEqual(cachesize[0], self.cachesize[0]) self.assertEqual(cachesize[2], self.cachesize[2]) # Berkeley DB expands the cache 25% accounting overhead, # if the cache is small. self.assertEqual(125, int(100.0*cachesize[1]/self.cachesize[1])) self.d.set_flags(self.dbsetflags) if self.dbname: self.d.open(self.filename, self.dbname, self.dbtype, self.dbopenflags|db.DB_CREATE, self.dbmode) else: self.d.open(self.filename, # try out keyword args mode = self.dbmode, dbtype = self.dbtype, flags = self.dbopenflags|db.DB_CREATE) if not self.useEnv: self.assertRaises(db.DBInvalidArgError, self.d.set_cachesize, *self.cachesize) self.populateDB() def tearDown(self): self.d.close() if self.env is not None: self.env.close() test_support.rmtree(self.homeDir) else: os.remove(self.filename) def populateDB(self, _txn=None): d = self.d for x in range(self._numKeys//2): key = '%04d' % (self._numKeys - x) # insert keys in reverse order data = self.makeData(key) d.put(key, data, _txn) d.put('empty value', '', _txn) for x in range(self._numKeys//2-1): key = '%04d' % x # and now some in forward order data = self.makeData(key) d.put(key, data, _txn) if _txn: _txn.commit() num = len(d) if verbose: print "created %d records" % num def makeData(self, key): return DASH.join([key] * 5) #---------------------------------------- def test01_GetsAndPuts(self): d = self.d if verbose: print '\n', '-=' * 30 print "Running %s.test01_GetsAndPuts..." % self.__class__.__name__ for key in ['0001', '0100', '0400', '0700', '0999']: data = d.get(key) if verbose: print data self.assertEqual(d.get('0321'), '0321-0321-0321-0321-0321') # By default non-existent keys return None... self.assertEqual(d.get('abcd'), None) # ...but they raise exceptions in other situations. Call # set_get_returns_none() to change it. try: d.delete('abcd') except db.DBNotFoundError, val: self.assertEqual(val.args[0], db.DB_NOTFOUND) if verbose: print val else: self.fail("expected exception") d.put('abcd', 'a new record') self.assertEqual(d.get('abcd'), 'a new record') d.put('abcd', 'same key') if self.dbsetflags & db.DB_DUP: self.assertEqual(d.get('abcd'), 'a new record') else: self.assertEqual(d.get('abcd'), 'same key') try: d.put('abcd', 'this should fail', flags=db.DB_NOOVERWRITE) except db.DBKeyExistError, val: self.assertEqual(val.args[0], db.DB_KEYEXIST) if verbose: print val else: self.fail("expected exception") if self.dbsetflags & db.DB_DUP: self.assertEqual(d.get('abcd'), 'a new record') else: self.assertEqual(d.get('abcd'), 'same key') d.sync() d.close() del d self.d = db.DB(self.env) if self.dbname: self.d.open(self.filename, self.dbname) else: self.d.open(self.filename) d = self.d self.assertEqual(d.get('0321'), '0321-0321-0321-0321-0321') if self.dbsetflags & db.DB_DUP: self.assertEqual(d.get('abcd'), 'a new record') else: self.assertEqual(d.get('abcd'), 'same key') rec = d.get_both('0555', '0555-0555-0555-0555-0555') if verbose: print rec self.assertEqual(d.get_both('0555', 'bad data'), None) # test default value data = d.get('bad key', 'bad data') self.assertEqual(data, 'bad data') # any object can pass through data = d.get('bad key', self) self.assertEqual(data, self) s = d.stat() self.assertEqual(type(s), type({})) if verbose: print 'd.stat() returned this dictionary:' pprint(s) #---------------------------------------- def test02_DictionaryMethods(self): d = self.d if verbose: print '\n', '-=' * 30 print "Running %s.test02_DictionaryMethods..." % \ self.__class__.__name__ for key in ['0002', '0101', '0401', '0701', '0998']: data = d[key] self.assertEqual(data, self.makeData(key)) if verbose: print data self.assertEqual(len(d), self._numKeys) keys = d.keys() self.assertEqual(len(keys), self._numKeys) self.assertEqual(type(keys), type([])) d['new record'] = 'a new record' self.assertEqual(len(d), self._numKeys+1) keys = d.keys() self.assertEqual(len(keys), self._numKeys+1) d['new record'] = 'a replacement record' self.assertEqual(len(d), self._numKeys+1) keys = d.keys() self.assertEqual(len(keys), self._numKeys+1) if verbose: print "the first 10 keys are:" pprint(keys[:10]) self.assertEqual(d['new record'], 'a replacement record') # We check also the positional parameter self.assertEqual(d.has_key('0001', None), 1) # We check also the keyword parameter self.assertEqual(d.has_key('spam', txn=None), 0) items = d.items() self.assertEqual(len(items), self._numKeys+1) self.assertEqual(type(items), type([])) self.assertEqual(type(items[0]), type(())) self.assertEqual(len(items[0]), 2) if verbose: print "the first 10 items are:" pprint(items[:10]) values = d.values() self.assertEqual(len(values), self._numKeys+1) self.assertEqual(type(values), type([])) if verbose: print "the first 10 values are:" pprint(values[:10]) #---------------------------------------- def test02b_SequenceMethods(self): d = self.d for key in ['0002', '0101', '0401', '0701', '0998']: data = d[key] self.assertEqual(data, self.makeData(key)) if verbose: print data self.assertTrue(hasattr(d, "__contains__")) self.assertTrue("0401" in d) self.assertFalse("1234" in d) #---------------------------------------- def test03_SimpleCursorStuff(self, get_raises_error=0, set_raises_error=0): if verbose: print '\n', '-=' * 30 print "Running %s.test03_SimpleCursorStuff (get_error %s, set_error %s)..." % \ (self.__class__.__name__, get_raises_error, set_raises_error) if self.env and self.dbopenflags & db.DB_AUTO_COMMIT: txn = self.env.txn_begin() else: txn = None c = self.d.cursor(txn=txn) rec = c.first() count = 0 while rec is not None: count = count + 1 if verbose and count % 100 == 0: print rec try: rec = c.next() except db.DBNotFoundError, val: if get_raises_error: self.assertEqual(val.args[0], db.DB_NOTFOUND) if verbose: print val rec = None else: self.fail("unexpected DBNotFoundError") self.assertEqual(c.get_current_size(), len(c.current()[1]), "%s != len(%r)" % (c.get_current_size(), c.current()[1])) self.assertEqual(count, self._numKeys) rec = c.last() count = 0 while rec is not None: count = count + 1 if verbose and count % 100 == 0: print rec try: rec = c.prev() except db.DBNotFoundError, val: if get_raises_error: self.assertEqual(val.args[0], db.DB_NOTFOUND) if verbose: print val rec = None else: self.fail("unexpected DBNotFoundError") self.assertEqual(count, self._numKeys) rec = c.set('0505') rec2 = c.current() self.assertEqual(rec, rec2) self.assertEqual(rec[0], '0505') self.assertEqual(rec[1], self.makeData('0505')) self.assertEqual(c.get_current_size(), len(rec[1])) # make sure we get empty values properly rec = c.set('empty value') self.assertEqual(rec[1], '') self.assertEqual(c.get_current_size(), 0) try: n = c.set('bad key') except db.DBNotFoundError, val: self.assertEqual(val.args[0], db.DB_NOTFOUND) if verbose: print val else: if set_raises_error: self.fail("expected exception") if n is not None: self.fail("expected None: %r" % (n,)) rec = c.get_both('0404', self.makeData('0404')) self.assertEqual(rec, ('0404', self.makeData('0404'))) try: n = c.get_both('0404', 'bad data') except db.DBNotFoundError, val: self.assertEqual(val.args[0], db.DB_NOTFOUND) if verbose: print val else: if get_raises_error: self.fail("expected exception") if n is not None: self.fail("expected None: %r" % (n,)) if self.d.get_type() == db.DB_BTREE: rec = c.set_range('011') if verbose: print "searched for '011', found: ", rec rec = c.set_range('011',dlen=0,doff=0) if verbose: print "searched (partial) for '011', found: ", rec if rec[1] != '': self.fail('expected empty data portion') ev = c.set_range('empty value') if verbose: print "search for 'empty value' returned", ev if ev[1] != '': self.fail('empty value lookup failed') c.set('0499') c.delete() try: rec = c.current() except db.DBKeyEmptyError, val: if get_raises_error: self.assertEqual(val.args[0], db.DB_KEYEMPTY) if verbose: print val else: self.fail("unexpected DBKeyEmptyError") else: if get_raises_error: self.fail('DBKeyEmptyError exception expected') c.next() c2 = c.dup(db.DB_POSITION) self.assertEqual(c.current(), c2.current()) c2.put('', 'a new value', db.DB_CURRENT) self.assertEqual(c.current(), c2.current()) self.assertEqual(c.current()[1], 'a new value') c2.put('', 'er', db.DB_CURRENT, dlen=0, doff=5) self.assertEqual(c2.current()[1], 'a newer value') c.close() c2.close() if txn: txn.commit() # time to abuse the closed cursors and hope we don't crash methods_to_test = { 'current': (), 'delete': (), 'dup': (db.DB_POSITION,), 'first': (), 'get': (0,), 'next': (), 'prev': (), 'last': (), 'put':('', 'spam', db.DB_CURRENT), 'set': ("0505",), } for method, args in methods_to_test.items(): try: if verbose: print "attempting to use a closed cursor's %s method" % \ method # a bug may cause a NULL pointer dereference... getattr(c, method)(*args) except db.DBError, val: self.assertEqual(val.args[0], 0) if verbose: print val else: self.fail("no exception raised when using a buggy cursor's" "%s method" % method) # # free cursor referencing a closed database, it should not barf: # oldcursor = self.d.cursor(txn=txn) self.d.close() # this would originally cause a segfault when the cursor for a # closed database was cleaned up. it should not anymore. # SF pybsddb bug id 667343 del oldcursor def test03b_SimpleCursorWithoutGetReturnsNone0(self): # same test but raise exceptions instead of returning None if verbose: print '\n', '-=' * 30 print "Running %s.test03b_SimpleCursorStuffWithoutGetReturnsNone..." % \ self.__class__.__name__ old = self.d.set_get_returns_none(0) self.assertEqual(old, 2) self.test03_SimpleCursorStuff(get_raises_error=1, set_raises_error=1) def test03b_SimpleCursorWithGetReturnsNone1(self): # same test but raise exceptions instead of returning None if verbose: print '\n', '-=' * 30 print "Running %s.test03b_SimpleCursorStuffWithoutGetReturnsNone..." % \ self.__class__.__name__ old = self.d.set_get_returns_none(1) self.test03_SimpleCursorStuff(get_raises_error=0, set_raises_error=1) def test03c_SimpleCursorGetReturnsNone2(self): # same test but raise exceptions instead of returning None if verbose: print '\n', '-=' * 30 print "Running %s.test03c_SimpleCursorStuffWithoutSetReturnsNone..." % \ self.__class__.__name__ old = self.d.set_get_returns_none(1) self.assertEqual(old, 2) old = self.d.set_get_returns_none(2) self.assertEqual(old, 1) self.test03_SimpleCursorStuff(get_raises_error=0, set_raises_error=0) def test03d_SimpleCursorPriority(self) : c = self.d.cursor() c.set_priority(db.DB_PRIORITY_VERY_LOW) # Positional self.assertEqual(db.DB_PRIORITY_VERY_LOW, c.get_priority()) c.set_priority(priority=db.DB_PRIORITY_HIGH) # Keyword self.assertEqual(db.DB_PRIORITY_HIGH, c.get_priority()) c.close() #---------------------------------------- def test04_PartialGetAndPut(self): d = self.d if verbose: print '\n', '-=' * 30 print "Running %s.test04_PartialGetAndPut..." % \ self.__class__.__name__ key = "partialTest" data = "1" * 1000 + "2" * 1000 d.put(key, data) self.assertEqual(d.get(key), data) self.assertEqual(d.get(key, dlen=20, doff=990), ("1" * 10) + ("2" * 10)) d.put("partialtest2", ("1" * 30000) + "robin" ) self.assertEqual(d.get("partialtest2", dlen=5, doff=30000), "robin") # There seems to be a bug in DB here... Commented out the test for # now. ##self.assertEqual(d.get("partialtest2", dlen=5, doff=30010), "") if self.dbsetflags != db.DB_DUP: # Partial put with duplicate records requires a cursor d.put(key, "0000", dlen=2000, doff=0) self.assertEqual(d.get(key), "0000") d.put(key, "1111", dlen=1, doff=2) self.assertEqual(d.get(key), "0011110") #---------------------------------------- def test05_GetSize(self): d = self.d if verbose: print '\n', '-=' * 30 print "Running %s.test05_GetSize..." % self.__class__.__name__ for i in range(1, 50000, 500): key = "size%s" % i #print "before ", i, d.put(key, "1" * i) #print "after", self.assertEqual(d.get_size(key), i) #print "done" #---------------------------------------- def test06_Truncate(self): d = self.d if verbose: print '\n', '-=' * 30 print "Running %s.test06_Truncate..." % self.__class__.__name__ d.put("abcde", "ABCDE"); num = d.truncate() self.assertTrue(num >= 1, "truncate returned <= 0 on non-empty database") num = d.truncate() self.assertEqual(num, 0, "truncate on empty DB returned nonzero (%r)" % (num,)) #---------------------------------------- def test07_verify(self): # Verify bug solved in 4.7.3pre8 self.d.close() d = db.DB(self.env) d.verify(self.filename) #---------------------------------------- def test08_exists(self) : self.d.put("abcde", "ABCDE") self.assertTrue(self.d.exists("abcde") == True, "DB->exists() returns wrong value") self.assertTrue(self.d.exists("x") == False, "DB->exists() returns wrong value") #---------------------------------------- def test_compact(self) : d = self.d self.assertEqual(0, d.compact(flags=db.DB_FREELIST_ONLY)) self.assertEqual(0, d.compact(flags=db.DB_FREELIST_ONLY)) d.put("abcde", "ABCDE"); d.put("bcde", "BCDE"); d.put("abc", "ABC"); d.put("monty", "python"); d.delete("abc") d.delete("bcde") d.compact(start='abcde', stop='monty', txn=None, compact_fillpercent=42, compact_pages=1, compact_timeout=50000000, flags=db.DB_FREELIST_ONLY|db.DB_FREE_SPACE) #---------------------------------------- #---------------------------------------------------------------------- class BasicBTreeTestCase(BasicTestCase): dbtype = db.DB_BTREE class BasicHashTestCase(BasicTestCase): dbtype = db.DB_HASH class BasicBTreeWithThreadFlagTestCase(BasicTestCase): dbtype = db.DB_BTREE dbopenflags = db.DB_THREAD class BasicHashWithThreadFlagTestCase(BasicTestCase): dbtype = db.DB_HASH dbopenflags = db.DB_THREAD class BasicWithEnvTestCase(BasicTestCase): dbopenflags = db.DB_THREAD useEnv = 1 envflags = db.DB_THREAD | db.DB_INIT_MPOOL | db.DB_INIT_LOCK #---------------------------------------- def test09_EnvRemoveAndRename(self): if not self.env: return if verbose: print '\n', '-=' * 30 print "Running %s.test09_EnvRemoveAndRename..." % self.__class__.__name__ # can't rename or remove an open DB self.d.close() newname = self.filename + '.renamed' self.env.dbrename(self.filename, None, newname) self.env.dbremove(newname) #---------------------------------------- class BasicBTreeWithEnvTestCase(BasicWithEnvTestCase): dbtype = db.DB_BTREE class BasicHashWithEnvTestCase(BasicWithEnvTestCase): dbtype = db.DB_HASH #---------------------------------------------------------------------- class BasicTransactionTestCase(BasicTestCase): if sys.version_info < (2, 7) : def assertIn(self, a, b, msg=None) : return self.assertTrue(a in b, msg=msg) dbopenflags = db.DB_THREAD | db.DB_AUTO_COMMIT useEnv = 1 envflags = (db.DB_THREAD | db.DB_INIT_MPOOL | db.DB_INIT_LOCK | db.DB_INIT_TXN) envsetflags = db.DB_AUTO_COMMIT def tearDown(self): self.txn.commit() BasicTestCase.tearDown(self) def populateDB(self): txn = self.env.txn_begin() BasicTestCase.populateDB(self, _txn=txn) self.txn = self.env.txn_begin() def test06_Transactions(self): d = self.d if verbose: print '\n', '-=' * 30 print "Running %s.test06_Transactions..." % self.__class__.__name__ self.assertEqual(d.get('new rec', txn=self.txn), None) d.put('new rec', 'this is a new record', self.txn) self.assertEqual(d.get('new rec', txn=self.txn), 'this is a new record') self.txn.abort() self.assertEqual(d.get('new rec'), None) self.txn = self.env.txn_begin() self.assertEqual(d.get('new rec', txn=self.txn), None) d.put('new rec', 'this is a new record', self.txn) self.assertEqual(d.get('new rec', txn=self.txn), 'this is a new record') self.txn.commit() self.assertEqual(d.get('new rec'), 'this is a new record') self.txn = self.env.txn_begin() c = d.cursor(self.txn) rec = c.first() count = 0 while rec is not None: count = count + 1 if verbose and count % 100 == 0: print rec rec = c.next() self.assertEqual(count, self._numKeys+1) c.close() # Cursors *MUST* be closed before commit! self.txn.commit() # flush pending updates self.env.txn_checkpoint (0, 0, 0) statDict = self.env.log_stat(0); self.assertIn('magic', statDict) self.assertIn('version', statDict) self.assertIn('cur_file', statDict) self.assertIn('region_nowait', statDict) # must have at least one log file present: logs = self.env.log_archive(db.DB_ARCH_ABS | db.DB_ARCH_LOG) self.assertNotEqual(logs, None) for log in logs: if verbose: print 'log file: ' + log logs = self.env.log_archive(db.DB_ARCH_REMOVE) self.assertTrue(not logs) self.txn = self.env.txn_begin() #---------------------------------------- def test08_exists(self) : txn = self.env.txn_begin() self.d.put("abcde", "ABCDE", txn=txn) txn.commit() txn = self.env.txn_begin() self.assertTrue(self.d.exists("abcde", txn=txn) == True, "DB->exists() returns wrong value") self.assertTrue(self.d.exists("x", txn=txn) == False, "DB->exists() returns wrong value") txn.abort() #---------------------------------------- def test09_TxnTruncate(self): d = self.d if verbose: print '\n', '-=' * 30 print "Running %s.test09_TxnTruncate..." % self.__class__.__name__ d.put("abcde", "ABCDE"); txn = self.env.txn_begin() num = d.truncate(txn) self.assertTrue(num >= 1, "truncate returned <= 0 on non-empty database") num = d.truncate(txn) self.assertEqual(num, 0, "truncate on empty DB returned nonzero (%r)" % (num,)) txn.commit() #---------------------------------------- def test10_TxnLateUse(self): txn = self.env.txn_begin() txn.abort() try: txn.abort() except db.DBError, e: pass else: raise RuntimeError, "DBTxn.abort() called after DB_TXN no longer valid w/o an exception" txn = self.env.txn_begin() txn.commit() try: txn.commit() except db.DBError, e: pass else: raise RuntimeError, "DBTxn.commit() called after DB_TXN no longer valid w/o an exception" #---------------------------------------- def test_txn_name(self) : txn=self.env.txn_begin() self.assertEqual(txn.get_name(), "") txn.set_name("XXYY") self.assertEqual(txn.get_name(), "XXYY") txn.set_name("ABC") self.assertEqual(txn.get_name(), "ABC") txn.abort() #---------------------------------------- def test_txn_set_timeout(self) : txn=self.env.txn_begin() txn.set_timeout(1234567, db.DB_SET_LOCK_TIMEOUT) txn.set_timeout(2345678, flags=db.DB_SET_TXN_TIMEOUT) txn.abort() #---------------------------------------- def test_get_tx_max(self) : self.assertEqual(self.env.get_tx_max(), 30) def test_get_tx_timestamp(self) : self.assertEqual(self.env.get_tx_timestamp(), self._t) class BTreeTransactionTestCase(BasicTransactionTestCase): dbtype = db.DB_BTREE class HashTransactionTestCase(BasicTransactionTestCase): dbtype = db.DB_HASH #---------------------------------------------------------------------- class BTreeRecnoTestCase(BasicTestCase): dbtype = db.DB_BTREE dbsetflags = db.DB_RECNUM def test09_RecnoInBTree(self): d = self.d if verbose: print '\n', '-=' * 30 print "Running %s.test09_RecnoInBTree..." % self.__class__.__name__ rec = d.get(200) self.assertEqual(type(rec), type(())) self.assertEqual(len(rec), 2) if verbose: print "Record #200 is ", rec c = d.cursor() c.set('0200') num = c.get_recno() self.assertEqual(type(num), type(1)) if verbose: print "recno of d['0200'] is ", num rec = c.current() self.assertEqual(c.set_recno(num), rec) c.close() class BTreeRecnoWithThreadFlagTestCase(BTreeRecnoTestCase): dbopenflags = db.DB_THREAD #---------------------------------------------------------------------- class BasicDUPTestCase(BasicTestCase): dbsetflags = db.DB_DUP def test10_DuplicateKeys(self): d = self.d if verbose: print '\n', '-=' * 30 print "Running %s.test10_DuplicateKeys..." % \ self.__class__.__name__ d.put("dup0", "before") for x in "The quick brown fox jumped over the lazy dog.".split(): d.put("dup1", x) d.put("dup2", "after") data = d.get("dup1") self.assertEqual(data, "The") if verbose: print data c = d.cursor() rec = c.set("dup1") self.assertEqual(rec, ('dup1', 'The')) next_reg = c.next() self.assertEqual(next_reg, ('dup1', 'quick')) rec = c.set("dup1") count = c.count() self.assertEqual(count, 9) next_dup = c.next_dup() self.assertEqual(next_dup, ('dup1', 'quick')) rec = c.set('dup1') while rec is not None: if verbose: print rec rec = c.next_dup() c.set('dup1') rec = c.next_nodup() self.assertNotEqual(rec[0], 'dup1') if verbose: print rec c.close() class BTreeDUPTestCase(BasicDUPTestCase): dbtype = db.DB_BTREE class HashDUPTestCase(BasicDUPTestCase): dbtype = db.DB_HASH class BTreeDUPWithThreadTestCase(BasicDUPTestCase): dbtype = db.DB_BTREE dbopenflags = db.DB_THREAD class HashDUPWithThreadTestCase(BasicDUPTestCase): dbtype = db.DB_HASH dbopenflags = db.DB_THREAD #---------------------------------------------------------------------- class BasicMultiDBTestCase(BasicTestCase): dbname = 'first' def otherType(self): if self.dbtype == db.DB_BTREE: return db.DB_HASH else: return db.DB_BTREE def test11_MultiDB(self): d1 = self.d if verbose: print '\n', '-=' * 30 print "Running %s.test11_MultiDB..." % self.__class__.__name__ d2 = db.DB(self.env) d2.open(self.filename, "second", self.dbtype, self.dbopenflags|db.DB_CREATE) d3 = db.DB(self.env) d3.open(self.filename, "third", self.otherType(), self.dbopenflags|db.DB_CREATE) for x in "The quick brown fox jumped over the lazy dog".split(): d2.put(x, self.makeData(x)) for x in string.ascii_letters: d3.put(x, x*70) d1.sync() d2.sync() d3.sync() d1.close() d2.close() d3.close() self.d = d1 = d2 = d3 = None self.d = d1 = db.DB(self.env) d1.open(self.filename, self.dbname, flags = self.dbopenflags) d2 = db.DB(self.env) d2.open(self.filename, "second", flags = self.dbopenflags) d3 = db.DB(self.env) d3.open(self.filename, "third", flags = self.dbopenflags) c1 = d1.cursor() c2 = d2.cursor() c3 = d3.cursor() count = 0 rec = c1.first() while rec is not None: count = count + 1 if verbose and (count % 50) == 0: print rec rec = c1.next() self.assertEqual(count, self._numKeys) count = 0 rec = c2.first() while rec is not None: count = count + 1 if verbose: print rec rec = c2.next() self.assertEqual(count, 9) count = 0 rec = c3.first() while rec is not None: count = count + 1 if verbose: print rec rec = c3.next() self.assertEqual(count, len(string.ascii_letters)) c1.close() c2.close() c3.close() d2.close() d3.close() # Strange things happen if you try to use Multiple DBs per file without a # DBEnv with MPOOL and LOCKing... class BTreeMultiDBTestCase(BasicMultiDBTestCase): dbtype = db.DB_BTREE dbopenflags = db.DB_THREAD useEnv = 1 envflags = db.DB_THREAD | db.DB_INIT_MPOOL | db.DB_INIT_LOCK class HashMultiDBTestCase(BasicMultiDBTestCase): dbtype = db.DB_HASH dbopenflags = db.DB_THREAD useEnv = 1 envflags = db.DB_THREAD | db.DB_INIT_MPOOL | db.DB_INIT_LOCK class PrivateObject(unittest.TestCase) : def tearDown(self) : del self.obj def test01_DefaultIsNone(self) : self.assertEqual(self.obj.get_private(), None) def test02_assignment(self) : a = "example of private object" self.obj.set_private(a) b = self.obj.get_private() self.assertTrue(a is b) # Object identity def test03_leak_assignment(self) : a = "example of private object" refcount = sys.getrefcount(a) self.obj.set_private(a) self.assertEqual(refcount+1, sys.getrefcount(a)) self.obj.set_private(None) self.assertEqual(refcount, sys.getrefcount(a)) def test04_leak_GC(self) : a = "example of private object" refcount = sys.getrefcount(a) self.obj.set_private(a) self.obj = None self.assertEqual(refcount, sys.getrefcount(a)) class DBEnvPrivateObject(PrivateObject) : def setUp(self) : self.obj = db.DBEnv() class DBPrivateObject(PrivateObject) : def setUp(self) : self.obj = db.DB() class CrashAndBurn(unittest.TestCase) : #def test01_OpenCrash(self) : # # See http://bugs.python.org/issue3307 # self.assertRaises(db.DBInvalidArgError, db.DB, None, 65535) if db.version() < (4, 8) : def test02_DBEnv_dealloc(self): # http://bugs.python.org/issue3885 import gc self.assertRaises(db.DBInvalidArgError, db.DBEnv, ~db.DB_RPCCLIENT) gc.collect() #---------------------------------------------------------------------- #---------------------------------------------------------------------- def test_suite(): suite = unittest.TestSuite() suite.addTest(unittest.makeSuite(VersionTestCase)) suite.addTest(unittest.makeSuite(BasicBTreeTestCase)) suite.addTest(unittest.makeSuite(BasicHashTestCase)) suite.addTest(unittest.makeSuite(BasicBTreeWithThreadFlagTestCase)) suite.addTest(unittest.makeSuite(BasicHashWithThreadFlagTestCase)) suite.addTest(unittest.makeSuite(BasicBTreeWithEnvTestCase)) suite.addTest(unittest.makeSuite(BasicHashWithEnvTestCase)) suite.addTest(unittest.makeSuite(BTreeTransactionTestCase)) suite.addTest(unittest.makeSuite(HashTransactionTestCase)) suite.addTest(unittest.makeSuite(BTreeRecnoTestCase)) suite.addTest(unittest.makeSuite(BTreeRecnoWithThreadFlagTestCase)) suite.addTest(unittest.makeSuite(BTreeDUPTestCase)) suite.addTest(unittest.makeSuite(HashDUPTestCase)) suite.addTest(unittest.makeSuite(BTreeDUPWithThreadTestCase)) suite.addTest(unittest.makeSuite(HashDUPWithThreadTestCase)) suite.addTest(unittest.makeSuite(BTreeMultiDBTestCase)) suite.addTest(unittest.makeSuite(HashMultiDBTestCase)) suite.addTest(unittest.makeSuite(DBEnvPrivateObject)) suite.addTest(unittest.makeSuite(DBPrivateObject)) suite.addTest(unittest.makeSuite(CrashAndBurn)) return suite if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib/bsddb/test/test_recno.py0000664000175000017500000002326613617051124020012 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """TestCases for exercising a Recno DB. """ import os, sys import errno from pprint import pprint import string import unittest from test_all import db, test_support, verbose, get_new_environment_path, get_new_database_path #---------------------------------------------------------------------- class SimpleRecnoTestCase(unittest.TestCase): if sys.version_info < (2, 7) : def assertIsInstance(self, obj, datatype, msg=None) : return self.assertEqual(type(obj), datatype, msg=msg) def assertGreaterEqual(self, a, b, msg=None) : return self.assertTrue(a>=b, msg=msg) def setUp(self): self.filename = get_new_database_path() self.homeDir = None def tearDown(self): test_support.unlink(self.filename) if self.homeDir: test_support.rmtree(self.homeDir) def test01_basic(self): d = db.DB() get_returns_none = d.set_get_returns_none(2) d.set_get_returns_none(get_returns_none) d.open(self.filename, db.DB_RECNO, db.DB_CREATE) for x in string.ascii_letters: recno = d.append(x * 60) self.assertIsInstance(recno, int) self.assertGreaterEqual(recno, 1) if verbose: print recno, if verbose: print stat = d.stat() if verbose: pprint(stat) for recno in range(1, len(d)+1): data = d[recno] if verbose: print data self.assertIsInstance(data, str) self.assertEqual(data, d.get(recno)) try: data = d[0] # This should raise a KeyError!?!?! except db.DBInvalidArgError, val: self.assertEqual(val.args[0], db.EINVAL) if verbose: print val else: self.fail("expected exception") # test that has_key raises DB exceptions (fixed in pybsddb 4.3.2) try: d.has_key(0) except db.DBError, val: pass else: self.fail("has_key did not raise a proper exception") try: data = d[100] except KeyError: pass else: self.fail("expected exception") try: data = d.get(100) except db.DBNotFoundError, val: if get_returns_none: self.fail("unexpected exception") else: self.assertEqual(data, None) keys = d.keys() if verbose: print keys self.assertIsInstance(keys, list) self.assertIsInstance(keys[0], int) self.assertEqual(len(keys), len(d)) items = d.items() if verbose: pprint(items) self.assertIsInstance(items, list) self.assertIsInstance(items[0], tuple) self.assertEqual(len(items[0]), 2) self.assertIsInstance(items[0][0], int) self.assertIsInstance(items[0][1], str) self.assertEqual(len(items), len(d)) self.assertTrue(d.has_key(25)) del d[25] self.assertFalse(d.has_key(25)) d.delete(13) self.assertFalse(d.has_key(13)) data = d.get_both(26, "z" * 60) self.assertEqual(data, "z" * 60, 'was %r' % data) if verbose: print data fd = d.fd() if verbose: print fd c = d.cursor() rec = c.first() while rec: if verbose: print rec rec = c.next() c.set(50) rec = c.current() if verbose: print rec c.put(-1, "a replacement record", db.DB_CURRENT) c.set(50) rec = c.current() self.assertEqual(rec, (50, "a replacement record")) if verbose: print rec rec = c.set_range(30) if verbose: print rec # test that non-existent key lookups work (and that # DBC_set_range doesn't have a memleak under valgrind) rec = c.set_range(999999) self.assertEqual(rec, None) if verbose: print rec c.close() d.close() d = db.DB() d.open(self.filename) c = d.cursor() # put a record beyond the consecutive end of the recno's d[100] = "way out there" self.assertEqual(d[100], "way out there") try: data = d[99] except KeyError: pass else: self.fail("expected exception") try: d.get(99) except db.DBKeyEmptyError, val: if get_returns_none: self.fail("unexpected DBKeyEmptyError exception") else: self.assertEqual(val.args[0], db.DB_KEYEMPTY) if verbose: print val else: if not get_returns_none: self.fail("expected exception") rec = c.set(40) while rec: if verbose: print rec rec = c.next() c.close() d.close() def test02_WithSource(self): """ A Recno file that is given a "backing source file" is essentially a simple ASCII file. Normally each record is delimited by \n and so is just a line in the file, but you can set a different record delimiter if needed. """ homeDir = get_new_environment_path() self.homeDir = homeDir source = os.path.join(homeDir, 'test_recno.txt') if not os.path.isdir(homeDir): os.mkdir(homeDir) f = open(source, 'w') # create the file f.close() d = db.DB() # This is the default value, just checking if both int d.set_re_delim(0x0A) d.set_re_delim('\n') # and char can be used... d.set_re_source(source) d.open(self.filename, db.DB_RECNO, db.DB_CREATE) data = "The quick brown fox jumped over the lazy dog".split() for datum in data: d.append(datum) d.sync() d.close() # get the text from the backing source f = open(source, 'r') text = f.read() f.close() text = text.strip() if verbose: print text print data print text.split('\n') self.assertEqual(text.split('\n'), data) # open as a DB again d = db.DB() d.set_re_source(source) d.open(self.filename, db.DB_RECNO) d[3] = 'reddish-brown' d[8] = 'comatose' d.sync() d.close() f = open(source, 'r') text = f.read() f.close() text = text.strip() if verbose: print text print text.split('\n') self.assertEqual(text.split('\n'), "The quick reddish-brown fox jumped over the comatose dog".split()) def test03_FixedLength(self): d = db.DB() d.set_re_len(40) # fixed length records, 40 bytes long d.set_re_pad('-') # sets the pad character... d.set_re_pad(45) # ...test both int and char d.open(self.filename, db.DB_RECNO, db.DB_CREATE) for x in string.ascii_letters: d.append(x * 35) # These will be padded d.append('.' * 40) # this one will be exact try: # this one will fail d.append('bad' * 20) except db.DBInvalidArgError, val: self.assertEqual(val.args[0], db.EINVAL) if verbose: print val else: self.fail("expected exception") c = d.cursor() rec = c.first() while rec: if verbose: print rec rec = c.next() c.close() d.close() def test04_get_size_empty(self) : d = db.DB() d.open(self.filename, dbtype=db.DB_RECNO, flags=db.DB_CREATE) row_id = d.append(' ') self.assertEqual(1, d.get_size(key=row_id)) row_id = d.append('') self.assertEqual(0, d.get_size(key=row_id)) #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(SimpleRecnoTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib/bsddb/test/test_get_none.py0000664000175000017500000000750313617051124020476 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """ TestCases for checking set_get_returns_none. """ import os, string import unittest from test_all import db, verbose, get_new_database_path #---------------------------------------------------------------------- class GetReturnsNoneTestCase(unittest.TestCase): def setUp(self): self.filename = get_new_database_path() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_get_returns_none(self): d = db.DB() d.open(self.filename, db.DB_BTREE, db.DB_CREATE) d.set_get_returns_none(1) for x in string.ascii_letters: d.put(x, x * 40) data = d.get('bad key') self.assertEqual(data, None) data = d.get(string.ascii_letters[0]) self.assertEqual(data, string.ascii_letters[0]*40) count = 0 c = d.cursor() rec = c.first() while rec: count = count + 1 rec = c.next() self.assertEqual(rec, None) self.assertEqual(count, len(string.ascii_letters)) c.close() d.close() def test02_get_raises_exception(self): d = db.DB() d.open(self.filename, db.DB_BTREE, db.DB_CREATE) d.set_get_returns_none(0) for x in string.ascii_letters: d.put(x, x * 40) self.assertRaises(db.DBNotFoundError, d.get, 'bad key') self.assertRaises(KeyError, d.get, 'bad key') data = d.get(string.ascii_letters[0]) self.assertEqual(data, string.ascii_letters[0]*40) count = 0 exceptionHappened = 0 c = d.cursor() rec = c.first() while rec: count = count + 1 try: rec = c.next() except db.DBNotFoundError: # end of the records exceptionHappened = 1 break self.assertNotEqual(rec, None) self.assertTrue(exceptionHappened) self.assertEqual(count, len(string.ascii_letters)) c.close() d.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(GetReturnsNoneTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib/bsddb/test/test_distributed_transactions.py0000664000175000017500000001434613617051124024015 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """TestCases for distributed transactions. """ import os import unittest from test_all import db, test_support, get_new_environment_path, \ get_new_database_path from test_all import verbose #---------------------------------------------------------------------- class DBTxn_distributed(unittest.TestCase): num_txns=1234 nosync=True must_open_db=False def _create_env(self, must_open_db) : self.dbenv = db.DBEnv() self.dbenv.set_tx_max(self.num_txns) self.dbenv.set_lk_max_lockers(self.num_txns*2) self.dbenv.set_lk_max_locks(self.num_txns*2) self.dbenv.set_lk_max_objects(self.num_txns*2) if self.nosync : self.dbenv.set_flags(db.DB_TXN_NOSYNC,True) self.dbenv.open(self.homeDir, db.DB_CREATE | db.DB_THREAD | db.DB_RECOVER | db.DB_INIT_TXN | db.DB_INIT_LOG | db.DB_INIT_MPOOL | db.DB_INIT_LOCK, 0666) self.db = db.DB(self.dbenv) self.db.set_re_len(db.DB_GID_SIZE) if must_open_db : txn=self.dbenv.txn_begin() self.db.open(self.filename, db.DB_QUEUE, db.DB_CREATE | db.DB_THREAD, 0666, txn=txn) txn.commit() def setUp(self) : self.homeDir = get_new_environment_path() self.filename = "test" return self._create_env(must_open_db=True) def _destroy_env(self): if self.nosync : self.dbenv.log_flush() self.db.close() self.dbenv.close() def tearDown(self): self._destroy_env() test_support.rmtree(self.homeDir) def _recreate_env(self,must_open_db) : self._destroy_env() self._create_env(must_open_db) def test01_distributed_transactions(self) : txns=set() adapt = lambda x : x import sys if sys.version_info[0] >= 3 : adapt = lambda x : bytes(x, "ascii") # Create transactions, "prepare" them, and # let them be garbage collected. for i in xrange(self.num_txns) : txn = self.dbenv.txn_begin() gid = "%%%dd" %db.DB_GID_SIZE gid = adapt(gid %i) self.db.put(i, gid, txn=txn, flags=db.DB_APPEND) txns.add(gid) txn.prepare(gid) del txn self._recreate_env(self.must_open_db) # Get "to be recovered" transactions but # let them be garbage collected. recovered_txns=self.dbenv.txn_recover() self.assertEqual(self.num_txns,len(recovered_txns)) for gid,txn in recovered_txns : self.assertTrue(gid in txns) del txn del recovered_txns self._recreate_env(self.must_open_db) # Get "to be recovered" transactions. Commit, abort and # discard them. recovered_txns=self.dbenv.txn_recover() self.assertEqual(self.num_txns,len(recovered_txns)) discard_txns=set() committed_txns=set() state=0 for gid,txn in recovered_txns : if state==0 or state==1: committed_txns.add(gid) txn.commit() elif state==2 : txn.abort() elif state==3 : txn.discard() discard_txns.add(gid) state=-1 state+=1 del txn del recovered_txns self._recreate_env(self.must_open_db) # Verify the discarded transactions are still # around, and dispose them. recovered_txns=self.dbenv.txn_recover() self.assertEqual(len(discard_txns),len(recovered_txns)) for gid,txn in recovered_txns : txn.abort() del txn del recovered_txns self._recreate_env(must_open_db=True) # Be sure there are not pending transactions. # Check also database size. recovered_txns=self.dbenv.txn_recover() self.assertTrue(len(recovered_txns)==0) self.assertEqual(len(committed_txns),self.db.stat()["nkeys"]) class DBTxn_distributedSYNC(DBTxn_distributed): nosync=False class DBTxn_distributed_must_open_db(DBTxn_distributed): must_open_db=True class DBTxn_distributedSYNC_must_open_db(DBTxn_distributed): nosync=False must_open_db=True #---------------------------------------------------------------------- def test_suite(): suite = unittest.TestSuite() suite.addTest(unittest.makeSuite(DBTxn_distributed)) suite.addTest(unittest.makeSuite(DBTxn_distributedSYNC)) suite.addTest(unittest.makeSuite(DBTxn_distributed_must_open_db)) suite.addTest(unittest.makeSuite(DBTxn_distributedSYNC_must_open_db)) return suite if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib/bsddb/test/test_thread.py0000664000175000017500000004145713617051124020155 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """TestCases for multi-threaded access to a DB. """ import os import sys import time import errno from random import random DASH = '-' try: WindowsError except NameError: class WindowsError(Exception): pass import unittest from test_all import db, dbutils, test_support, verbose, have_threads, \ get_new_environment_path, get_new_database_path if have_threads : from threading import Thread if sys.version_info[0] < 3 : from threading import currentThread else : from threading import current_thread as currentThread #---------------------------------------------------------------------- class BaseThreadedTestCase(unittest.TestCase): dbtype = db.DB_UNKNOWN # must be set in derived class dbopenflags = 0 dbsetflags = 0 envflags = 0 def setUp(self): if verbose: dbutils._deadlock_VerboseFile = sys.stdout self.homeDir = get_new_environment_path() self.env = db.DBEnv() self.setEnvOpts() self.env.open(self.homeDir, self.envflags | db.DB_CREATE) self.filename = self.__class__.__name__ + '.db' self.d = db.DB(self.env) if self.dbsetflags: self.d.set_flags(self.dbsetflags) self.d.open(self.filename, self.dbtype, self.dbopenflags|db.DB_CREATE) def tearDown(self): self.d.close() self.env.close() test_support.rmtree(self.homeDir) def setEnvOpts(self): pass def makeData(self, key): return DASH.join([key] * 5) #---------------------------------------------------------------------- class ConcurrentDataStoreBase(BaseThreadedTestCase): dbopenflags = db.DB_THREAD envflags = db.DB_THREAD | db.DB_INIT_CDB | db.DB_INIT_MPOOL readers = 0 # derived class should set writers = 0 records = 1000 def test01_1WriterMultiReaders(self): if verbose: print '\n', '-=' * 30 print "Running %s.test01_1WriterMultiReaders..." % \ self.__class__.__name__ keys=range(self.records) import random random.shuffle(keys) records_per_writer=self.records//self.writers readers_per_writer=self.readers//self.writers self.assertEqual(self.records,self.writers*records_per_writer) self.assertEqual(self.readers,self.writers*readers_per_writer) self.assertTrue((records_per_writer%readers_per_writer)==0) readers = [] for x in xrange(self.readers): rt = Thread(target = self.readerThread, args = (self.d, x), name = 'reader %d' % x, )#verbose = verbose) if sys.version_info[0] < 3 : rt.setDaemon(True) else : rt.daemon = True readers.append(rt) writers=[] for x in xrange(self.writers): a=keys[records_per_writer*x:records_per_writer*(x+1)] a.sort() # Generate conflicts b=readers[readers_per_writer*x:readers_per_writer*(x+1)] wt = Thread(target = self.writerThread, args = (self.d, a, b), name = 'writer %d' % x, )#verbose = verbose) writers.append(wt) for t in writers: if sys.version_info[0] < 3 : t.setDaemon(True) else : t.daemon = True t.start() for t in writers: t.join() for t in readers: t.join() def writerThread(self, d, keys, readers): if sys.version_info[0] < 3 : name = currentThread().getName() else : name = currentThread().name if verbose: print "%s: creating records %d - %d" % (name, start, stop) count=len(keys)//len(readers) count2=count for x in keys : key = '%04d' % x dbutils.DeadlockWrap(d.put, key, self.makeData(key), max_retries=12) if verbose and x % 100 == 0: print "%s: records %d - %d finished" % (name, start, x) count2-=1 if not count2 : readers.pop().start() count2=count if verbose: print "%s: finished creating records" % name if verbose: print "%s: thread finished" % name def readerThread(self, d, readerNum): if sys.version_info[0] < 3 : name = currentThread().getName() else : name = currentThread().name for i in xrange(5) : c = d.cursor() count = 0 rec = c.first() while rec: count += 1 key, data = rec self.assertEqual(self.makeData(key), data) rec = c.next() if verbose: print "%s: found %d records" % (name, count) c.close() if verbose: print "%s: thread finished" % name class BTreeConcurrentDataStore(ConcurrentDataStoreBase): dbtype = db.DB_BTREE writers = 2 readers = 10 records = 1000 class HashConcurrentDataStore(ConcurrentDataStoreBase): dbtype = db.DB_HASH writers = 2 readers = 10 records = 1000 #---------------------------------------------------------------------- class SimpleThreadedBase(BaseThreadedTestCase): dbopenflags = db.DB_THREAD envflags = db.DB_THREAD | db.DB_INIT_MPOOL | db.DB_INIT_LOCK readers = 10 writers = 2 records = 1000 def setEnvOpts(self): self.env.set_lk_detect(db.DB_LOCK_DEFAULT) def test02_SimpleLocks(self): if verbose: print '\n', '-=' * 30 print "Running %s.test02_SimpleLocks..." % self.__class__.__name__ keys=range(self.records) import random random.shuffle(keys) records_per_writer=self.records//self.writers readers_per_writer=self.readers//self.writers self.assertEqual(self.records,self.writers*records_per_writer) self.assertEqual(self.readers,self.writers*readers_per_writer) self.assertTrue((records_per_writer%readers_per_writer)==0) readers = [] for x in xrange(self.readers): rt = Thread(target = self.readerThread, args = (self.d, x), name = 'reader %d' % x, )#verbose = verbose) if sys.version_info[0] < 3 : rt.setDaemon(True) else : rt.daemon = True readers.append(rt) writers = [] for x in xrange(self.writers): a=keys[records_per_writer*x:records_per_writer*(x+1)] a.sort() # Generate conflicts b=readers[readers_per_writer*x:readers_per_writer*(x+1)] wt = Thread(target = self.writerThread, args = (self.d, a, b), name = 'writer %d' % x, )#verbose = verbose) writers.append(wt) for t in writers: if sys.version_info[0] < 3 : t.setDaemon(True) else : t.daemon = True t.start() for t in writers: t.join() for t in readers: t.join() def writerThread(self, d, keys, readers): if sys.version_info[0] < 3 : name = currentThread().getName() else : name = currentThread().name if verbose: print "%s: creating records %d - %d" % (name, start, stop) count=len(keys)//len(readers) count2=count for x in keys : key = '%04d' % x dbutils.DeadlockWrap(d.put, key, self.makeData(key), max_retries=12) if verbose and x % 100 == 0: print "%s: records %d - %d finished" % (name, start, x) count2-=1 if not count2 : readers.pop().start() count2=count if verbose: print "%s: thread finished" % name def readerThread(self, d, readerNum): if sys.version_info[0] < 3 : name = currentThread().getName() else : name = currentThread().name c = d.cursor() count = 0 rec = dbutils.DeadlockWrap(c.first, max_retries=10) while rec: count += 1 key, data = rec self.assertEqual(self.makeData(key), data) rec = dbutils.DeadlockWrap(c.next, max_retries=10) if verbose: print "%s: found %d records" % (name, count) c.close() if verbose: print "%s: thread finished" % name class BTreeSimpleThreaded(SimpleThreadedBase): dbtype = db.DB_BTREE class HashSimpleThreaded(SimpleThreadedBase): dbtype = db.DB_HASH #---------------------------------------------------------------------- class ThreadedTransactionsBase(BaseThreadedTestCase): dbopenflags = db.DB_THREAD | db.DB_AUTO_COMMIT envflags = (db.DB_THREAD | db.DB_INIT_MPOOL | db.DB_INIT_LOCK | db.DB_INIT_LOG | db.DB_INIT_TXN ) readers = 0 writers = 0 records = 2000 txnFlag = 0 def setEnvOpts(self): #self.env.set_lk_detect(db.DB_LOCK_DEFAULT) pass def test03_ThreadedTransactions(self): if verbose: print '\n', '-=' * 30 print "Running %s.test03_ThreadedTransactions..." % \ self.__class__.__name__ keys=range(self.records) import random random.shuffle(keys) records_per_writer=self.records//self.writers readers_per_writer=self.readers//self.writers self.assertEqual(self.records,self.writers*records_per_writer) self.assertEqual(self.readers,self.writers*readers_per_writer) self.assertTrue((records_per_writer%readers_per_writer)==0) readers=[] for x in xrange(self.readers): rt = Thread(target = self.readerThread, args = (self.d, x), name = 'reader %d' % x, )#verbose = verbose) if sys.version_info[0] < 3 : rt.setDaemon(True) else : rt.daemon = True readers.append(rt) writers = [] for x in xrange(self.writers): a=keys[records_per_writer*x:records_per_writer*(x+1)] b=readers[readers_per_writer*x:readers_per_writer*(x+1)] wt = Thread(target = self.writerThread, args = (self.d, a, b), name = 'writer %d' % x, )#verbose = verbose) writers.append(wt) dt = Thread(target = self.deadlockThread) if sys.version_info[0] < 3 : dt.setDaemon(True) else : dt.daemon = True dt.start() for t in writers: if sys.version_info[0] < 3 : t.setDaemon(True) else : t.daemon = True t.start() for t in writers: t.join() for t in readers: t.join() self.doLockDetect = False dt.join() def writerThread(self, d, keys, readers): if sys.version_info[0] < 3 : name = currentThread().getName() else : name = currentThread().name count=len(keys)//len(readers) while len(keys): try: txn = self.env.txn_begin(None, self.txnFlag) keys2=keys[:count] for x in keys2 : key = '%04d' % x d.put(key, self.makeData(key), txn) if verbose and x % 100 == 0: print "%s: records %d - %d finished" % (name, start, x) txn.commit() keys=keys[count:] readers.pop().start() except (db.DBLockDeadlockError, db.DBLockNotGrantedError), val: if verbose: print "%s: Aborting transaction (%s)" % (name, val.args[1]) txn.abort() if verbose: print "%s: thread finished" % name def readerThread(self, d, readerNum): if sys.version_info[0] < 3 : name = currentThread().getName() else : name = currentThread().name finished = False while not finished: try: txn = self.env.txn_begin(None, self.txnFlag) c = d.cursor(txn) count = 0 rec = c.first() while rec: count += 1 key, data = rec self.assertEqual(self.makeData(key), data) rec = c.next() if verbose: print "%s: found %d records" % (name, count) c.close() txn.commit() finished = True except (db.DBLockDeadlockError, db.DBLockNotGrantedError), val: if verbose: print "%s: Aborting transaction (%s)" % (name, val.args[1]) c.close() txn.abort() if verbose: print "%s: thread finished" % name def deadlockThread(self): self.doLockDetect = True while self.doLockDetect: time.sleep(0.05) try: aborted = self.env.lock_detect( db.DB_LOCK_RANDOM, db.DB_LOCK_CONFLICT) if verbose and aborted: print "deadlock: Aborted %d deadlocked transaction(s)" \ % aborted except db.DBError: pass class BTreeThreadedTransactions(ThreadedTransactionsBase): dbtype = db.DB_BTREE writers = 2 readers = 10 records = 1000 class HashThreadedTransactions(ThreadedTransactionsBase): dbtype = db.DB_HASH writers = 2 readers = 10 records = 1000 class BTreeThreadedNoWaitTransactions(ThreadedTransactionsBase): dbtype = db.DB_BTREE writers = 2 readers = 10 records = 1000 txnFlag = db.DB_TXN_NOWAIT class HashThreadedNoWaitTransactions(ThreadedTransactionsBase): dbtype = db.DB_HASH writers = 2 readers = 10 records = 1000 txnFlag = db.DB_TXN_NOWAIT #---------------------------------------------------------------------- def test_suite(): suite = unittest.TestSuite() if have_threads: suite.addTest(unittest.makeSuite(BTreeConcurrentDataStore)) suite.addTest(unittest.makeSuite(HashConcurrentDataStore)) suite.addTest(unittest.makeSuite(BTreeSimpleThreaded)) suite.addTest(unittest.makeSuite(HashSimpleThreaded)) suite.addTest(unittest.makeSuite(BTreeThreadedTransactions)) suite.addTest(unittest.makeSuite(HashThreadedTransactions)) suite.addTest(unittest.makeSuite(BTreeThreadedNoWaitTransactions)) suite.addTest(unittest.makeSuite(HashThreadedNoWaitTransactions)) else: print "Threads not available, skipping thread tests." return suite if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib/bsddb/test/test_replication.py0000664000175000017500000005177513617051124021223 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """TestCases for distributed transactions. """ import os import time import unittest from test_all import db, test_support, have_threads, verbose, \ get_new_environment_path, get_new_database_path #---------------------------------------------------------------------- class DBReplication(unittest.TestCase) : def setUp(self) : self.homeDirMaster = get_new_environment_path() self.homeDirClient = get_new_environment_path() self.dbenvMaster = db.DBEnv() self.dbenvClient = db.DBEnv() # Must use "DB_THREAD" because the Replication Manager will # be executed in other threads but will use the same environment. # http://forums.oracle.com/forums/thread.jspa?threadID=645788&tstart=0 self.dbenvMaster.open(self.homeDirMaster, db.DB_CREATE | db.DB_INIT_TXN | db.DB_INIT_LOG | db.DB_INIT_MPOOL | db.DB_INIT_LOCK | db.DB_INIT_REP | db.DB_RECOVER | db.DB_THREAD, 0666) self.dbenvClient.open(self.homeDirClient, db.DB_CREATE | db.DB_INIT_TXN | db.DB_INIT_LOG | db.DB_INIT_MPOOL | db.DB_INIT_LOCK | db.DB_INIT_REP | db.DB_RECOVER | db.DB_THREAD, 0666) self.confirmed_master=self.client_startupdone=False def confirmed_master(a,b,c) : if b==db.DB_EVENT_REP_MASTER : self.confirmed_master=True def client_startupdone(a,b,c) : if b==db.DB_EVENT_REP_STARTUPDONE : self.client_startupdone=True self.dbenvMaster.set_event_notify(confirmed_master) self.dbenvClient.set_event_notify(client_startupdone) #self.dbenvMaster.set_verbose(db.DB_VERB_REPLICATION, True) #self.dbenvMaster.set_verbose(db.DB_VERB_FILEOPS_ALL, True) #self.dbenvClient.set_verbose(db.DB_VERB_REPLICATION, True) #self.dbenvClient.set_verbose(db.DB_VERB_FILEOPS_ALL, True) self.dbMaster = self.dbClient = None def tearDown(self): if self.dbClient : self.dbClient.close() if self.dbMaster : self.dbMaster.close() # Here we assign dummy event handlers to allow GC of the test object. # Since the dummy handler doesn't use any outer scope variable, it # doesn't keep any reference to the test object. def dummy(*args) : pass self.dbenvMaster.set_event_notify(dummy) self.dbenvClient.set_event_notify(dummy) self.dbenvClient.close() self.dbenvMaster.close() test_support.rmtree(self.homeDirClient) test_support.rmtree(self.homeDirMaster) class DBReplicationManager(DBReplication) : def test01_basic_replication(self) : master_port = test_support.find_unused_port() client_port = test_support.find_unused_port() if db.version() >= (5, 2) : self.site = self.dbenvMaster.repmgr_site("127.0.0.1", master_port) self.site.set_config(db.DB_GROUP_CREATOR, True) self.site.set_config(db.DB_LOCAL_SITE, True) self.site2 = self.dbenvMaster.repmgr_site("127.0.0.1", client_port) self.site3 = self.dbenvClient.repmgr_site("127.0.0.1", master_port) self.site3.set_config(db.DB_BOOTSTRAP_HELPER, True) self.site4 = self.dbenvClient.repmgr_site("127.0.0.1", client_port) self.site4.set_config(db.DB_LOCAL_SITE, True) d = { db.DB_BOOTSTRAP_HELPER: [False, False, True, False], db.DB_GROUP_CREATOR: [True, False, False, False], db.DB_LEGACY: [False, False, False, False], db.DB_LOCAL_SITE: [True, False, False, True], db.DB_REPMGR_PEER: [False, False, False, False ], } for i, j in d.items() : for k, v in \ zip([self.site, self.site2, self.site3, self.site4], j) : if v : self.assertTrue(k.get_config(i)) else : self.assertFalse(k.get_config(i)) self.assertNotEqual(self.site.get_eid(), self.site2.get_eid()) self.assertNotEqual(self.site3.get_eid(), self.site4.get_eid()) for i, j in zip([self.site, self.site2, self.site3, self.site4], \ [master_port, client_port, master_port, client_port]) : addr = i.get_address() self.assertEqual(addr, ("127.0.0.1", j)) for i in [self.site, self.site2] : self.assertEqual(i.get_address(), self.dbenvMaster.repmgr_site_by_eid(i.get_eid()).get_address()) for i in [self.site3, self.site4] : self.assertEqual(i.get_address(), self.dbenvClient.repmgr_site_by_eid(i.get_eid()).get_address()) else : self.dbenvMaster.repmgr_set_local_site("127.0.0.1", master_port) self.dbenvClient.repmgr_set_local_site("127.0.0.1", client_port) self.dbenvMaster.repmgr_add_remote_site("127.0.0.1", client_port) self.dbenvClient.repmgr_add_remote_site("127.0.0.1", master_port) self.dbenvMaster.rep_set_nsites(2) self.dbenvClient.rep_set_nsites(2) self.dbenvMaster.rep_set_priority(10) self.dbenvClient.rep_set_priority(0) self.dbenvMaster.rep_set_timeout(db.DB_REP_CONNECTION_RETRY,100123) self.dbenvClient.rep_set_timeout(db.DB_REP_CONNECTION_RETRY,100321) self.assertEqual(self.dbenvMaster.rep_get_timeout( db.DB_REP_CONNECTION_RETRY), 100123) self.assertEqual(self.dbenvClient.rep_get_timeout( db.DB_REP_CONNECTION_RETRY), 100321) self.dbenvMaster.rep_set_timeout(db.DB_REP_ELECTION_TIMEOUT, 100234) self.dbenvClient.rep_set_timeout(db.DB_REP_ELECTION_TIMEOUT, 100432) self.assertEqual(self.dbenvMaster.rep_get_timeout( db.DB_REP_ELECTION_TIMEOUT), 100234) self.assertEqual(self.dbenvClient.rep_get_timeout( db.DB_REP_ELECTION_TIMEOUT), 100432) self.dbenvMaster.rep_set_timeout(db.DB_REP_ELECTION_RETRY, 100345) self.dbenvClient.rep_set_timeout(db.DB_REP_ELECTION_RETRY, 100543) self.assertEqual(self.dbenvMaster.rep_get_timeout( db.DB_REP_ELECTION_RETRY), 100345) self.assertEqual(self.dbenvClient.rep_get_timeout( db.DB_REP_ELECTION_RETRY), 100543) self.dbenvMaster.repmgr_set_ack_policy(db.DB_REPMGR_ACKS_ALL) self.dbenvClient.repmgr_set_ack_policy(db.DB_REPMGR_ACKS_ALL) self.dbenvMaster.repmgr_start(1, db.DB_REP_MASTER); self.dbenvClient.repmgr_start(1, db.DB_REP_CLIENT); self.assertEqual(self.dbenvMaster.rep_get_nsites(),2) self.assertEqual(self.dbenvClient.rep_get_nsites(),2) self.assertEqual(self.dbenvMaster.rep_get_priority(),10) self.assertEqual(self.dbenvClient.rep_get_priority(),0) self.assertEqual(self.dbenvMaster.repmgr_get_ack_policy(), db.DB_REPMGR_ACKS_ALL) self.assertEqual(self.dbenvClient.repmgr_get_ack_policy(), db.DB_REPMGR_ACKS_ALL) # The timeout is necessary in BDB 4.5, since DB_EVENT_REP_STARTUPDONE # is not generated if the master has no new transactions. # This is solved in BDB 4.6 (#15542). import time timeout = time.time()+10 while (time.time() All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ import os import pickle import sys if sys.version_info[0] < 3 : try: import cPickle except ImportError: cPickle = None else : cPickle = None import unittest from test_all import db, test_support, get_new_environment_path, get_new_database_path #---------------------------------------------------------------------- class pickleTestCase(unittest.TestCase): """Verify that DBError can be pickled and unpickled""" db_name = 'test-dbobj.db' def setUp(self): self.homeDir = get_new_environment_path() def tearDown(self): if hasattr(self, 'db'): del self.db if hasattr(self, 'env'): del self.env test_support.rmtree(self.homeDir) def _base_test_pickle_DBError(self, pickle): self.env = db.DBEnv() self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL) self.db = db.DB(self.env) self.db.open(self.db_name, db.DB_HASH, db.DB_CREATE) self.db.put('spam', 'eggs') self.assertEqual(self.db['spam'], 'eggs') try: self.db.put('spam', 'ham', flags=db.DB_NOOVERWRITE) except db.DBError, egg: pickledEgg = pickle.dumps(egg) #print repr(pickledEgg) rottenEgg = pickle.loads(pickledEgg) if rottenEgg.args != egg.args or type(rottenEgg) != type(egg): raise Exception, (rottenEgg, '!=', egg) else: raise Exception, "where's my DBError exception?!?" self.db.close() self.env.close() def test01_pickle_DBError(self): self._base_test_pickle_DBError(pickle=pickle) if cPickle: def test02_cPickle_DBError(self): self._base_test_pickle_DBError(pickle=cPickle) #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(pickleTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib/bsddb/test/test_dbenv.py0000664000175000017500000004646713617051124020012 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ import unittest import os, glob from test_all import db, test_support, get_new_environment_path, \ get_new_database_path #---------------------------------------------------------------------- class DBEnv(unittest.TestCase): def setUp(self): self.homeDir = get_new_environment_path() self.env = db.DBEnv() def tearDown(self): self.env.close() del self.env test_support.rmtree(self.homeDir) class DBEnv_general(DBEnv) : def test_get_open_flags(self) : flags = db.DB_CREATE | db.DB_INIT_MPOOL self.env.open(self.homeDir, flags) self.assertEqual(flags, self.env.get_open_flags()) def test_get_open_flags2(self) : flags = db.DB_CREATE | db.DB_INIT_MPOOL | \ db.DB_INIT_LOCK | db.DB_THREAD self.env.open(self.homeDir, flags) self.assertEqual(flags, self.env.get_open_flags()) def test_lk_partitions(self) : for i in [10, 20, 40] : self.env.set_lk_partitions(i) self.assertEqual(i, self.env.get_lk_partitions()) def test_getset_intermediate_dir_mode(self) : self.assertEqual(None, self.env.get_intermediate_dir_mode()) for mode in ["rwx------", "rw-rw-rw-", "rw-r--r--"] : self.env.set_intermediate_dir_mode(mode) self.assertEqual(mode, self.env.get_intermediate_dir_mode()) self.assertRaises(db.DBInvalidArgError, self.env.set_intermediate_dir_mode, "abcde") def test_thread(self) : for i in [16, 100, 1000] : self.env.set_thread_count(i) self.assertEqual(i, self.env.get_thread_count()) def test_cache_max(self) : for size in [64, 128] : size = size*1024*1024 # Megabytes self.env.set_cache_max(0, size) size2 = self.env.get_cache_max() self.assertEqual(0, size2[0]) self.assertTrue(size <= size2[1]) self.assertTrue(2*size > size2[1]) def test_mutex_stat(self) : self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL | db.DB_INIT_LOCK) stat = self.env.mutex_stat() self.assertTrue("mutex_inuse_max" in stat) def test_lg_filemode(self) : for i in [0600, 0660, 0666] : self.env.set_lg_filemode(i) self.assertEqual(i, self.env.get_lg_filemode()) def test_mp_max_openfd(self) : for i in [17, 31, 42] : self.env.set_mp_max_openfd(i) self.assertEqual(i, self.env.get_mp_max_openfd()) def test_mp_max_write(self) : for i in [100, 200, 300] : for j in [1, 2, 3] : j *= 1000000 self.env.set_mp_max_write(i, j) v=self.env.get_mp_max_write() self.assertEqual((i, j), v) def test_invalid_txn(self) : # This environment doesn't support transactions self.assertRaises(db.DBInvalidArgError, self.env.txn_begin) def test_mp_mmapsize(self) : for i in [16, 32, 64] : i *= 1024*1024 self.env.set_mp_mmapsize(i) self.assertEqual(i, self.env.get_mp_mmapsize()) def test_tmp_dir(self) : for i in ["a", "bb", "ccc"] : self.env.set_tmp_dir(i) self.assertEqual(i, self.env.get_tmp_dir()) def test_flags(self) : self.env.set_flags(db.DB_AUTO_COMMIT, 1) self.assertEqual(db.DB_AUTO_COMMIT, self.env.get_flags()) self.env.set_flags(db.DB_TXN_NOSYNC, 1) self.assertEqual(db.DB_AUTO_COMMIT | db.DB_TXN_NOSYNC, self.env.get_flags()) self.env.set_flags(db.DB_AUTO_COMMIT, 0) self.assertEqual(db.DB_TXN_NOSYNC, self.env.get_flags()) self.env.set_flags(db.DB_TXN_NOSYNC, 0) self.assertEqual(0, self.env.get_flags()) def test_lk_max_objects(self) : for i in [1000, 2000, 3000] : self.env.set_lk_max_objects(i) self.assertEqual(i, self.env.get_lk_max_objects()) def test_lk_max_locks(self) : for i in [1000, 2000, 3000] : self.env.set_lk_max_locks(i) self.assertEqual(i, self.env.get_lk_max_locks()) def test_lk_max_lockers(self) : for i in [1000, 2000, 3000] : self.env.set_lk_max_lockers(i) self.assertEqual(i, self.env.get_lk_max_lockers()) def test_lg_regionmax(self) : for i in [128, 256, 1000] : i = i*1024*1024 self.env.set_lg_regionmax(i) j = self.env.get_lg_regionmax() self.assertTrue(i <= j) self.assertTrue(2*i > j) def test_lk_detect(self) : flags= [db.DB_LOCK_DEFAULT, db.DB_LOCK_EXPIRE, db.DB_LOCK_MAXLOCKS, db.DB_LOCK_MINLOCKS, db.DB_LOCK_MINWRITE, db.DB_LOCK_OLDEST, db.DB_LOCK_RANDOM, db.DB_LOCK_YOUNGEST] flags.append(db.DB_LOCK_MAXWRITE) for i in flags : self.env.set_lk_detect(i) self.assertEqual(i, self.env.get_lk_detect()) def test_lg_dir(self) : for i in ["a", "bb", "ccc", "dddd"] : self.env.set_lg_dir(i) self.assertEqual(i, self.env.get_lg_dir()) def test_lg_bsize(self) : log_size = 70*1024 self.env.set_lg_bsize(log_size) self.assertTrue(self.env.get_lg_bsize() >= log_size) self.assertTrue(self.env.get_lg_bsize() < 4*log_size) self.env.set_lg_bsize(4*log_size) self.assertTrue(self.env.get_lg_bsize() >= 4*log_size) def test_setget_data_dirs(self) : dirs = ("a", "b", "c", "d") for i in dirs : self.env.set_data_dir(i) self.assertEqual(dirs, self.env.get_data_dirs()) def test_setget_cachesize(self) : cachesize = (0, 512*1024*1024, 3) self.env.set_cachesize(*cachesize) self.assertEqual(cachesize, self.env.get_cachesize()) cachesize = (0, 1*1024*1024, 5) self.env.set_cachesize(*cachesize) cachesize2 = self.env.get_cachesize() self.assertEqual(cachesize[0], cachesize2[0]) self.assertEqual(cachesize[2], cachesize2[2]) # Berkeley DB expands the cache 25% accounting overhead, # if the cache is small. self.assertEqual(125, int(100.0*cachesize2[1]/cachesize[1])) # You can not change configuration after opening # the environment. self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL) cachesize = (0, 2*1024*1024, 1) self.assertRaises(db.DBInvalidArgError, self.env.set_cachesize, *cachesize) cachesize3 = self.env.get_cachesize() self.assertEqual(cachesize2[0], cachesize3[0]) self.assertEqual(cachesize2[2], cachesize3[2]) # In Berkeley DB 5.1, the cachesize can change when opening the Env self.assertTrue(cachesize2[1] <= cachesize3[1]) def test_set_cachesize_dbenv_db(self) : # You can not configure the cachesize using # the database handle, if you are using an environment. d = db.DB(self.env) self.assertRaises(db.DBInvalidArgError, d.set_cachesize, 0, 1024*1024, 1) def test_setget_shm_key(self) : shm_key=137 self.env.set_shm_key(shm_key) self.assertEqual(shm_key, self.env.get_shm_key()) self.env.set_shm_key(shm_key+1) self.assertEqual(shm_key+1, self.env.get_shm_key()) # You can not change configuration after opening # the environment. self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL) # If we try to reconfigure cache after opening the # environment, core dump. self.assertRaises(db.DBInvalidArgError, self.env.set_shm_key, shm_key) self.assertEqual(shm_key+1, self.env.get_shm_key()) def test_mutex_setget_max(self) : v = self.env.mutex_get_max() v2 = v*2+1 self.env.mutex_set_max(v2) self.assertEqual(v2, self.env.mutex_get_max()) self.env.mutex_set_max(v) self.assertEqual(v, self.env.mutex_get_max()) # You can not change configuration after opening # the environment. self.env.open(self.homeDir, db.DB_CREATE) self.assertRaises(db.DBInvalidArgError, self.env.mutex_set_max, v2) def test_mutex_setget_increment(self) : v = self.env.mutex_get_increment() v2 = 127 self.env.mutex_set_increment(v2) self.assertEqual(v2, self.env.mutex_get_increment()) self.env.mutex_set_increment(v) self.assertEqual(v, self.env.mutex_get_increment()) # You can not change configuration after opening # the environment. self.env.open(self.homeDir, db.DB_CREATE) self.assertRaises(db.DBInvalidArgError, self.env.mutex_set_increment, v2) def test_mutex_setget_tas_spins(self) : self.env.mutex_set_tas_spins(0) # Default = BDB decides v = self.env.mutex_get_tas_spins() v2 = v*2+1 self.env.mutex_set_tas_spins(v2) self.assertEqual(v2, self.env.mutex_get_tas_spins()) self.env.mutex_set_tas_spins(v) self.assertEqual(v, self.env.mutex_get_tas_spins()) # In this case, you can change configuration # after opening the environment. self.env.open(self.homeDir, db.DB_CREATE) self.env.mutex_set_tas_spins(v2) def test_mutex_setget_align(self) : v = self.env.mutex_get_align() v2 = 64 if v == 64 : v2 = 128 self.env.mutex_set_align(v2) self.assertEqual(v2, self.env.mutex_get_align()) # Requires a nonzero power of two self.assertRaises(db.DBInvalidArgError, self.env.mutex_set_align, 0) self.assertRaises(db.DBInvalidArgError, self.env.mutex_set_align, 17) self.env.mutex_set_align(2*v2) self.assertEqual(2*v2, self.env.mutex_get_align()) # You can not change configuration after opening # the environment. self.env.open(self.homeDir, db.DB_CREATE) self.assertRaises(db.DBInvalidArgError, self.env.mutex_set_align, v2) class DBEnv_log(DBEnv) : def setUp(self): DBEnv.setUp(self) self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL | db.DB_INIT_LOG) def test_log_file(self) : log_file = self.env.log_file((1, 1)) self.assertEqual("log.0000000001", log_file[-14:]) # The version with transactions is checked in other test object def test_log_printf(self) : msg = "This is a test..." self.env.log_printf(msg) logc = self.env.log_cursor() self.assertTrue(msg in (logc.last()[1])) if db.version() >= (4, 7) : def test_log_config(self) : self.env.log_set_config(db.DB_LOG_DSYNC | db.DB_LOG_ZERO, 1) self.assertTrue(self.env.log_get_config(db.DB_LOG_DSYNC)) self.assertTrue(self.env.log_get_config(db.DB_LOG_ZERO)) self.env.log_set_config(db.DB_LOG_ZERO, 0) self.assertTrue(self.env.log_get_config(db.DB_LOG_DSYNC)) self.assertFalse(self.env.log_get_config(db.DB_LOG_ZERO)) class DBEnv_log_txn(DBEnv) : def setUp(self): DBEnv.setUp(self) self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL | db.DB_INIT_LOG | db.DB_INIT_TXN) if db.version() < (5, 2) : def test_tx_max(self) : txns=[] def tx() : for i in xrange(self.env.get_tx_max()) : txns.append(self.env.txn_begin()) tx() self.assertRaises(MemoryError, tx) # Abort the transactions before garbage collection, # to avoid "warnings". for i in txns : i.abort() # The version without transactions is checked in other test object def test_log_printf(self) : msg = "This is a test..." txn = self.env.txn_begin() self.env.log_printf(msg, txn=txn) txn.commit() logc = self.env.log_cursor() logc.last() # Skip the commit self.assertTrue(msg in (logc.prev()[1])) msg = "This is another test..." txn = self.env.txn_begin() self.env.log_printf(msg, txn=txn) txn.abort() # Do not store the new message logc.last() # Skip the abort self.assertTrue(msg not in (logc.prev()[1])) msg = "This is a third test..." txn = self.env.txn_begin() self.env.log_printf(msg, txn=txn) txn.commit() # Do not store the new message logc.last() # Skip the commit self.assertTrue(msg in (logc.prev()[1])) class DBEnv_memp(DBEnv): def setUp(self): DBEnv.setUp(self) self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL | db.DB_INIT_LOG) self.db = db.DB(self.env) self.db.open("test", db.DB_HASH, db.DB_CREATE, 0660) def tearDown(self): self.db.close() del self.db DBEnv.tearDown(self) def test_memp_1_trickle(self) : self.db.put("hi", "bye") self.assertTrue(self.env.memp_trickle(100) > 0) # Preserve the order, do "memp_trickle" test first def test_memp_2_sync(self) : self.db.put("hi", "bye") self.env.memp_sync() # Full flush # Nothing to do... self.assertTrue(self.env.memp_trickle(100) == 0) self.db.put("hi", "bye2") self.env.memp_sync((1, 0)) # NOP, probably # Something to do... or not self.assertTrue(self.env.memp_trickle(100) >= 0) self.db.put("hi", "bye3") self.env.memp_sync((123, 99)) # Full flush # Nothing to do... self.assertTrue(self.env.memp_trickle(100) == 0) def test_memp_stat_1(self) : stats = self.env.memp_stat() # No param self.assertTrue(len(stats)==2) self.assertTrue("cache_miss" in stats[0]) stats = self.env.memp_stat(db.DB_STAT_CLEAR) # Positional param self.assertTrue("cache_miss" in stats[0]) stats = self.env.memp_stat(flags=0) # Keyword param self.assertTrue("cache_miss" in stats[0]) def test_memp_stat_2(self) : stats=self.env.memp_stat()[1] self.assertTrue(len(stats))==1 self.assertTrue("test" in stats) self.assertTrue("page_in" in stats["test"]) class DBEnv_logcursor(DBEnv): def setUp(self): DBEnv.setUp(self) self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL | db.DB_INIT_LOG | db.DB_INIT_TXN) txn = self.env.txn_begin() self.db = db.DB(self.env) self.db.open("test", db.DB_HASH, db.DB_CREATE, 0660, txn=txn) txn.commit() for i in ["2", "8", "20"] : txn = self.env.txn_begin() self.db.put(key = i, data = i*int(i), txn=txn) txn.commit() def tearDown(self): self.db.close() del self.db DBEnv.tearDown(self) def _check_return(self, value) : self.assertTrue(isinstance(value, tuple)) self.assertEqual(len(value), 2) self.assertTrue(isinstance(value[0], tuple)) self.assertEqual(len(value[0]), 2) self.assertTrue(isinstance(value[0][0], int)) self.assertTrue(isinstance(value[0][1], int)) self.assertTrue(isinstance(value[1], str)) # Preserve test order def test_1_first(self) : logc = self.env.log_cursor() v = logc.first() self._check_return(v) self.assertTrue((1, 1) < v[0]) self.assertTrue(len(v[1])>0) def test_2_last(self) : logc = self.env.log_cursor() lsn_first = logc.first()[0] v = logc.last() self._check_return(v) self.assertTrue(lsn_first < v[0]) def test_3_next(self) : logc = self.env.log_cursor() lsn_last = logc.last()[0] self.assertEqual(logc.next(), None) lsn_first = logc.first()[0] v = logc.next() self._check_return(v) self.assertTrue(lsn_first < v[0]) self.assertTrue(lsn_last > v[0]) v2 = logc.next() self.assertTrue(v2[0] > v[0]) self.assertTrue(lsn_last > v2[0]) v3 = logc.next() self.assertTrue(v3[0] > v2[0]) self.assertTrue(lsn_last > v3[0]) def test_4_prev(self) : logc = self.env.log_cursor() lsn_first = logc.first()[0] self.assertEqual(logc.prev(), None) lsn_last = logc.last()[0] v = logc.prev() self._check_return(v) self.assertTrue(lsn_first < v[0]) self.assertTrue(lsn_last > v[0]) v2 = logc.prev() self.assertTrue(v2[0] < v[0]) self.assertTrue(lsn_first < v2[0]) v3 = logc.prev() self.assertTrue(v3[0] < v2[0]) self.assertTrue(lsn_first < v3[0]) def test_5_current(self) : logc = self.env.log_cursor() logc.first() v = logc.next() self.assertEqual(v, logc.current()) def test_6_set(self) : logc = self.env.log_cursor() logc.first() v = logc.next() self.assertNotEqual(v, logc.next()) self.assertNotEqual(v, logc.next()) self.assertEqual(v, logc.set(v[0])) def test_explicit_close(self) : logc = self.env.log_cursor() logc.close() self.assertRaises(db.DBCursorClosedError, logc.next) def test_implicit_close(self) : logc = [self.env.log_cursor() for i in xrange(10)] self.env.close() # This close should close too all its tree for i in logc : self.assertRaises(db.DBCursorClosedError, i.next) def test_suite(): suite = unittest.TestSuite() suite.addTest(unittest.makeSuite(DBEnv_general)) suite.addTest(unittest.makeSuite(DBEnv_memp)) suite.addTest(unittest.makeSuite(DBEnv_logcursor)) suite.addTest(unittest.makeSuite(DBEnv_log)) suite.addTest(unittest.makeSuite(DBEnv_log_txn)) return suite if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib/bsddb/test/__init__.py0000644000175000017500000000000013316226203017355 0ustar jceajcea00000000000000bsddb3-6.2.7/Lib/bsddb/test/test_queue.py0000664000175000017500000001300013617051124020011 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """ TestCases for exercising a Queue DB. """ import os, string from pprint import pprint import unittest from test_all import db, verbose, get_new_database_path #---------------------------------------------------------------------- class SimpleQueueTestCase(unittest.TestCase): def setUp(self): self.filename = get_new_database_path() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_basic(self): # Basic Queue tests using the deprecated DBCursor.consume method. if verbose: print '\n', '-=' * 30 print "Running %s.test01_basic..." % self.__class__.__name__ d = db.DB() d.set_re_len(40) # Queues must be fixed length d.open(self.filename, db.DB_QUEUE, db.DB_CREATE) if verbose: print "before appends" + '-' * 30 pprint(d.stat()) for x in string.ascii_letters: d.append(x * 40) self.assertEqual(len(d), len(string.ascii_letters)) d.put(100, "some more data") d.put(101, "and some more ") d.put(75, "out of order") d.put(1, "replacement data") self.assertEqual(len(d), len(string.ascii_letters)+3) if verbose: print "before close" + '-' * 30 pprint(d.stat()) d.close() del d d = db.DB() d.open(self.filename) if verbose: print "after open" + '-' * 30 pprint(d.stat()) # Test "txn" as a positional parameter d.append("one more", None) # Test "txn" as a keyword parameter d.append("another one", txn=None) c = d.cursor() if verbose: print "after append" + '-' * 30 pprint(d.stat()) rec = c.consume() while rec: if verbose: print rec rec = c.consume() c.close() if verbose: print "after consume loop" + '-' * 30 pprint(d.stat()) self.assertEqual(len(d), 0, \ "if you see this message then you need to rebuild " \ "Berkeley DB 3.1.17 with the patch in patches/qam_stat.diff") d.close() def test02_basicPost32(self): # Basic Queue tests using the new DB.consume method in DB 3.2+ # (No cursor needed) if verbose: print '\n', '-=' * 30 print "Running %s.test02_basicPost32..." % self.__class__.__name__ d = db.DB() d.set_re_len(40) # Queues must be fixed length d.open(self.filename, db.DB_QUEUE, db.DB_CREATE) if verbose: print "before appends" + '-' * 30 pprint(d.stat()) for x in string.ascii_letters: d.append(x * 40) self.assertEqual(len(d), len(string.ascii_letters)) d.put(100, "some more data") d.put(101, "and some more ") d.put(75, "out of order") d.put(1, "replacement data") self.assertEqual(len(d), len(string.ascii_letters)+3) if verbose: print "before close" + '-' * 30 pprint(d.stat()) d.close() del d d = db.DB() d.open(self.filename) #d.set_get_returns_none(true) if verbose: print "after open" + '-' * 30 pprint(d.stat()) d.append("one more") if verbose: print "after append" + '-' * 30 pprint(d.stat()) rec = d.consume() while rec: if verbose: print rec rec = d.consume() if verbose: print "after consume loop" + '-' * 30 pprint(d.stat()) d.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(SimpleQueueTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib/bsddb/test/test_misc.py0000664000175000017500000001450513617051124017633 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """Miscellaneous bsddb module test cases """ import os, sys import unittest from test_all import db, dbshelve, hashopen, test_support, get_new_environment_path, get_new_database_path #---------------------------------------------------------------------- class MiscTestCase(unittest.TestCase): def setUp(self): self.filename = get_new_database_path() self.homeDir = get_new_environment_path() def tearDown(self): test_support.unlink(self.filename) test_support.rmtree(self.homeDir) def test01_badpointer(self): dbs = dbshelve.open(self.filename) dbs.close() self.assertRaises(db.DBError, dbs.get, "foo") def test02_db_home(self): env = db.DBEnv() # check for crash fixed when db_home is used before open() self.assertTrue(env.db_home is None) env.open(self.homeDir, db.DB_CREATE) if sys.version_info[0] < 3 : self.assertEqual(self.homeDir, env.db_home) else : self.assertEqual(bytes(self.homeDir, "ascii"), env.db_home) def test03_repr_closed_db(self): db = hashopen(self.filename) db.close() rp = repr(db) self.assertEqual(rp, "{}") def test04_repr_db(self) : db = hashopen(self.filename) d = {} for i in xrange(100) : db[repr(i)] = repr(100*i) d[repr(i)] = repr(100*i) db.close() db = hashopen(self.filename) rp = repr(sorted(db.items())) rd = repr(sorted(d.items())) self.assertEqual(rp, rd) db.close() # http://sourceforge.net/tracker/index.php?func=detail&aid=1708868&group_id=13900&atid=313900 # # See the bug report for details. # # The problem was that make_key_dbt() was not allocating a copy of # string keys but FREE_DBT() was always being told to free it when the # database was opened with DB_THREAD. def test05_double_free_make_key_dbt(self): try: db1 = db.DB() db1.open(self.filename, None, db.DB_BTREE, db.DB_CREATE | db.DB_THREAD) curs = db1.cursor() t = curs.get("/foo", db.DB_SET) # double free happened during exit from DBC_get finally: db1.close() test_support.unlink(self.filename) def test06_key_with_null_bytes(self): try: db1 = db.DB() db1.open(self.filename, None, db.DB_HASH, db.DB_CREATE) db1['a'] = 'eh?' db1['a\x00'] = 'eh zed.' db1['a\x00a'] = 'eh zed eh?' db1['aaa'] = 'eh eh eh!' keys = db1.keys() keys.sort() self.assertEqual(['a', 'a\x00', 'a\x00a', 'aaa'], keys) self.assertEqual(db1['a'], 'eh?') self.assertEqual(db1['a\x00'], 'eh zed.') self.assertEqual(db1['a\x00a'], 'eh zed eh?') self.assertEqual(db1['aaa'], 'eh eh eh!') finally: db1.close() test_support.unlink(self.filename) def test07_DB_set_flags_persists(self): try: db1 = db.DB() db1.set_flags(db.DB_DUPSORT) db1.open(self.filename, db.DB_HASH, db.DB_CREATE) db1['a'] = 'eh' db1['a'] = 'A' self.assertEqual([('a', 'A')], db1.items()) db1.put('a', 'Aa') self.assertEqual([('a', 'A'), ('a', 'Aa')], db1.items()) db1.close() db1 = db.DB() # no set_flags call, we're testing that it reads and obeys # the flags on open. db1.open(self.filename, db.DB_HASH) self.assertEqual([('a', 'A'), ('a', 'Aa')], db1.items()) # if it read the flags right this will replace all values # for key 'a' instead of adding a new one. (as a dict should) db1['a'] = 'new A' self.assertEqual([('a', 'new A')], db1.items()) finally: db1.close() test_support.unlink(self.filename) def test08_ExceptionTypes(self) : self.assertTrue(issubclass(db.DBError, Exception)) for i, j in db.__dict__.items() : if i.startswith("DB") and i.endswith("Error") : self.assertTrue(issubclass(j, db.DBError), msg=i) if i not in ("DBKeyEmptyError", "DBNotFoundError") : self.assertFalse(issubclass(j, KeyError), msg=i) # This two exceptions have two bases self.assertTrue(issubclass(db.DBKeyEmptyError, KeyError)) self.assertTrue(issubclass(db.DBNotFoundError, KeyError)) #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(MiscTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib/bsddb/__init__.py0000664000175000017500000003464513617056340016435 0ustar jceajcea00000000000000#---------------------------------------------------------------------- # Copyright (c) 1999-2001, Digital Creations, Fredericksburg, VA, USA # and Andrew Kuchling. All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: # # o Redistributions of source code must retain the above copyright # notice, this list of conditions, and the disclaimer that follows. # # o Redistributions in binary form must reproduce the above copyright # notice, this list of conditions, and the following disclaimer in # the documentation and/or other materials provided with the # distribution. # # o Neither the name of Digital Creations nor the names of its # contributors may be used to endorse or promote products derived # from this software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY DIGITAL CREATIONS AND CONTRIBUTORS *AS # IS* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED # TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A # PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL DIGITAL # CREATIONS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, # BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS # OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND # ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR # TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE # USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH # DAMAGE. #---------------------------------------------------------------------- """Support for Berkeley DB 4.3 through 5.3 with a simple interface. For the full featured object oriented interface use the bsddb.db module instead. It mirrors the Oracle Berkeley DB C API. """ import sys absolute_import = (sys.version_info[0] >= 3) try: if absolute_import : from . import _pybsddb else : import _pybsddb from bsddb3.dbutils import DeadlockWrap as _DeadlockWrap except ImportError: # Remove ourselves from sys.modules import sys del sys.modules[__name__] raise # bsddb3 calls it db, but provide _db for backwards compatibility db = _db = _pybsddb __version__ = db.__version__ error = db.DBError # So bsddb.error will mean something... #---------------------------------------------------------------------- import sys, os from weakref import ref if (sys.version_info[0] >= 3): from collections.abc import MutableMapping else: from collections import MutableMapping class _iter_mixin(MutableMapping): def _make_iter_cursor(self): cur = _DeadlockWrap(self.db.cursor) key = id(cur) self._cursor_refs[key] = ref(cur, self._gen_cref_cleaner(key)) return cur def _gen_cref_cleaner(self, key): # use generate the function for the weakref callback here # to ensure that we do not hold a strict reference to cur # in the callback. return lambda ref: self._cursor_refs.pop(key, None) def __iter__(self): self._kill_iteration = False self._in_iter += 1 try: try: cur = self._make_iter_cursor() # FIXME-20031102-greg: race condition. cursor could # be closed by another thread before this call. # since we're only returning keys, we call the cursor # methods with flags=0, dlen=0, dofs=0 key = _DeadlockWrap(cur.first, 0,0,0)[0] yield key next = getattr(cur, "next") while 1: try: key = _DeadlockWrap(next, 0,0,0)[0] yield key except _db.DBCursorClosedError: if self._kill_iteration: raise RuntimeError('Database changed size ' 'during iteration.') cur = self._make_iter_cursor() # FIXME-20031101-greg: race condition. cursor could # be closed by another thread before this call. _DeadlockWrap(cur.set, key,0,0,0) next = getattr(cur, "next") except _db.DBNotFoundError: pass except _db.DBCursorClosedError: # the database was modified during iteration. abort. pass finally : self._in_iter -= 1 def iteritems(self): if not self.db: return self._kill_iteration = False self._in_iter += 1 try: try: cur = self._make_iter_cursor() # FIXME-20031102-greg: race condition. cursor could # be closed by another thread before this call. kv = _DeadlockWrap(cur.first) key = kv[0] yield kv next = getattr(cur, "next") while 1: try: kv = _DeadlockWrap(next) key = kv[0] yield kv except _db.DBCursorClosedError: if self._kill_iteration: raise RuntimeError('Database changed size ' 'during iteration.') cur = self._make_iter_cursor() # FIXME-20031101-greg: race condition. cursor could # be closed by another thread before this call. _DeadlockWrap(cur.set, key,0,0,0) next = getattr(cur, "next") except _db.DBNotFoundError: pass except _db.DBCursorClosedError: # the database was modified during iteration. abort. pass finally : self._in_iter -= 1 class _DBWithCursor(_iter_mixin): """ A simple wrapper around DB that makes it look like the bsddbobject in the old module. It uses a cursor as needed to provide DB traversal. """ def __init__(self, db): self.db = db self.db.set_get_returns_none(0) # FIXME-20031101-greg: I believe there is still the potential # for deadlocks in a multithreaded environment if someone # attempts to use the any of the cursor interfaces in one # thread while doing a put or delete in another thread. The # reason is that _checkCursor and _closeCursors are not atomic # operations. Doing our own locking around self.dbc, # self.saved_dbc_key and self._cursor_refs could prevent this. # TODO: A test case demonstrating the problem needs to be written. # self.dbc is a DBCursor object used to implement the # first/next/previous/last/set_location methods. self.dbc = None self.saved_dbc_key = None # a collection of all DBCursor objects currently allocated # by the _iter_mixin interface. self._cursor_refs = {} self._in_iter = 0 self._kill_iteration = False def __del__(self): self.close() def _checkCursor(self): if self.dbc is None: self.dbc = _DeadlockWrap(self.db.cursor) if self.saved_dbc_key is not None: _DeadlockWrap(self.dbc.set, self.saved_dbc_key) self.saved_dbc_key = None # This method is needed for all non-cursor DB calls to avoid # Berkeley DB deadlocks (due to being opened with DB_INIT_LOCK # and DB_THREAD to be thread safe) when intermixing database # operations that use the cursor internally with those that don't. def _closeCursors(self, save=1): if self.dbc: c = self.dbc self.dbc = None if save: try: self.saved_dbc_key = _DeadlockWrap(c.current, 0,0,0)[0] except db.DBError: pass _DeadlockWrap(c.close) del c for cref in self._cursor_refs.values(): c = cref() if c is not None: _DeadlockWrap(c.close) def _checkOpen(self): if self.db is None: raise error, "BSDDB object has already been closed" def isOpen(self): return self.db is not None def __len__(self): self._checkOpen() return _DeadlockWrap(lambda: len(self.db)) # len(self.db) def __repr__(self) : if self.isOpen() : return repr(dict(_DeadlockWrap(self.db.items))) return repr(dict()) def __getitem__(self, key): self._checkOpen() return _DeadlockWrap(lambda: self.db[key]) # self.db[key] def __setitem__(self, key, value): self._checkOpen() self._closeCursors() if self._in_iter and key not in self: self._kill_iteration = True def wrapF(): self.db[key] = value _DeadlockWrap(wrapF) # self.db[key] = value def __delitem__(self, key): self._checkOpen() self._closeCursors() if self._in_iter and key in self: self._kill_iteration = True def wrapF(): del self.db[key] _DeadlockWrap(wrapF) # del self.db[key] def close(self): self._closeCursors(save=0) if self.dbc is not None: _DeadlockWrap(self.dbc.close) v = 0 if self.db is not None: v = _DeadlockWrap(self.db.close) self.dbc = None self.db = None return v def keys(self): self._checkOpen() return _DeadlockWrap(self.db.keys) def has_key(self, key): self._checkOpen() return _DeadlockWrap(self.db.has_key, key) def set_location(self, key): self._checkOpen() self._checkCursor() return _DeadlockWrap(self.dbc.set_range, key) def next(self): # Renamed by "2to3" self._checkOpen() self._checkCursor() rv = _DeadlockWrap(getattr(self.dbc, "next")) return rv if sys.version_info[0] >= 3 : # For "2to3" conversion next = __next__ def previous(self): self._checkOpen() self._checkCursor() rv = _DeadlockWrap(self.dbc.prev) return rv def first(self): self._checkOpen() # fix 1725856: don't needlessly try to restore our cursor position self.saved_dbc_key = None self._checkCursor() rv = _DeadlockWrap(self.dbc.first) return rv def last(self): self._checkOpen() # fix 1725856: don't needlessly try to restore our cursor position self.saved_dbc_key = None self._checkCursor() rv = _DeadlockWrap(self.dbc.last) return rv def sync(self): self._checkOpen() return _DeadlockWrap(self.db.sync) #---------------------------------------------------------------------- # Compatibility object factory functions def hashopen(file, flag='c', mode=0666, pgsize=None, ffactor=None, nelem=None, cachesize=None, lorder=None, hflags=0): flags = _checkflag(flag, file) e = _openDBEnv(cachesize) d = db.DB(e) d.set_flags(hflags) if pgsize is not None: d.set_pagesize(pgsize) if lorder is not None: d.set_lorder(lorder) if ffactor is not None: d.set_h_ffactor(ffactor) if nelem is not None: d.set_h_nelem(nelem) d.open(file, db.DB_HASH, flags, mode) return _DBWithCursor(d) #---------------------------------------------------------------------- def btopen(file, flag='c', mode=0666, btflags=0, cachesize=None, maxkeypage=None, minkeypage=None, pgsize=None, lorder=None): flags = _checkflag(flag, file) e = _openDBEnv(cachesize) d = db.DB(e) if pgsize is not None: d.set_pagesize(pgsize) if lorder is not None: d.set_lorder(lorder) d.set_flags(btflags) if minkeypage is not None: d.set_bt_minkey(minkeypage) if maxkeypage is not None: d.set_bt_maxkey(maxkeypage) d.open(file, db.DB_BTREE, flags, mode) return _DBWithCursor(d) #---------------------------------------------------------------------- def rnopen(file, flag='c', mode=0666, rnflags=0, cachesize=None, pgsize=None, lorder=None, rlen=None, delim=None, source=None, pad=None): flags = _checkflag(flag, file) e = _openDBEnv(cachesize) d = db.DB(e) if pgsize is not None: d.set_pagesize(pgsize) if lorder is not None: d.set_lorder(lorder) d.set_flags(rnflags) if delim is not None: d.set_re_delim(delim) if rlen is not None: d.set_re_len(rlen) if source is not None: d.set_re_source(source) if pad is not None: d.set_re_pad(pad) d.open(file, db.DB_RECNO, flags, mode) return _DBWithCursor(d) #---------------------------------------------------------------------- def _openDBEnv(cachesize): e = db.DBEnv() if cachesize is not None: if cachesize >= 20480: e.set_cachesize(0, cachesize) else: raise error, "cachesize must be >= 20480" e.set_lk_detect(db.DB_LOCK_DEFAULT) e.open('.', db.DB_PRIVATE | db.DB_CREATE | db.DB_THREAD | db.DB_INIT_LOCK | db.DB_INIT_MPOOL) return e def _checkflag(flag, file): if flag == 'r': flags = db.DB_RDONLY elif flag == 'rw': flags = 0 elif flag == 'w': flags = db.DB_CREATE elif flag == 'c': flags = db.DB_CREATE elif flag == 'n': flags = db.DB_CREATE #flags = db.DB_CREATE | db.DB_TRUNCATE # we used db.DB_TRUNCATE flag for this before but Berkeley DB # 4.2.52 changed to disallowed truncate with txn environments. if file is not None and os.path.isfile(file): os.unlink(file) else: raise error, "flags should be one of 'r', 'w', 'c' or 'n'" return flags | db.DB_THREAD #---------------------------------------------------------------------- # This is a silly little hack that allows apps to continue to use the # DB_THREAD flag even on systems without threads without freaking out # Berkeley DB. # # This assumes that if Python was built with thread support then # Berkeley DB was too. try: # 2to3 automatically changes "import thread" to "import _thread" import thread as T del T except ImportError: db.DB_THREAD = 0 #---------------------------------------------------------------------- bsddb3-6.2.7/Lib/bsddb/dbobj.py0000664000175000017500000002537513617056340015756 0ustar jceajcea00000000000000#------------------------------------------------------------------------- # This file contains real Python object wrappers for DB and DBEnv # C "objects" that can be usefully subclassed. The previous SWIG # based interface allowed this thanks to SWIG's shadow classes. # -- Gregory P. Smith #------------------------------------------------------------------------- # # (C) Copyright 2001 Autonomous Zone Industries # # License: This is free software. You may use this software for any # purpose including modification/redistribution, so long as # this header remains intact and that you do not claim any # rights of ownership or authorship of this software. This # software has been tested, but no warranty is expressed or # implied. # # # TODO it would be *really nice* to have an automatic shadow class populator # so that new methods don't need to be added here manually after being # added to _bsddb.c. # import sys absolute_import = (sys.version_info[0] >= 3) if absolute_import : from . import db else : import db if (sys.version_info[0] >= 3): from collections.abc import MutableMapping else: from collections import MutableMapping class DBEnv: def __init__(self, *args, **kwargs): self._cobj = db.DBEnv(*args, **kwargs) def close(self, *args, **kwargs): return self._cobj.close(*args, **kwargs) def open(self, *args, **kwargs): return self._cobj.open(*args, **kwargs) def remove(self, *args, **kwargs): return self._cobj.remove(*args, **kwargs) def set_shm_key(self, *args, **kwargs): return self._cobj.set_shm_key(*args, **kwargs) def set_cachesize(self, *args, **kwargs): return self._cobj.set_cachesize(*args, **kwargs) def set_data_dir(self, *args, **kwargs): return self._cobj.set_data_dir(*args, **kwargs) def set_flags(self, *args, **kwargs): return self._cobj.set_flags(*args, **kwargs) def set_lg_bsize(self, *args, **kwargs): return self._cobj.set_lg_bsize(*args, **kwargs) def set_lg_dir(self, *args, **kwargs): return self._cobj.set_lg_dir(*args, **kwargs) def set_lg_max(self, *args, **kwargs): return self._cobj.set_lg_max(*args, **kwargs) def set_lk_detect(self, *args, **kwargs): return self._cobj.set_lk_detect(*args, **kwargs) def set_lk_max_locks(self, *args, **kwargs): return self._cobj.set_lk_max_locks(*args, **kwargs) def set_lk_max_lockers(self, *args, **kwargs): return self._cobj.set_lk_max_lockers(*args, **kwargs) def set_lk_max_objects(self, *args, **kwargs): return self._cobj.set_lk_max_objects(*args, **kwargs) def set_mp_mmapsize(self, *args, **kwargs): return self._cobj.set_mp_mmapsize(*args, **kwargs) def set_timeout(self, *args, **kwargs): return self._cobj.set_timeout(*args, **kwargs) def set_tmp_dir(self, *args, **kwargs): return self._cobj.set_tmp_dir(*args, **kwargs) def txn_begin(self, *args, **kwargs): return self._cobj.txn_begin(*args, **kwargs) def txn_checkpoint(self, *args, **kwargs): return self._cobj.txn_checkpoint(*args, **kwargs) def txn_stat(self, *args, **kwargs): return self._cobj.txn_stat(*args, **kwargs) def set_tx_max(self, *args, **kwargs): return self._cobj.set_tx_max(*args, **kwargs) def set_tx_timestamp(self, *args, **kwargs): return self._cobj.set_tx_timestamp(*args, **kwargs) def lock_detect(self, *args, **kwargs): return self._cobj.lock_detect(*args, **kwargs) def lock_get(self, *args, **kwargs): return self._cobj.lock_get(*args, **kwargs) def lock_id(self, *args, **kwargs): return self._cobj.lock_id(*args, **kwargs) def lock_put(self, *args, **kwargs): return self._cobj.lock_put(*args, **kwargs) def lock_stat(self, *args, **kwargs): return self._cobj.lock_stat(*args, **kwargs) def log_archive(self, *args, **kwargs): return self._cobj.log_archive(*args, **kwargs) def set_get_returns_none(self, *args, **kwargs): return self._cobj.set_get_returns_none(*args, **kwargs) def log_stat(self, *args, **kwargs): return self._cobj.log_stat(*args, **kwargs) def dbremove(self, *args, **kwargs): return self._cobj.dbremove(*args, **kwargs) def dbrename(self, *args, **kwargs): return self._cobj.dbrename(*args, **kwargs) def set_encrypt(self, *args, **kwargs): return self._cobj.set_encrypt(*args, **kwargs) def fileid_reset(self, *args, **kwargs): return self._cobj.fileid_reset(*args, **kwargs) def lsn_reset(self, *args, **kwargs): return self._cobj.lsn_reset(*args, **kwargs) class DB(MutableMapping): def __init__(self, dbenv, *args, **kwargs): # give it the proper DBEnv C object that its expecting self._cobj = db.DB(*((dbenv._cobj,) + args), **kwargs) # TODO are there other dict methods that need to be overridden? def __len__(self): return len(self._cobj) def __getitem__(self, arg): return self._cobj[arg] def __setitem__(self, key, value): self._cobj[key] = value def __delitem__(self, arg): del self._cobj[arg] def __iter__(self) : return self._cobj.__iter__() def append(self, *args, **kwargs): return self._cobj.append(*args, **kwargs) def associate(self, *args, **kwargs): return self._cobj.associate(*args, **kwargs) def close(self, *args, **kwargs): return self._cobj.close(*args, **kwargs) def consume(self, *args, **kwargs): return self._cobj.consume(*args, **kwargs) def consume_wait(self, *args, **kwargs): return self._cobj.consume_wait(*args, **kwargs) def cursor(self, *args, **kwargs): return self._cobj.cursor(*args, **kwargs) def delete(self, *args, **kwargs): return self._cobj.delete(*args, **kwargs) def fd(self, *args, **kwargs): return self._cobj.fd(*args, **kwargs) def get(self, *args, **kwargs): return self._cobj.get(*args, **kwargs) def pget(self, *args, **kwargs): return self._cobj.pget(*args, **kwargs) def get_both(self, *args, **kwargs): return self._cobj.get_both(*args, **kwargs) def get_byteswapped(self, *args, **kwargs): return self._cobj.get_byteswapped(*args, **kwargs) def get_size(self, *args, **kwargs): return self._cobj.get_size(*args, **kwargs) def get_type(self, *args, **kwargs): return self._cobj.get_type(*args, **kwargs) def join(self, *args, **kwargs): return self._cobj.join(*args, **kwargs) def key_range(self, *args, **kwargs): return self._cobj.key_range(*args, **kwargs) def has_key(self, *args, **kwargs): return self._cobj.has_key(*args, **kwargs) def items(self, *args, **kwargs): return self._cobj.items(*args, **kwargs) def keys(self, *args, **kwargs): return self._cobj.keys(*args, **kwargs) def open(self, *args, **kwargs): return self._cobj.open(*args, **kwargs) def put(self, *args, **kwargs): return self._cobj.put(*args, **kwargs) def remove(self, *args, **kwargs): return self._cobj.remove(*args, **kwargs) def rename(self, *args, **kwargs): return self._cobj.rename(*args, **kwargs) def set_bt_minkey(self, *args, **kwargs): return self._cobj.set_bt_minkey(*args, **kwargs) def set_bt_compare(self, *args, **kwargs): return self._cobj.set_bt_compare(*args, **kwargs) def set_cachesize(self, *args, **kwargs): return self._cobj.set_cachesize(*args, **kwargs) def set_dup_compare(self, *args, **kwargs) : return self._cobj.set_dup_compare(*args, **kwargs) def set_flags(self, *args, **kwargs): return self._cobj.set_flags(*args, **kwargs) def set_h_ffactor(self, *args, **kwargs): return self._cobj.set_h_ffactor(*args, **kwargs) def set_h_nelem(self, *args, **kwargs): return self._cobj.set_h_nelem(*args, **kwargs) def set_lorder(self, *args, **kwargs): return self._cobj.set_lorder(*args, **kwargs) def set_pagesize(self, *args, **kwargs): return self._cobj.set_pagesize(*args, **kwargs) def set_re_delim(self, *args, **kwargs): return self._cobj.set_re_delim(*args, **kwargs) def set_re_len(self, *args, **kwargs): return self._cobj.set_re_len(*args, **kwargs) def set_re_pad(self, *args, **kwargs): return self._cobj.set_re_pad(*args, **kwargs) def set_re_source(self, *args, **kwargs): return self._cobj.set_re_source(*args, **kwargs) def set_q_extentsize(self, *args, **kwargs): return self._cobj.set_q_extentsize(*args, **kwargs) def stat(self, *args, **kwargs): return self._cobj.stat(*args, **kwargs) def sync(self, *args, **kwargs): return self._cobj.sync(*args, **kwargs) def type(self, *args, **kwargs): return self._cobj.type(*args, **kwargs) def upgrade(self, *args, **kwargs): return self._cobj.upgrade(*args, **kwargs) def values(self, *args, **kwargs): return self._cobj.values(*args, **kwargs) def verify(self, *args, **kwargs): return self._cobj.verify(*args, **kwargs) def set_get_returns_none(self, *args, **kwargs): return self._cobj.set_get_returns_none(*args, **kwargs) def set_encrypt(self, *args, **kwargs): return self._cobj.set_encrypt(*args, **kwargs) class DBSequence: def __init__(self, *args, **kwargs): self._cobj = db.DBSequence(*args, **kwargs) def close(self, *args, **kwargs): return self._cobj.close(*args, **kwargs) def get(self, *args, **kwargs): return self._cobj.get(*args, **kwargs) def get_dbp(self, *args, **kwargs): return self._cobj.get_dbp(*args, **kwargs) def get_key(self, *args, **kwargs): return self._cobj.get_key(*args, **kwargs) def init_value(self, *args, **kwargs): return self._cobj.init_value(*args, **kwargs) def open(self, *args, **kwargs): return self._cobj.open(*args, **kwargs) def remove(self, *args, **kwargs): return self._cobj.remove(*args, **kwargs) def stat(self, *args, **kwargs): return self._cobj.stat(*args, **kwargs) def set_cachesize(self, *args, **kwargs): return self._cobj.set_cachesize(*args, **kwargs) def set_flags(self, *args, **kwargs): return self._cobj.set_flags(*args, **kwargs) def set_range(self, *args, **kwargs): return self._cobj.set_range(*args, **kwargs) def get_cachesize(self, *args, **kwargs): return self._cobj.get_cachesize(*args, **kwargs) def get_flags(self, *args, **kwargs): return self._cobj.get_flags(*args, **kwargs) def get_range(self, *args, **kwargs): return self._cobj.get_range(*args, **kwargs) bsddb3-6.2.7/Lib/bsddb/dbshelve.py0000664000175000017500000002473613617056340016472 0ustar jceajcea00000000000000#!/usr/bin/env python #------------------------------------------------------------------------ # Copyright (c) 1997-2001 by Total Control Software # All Rights Reserved #------------------------------------------------------------------------ # # Module Name: dbShelve.py # # Description: A reimplementation of the standard shelve.py that # forces the use of cPickle, and DB. # # Creation Date: 11/3/97 3:39:04PM # # License: This is free software. You may use this software for any # purpose including modification/redistribution, so long as # this header remains intact and that you do not claim any # rights of ownership or authorship of this software. This # software has been tested, but no warranty is expressed or # implied. # # 13-Dec-2000: Updated to be used with the new bsddb3 package. # Added DBShelfCursor class. # #------------------------------------------------------------------------ """Manage shelves of pickled objects using bsddb database files for the storage. """ #------------------------------------------------------------------------ import sys absolute_import = (sys.version_info[0] >= 3) if absolute_import : from . import db else : import db if sys.version_info[0] >= 3 : import cPickle # Will be converted to "pickle" by "2to3" else : import warnings with warnings.catch_warnings() : warnings.filterwarnings("ignore", category=DeprecationWarning) import cPickle HIGHEST_PROTOCOL = cPickle.HIGHEST_PROTOCOL def _dumps(object, protocol): return cPickle.dumps(object, protocol=protocol) if (sys.version_info[0] >= 3): from collections.abc import MutableMapping else: from collections import MutableMapping #------------------------------------------------------------------------ def open(filename, flags=db.DB_CREATE, mode=0660, filetype=db.DB_HASH, dbenv=None, dbname=None): """ A simple factory function for compatibility with the standard shelve.py module. It can be used like this, where key is a string and data is a pickleable object: from bsddb import dbshelve db = dbshelve.open(filename) db[key] = data db.close() """ if type(flags) == type(''): sflag = flags if sflag == 'r': flags = db.DB_RDONLY elif sflag == 'rw': flags = 0 elif sflag == 'w': flags = db.DB_CREATE elif sflag == 'c': flags = db.DB_CREATE elif sflag == 'n': flags = db.DB_TRUNCATE | db.DB_CREATE else: raise db.DBError, "flags should be one of 'r', 'w', 'c' or 'n' or use the bsddb.db.DB_* flags" d = DBShelf(dbenv) d.open(filename, dbname, filetype, flags, mode) return d #--------------------------------------------------------------------------- class DBShelveError(db.DBError): pass class DBShelf(MutableMapping): """A shelf to hold pickled objects, built upon a bsddb DB object. It automatically pickles/unpickles data objects going to/from the DB. """ def __init__(self, dbenv=None): self.db = db.DB(dbenv) self._closed = True if HIGHEST_PROTOCOL: self.protocol = HIGHEST_PROTOCOL else: self.protocol = 1 def __del__(self): self.close() def __getattr__(self, name): """Many methods we can just pass through to the DB object. (See below) """ return getattr(self.db, name) #----------------------------------- # Dictionary access methods def __len__(self): return len(self.db) def __getitem__(self, key): data = self.db[key] return cPickle.loads(data) def __setitem__(self, key, value): data = _dumps(value, self.protocol) self.db[key] = data def __delitem__(self, key): del self.db[key] def keys(self, txn=None): if txn is not None: return self.db.keys(txn) else: return self.db.keys() def __iter__(self) : # XXX: Load all keys in memory :-( for k in self.db.keys() : yield k # Do this when "DB" support iteration # Or is it enough to pass thru "getattr"? # # def __iter__(self) : # return self.db.__iter__() def open(self, *args, **kwargs): self.db.open(*args, **kwargs) self._closed = False def close(self, *args, **kwargs): self.db.close(*args, **kwargs) self._closed = True def __repr__(self): if self._closed: return '' % (id(self)) else: return repr(dict(self.iteritems())) def items(self, txn=None): if txn is not None: items = self.db.items(txn) else: items = self.db.items() newitems = [] for k, v in items: newitems.append( (k, cPickle.loads(v)) ) return newitems def values(self, txn=None): if txn is not None: values = self.db.values(txn) else: values = self.db.values() return map(cPickle.loads, values) #----------------------------------- # Other methods def __append(self, value, txn=None): data = _dumps(value, self.protocol) return self.db.append(data, txn) def append(self, value, txn=None): if self.get_type() == db.DB_RECNO: return self.__append(value, txn=txn) raise DBShelveError, "append() only supported when dbshelve opened with filetype=dbshelve.db.DB_RECNO" def associate(self, secondaryDB, callback, flags=0): def _shelf_callback(priKey, priData, realCallback=callback): # Safe in Python 2.x because expresion short circuit if sys.version_info[0] < 3 or isinstance(priData, bytes) : data = cPickle.loads(priData) else : data = cPickle.loads(bytes(priData, "iso8859-1")) # 8 bits return realCallback(priKey, data) return self.db.associate(secondaryDB, _shelf_callback, flags) #def get(self, key, default=None, txn=None, flags=0): def get(self, *args, **kw): # We do it with *args and **kw so if the default value wasn't # given nothing is passed to the extension module. That way # an exception can be raised if set_get_returns_none is turned # off. data = self.db.get(*args, **kw) try: return cPickle.loads(data) except (EOFError, TypeError, cPickle.UnpicklingError): return data # we may be getting the default value, or None, # so it doesn't need unpickled. def get_both(self, key, value, txn=None, flags=0): data = _dumps(value, self.protocol) data = self.db.get(key, data, txn, flags) return cPickle.loads(data) def cursor(self, txn=None, flags=0): c = DBShelfCursor(self.db.cursor(txn, flags)) c.protocol = self.protocol return c def put(self, key, value, txn=None, flags=0): data = _dumps(value, self.protocol) return self.db.put(key, data, txn, flags) def join(self, cursorList, flags=0): raise NotImplementedError #---------------------------------------------- # Methods allowed to pass-through to self.db # # close, delete, fd, get_byteswapped, get_type, has_key, # key_range, open, remove, rename, stat, sync, # upgrade, verify, and all set_* methods. #--------------------------------------------------------------------------- class DBShelfCursor: """ """ def __init__(self, cursor): self.dbc = cursor def __del__(self): self.close() def __getattr__(self, name): """Some methods we can just pass through to the cursor object. (See below)""" return getattr(self.dbc, name) #---------------------------------------------- def dup(self, flags=0): c = DBShelfCursor(self.dbc.dup(flags)) c.protocol = self.protocol return c def put(self, key, value, flags=0): data = _dumps(value, self.protocol) return self.dbc.put(key, data, flags) def get(self, *args): count = len(args) # a method overloading hack method = getattr(self, 'get_%d' % count) method(*args) def get_1(self, flags): rec = self.dbc.get(flags) return self._extract(rec) def get_2(self, key, flags): rec = self.dbc.get(key, flags) return self._extract(rec) def get_3(self, key, value, flags): data = _dumps(value, self.protocol) rec = self.dbc.get(key, flags) return self._extract(rec) def current(self, flags=0): return self.get_1(flags|db.DB_CURRENT) def first(self, flags=0): return self.get_1(flags|db.DB_FIRST) def last(self, flags=0): return self.get_1(flags|db.DB_LAST) def next(self, flags=0): return self.get_1(flags|db.DB_NEXT) def prev(self, flags=0): return self.get_1(flags|db.DB_PREV) def consume(self, flags=0): return self.get_1(flags|db.DB_CONSUME) def next_dup(self, flags=0): return self.get_1(flags|db.DB_NEXT_DUP) def next_nodup(self, flags=0): return self.get_1(flags|db.DB_NEXT_NODUP) def prev_nodup(self, flags=0): return self.get_1(flags|db.DB_PREV_NODUP) def get_both(self, key, value, flags=0): data = _dumps(value, self.protocol) rec = self.dbc.get_both(key, flags) return self._extract(rec) def set(self, key, flags=0): rec = self.dbc.set(key, flags) return self._extract(rec) def set_range(self, key, flags=0): rec = self.dbc.set_range(key, flags) return self._extract(rec) def set_recno(self, recno, flags=0): rec = self.dbc.set_recno(recno, flags) return self._extract(rec) set_both = get_both def _extract(self, rec): if rec is None: return None else: key, data = rec # Safe in Python 2.x because expresion short circuit if sys.version_info[0] < 3 or isinstance(data, bytes) : return key, cPickle.loads(data) else : return key, cPickle.loads(bytes(data, "iso8859-1")) # 8 bits #---------------------------------------------- # Methods allowed to pass-through to self.dbc # # close, count, delete, get_recno, join_item #--------------------------------------------------------------------------- bsddb3-6.2.7/Lib/bsddb/dbrecio.py0000644000175000017500000001227413316226203016266 0ustar jceajcea00000000000000 """ File-like objects that read from or write to a bsddb record. This implements (nearly) all stdio methods. f = DBRecIO(db, key, txn=None) f.close() # explicitly release resources held flag = f.isatty() # always false pos = f.tell() # get current position f.seek(pos) # set current position f.seek(pos, mode) # mode 0: absolute; 1: relative; 2: relative to EOF buf = f.read() # read until EOF buf = f.read(n) # read up to n bytes f.truncate([size]) # truncate file at to at most size (default: current pos) f.write(buf) # write at current position f.writelines(list) # for line in list: f.write(line) Notes: - fileno() is left unimplemented so that code which uses it triggers an exception early. - There's a simple test set (see end of this file) - not yet updated for DBRecIO. - readline() is not implemented yet. From: Itamar Shtull-Trauring """ import errno import string class DBRecIO: def __init__(self, db, key, txn=None): self.db = db self.key = key self.txn = txn self.len = None self.pos = 0 self.closed = 0 self.softspace = 0 def close(self): if not self.closed: self.closed = 1 del self.db, self.txn def isatty(self): if self.closed: raise ValueError, "I/O operation on closed file" return 0 def seek(self, pos, mode = 0): if self.closed: raise ValueError, "I/O operation on closed file" if mode == 1: pos = pos + self.pos elif mode == 2: pos = pos + self.len self.pos = max(0, pos) def tell(self): if self.closed: raise ValueError, "I/O operation on closed file" return self.pos def read(self, n = -1): if self.closed: raise ValueError, "I/O operation on closed file" if n < 0: newpos = self.len else: newpos = min(self.pos+n, self.len) dlen = newpos - self.pos r = self.db.get(self.key, txn=self.txn, dlen=dlen, doff=self.pos) self.pos = newpos return r __fixme = """ def readline(self, length=None): if self.closed: raise ValueError, "I/O operation on closed file" if self.buflist: self.buf = self.buf + string.joinfields(self.buflist, '') self.buflist = [] i = string.find(self.buf, '\n', self.pos) if i < 0: newpos = self.len else: newpos = i+1 if length is not None: if self.pos + length < newpos: newpos = self.pos + length r = self.buf[self.pos:newpos] self.pos = newpos return r def readlines(self, sizehint = 0): total = 0 lines = [] line = self.readline() while line: lines.append(line) total += len(line) if 0 < sizehint <= total: break line = self.readline() return lines """ def truncate(self, size=None): if self.closed: raise ValueError, "I/O operation on closed file" if size is None: size = self.pos elif size < 0: raise IOError(errno.EINVAL, "Negative size not allowed") elif size < self.pos: self.pos = size self.db.put(self.key, "", txn=self.txn, dlen=self.len-size, doff=size) def write(self, s): if self.closed: raise ValueError, "I/O operation on closed file" if not s: return if self.pos > self.len: self.buflist.append('\0'*(self.pos - self.len)) self.len = self.pos newpos = self.pos + len(s) self.db.put(self.key, s, txn=self.txn, dlen=len(s), doff=self.pos) self.pos = newpos def writelines(self, list): self.write(string.joinfields(list, '')) def flush(self): if self.closed: raise ValueError, "I/O operation on closed file" """ # A little test suite def _test(): import sys if sys.argv[1:]: file = sys.argv[1] else: file = '/etc/passwd' lines = open(file, 'r').readlines() text = open(file, 'r').read() f = StringIO() for line in lines[:-2]: f.write(line) f.writelines(lines[-2:]) if f.getvalue() != text: raise RuntimeError, 'write failed' length = f.tell() print 'File length =', length f.seek(len(lines[0])) f.write(lines[1]) f.seek(0) print 'First line =', repr(f.readline()) here = f.tell() line = f.readline() print 'Second line =', repr(line) f.seek(-len(line), 1) line2 = f.read(len(line)) if line != line2: raise RuntimeError, 'bad result after seek back' f.seek(len(line2), 1) list = f.readlines() line = list[-1] f.seek(f.tell() - len(line)) line2 = f.read() if line != line2: raise RuntimeError, 'bad result after seek back from EOF' print 'Read', len(list), 'more lines' print 'File length =', f.tell() if f.tell() != length: raise RuntimeError, 'bad length' f.close() if __name__ == '__main__': _test() """ bsddb3-6.2.7/Lib/bsddb/dbtables.py0000644000175000017500000007262713316226203016447 0ustar jceajcea00000000000000#----------------------------------------------------------------------- # # Copyright (C) 2000, 2001 by Autonomous Zone Industries # Copyright (C) 2002 Gregory P. Smith # # License: This is free software. You may use this software for any # purpose including modification/redistribution, so long as # this header remains intact and that you do not claim any # rights of ownership or authorship of this software. This # software has been tested, but no warranty is expressed or # implied. # # -- Gregory P. Smith # This provides a simple database table interface built on top of # the Python Berkeley DB 3 interface. # import re import sys import copy import random import struct if sys.version_info[0] >= 3 : import pickle else : import warnings with warnings.catch_warnings() : warnings.filterwarnings("ignore", category=DeprecationWarning) import cPickle as pickle from bsddb3 import db class TableDBError(StandardError): pass class TableAlreadyExists(TableDBError): pass class Cond: """This condition matches everything""" def __call__(self, s): return 1 class ExactCond(Cond): """Acts as an exact match condition function""" def __init__(self, strtomatch): self.strtomatch = strtomatch def __call__(self, s): return s == self.strtomatch class PrefixCond(Cond): """Acts as a condition function for matching a string prefix""" def __init__(self, prefix): self.prefix = prefix def __call__(self, s): return s[:len(self.prefix)] == self.prefix class PostfixCond(Cond): """Acts as a condition function for matching a string postfix""" def __init__(self, postfix): self.postfix = postfix def __call__(self, s): return s[-len(self.postfix):] == self.postfix class LikeCond(Cond): """ Acts as a function that will match using an SQL 'LIKE' style string. Case insensitive and % signs are wild cards. This isn't perfect but it should work for the simple common cases. """ def __init__(self, likestr, re_flags=re.IGNORECASE): # escape python re characters chars_to_escape = '.*+()[]?' for char in chars_to_escape : likestr = likestr.replace(char, '\\'+char) # convert %s to wildcards self.likestr = likestr.replace('%', '.*') self.re = re.compile('^'+self.likestr+'$', re_flags) def __call__(self, s): return self.re.match(s) # # keys used to store database metadata # _table_names_key = '__TABLE_NAMES__' # list of the tables in this db _columns = '._COLUMNS__' # table_name+this key contains a list of columns def _columns_key(table): return table + _columns # # these keys are found within table sub databases # _data = '._DATA_.' # this+column+this+rowid key contains table data _rowid = '._ROWID_.' # this+rowid+this key contains a unique entry for each # row in the table. (no data is stored) _rowid_str_len = 8 # length in bytes of the unique rowid strings def _data_key(table, col, rowid): return table + _data + col + _data + rowid def _search_col_data_key(table, col): return table + _data + col + _data def _search_all_data_key(table): return table + _data def _rowid_key(table, rowid): return table + _rowid + rowid + _rowid def _search_rowid_key(table): return table + _rowid def contains_metastrings(s) : """Verify that the given string does not contain any metadata strings that might interfere with dbtables database operation. """ if (s.find(_table_names_key) >= 0 or s.find(_columns) >= 0 or s.find(_data) >= 0 or s.find(_rowid) >= 0): # Then return 1 else: return 0 class bsdTableDB : def __init__(self, filename, dbhome, create=0, truncate=0, mode=0600, recover=0, dbflags=0): """bsdTableDB(filename, dbhome, create=0, truncate=0, mode=0600) Open database name in the dbhome Berkeley DB directory. Use keyword arguments when calling this constructor. """ self.db = None myflags = db.DB_THREAD if create: myflags |= db.DB_CREATE flagsforenv = (db.DB_INIT_MPOOL | db.DB_INIT_LOCK | db.DB_INIT_LOG | db.DB_INIT_TXN | dbflags) # DB_AUTO_COMMIT isn't a valid flag for env.open() try: dbflags |= db.DB_AUTO_COMMIT except AttributeError: pass if recover: flagsforenv = flagsforenv | db.DB_RECOVER self.env = db.DBEnv() # enable auto deadlock avoidance self.env.set_lk_detect(db.DB_LOCK_DEFAULT) self.env.open(dbhome, myflags | flagsforenv) if truncate: myflags |= db.DB_TRUNCATE self.db = db.DB(self.env) # this code relies on DBCursor.set* methods to raise exceptions # rather than returning None self.db.set_get_returns_none(1) # allow duplicate entries [warning: be careful w/ metadata] self.db.set_flags(db.DB_DUP) self.db.open(filename, db.DB_BTREE, dbflags | myflags, mode) self.dbfilename = filename if sys.version_info[0] >= 3 : class cursor_py3k(object) : def __init__(self, dbcursor) : self._dbcursor = dbcursor def close(self) : return self._dbcursor.close() def set_range(self, search) : v = self._dbcursor.set_range(bytes(search, "iso8859-1")) if v is not None : v = (v[0].decode("iso8859-1"), v[1].decode("iso8859-1")) return v def __next__(self) : v = getattr(self._dbcursor, "next")() if v is not None : v = (v[0].decode("iso8859-1"), v[1].decode("iso8859-1")) return v class db_py3k(object) : def __init__(self, db) : self._db = db def cursor(self, txn=None) : return cursor_py3k(self._db.cursor(txn=txn)) def has_key(self, key, txn=None) : return getattr(self._db,"has_key")(bytes(key, "iso8859-1"), txn=txn) def put(self, key, value, flags=0, txn=None) : key = bytes(key, "iso8859-1") if value is not None : value = bytes(value, "iso8859-1") return self._db.put(key, value, flags=flags, txn=txn) def put_bytes(self, key, value, txn=None) : key = bytes(key, "iso8859-1") return self._db.put(key, value, txn=txn) def get(self, key, txn=None, flags=0) : key = bytes(key, "iso8859-1") v = self._db.get(key, txn=txn, flags=flags) if v is not None : v = v.decode("iso8859-1") return v def get_bytes(self, key, txn=None, flags=0) : key = bytes(key, "iso8859-1") return self._db.get(key, txn=txn, flags=flags) def delete(self, key, txn=None) : key = bytes(key, "iso8859-1") return self._db.delete(key, txn=txn) def close (self) : return self._db.close() self.db = db_py3k(self.db) else : # Python 2.x pass # Initialize the table names list if this is a new database txn = self.env.txn_begin() try: if not getattr(self.db, "has_key")(_table_names_key, txn): getattr(self.db, "put_bytes", self.db.put) \ (_table_names_key, pickle.dumps([], 1), txn=txn) # Yes, bare except except: txn.abort() raise else: txn.commit() # TODO verify more of the database's metadata? self.__tablecolumns = {} def __del__(self): self.close() def close(self): if self.db is not None: self.db.close() self.db = None if self.env is not None: self.env.close() self.env = None def checkpoint(self, mins=0): self.env.txn_checkpoint(mins) def sync(self): self.db.sync() def _db_print(self) : """Print the database to stdout for debugging""" print "******** Printing raw database for debugging ********" cur = self.db.cursor() try: key, data = cur.first() while 1: print repr({key: data}) next = cur.next() if next: key, data = next else: cur.close() return except db.DBNotFoundError: cur.close() def CreateTable(self, table, columns): """CreateTable(table, columns) - Create a new table in the database. raises TableDBError if it already exists or for other DB errors. """ assert isinstance(columns, list) txn = None try: # checking sanity of the table and column names here on # table creation will prevent problems elsewhere. if contains_metastrings(table): raise ValueError( "bad table name: contains reserved metastrings") for column in columns : if contains_metastrings(column): raise ValueError( "bad column name: contains reserved metastrings") columnlist_key = _columns_key(table) if getattr(self.db, "has_key")(columnlist_key): raise TableAlreadyExists, "table already exists" txn = self.env.txn_begin() # store the table's column info getattr(self.db, "put_bytes", self.db.put)(columnlist_key, pickle.dumps(columns, 1), txn=txn) # add the table name to the tablelist tablelist = pickle.loads(getattr(self.db, "get_bytes", self.db.get) (_table_names_key, txn=txn, flags=db.DB_RMW)) tablelist.append(table) # delete 1st, in case we opened with DB_DUP self.db.delete(_table_names_key, txn=txn) getattr(self.db, "put_bytes", self.db.put)(_table_names_key, pickle.dumps(tablelist, 1), txn=txn) txn.commit() txn = None except db.DBError, dberror: if txn: txn.abort() if sys.version_info < (2, 6) : raise TableDBError, dberror[1] else : raise TableDBError, dberror.args[1] def ListTableColumns(self, table): """Return a list of columns in the given table. [] if the table doesn't exist. """ assert isinstance(table, str) if contains_metastrings(table): raise ValueError, "bad table name: contains reserved metastrings" columnlist_key = _columns_key(table) if not getattr(self.db, "has_key")(columnlist_key): return [] pickledcolumnlist = getattr(self.db, "get_bytes", self.db.get)(columnlist_key) if pickledcolumnlist: return pickle.loads(pickledcolumnlist) else: return [] def ListTables(self): """Return a list of tables in this database.""" pickledtablelist = getattr(self.db, "get_bytes", self.db.get)(_table_names_key) if pickledtablelist: return pickle.loads(pickledtablelist) else: return [] def CreateOrExtendTable(self, table, columns): """CreateOrExtendTable(table, columns) Create a new table in the database. If a table of this name already exists, extend it to have any additional columns present in the given list as well as all of its current columns. """ assert isinstance(columns, list) try: self.CreateTable(table, columns) except TableAlreadyExists: # the table already existed, add any new columns txn = None try: columnlist_key = _columns_key(table) txn = self.env.txn_begin() # load the current column list oldcolumnlist = pickle.loads( getattr(self.db, "get_bytes", self.db.get)(columnlist_key, txn=txn, flags=db.DB_RMW)) # create a hash table for fast lookups of column names in the # loop below oldcolumnhash = {} for c in oldcolumnlist: oldcolumnhash[c] = c # create a new column list containing both the old and new # column names newcolumnlist = copy.copy(oldcolumnlist) for c in columns: if not c in oldcolumnhash: newcolumnlist.append(c) # store the table's new extended column list if newcolumnlist != oldcolumnlist : # delete the old one first since we opened with DB_DUP self.db.delete(columnlist_key, txn=txn) getattr(self.db, "put_bytes", self.db.put)(columnlist_key, pickle.dumps(newcolumnlist, 1), txn=txn) txn.commit() txn = None self.__load_column_info(table) except db.DBError, dberror: if txn: txn.abort() if sys.version_info < (2, 6) : raise TableDBError, dberror[1] else : raise TableDBError, dberror.args[1] def __load_column_info(self, table) : """initialize the self.__tablecolumns dict""" # check the column names try: tcolpickles = getattr(self.db, "get_bytes", self.db.get)(_columns_key(table)) except db.DBNotFoundError: raise TableDBError, "unknown table: %r" % (table,) if not tcolpickles: raise TableDBError, "unknown table: %r" % (table,) self.__tablecolumns[table] = pickle.loads(tcolpickles) def __new_rowid(self, table, txn) : """Create a new unique row identifier""" unique = 0 while not unique: # Generate a random 64-bit row ID string # (note: might have <64 bits of true randomness # but it's plenty for our database id needs!) blist = [] for x in xrange(_rowid_str_len): blist.append(random.randint(0,255)) newid = struct.pack('B'*_rowid_str_len, *blist) if sys.version_info[0] >= 3 : newid = newid.decode("iso8859-1") # 8 bits # Guarantee uniqueness by adding this key to the database try: self.db.put(_rowid_key(table, newid), None, txn=txn, flags=db.DB_NOOVERWRITE) except db.DBKeyExistError: pass else: unique = 1 return newid def Insert(self, table, rowdict) : """Insert(table, datadict) - Insert a new row into the table using the keys+values from rowdict as the column values. """ txn = None try: if not getattr(self.db, "has_key")(_columns_key(table)): raise TableDBError, "unknown table" # check the validity of each column name if not table in self.__tablecolumns: self.__load_column_info(table) for column in rowdict.keys() : if not self.__tablecolumns[table].count(column): raise TableDBError, "unknown column: %r" % (column,) # get a unique row identifier for this row txn = self.env.txn_begin() rowid = self.__new_rowid(table, txn=txn) # insert the row values into the table database for column, dataitem in rowdict.items(): # store the value self.db.put(_data_key(table, column, rowid), dataitem, txn=txn) txn.commit() txn = None except db.DBError, dberror: # WIBNI we could just abort the txn and re-raise the exception? # But no, because TableDBError is not related to DBError via # inheritance, so it would be backwards incompatible. Do the next # best thing. info = sys.exc_info() if txn: txn.abort() self.db.delete(_rowid_key(table, rowid)) if sys.version_info < (2, 6) : raise TableDBError, dberror[1], info[2] else : raise TableDBError, dberror.args[1], info[2] def Modify(self, table, conditions={}, mappings={}): """Modify(table, conditions={}, mappings={}) - Modify items in rows matching 'conditions' using mapping functions in 'mappings' * table - the table name * conditions - a dictionary keyed on column names containing a condition callable expecting the data string as an argument and returning a boolean. * mappings - a dictionary keyed on column names containing a condition callable expecting the data string as an argument and returning the new string for that column. """ try: matching_rowids = self.__Select(table, [], conditions) # modify only requested columns columns = mappings.keys() for rowid in matching_rowids.keys(): txn = None try: for column in columns: txn = self.env.txn_begin() # modify the requested column try: dataitem = self.db.get( _data_key(table, column, rowid), txn=txn) self.db.delete( _data_key(table, column, rowid), txn=txn) except db.DBNotFoundError: # XXXXXXX row key somehow didn't exist, assume no # error dataitem = None dataitem = mappings[column](dataitem) if dataitem is not None: self.db.put( _data_key(table, column, rowid), dataitem, txn=txn) txn.commit() txn = None # catch all exceptions here since we call unknown callables except: if txn: txn.abort() raise except db.DBError, dberror: if sys.version_info < (2, 6) : raise TableDBError, dberror[1] else : raise TableDBError, dberror.args[1] def Delete(self, table, conditions={}): """Delete(table, conditions) - Delete items matching the given conditions from the table. * conditions - a dictionary keyed on column names containing condition functions expecting the data string as an argument and returning a boolean. """ try: matching_rowids = self.__Select(table, [], conditions) # delete row data from all columns columns = self.__tablecolumns[table] for rowid in matching_rowids.keys(): txn = None try: txn = self.env.txn_begin() for column in columns: # delete the data key try: self.db.delete(_data_key(table, column, rowid), txn=txn) except db.DBNotFoundError: # XXXXXXX column may not exist, assume no error pass try: self.db.delete(_rowid_key(table, rowid), txn=txn) except db.DBNotFoundError: # XXXXXXX row key somehow didn't exist, assume no error pass txn.commit() txn = None except db.DBError, dberror: if txn: txn.abort() raise except db.DBError, dberror: if sys.version_info < (2, 6) : raise TableDBError, dberror[1] else : raise TableDBError, dberror.args[1] def Select(self, table, columns, conditions={}): """Select(table, columns, conditions) - retrieve specific row data Returns a list of row column->value mapping dictionaries. * columns - a list of which column data to return. If columns is None, all columns will be returned. * conditions - a dictionary keyed on column names containing callable conditions expecting the data string as an argument and returning a boolean. """ try: if not table in self.__tablecolumns: self.__load_column_info(table) if columns is None: columns = self.__tablecolumns[table] matching_rowids = self.__Select(table, columns, conditions) except db.DBError, dberror: if sys.version_info < (2, 6) : raise TableDBError, dberror[1] else : raise TableDBError, dberror.args[1] # return the matches as a list of dictionaries return matching_rowids.values() def __Select(self, table, columns, conditions): """__Select() - Used to implement Select and Delete (above) Returns a dictionary keyed on rowids containing dicts holding the row data for columns listed in the columns param that match the given conditions. * conditions is a dictionary keyed on column names containing callable conditions expecting the data string as an argument and returning a boolean. """ # check the validity of each column name if not table in self.__tablecolumns: self.__load_column_info(table) if columns is None: columns = self.tablecolumns[table] for column in (columns + conditions.keys()): if not self.__tablecolumns[table].count(column): raise TableDBError, "unknown column: %r" % (column,) # keyed on rows that match so far, containings dicts keyed on # column names containing the data for that row and column. matching_rowids = {} # keys are rowids that do not match rejected_rowids = {} # attempt to sort the conditions in such a way as to minimize full # column lookups def cmp_conditions(atuple, btuple): a = atuple[1] b = btuple[1] if type(a) is type(b): # Needed for python 3. "cmp" vanished in 3.0.1 def cmp(a, b) : if a==b : return 0 if a 0: for rowid, rowdata in matching_rowids.items(): for column in columns: if column in rowdata: continue try: rowdata[column] = self.db.get( _data_key(table, column, rowid)) except db.DBError, dberror: if sys.version_info < (2, 6) : if dberror[0] != db.DB_NOTFOUND: raise else : if dberror.args[0] != db.DB_NOTFOUND: raise rowdata[column] = None # return the matches return matching_rowids def Drop(self, table): """Remove an entire table from the database""" txn = None try: txn = self.env.txn_begin() # delete the column list self.db.delete(_columns_key(table), txn=txn) cur = self.db.cursor(txn) # delete all keys containing this tables column and row info table_key = _search_all_data_key(table) while 1: try: key, data = cur.set_range(table_key) except db.DBNotFoundError: break # only delete items in this table if key[:len(table_key)] != table_key: break cur.delete() # delete all rowids used by this table table_key = _search_rowid_key(table) while 1: try: key, data = cur.set_range(table_key) except db.DBNotFoundError: break # only delete items in this table if key[:len(table_key)] != table_key: break cur.delete() cur.close() # delete the tablename from the table name list tablelist = pickle.loads( getattr(self.db, "get_bytes", self.db.get)(_table_names_key, txn=txn, flags=db.DB_RMW)) try: tablelist.remove(table) except ValueError: # hmm, it wasn't there, oh well, that's what we want. pass # delete 1st, incase we opened with DB_DUP self.db.delete(_table_names_key, txn=txn) getattr(self.db, "put_bytes", self.db.put)(_table_names_key, pickle.dumps(tablelist, 1), txn=txn) txn.commit() txn = None if table in self.__tablecolumns: del self.__tablecolumns[table] except db.DBError, dberror: if txn: txn.abort() raise TableDBError(dberror.args[1]) bsddb3-6.2.7/Lib/bsddb/db.py0000644000175000017500000000422413316226203015240 0ustar jceajcea00000000000000#---------------------------------------------------------------------- # Copyright (c) 1999-2001, Digital Creations, Fredericksburg, VA, USA # and Andrew Kuchling. All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: # # o Redistributions of source code must retain the above copyright # notice, this list of conditions, and the disclaimer that follows. # # o Redistributions in binary form must reproduce the above copyright # notice, this list of conditions, and the following disclaimer in # the documentation and/or other materials provided with the # distribution. # # o Neither the name of Digital Creations nor the names of its # contributors may be used to endorse or promote products derived # from this software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY DIGITAL CREATIONS AND CONTRIBUTORS *AS # IS* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED # TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A # PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL DIGITAL # CREATIONS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, # BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS # OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND # ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR # TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE # USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH # DAMAGE. #---------------------------------------------------------------------- # This module is just a placeholder for possible future expansion, in # case we ever want to augment the stuff in _db in any way. For now # it just simply imports everything from _db. import sys absolute_import = (sys.version_info[0] >= 3) if not absolute_import : from _pybsddb import * from _pybsddb import __version__ else : from ._pybsddb import * from ._pybsddb import __version__ bsddb3-6.2.7/test-full_prerelease.py0000775000175000017500000000640713617051124017231 0ustar jceajcea00000000000000#!/usr/bin/env python """ Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ info = """ This program checks all the matrix formed by several Python and Berkeley DB versions. This code is only intented to be used by the maintainer, just before a pybsddb release, to verify compatibility and regresions. It contains local details only applicable to maintainer. If you try it as is, it would fail. """ import subprocess import sys import os # We need to be able to test BDB releases, even if the license is incompatible os.environ['YES_I_HAVE_THE_RIGHT_TO_USE_THIS_BERKELEY_DB_VERSION'] = '' def do_matrix_check() : python_versions = ('2.6', '2.7', '3.3', '3.4', '3.5', '3.6', '3.7', 3.8', '3.9') berkeleydb_versions=('4.7', '4.8', '5.1', '5.3', '6.1', '6.2') warning_level=("-Wdefault", "-Werror")[1] for py in python_versions : for bdb in berkeleydb_versions : print print "*** Testing bindings for Python %s and Berkeley DB %s" %(py,bdb) extra_params = [warning_level, "-tt"] # Extra flags for 3.x extra_params += [] if float(py)<=2.999 else ["-bb"] # Extra flags for >=2.6 extra_params += [] if ((float(py)<=2.599) or (float(py)>=2.999)) else ["-3"] params = extra_params + ["setup.py", "-q", \ "--berkeley-db=/usr/local/BerkeleyDB."+bdb,"build", "-f"] params = ["/usr/local/bin/python"+py] + params print "EXECUTING:", " ".join(params) ret=subprocess.call(params) if not ret : params = ["/usr/local/bin/python"+py] + extra_params + ["test.py","-p"] print "EXECUTING:", " ".join(params) ret = subprocess.call(params) if ret : print print ">>> WE HAVE A PROBLEM!" print sys.exit(1) if __name__=="__main__" : print info do_matrix_check() bsddb3-6.2.7/make3.py0000775000175000017500000000633313617051124014101 0ustar jceajcea00000000000000#!/usr/bin/env python """ Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ import sys, os refactor_path="/usr/local/lib/python3.5/" def copy2to3(path_from, path_to) : files_to_convert = {} if os.path.isdir(path_from) : if path_from.endswith(".hg") : return {} try : os.mkdir(path_to) except : pass for i in os.listdir(path_from) : files_to_convert.update(copy2to3(path_from+"/"+i,path_to+"/"+i)) return files_to_convert cwd = os.getcwd() if (not path_from.endswith(".py")) or (os.path.exists(path_to) and \ (os.stat(path_from).st_mtime < os.stat(path_to).st_mtime)) : return {} if path_from[0] != "/" : path_from = cwd+"/"+path_from if path_to[0] != "/" : path_to = cwd+"/"+path_to files_to_convert[path_from] = path_to try : open(path_to, "w").write(open(path_from, "r").read()) except : os.remove(path_to) raise return files_to_convert def make2to3(path_from, path_to) : files_to_convert = copy2to3(path_from, path_to) retcode = 0 for path_from, path_to in files_to_convert.iteritems() : print "*** Converting", path_to try : import subprocess process = subprocess.Popen(["2to3", "-w", path_to], cwd=refactor_path) retcode = process.wait() except : os.remove(path_to) raise try : os.remove(path_to+".bak") except : pass if retcode : os.remove(path_to) print "ERROR!" return bool(retcode) return bool(retcode) print "Using '%s' for 2to3 conversion tool" %refactor_path make2to3("setup2.py", "setup3.py") make2to3("test2.py", "test3.py") make2to3("Lib", "Lib3") bsddb3-6.2.7/setup2.py0000664000175000017500000005427113617132775014340 0ustar jceajcea00000000000000#!/usr/bin/env python """ Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ import os import re import sys import glob if (sys.version_info[0] < 3) and (sys.version_info >= (2, 6)) : # Silence deprecation warnings during "setup" import warnings warnings.filterwarnings('ignore', message='in 3.x, bsddb has been removed; ' \ 'please use the pybsddb project instead', category=DeprecationWarning) warnings.filterwarnings('ignore', message='in 3.x, the bsddb module has been removed; ' \ 'please use the pybsddb project instead', category=DeprecationWarning) if sys.version_info[:2] == (2, 7) : with warnings.catch_warnings() : # Python 2.7.0 warnings.filterwarnings('ignore', message='The CObject type is marked Pending Deprecation ' \ 'in Python 2.7. Please use capsule objects instead.', category=PendingDeprecationWarning) # Python 2.7.1 warnings.filterwarnings('ignore', message='CObject type is not supported in 3.x. ' \ 'Please use capsule objects instead.', category=DeprecationWarning) try : # 'bsddb' library could be not available import bsddb # Import the 2.7 version, that uses CObject except ImportError : pass # setuptools warnings warnings.filterwarnings('ignore', message='tuple parameter unpacking has been removed in 3.x', category=SyntaxWarning) warnings.filterwarnings('ignore', message='the dl module has been removed in Python 3.0; ' \ 'use the ctypes module instead', category=DeprecationWarning) try : from setuptools import setup, Extension except : from distutils.core import setup, Extension from distutils.dep_util import newer import distutils.ccompiler # read the module version number out of the .c file VERSION = None _ver_re = re.compile('^#\s*define\s+PY_BSDDB_VERSION\s+"(\d+\.\d+\.\d+.*)"') try: _srcFile = open('Modules/bsddb.h', 'r') except IOError: print "Could not open module source to read the version number." raise for line in _srcFile.readlines(): m = _ver_re.match(line) if m: VERSION = m.group(1) continue # We close first, to avoid a "ResourceWarning" _srcFile.close() del _srcFile del _ver_re del m if not VERSION: raise RuntimeError, "could not find PY_BSDDB_VERSION in Modules/bsddb.h" #---------------------------------------------------------------------- debug = '--debug' in sys.argv or '-g' in sys.argv lflags_arg = [] if os.name == 'posix': # Allow setting the DB dir and additional link flags either in # the environment or on the command line. # First check the environment... BERKELEYDB_INCDIR = os.environ.get('BERKELEYDB_INCDIR', '') BERKELEYDB_LIBDIR = os.environ.get('BERKELEYDB_LIBDIR', '') BERKELEYDB_DIR = os.environ.get('BERKELEYDB_DIR', '') LFLAGS = os.environ.get('LFLAGS', []) LIBS = os.environ.get('LIBS', []) # ...then the command line. # Handle --berkeley-db=[PATH] and --lflags=[FLAGS] args = sys.argv[:] for arg in args: if arg.startswith('--berkeley-db-incdir='): BERKELEYDB_INCDIR = arg.split('=')[1] sys.argv.remove(arg) if arg.startswith('--berkeley-db-libdir='): BERKELEYDB_LIBDIR = arg.split('=')[1] sys.argv.remove(arg) if arg.startswith('--berkeley-db='): BERKELEYDB_DIR = arg.split('=')[1] sys.argv.remove(arg) elif arg.startswith('--lflags='): LFLAGS = arg.split('=')[1].split() sys.argv.remove(arg) elif arg.startswith('--libs='): LIBS = arg.split('=')[1].split() sys.argv.remove(arg) if LFLAGS or LIBS: lflags_arg = LFLAGS + LIBS # Supported Berkeley DB versions, in order of preference. db_ver_list = ((6, 2), (6, 1), (5, 3), (5, 1), (4, 8), (4, 7)) db_ver = None # If we were not told where it is, go looking for it. dblib = 'db' incdir = libdir = None if not BERKELEYDB_DIR and not BERKELEYDB_LIBDIR and not BERKELEYDB_INCDIR: # construct a list of paths to look for the header file in on # top of the normal inc_dirs. db_inc_paths = [] db_major = set() bitness = "" import platform if (platform.architecture()[0] == "64bit") and \ (platform.platform(True, True).startswith("Solaris-")) and \ (not platform.uname()[3].startswith('joyent_')): bitness = "/64" for major, minor in db_ver_list : if major not in db_major : db_major.add(major) db_inc_paths.extend([ '/usr/include/db%d%s' %(major, bitness), '/usr/local/include/db%d%s' %(major, bitness), '/opt/local/include/db%d%s' %(major, bitness), '/opt/sfw/include/db%d%s' %(major, bitness), '/sw/include/db%d%s' %(major, bitness), '/usr/local/opt/berkeley-db@%s/include' % (major), ]) db_inc_paths.append('/usr/include/db%d%d%s' % \ (major, minor, bitness)) db_inc_paths.append('/usr/local/BerkeleyDB.%d.%d%s/include' % \ (major, minor, bitness)) db_inc_paths.append('/usr/local/include/db%d%d%s' % \ (major, minor, bitness)) db_inc_paths.append('/pkg/db-%d.%d%s/include' % \ (major, minor, bitness)) db_inc_paths.append('/opt/db-%d.%d%s/include' % \ (major, minor, bitness)) db_ver_inc_map = {} class db_found(Exception): pass try: # this CCompiler object is only used to locate include files compiler = distutils.ccompiler.new_compiler() lib_dirs = compiler.library_dirs + [ '/lib64', '/usr/lib64', '/lib', '/usr/lib', '/usr/lib/x86_64-linux-gnu/', ] inc_dirs = compiler.include_dirs + [ '/usr/include', '/usr/local/opt/berkeley-db/include', ] # See whether there is a Oracle or Sleepycat header in the standard # search path. for d in inc_dirs + db_inc_paths: f = os.path.join(d, "db.h") if debug: print "db: looking for db.h in", f if os.path.exists(f): with open(f) as fichero : f = fichero.read() m = re.search(r"#define\WDB_VERSION_MAJOR\W(\d+)", f) if m: db_major = int(m.group(1)) m = re.search(r"#define\WDB_VERSION_MINOR\W(\d+)", f) db_minor = int(m.group(1)) db_ver = (db_major, db_minor) if ( (not db_ver_inc_map.has_key(db_ver)) and (db_ver in db_ver_list) ): # save the include directory with the db.h version # (first occurrance only) db_ver_inc_map[db_ver] = d if debug: print "db.h: found", db_ver, "in", d else: # we already found a header for this library version if debug: print "db.h: ignoring", d else: # ignore this header, it didn't contain a version number if debug: print "db.h: unsupported version", db_ver, "in", d db_found_vers = db_ver_inc_map.keys() db_found_vers.sort() while db_found_vers: db_ver = db_found_vers.pop() db_incdir = db_ver_inc_map[db_ver] # check lib directories parallel to the location of the header db_dirs_to_check = [ os.path.join(db_incdir, '..', 'lib64'), os.path.join(db_incdir, '..', 'lib'), os.path.join(db_incdir, '..', '..', 'lib64'), os.path.join(db_incdir, '..', '..', 'lib'), ] db_dirs_to_check = filter(os.path.isdir, db_dirs_to_check) # Look for a version specific db-X.Y before an ambiguoius dbX # XXX should we -ever- look for a dbX name? Do any # systems really not name their library by version and # symlink to more general names? for dblib in ( ('db%d-%d.%d' % (db_ver[0], db_ver[0], db_ver[1])), ('db-%d.%d' % db_ver), ('db%d' % db_ver[0]) ): dblib_file = compiler.find_library_file( db_dirs_to_check + lib_dirs, dblib ) if dblib_file: db_libdir = os.path.abspath(os.path.dirname(dblib_file)) raise db_found else: if debug: print "db lib: ", dblib, "not found" except db_found: print "Found Berkeley DB %d.%d installation." % db_ver print " include files in", db_incdir print " library files in", db_libdir print " library name is lib"+dblib if debug: print "db: lib dir", db_libdir, "inc dir", db_incdir incdir = db_incdir libdir = db_libdir else: # this means Berkeley DB could not be found pass if BERKELEYDB_LIBDIR or BERKELEYDB_INCDIR: libdir = BERKELEYDB_LIBDIR or None incdir = BERKELEYDB_INCDIR or None if not BERKELEYDB_DIR and not incdir and not libdir: print "Can't find a local Berkeley DB installation." print "(suggestion: try the --berkeley-db=/path/to/bsddb option)" sys.exit(1) # figure out from the base setting where the lib and .h are if not incdir: incdir = os.path.join(BERKELEYDB_DIR, 'include') if not libdir: libdir = os.path.join(BERKELEYDB_DIR, 'lib') if not '-ldb' in LIBS: libname = [dblib] else: if debug: print "LIBS already contains '-ldb' not adding our own", "'-l"+dblib+"'" libname = [] utils = [] # Test if the old bsddb is built-in static = 0 try: # Possibly already imported in the "warning" section (python 2.7) import bsddb if str(bsddb).find('built-in') >= 0: static = 1 except ImportError: pass # On Un*x, double check that no other built-in module pulls libdb in as a # side-effect. TBD: how/what to do on other platforms? fp = os.popen('ldd %s 2>&1' % sys.executable) results = fp.read() status = fp.close() if not status and results.find('libdb.') >= 0: static = 1 if static: print """\ \aWARNING: \tIt appears that the old bsddb module is staticly linked in the \tPython executable. This will cause various random problems for \tbsddb3, up to and including segfaults. Please rebuild your \tPython either with bsddb disabled, or with it built as a shared \tdynamic extension. Watch out for other modules (e.g. dbm) that create \tdependencies in the python executable to libdb as a side effect.""" st = raw_input("Build anyway? (yes/[no]) ") if st != "yes": sys.exit(1) # read db.h to figure out what version of Berkeley DB this is ver = None with open(os.path.join(incdir, 'db.h'), 'r') as f : db_h_lines = f.readlines() db_ver_re = re.compile( r'^#define\s+DB_VERSION_STRING\s.*Berkeley DB (\d+\.\d+).*') db_ver2 = db_ver if db_ver is None : print "Trying to use the Berkeley DB you specified..." for line in db_h_lines: match = db_ver_re.match(line) if not match: continue fullverstr = match.group(1) ver = fullverstr[0] + fullverstr[2] # 31 == 3.1, 32 == 3.2, etc. db_ver = (int(fullverstr[0]), int(fullverstr[2])) if (db_ver2 is not None) and (db_ver != db_ver2) : raise AssertionError("Detected Berkeley DB version is inconsistent") if db_ver not in db_ver_list: raise AssertionError("pybsddb untested with this Berkeley DB " "version %d.%d" %db_ver) print 'Detected Berkeley DB version %d.%d from db.h' %db_ver elif os.name == 'nt': # The default build of Berkeley DB for windows just leaves # everything in the build dirs in the db source tree. That means # that we either have to hunt around to find it, (which would be # even more difficult than the mess above for Unix...) or we make # the builder specify everything here. Compounding the problem is # version numbers in default path names, and different library # names for debug/release or dll/static. # # So to make things easier, I'm just going to expect that the DB stuff # has been moved to the ./db directory. There's an updatedb.bat file to # help. # # You'll need to edit the project file that comes with Berkeley DB so it # uses "Multithreaded DLL" and "Debug Multithreaded DLL" (/MD and /MDd) # settings as appropriate to build .lib file (the db_static project). incdir = 'db/include' libdir = 'db/lib' # read db.h to figure out what version of Berkeley DB this is ver = None with open(os.path.join(incdir, 'db.h'), 'r') as f : db_h_lines = f.readlines() db_ver_re = re.compile( r'^#define\s+DB_VERSION_STRING\s.*Berkeley DB (\d+\.\d+).*') for line in db_h_lines: match = db_ver_re.match(line) if not match: continue fullverstr = match.group(1) ver = fullverstr[0] + fullverstr[2] # 31 == 3.1, 32 == 3.2, etc. db_ver = (int(fullverstr[0]), int(fullverstr[2])) if db_ver not in db_ver_list: raise AssertionError("pybsddb untested with this Berkeley DB " "version %d.%d" %db_ver) print 'Detected Berkeley DB version %d.%d from db.h' %db_ver if debug: libname = ['libdb%ssd' % ver] # Debug, static else: libname = ['libdb%ss' % ver] # Release, static utils = [("bsddb3/utils", ["db/bin/db_archive.exe", "db/bin/db_checkpoint.exe", "db/bin/db_deadlock.exe", "db/bin/db_dump.exe", "db/bin/db_load.exe", "db/bin/db_printlog.exe", "db/bin/db_recover.exe", "db/bin/db_stat.exe", "db/bin/db_upgrade.exe", "db/bin/db_verify.exe", "db/bin/libdb%s.dll" % ver, ]), ("bsddb3/test", glob.glob("test/*.py")) ] if (db_ver in ((6, 0), (6, 1), (6, 2))) and \ ("YES_I_HAVE_THE_RIGHT_TO_USE_THIS_BERKELEY_DB_VERSION" not in os.environ) : print ( "\n" "******* COMPILATION ABORTED *******\n" "\n" "You are linking a Berkeley DB version licensed under " "AGPL3 or have a commercial license.\n" "\n" "AGPL3 is a strong copyleft license and derivative " "works must be equivalently licensed.\n" "\n" "You have two choices:\n" "\n" " 1. If your code is AGPL3 or you have a commercial Berkeley DB " "license from Oracle, please, define the environment variable " "'YES_I_HAVE_THE_RIGHT_TO_USE_THIS_BERKELEY_DB_VERSION' to " "any value, and try to install this python library again.\n" "\n" " 2. In any other case, you have to link to a previous version " "of Berkeley DB. Remove Berlekey DB version 6.x and let this " "python library try to locate an older version of the " "Berkeley DB library in your system. Alternatively, you can " "define the environment variable 'BERKELEYDB_DIR', or " "'BERKELEYDB_INCDIR' and 'BERKELEYDB_LIBDIR', with the path of " "the Berkeley DB you want to use and try to install this " "python library again.\n" "\n" "Sorry for the inconvenience. I am trying to protect you.\n" "\n" "More details:\n" "\n" " https://forums.oracle.com/message/11184885\n" " http://lists.debian.org/debian-legal/2013/07/\n" "\n" "******* COMPILATION ABORTED *******\n" ) sys.exit(1) version_suffix = "" if sys.version_info[0] > 2 : version_suffix = "3" # ############################# # Delete pkgsrc stale info # This is something that eventually should be not necesary. # XXX - jcea@jcea.es - 20170125 from distutils import sysconfig # The same dictionary is always returned, so we abuse it # and modify it in place. config_vars = sysconfig.get_config_vars() for k, v in list(config_vars.items()): if isinstance(v, str) and ('/db4' in v): j = ' '.join([i for i in v.split() if not i.endswith('/db4')]) config_vars[k] = j del config_vars # ############################# # do the actual build, install, whatever... setup(name = 'bsddb3', version = VERSION, description = 'Python bindings for Oracle Berkeley DB', long_description = """\ This module provides a nearly complete wrapping of the Oracle/Sleepycat C API for the Database Environment, Database, Cursor, Log Cursor, Sequence and Transaction objects, and each of these is exposed as a Python type in the bsddb3.db module. The database objects can use various access methods: btree, hash, recno, and queue. Complete support of Berkeley DB distributed transactions. Complete support for Berkeley DB Replication Manager. Complete support for Berkeley DB Base Replication. Support for RPC. Please see the documents in the docs directory of the source distribution or at the website for more details on the types and methods provided. The goal is to mirror most of the real Berkeley DB API so fall back to the Oracle Berkeley DB documentation as appropriate. If you need to support ancient versiones of Python and/or Berkeley DB , you can use old releases of this bindings. `Homepage `__ -- `Releases (changelog) `__ -- `Documentation `__ -- `Mailing List `__ -- `Donation `__ """, long_description_content_type = 'text/x-rst', author = 'Jesus Cea, Robin Dunn, Gregory P. Smith, Andrew Kuchling, Barry Warsaw', author_email = 'pybsddb@jcea.es', url = 'https://www.jcea.es/programacion/pybsddb.htm', license = "3-clause BSD License", packages = ['bsddb3', 'bsddb3/tests'], package_dir = {'bsddb3': 'Lib%s/bsddb' %version_suffix, 'bsddb3/tests': 'Lib%s/bsddb/test' %version_suffix}, ext_modules = [Extension('bsddb3._pybsddb', sources = ['Modules/_bsddb.c'], depends = ['Modules/bsddb.h'], include_dirs = [ incdir ], library_dirs = [ libdir ], runtime_library_dirs = [ libdir ], libraries = libname, extra_link_args = lflags_arg, )], headers = ['Modules/bsddb.h'], data_files = utils, classifiers = [ 'License :: OSI Approved :: BSD License', 'Development Status :: 5 - Production/Stable', 'Intended Audience :: Developers', 'Intended Audience :: Information Technology', 'Natural Language :: English', 'Natural Language :: Spanish', 'Operating System :: OS Independent', 'Programming Language :: Python', 'Topic :: Database', 'Topic :: Software Development', 'Topic :: System :: Clustering', 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 2.6', 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.3', 'Programming Language :: Python :: 3.4', 'Programming Language :: Python :: 3.5', 'Programming Language :: Python :: 3.6', 'Programming Language :: Python :: 3.7', 'Programming Language :: Python :: 3.8', 'Programming Language :: Python :: 3.9', ], ) bsddb3-6.2.7/test2.py0000644000175000017500000004665113316226203014142 0ustar jceajcea00000000000000############################################################################## # # Copyright (c) 2001, 2002, 2003 Zope Corporation and Contributors. # All Rights Reserved. # # This software is subject to the provisions of the Zope Public License, # Version 2.0 (ZPL). A copy of the ZPL should accompany this distribution. # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # FOR A PARTICULAR PURPOSE. # ############################################################################## """Run the test suite. Usage: %(PROGRAM)s [options] [modfilter [testfilter]] Options: -b Run "python setup.py build" before running tests, where "python" is the version of python used to run test.py. Highly recommended. Tests will be run from the build directory. -B Run "python setup.py build_ext -i" before running tests. Tests will be run from the source directory. -c Use pychecker. -d Instead of the normal test harness, run a debug version which doesn't catch any exceptions. This is occasionally handy when the unittest code catching the exception doesn't work right. Unfortunately, the debug harness doesn't print the name of the test, so Use With Care. -D Works like -d, except that it loads pdb when an exception occurs. -g threshold Set the garbage collector generation0 threshold. This can be used to stress memory and gc correctness. Some crashes are only reproducible when the threshold is set to 1 (aggressive garbage collection). Do "-g 0" to disable garbage collection altogether. -G gc_option Set the garbage collection debugging flags. The argument must be one of the DEBUG_ flags defined by the Python gc module. Multiple options can be specified by using "-G OPTION1 -G OPTION2." -h / --help Print this help text and exit. -L Keep running the selected tests in a loop. You may experience memory leakage, but this is a handy option for catching race conditions. -u -m Use the PyUnit GUI instead of output to the command line. The GUI imports tests on its own, taking care to reload all dependencies on each run. The debug (-d), verbose (-v), and Loop (-L) options will be ignored. The testfilter filter is also not applied. -m starts the gui minimized. Double-clicking the progress bar will start the import and run all tests. -p Show running progress. It can be combined with -v or -vv. -T Use the trace module from Python for code coverage. XXX This only works if trace.py is explicitly added to PYTHONPATH. The current utility writes coverage files to a directory named `coverage' that is parallel to `build'. It also prints a summary to stdout. -v Verbose output. With one -v, unittest prints a dot (".") for each test run. With -vv, unittest prints the name of each test (for some definition of "name" ...). With no -v, unittest is silent until the end of the run, except when errors occur. modfilter testfilter Case-sensitive regexps to limit which tests are run, used in search (not match) mode. In an extension of Python regexp notation, a leading "!" is stripped and causes the sense of the remaining regexp to be negated (so "!bc" matches any string that does not match "bc", and vice versa). By default these act like ".", i.e. nothing is excluded. modfilter is applied to a test file's path, starting at "build" and including (OS-dependent) path separators. testfilter is applied to the (method) name of the unittest methods contained in the test files whose paths modfilter matched. Extreme (yet useful) examples: test.py -vvb . "^checkWriteClient$" Builds the project silently, then runs unittest in verbose mode on all tests whose names are precisely "checkWriteClient". Useful when debugging a specific test. test.py -vvb . "!^checkWriteClient$" As before, but runs all tests whose names aren't precisely "checkWriteClient". Useful to avoid a specific failing test you don't want to deal with just yet. test.py -m . "!^checkWriteClient$" As before, but now opens up a minimized PyUnit GUI window (only showing the progress bar). Useful for refactoring runs where you continually want to make sure all tests still pass. """ import warnings # Simulate "python -Wdefault". # http://docs.python.org/dev/library/warnings.html#updating-code-for-new-versions-of-python # Command line argument has priority, so the full matrix check can be more # strict. warnings.simplefilter('default') import gc import os import re import pdb import sys import getopt import unittest import linecache import traceback from distutils.util import get_platform # We need to be able to test BDB releases, even if the license is incompatible os.environ['YES_I_HAVE_THE_RIGHT_TO_USE_THIS_BERKELEY_DB_VERSION'] = '' PROGRAM = sys.argv[0] PLAT_SPEC = "%s-%s" % (get_platform(), sys.version[0:3]) # This hack copied from distutils.command.build. Too bad distutils # doesn't export its build/ directory naming scheme as a library function. if hasattr(sys, 'gettotalrefcount'): PLAT_SPEC += '-pydebug' try : # Check in the future if this still necessary # Python 2.7 and 3.2 from unittest.runner import _TextTestResult except ImportError : from unittest import _TextTestResult class ImmediateTestResult(_TextTestResult): __super_init = _TextTestResult.__init__ __super_startTest = _TextTestResult.startTest __super_printErrors = _TextTestResult.printErrors def __init__(self, stream, descriptions, verbosity, debug=False, count=None, progress=False): self.__super_init(stream, descriptions, verbosity) self._debug = debug self._progress = progress self._progressWithNames = False self._count = count if progress and verbosity == 1: self.dots = False self._progressWithNames = True self._lastWidth = 0 self._maxWidth = 80 # would be nice to determine terminal width self._maxWidth -= len('xxxx/xxxx (xxx.x%): ') + 1 def stopTest(self, test): import time #print time.time()-self._time if gc.garbage: print test print gc.garbage def _print_traceback(self, msg, err, test, errlist): if self.showAll or self.dots: self.stream.writeln("\n") tb = ''.join(traceback.format_exception(*err)) self.stream.writeln(msg) self.stream.writeln(tb) errlist.append((test, tb)) def startTest(self, test): import time self._time=time.time() if self._progress: self.stream.write('\r%4d' % (self.testsRun + 1)) if self._count: self.stream.write('/%d (%5.1f%%)' % (self._count, (self.testsRun + 1) * 100.0 / self._count)) if self.showAll: self.stream.write(": ") elif self._progressWithNames: # XXX will break with multibyte strings name = self.getDescription(test) width = len(name) if width < self._lastWidth: name += ' ' * (self._lastWidth - width) self.stream.write(': %s' % name[:self._maxWidth]) self._lastWidth = width self.stream.flush() self.__super_startTest(test) def addError(self, test, err): if self._progress: self.stream.write('\r') if self._debug: raise err[0], err[1], err[2] self._print_traceback("Error in test %s" % test, err, test, self.errors) def addFailure(self, test, err): if self._progress: self.stream.write('\r') if self._debug: raise err[0], err[1], err[2] self._print_traceback("Failure in test %s" % test, err, test, self.failures) def printErrors(self): if self._progress and not (self.dots or self.showAll): self.stream.writeln() self.__super_printErrors() def printErrorList(self, flavor, errors): for test, err in errors: self.stream.writeln(self.separator1) self.stream.writeln("%s: %s" % (flavor, self.getDescription(test))) self.stream.writeln(self.separator2) self.stream.writeln(err) class ImmediateTestRunner(unittest.TextTestRunner): __super_init = unittest.TextTestRunner.__init__ def __init__(self, **kwarg): debug = kwarg.get('debug') if debug is not None: del kwarg['debug'] progress = kwarg.get('progress') if progress is not None: del kwarg['progress'] self.__super_init(**kwarg) self._debug = debug self._progress = progress def _makeResult(self): return ImmediateTestResult(self.stream, self.descriptions, self.verbosity, debug=self._debug, count=self._count, progress=self._progress) def run(self, test): self._count = test.countTestCases() return unittest.TextTestRunner.run(self, test) # setup list of directories to put on the path class PathInit: def __init__(self, build, build_inplace): self.inplace = None # Figure out if we should test in-place or test in-build. If the -b # or -B option was given, test in the place we were told to build in. # Otherwise, we'll look for a build directory and if we find one, # we'll test there, otherwise we'll test in-place. if build: self.inplace = build_inplace if self.inplace is None: # Need to figure it out if os.path.isdir(os.path.join('build', 'lib.%s' % PLAT_SPEC)): self.inplace = False else: self.inplace = True # Calculate which directories we're going to add to sys.path, and cd # to the appropriate working directory if self.inplace: self.libdir = 'src' else: self.libdir = 'lib.%s' % PLAT_SPEC os.chdir('build') # Hack sys.path self.cwd = os.getcwd() print 'Running tests from', self.cwd sys.path[0] = os.path.join(self.cwd, self.libdir) def match(rx, s): if not rx: return True if rx[0] == '!': return re.search(rx[1:], s) is None else: return re.search(rx, s) is not None class TestFileFinder: def __init__(self, prefix): self.files = [] self._plen = len(prefix)+1 def visit(self, rx, dir, files): if os.path.split(dir)[-1] != 'tests': return # ignore tests that aren't in packages if not "__init__.py" in files: if not files : return print "not a package", dir return # ignore tests when the package can't be imported, possibly due to # dependency failures. pkg = dir[self._plen:].replace(os.sep, '.') try: __import__(pkg) # We specifically do not want to catch ImportError since that's useful # information to know when running the tests. except RuntimeError, e: if VERBOSE: print 'skipping', pkg, 'because:', e return for file in files: if file.startswith('test') and os.path.splitext(file)[-1] == '.py': path = os.path.join(dir, file) if match(rx, path): self.files.append(path) def module_from_path(self, path): """Return the Python package name indiciated by the filesystem path.""" if not path.endswith('.py') : raise AssertionError() path = path[self._plen:-3] mod = path.replace(os.sep, '.') return mod def find_tests(rx): global finder # pathinit is a global created in main() prefix = pathinit.libdir finder = TestFileFinder(prefix) for root, dirs, files in os.walk(prefix) : if len(files) : finder.visit(rx, root, files) return finder.files def package_import(modname): mod = __import__(modname) for part in modname.split(".")[1:]: mod = getattr(mod, part) return mod def get_suite(file): modname = finder.module_from_path(file) try: mod = package_import(modname) except RuntimeError: # test uses some optional software if VERBOSE: print 'Module with missing optional software skipped:', modname return None except ImportError, err: # print traceback print "Error importing %s\n%s" % (modname, err) print_tb_last() print if debug: raise return None try: suite_func = mod.test_suite except AttributeError: print "No test_suite() in %s" % file return None return suite_func() def filter_testcases(s, rx): new = unittest.TestSuite() for test in s._tests: if isinstance(test, unittest.TestCase): name = test.id() # Full test name: package.module.class.method name = name[1 + name.rfind('.'):] # extract method name if match(rx, name): new.addTest(test) else: filtered = filter_testcases(test, rx) if filtered: new.addTest(filtered) return new def gui_runner(files, test_filter): sys.path.insert(0, os.path.join(os.getcwd(), 'utilities')) import unittestgui suites = [] for file in files: suites.append(finder.module_from_path(file) + '.test_suite') suites = ", ".join(suites) minimal = (GUI == 'minimal') unittestgui.main(suites, minimal) def runner(files, test_filter, debug): runner = ImmediateTestRunner(verbosity=VERBOSE, debug=debug, progress=progress) suite = unittest.TestSuite() for file in files: s = get_suite(file) if s is None: continue if test_filter is not None: s = filter_testcases(s, test_filter) suite.addTest(s) try: r = runner.run(suite) except: if debugger: pdb.post_mortem(sys.exc_info()[2]) else: raise return r def main(module_filter, test_filter): global pathinit # Get the log.ini file from the current directory instead of possibly # buried in the build directory. XXX This isn't perfect because if # log.ini specifies a log file, it'll be relative to the build directory. # Hmm... logini = os.path.abspath('log.ini') # Initialize the path and cwd pathinit = PathInit(build, build_inplace) files = find_tests(module_filter) files.sort() if GUI: gui_runner(files, test_filter) elif LOOP: while True: r = runner(files, test_filter, debug) elif TRACE: coverdir = os.path.join(os.getcwd(), "coverage") import trace tracer = trace.Trace(ignoredirs=[sys.prefix, sys.exec_prefix], trace=0, count=1) tracer.runctx("runner(files, test_filter, debug)", globals=globals(), locals=vars()) r = tracer.results() r.write_results(show_missing=True, summary=True, coverdir=coverdir) else: r = runner(files, test_filter, debug) bad = r.errors + r.failures return bad def process_args(argv=None): global module_filter global test_filter global VERBOSE global LOOP global GUI global TRACE global debug global debugger global build global gcthresh global progress global build_inplace if argv is None: argv = sys.argv module_filter = None test_filter = None VERBOSE = 0 LOOP = False GUI = 0 TRACE = False # Don't collect test results; simply let tests crash debug = False debugger = False build = False build_inplace = False gcthresh = None gcflags = [] progress = False try: opts, args = getopt.getopt(argv[1:], 'bBcdDg:G:hLumpTv', ['help']) except getopt.error, msg: print msg print "Try `python %s -h' for more information." % argv[0] sys.exit(2) for k, v in opts: if k == '-b': build = True elif k == '-B': build = build_inplace = True elif k == '-c': os.environ['PYCHECKER'] = "-q" import pychecker.checker elif k == '-d': debug = True elif k == '-D': debug = True debugger = True elif k == '-g': gcthresh = int(v) elif k == '-G': if not v.startswith("DEBUG_"): print "-G argument must be DEBUG_ flag, not", repr(v) sys.exit(1) gcflags.append(v) elif k in ('-h', '--help'): print __doc__ % globals() sys.exit(0) elif k == '-L': LOOP = True elif k == '-u': GUI = 1 elif k == '-m': GUI = 'minimal' elif k == '-p': progress = True elif k == '-T': TRACE = True elif k == '-v': VERBOSE += 1 if gcthresh is not None: gc.set_threshold(gcthresh) print 'gc threshold:', gc.get_threshold() if gcflags: import gc val = 0 for flag in gcflags: v = getattr(gc, flag, None) if v is None: print "Unknown gc flag", repr(flag) print gc.set_debug.__doc__ sys.exit(1) val |= v gc.set_debug(v) # Do the builds if build: cmd = sys.executable + ' setup.py build' if build_inplace: cmd += '_ext -i' sts = os.system(cmd) if sts: print "Build failed", hex(sts) sys.exit(1) if args: if len(args) > 1: test_filter = args[1] module_filter = args[0] try: bad = main(module_filter, test_filter) if bad: sys.exit(1) except ImportError, err: print err print sys.path raise def print_tb_last(): tb = sys.exc_info()[2] file = sys.stderr while True: f = tb.tb_frame lineno = tb.tb_lineno tb = tb.tb_next if tb is not None: continue co = f.f_code filename = co.co_filename name = co.co_name file.write(' File "%s", line %d, in %s\n' % (filename,lineno,name)) line = linecache.getline(filename, lineno) if line: file.write(' %s\n' % line.strip()) break # The following method is for debugging unit tests from a Python prompt: def debug(args=""): """Debug your unit tests with the post mortem debugger. Just run the debug function with a string containing command-line arguments. (The function uses a cheesy parser, aka split. ;) For example, to debug the tests in package Zope.App.DublinCore: import test test.debug('Zope.App.DublinCore') At the first failure or error, an exception will be raised. At that point, you can use pdb's post-mortem debugger: import pdb pdb.pm() """ process_args(["", "-d"] + args.split()) if __name__ == "__main__": process_args() bsddb3-6.2.7/test3.py0000644000175000017500000004674313316226230014145 0ustar jceajcea00000000000000############################################################################## # # Copyright (c) 2001, 2002, 2003 Zope Corporation and Contributors. # All Rights Reserved. # # This software is subject to the provisions of the Zope Public License, # Version 2.0 (ZPL). A copy of the ZPL should accompany this distribution. # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # FOR A PARTICULAR PURPOSE. # ############################################################################## """Run the test suite. Usage: %(PROGRAM)s [options] [modfilter [testfilter]] Options: -b Run "python setup.py build" before running tests, where "python" is the version of python used to run test.py. Highly recommended. Tests will be run from the build directory. -B Run "python setup.py build_ext -i" before running tests. Tests will be run from the source directory. -c Use pychecker. -d Instead of the normal test harness, run a debug version which doesn't catch any exceptions. This is occasionally handy when the unittest code catching the exception doesn't work right. Unfortunately, the debug harness doesn't print the name of the test, so Use With Care. -D Works like -d, except that it loads pdb when an exception occurs. -g threshold Set the garbage collector generation0 threshold. This can be used to stress memory and gc correctness. Some crashes are only reproducible when the threshold is set to 1 (aggressive garbage collection). Do "-g 0" to disable garbage collection altogether. -G gc_option Set the garbage collection debugging flags. The argument must be one of the DEBUG_ flags defined by the Python gc module. Multiple options can be specified by using "-G OPTION1 -G OPTION2." -h / --help Print this help text and exit. -L Keep running the selected tests in a loop. You may experience memory leakage, but this is a handy option for catching race conditions. -u -m Use the PyUnit GUI instead of output to the command line. The GUI imports tests on its own, taking care to reload all dependencies on each run. The debug (-d), verbose (-v), and Loop (-L) options will be ignored. The testfilter filter is also not applied. -m starts the gui minimized. Double-clicking the progress bar will start the import and run all tests. -p Show running progress. It can be combined with -v or -vv. -T Use the trace module from Python for code coverage. XXX This only works if trace.py is explicitly added to PYTHONPATH. The current utility writes coverage files to a directory named `coverage' that is parallel to `build'. It also prints a summary to stdout. -v Verbose output. With one -v, unittest prints a dot (".") for each test run. With -vv, unittest prints the name of each test (for some definition of "name" ...). With no -v, unittest is silent until the end of the run, except when errors occur. modfilter testfilter Case-sensitive regexps to limit which tests are run, used in search (not match) mode. In an extension of Python regexp notation, a leading "!" is stripped and causes the sense of the remaining regexp to be negated (so "!bc" matches any string that does not match "bc", and vice versa). By default these act like ".", i.e. nothing is excluded. modfilter is applied to a test file's path, starting at "build" and including (OS-dependent) path separators. testfilter is applied to the (method) name of the unittest methods contained in the test files whose paths modfilter matched. Extreme (yet useful) examples: test.py -vvb . "^checkWriteClient$" Builds the project silently, then runs unittest in verbose mode on all tests whose names are precisely "checkWriteClient". Useful when debugging a specific test. test.py -vvb . "!^checkWriteClient$" As before, but runs all tests whose names aren't precisely "checkWriteClient". Useful to avoid a specific failing test you don't want to deal with just yet. test.py -m . "!^checkWriteClient$" As before, but now opens up a minimized PyUnit GUI window (only showing the progress bar). Useful for refactoring runs where you continually want to make sure all tests still pass. """ import warnings # Simulate "python -Wdefault". # http://docs.python.org/dev/library/warnings.html#updating-code-for-new-versions-of-python # Command line argument has priority, so the full matrix check can be more # strict. warnings.simplefilter('default') import gc import os import re import pdb import sys import getopt import unittest import linecache import traceback from distutils.util import get_platform # We need to be able to test BDB releases, even if the license is incompatible os.environ['YES_I_HAVE_THE_RIGHT_TO_USE_THIS_BERKELEY_DB_VERSION'] = '' PROGRAM = sys.argv[0] PLAT_SPEC = "%s-%s" % (get_platform(), sys.version[0:3]) # This hack copied from distutils.command.build. Too bad distutils # doesn't export its build/ directory naming scheme as a library function. if hasattr(sys, 'gettotalrefcount'): PLAT_SPEC += '-pydebug' try : # Check in the future if this still necessary # Python 2.7 and 3.2 from unittest.runner import _TextTestResult except ImportError : from unittest import _TextTestResult class ImmediateTestResult(_TextTestResult): __super_init = _TextTestResult.__init__ __super_startTest = _TextTestResult.startTest __super_printErrors = _TextTestResult.printErrors def __init__(self, stream, descriptions, verbosity, debug=False, count=None, progress=False): self.__super_init(stream, descriptions, verbosity) self._debug = debug self._progress = progress self._progressWithNames = False self._count = count if progress and verbosity == 1: self.dots = False self._progressWithNames = True self._lastWidth = 0 self._maxWidth = 80 # would be nice to determine terminal width self._maxWidth -= len('xxxx/xxxx (xxx.x%): ') + 1 def stopTest(self, test): import time #print time.time()-self._time if gc.garbage: print(test) print(gc.garbage) def _print_traceback(self, msg, err, test, errlist): if self.showAll or self.dots: self.stream.writeln("\n") tb = ''.join(traceback.format_exception(*err)) self.stream.writeln(msg) self.stream.writeln(tb) errlist.append((test, tb)) def startTest(self, test): import time self._time=time.time() if self._progress: self.stream.write('\r%4d' % (self.testsRun + 1)) if self._count: self.stream.write('/%d (%5.1f%%)' % (self._count, (self.testsRun + 1) * 100.0 / self._count)) if self.showAll: self.stream.write(": ") elif self._progressWithNames: # XXX will break with multibyte strings name = self.getDescription(test) width = len(name) if width < self._lastWidth: name += ' ' * (self._lastWidth - width) self.stream.write(': %s' % name[:self._maxWidth]) self._lastWidth = width self.stream.flush() self.__super_startTest(test) def addError(self, test, err): if self._progress: self.stream.write('\r') if self._debug: raise err[0](err[1]).with_traceback(err[2]) self._print_traceback("Error in test %s" % test, err, test, self.errors) def addFailure(self, test, err): if self._progress: self.stream.write('\r') if self._debug: raise err[0](err[1]).with_traceback(err[2]) self._print_traceback("Failure in test %s" % test, err, test, self.failures) def printErrors(self): if self._progress and not (self.dots or self.showAll): self.stream.writeln() self.__super_printErrors() def printErrorList(self, flavor, errors): for test, err in errors: self.stream.writeln(self.separator1) self.stream.writeln("%s: %s" % (flavor, self.getDescription(test))) self.stream.writeln(self.separator2) self.stream.writeln(err) class ImmediateTestRunner(unittest.TextTestRunner): __super_init = unittest.TextTestRunner.__init__ def __init__(self, **kwarg): debug = kwarg.get('debug') if debug is not None: del kwarg['debug'] progress = kwarg.get('progress') if progress is not None: del kwarg['progress'] self.__super_init(**kwarg) self._debug = debug self._progress = progress def _makeResult(self): return ImmediateTestResult(self.stream, self.descriptions, self.verbosity, debug=self._debug, count=self._count, progress=self._progress) def run(self, test): self._count = test.countTestCases() return unittest.TextTestRunner.run(self, test) # setup list of directories to put on the path class PathInit: def __init__(self, build, build_inplace): self.inplace = None # Figure out if we should test in-place or test in-build. If the -b # or -B option was given, test in the place we were told to build in. # Otherwise, we'll look for a build directory and if we find one, # we'll test there, otherwise we'll test in-place. if build: self.inplace = build_inplace if self.inplace is None: # Need to figure it out if os.path.isdir(os.path.join('build', 'lib.%s' % PLAT_SPEC)): self.inplace = False else: self.inplace = True # Calculate which directories we're going to add to sys.path, and cd # to the appropriate working directory if self.inplace: self.libdir = 'src' else: self.libdir = 'lib.%s' % PLAT_SPEC os.chdir('build') # Hack sys.path self.cwd = os.getcwd() print('Running tests from', self.cwd) sys.path[0] = os.path.join(self.cwd, self.libdir) def match(rx, s): if not rx: return True if rx[0] == '!': return re.search(rx[1:], s) is None else: return re.search(rx, s) is not None class TestFileFinder: def __init__(self, prefix): self.files = [] self._plen = len(prefix)+1 def visit(self, rx, dir, files): if os.path.split(dir)[-1] != 'tests': return # ignore tests that aren't in packages if not "__init__.py" in files: if not files : return print("not a package", dir) return # ignore tests when the package can't be imported, possibly due to # dependency failures. pkg = dir[self._plen:].replace(os.sep, '.') try: __import__(pkg) # We specifically do not want to catch ImportError since that's useful # information to know when running the tests. except RuntimeError as e: if VERBOSE: print('skipping', pkg, 'because:', e) return for file in files: if file.startswith('test') and os.path.splitext(file)[-1] == '.py': path = os.path.join(dir, file) if match(rx, path): self.files.append(path) def module_from_path(self, path): """Return the Python package name indiciated by the filesystem path.""" if not path.endswith('.py') : raise AssertionError() path = path[self._plen:-3] mod = path.replace(os.sep, '.') return mod def find_tests(rx): global finder # pathinit is a global created in main() prefix = pathinit.libdir finder = TestFileFinder(prefix) for root, dirs, files in os.walk(prefix) : if len(files) : finder.visit(rx, root, files) return finder.files def package_import(modname): mod = __import__(modname) for part in modname.split(".")[1:]: mod = getattr(mod, part) return mod def get_suite(file): modname = finder.module_from_path(file) try: mod = package_import(modname) except RuntimeError: # test uses some optional software if VERBOSE: print('Module with missing optional software skipped:', modname) return None except ImportError as err: # print traceback print("Error importing %s\n%s" % (modname, err)) print_tb_last() print() if debug: raise return None try: suite_func = mod.test_suite except AttributeError: print("No test_suite() in %s" % file) return None return suite_func() def filter_testcases(s, rx): new = unittest.TestSuite() for test in s._tests: if isinstance(test, unittest.TestCase): name = test.id() # Full test name: package.module.class.method name = name[1 + name.rfind('.'):] # extract method name if match(rx, name): new.addTest(test) else: filtered = filter_testcases(test, rx) if filtered: new.addTest(filtered) return new def gui_runner(files, test_filter): sys.path.insert(0, os.path.join(os.getcwd(), 'utilities')) import unittestgui suites = [] for file in files: suites.append(finder.module_from_path(file) + '.test_suite') suites = ", ".join(suites) minimal = (GUI == 'minimal') unittestgui.main(suites, minimal) def runner(files, test_filter, debug): runner = ImmediateTestRunner(verbosity=VERBOSE, debug=debug, progress=progress) suite = unittest.TestSuite() for file in files: s = get_suite(file) if s is None: continue if test_filter is not None: s = filter_testcases(s, test_filter) suite.addTest(s) try: r = runner.run(suite) except: if debugger: pdb.post_mortem(sys.exc_info()[2]) else: raise return r def main(module_filter, test_filter): global pathinit # Get the log.ini file from the current directory instead of possibly # buried in the build directory. XXX This isn't perfect because if # log.ini specifies a log file, it'll be relative to the build directory. # Hmm... logini = os.path.abspath('log.ini') # Initialize the path and cwd pathinit = PathInit(build, build_inplace) files = find_tests(module_filter) files.sort() if GUI: gui_runner(files, test_filter) elif LOOP: while True: r = runner(files, test_filter, debug) elif TRACE: coverdir = os.path.join(os.getcwd(), "coverage") import trace tracer = trace.Trace(ignoredirs=[sys.prefix, sys.exec_prefix], trace=0, count=1) tracer.runctx("runner(files, test_filter, debug)", globals=globals(), locals=vars()) r = tracer.results() r.write_results(show_missing=True, summary=True, coverdir=coverdir) else: r = runner(files, test_filter, debug) bad = r.errors + r.failures return bad def process_args(argv=None): global module_filter global test_filter global VERBOSE global LOOP global GUI global TRACE global debug global debugger global build global gcthresh global progress global build_inplace if argv is None: argv = sys.argv module_filter = None test_filter = None VERBOSE = 0 LOOP = False GUI = 0 TRACE = False # Don't collect test results; simply let tests crash debug = False debugger = False build = False build_inplace = False gcthresh = None gcflags = [] progress = False try: opts, args = getopt.getopt(argv[1:], 'bBcdDg:G:hLumpTv', ['help']) except getopt.error as msg: print(msg) print("Try `python %s -h' for more information." % argv[0]) sys.exit(2) for k, v in opts: if k == '-b': build = True elif k == '-B': build = build_inplace = True elif k == '-c': os.environ['PYCHECKER'] = "-q" import pychecker.checker elif k == '-d': debug = True elif k == '-D': debug = True debugger = True elif k == '-g': gcthresh = int(v) elif k == '-G': if not v.startswith("DEBUG_"): print("-G argument must be DEBUG_ flag, not", repr(v)) sys.exit(1) gcflags.append(v) elif k in ('-h', '--help'): print(__doc__ % globals()) sys.exit(0) elif k == '-L': LOOP = True elif k == '-u': GUI = 1 elif k == '-m': GUI = 'minimal' elif k == '-p': progress = True elif k == '-T': TRACE = True elif k == '-v': VERBOSE += 1 if gcthresh is not None: gc.set_threshold(gcthresh) print('gc threshold:', gc.get_threshold()) if gcflags: import gc val = 0 for flag in gcflags: v = getattr(gc, flag, None) if v is None: print("Unknown gc flag", repr(flag)) print(gc.set_debug.__doc__) sys.exit(1) val |= v gc.set_debug(v) # Do the builds if build: cmd = sys.executable + ' setup.py build' if build_inplace: cmd += '_ext -i' sts = os.system(cmd) if sts: print("Build failed", hex(sts)) sys.exit(1) if args: if len(args) > 1: test_filter = args[1] module_filter = args[0] try: bad = main(module_filter, test_filter) if bad: sys.exit(1) except ImportError as err: print(err) print(sys.path) raise def print_tb_last(): tb = sys.exc_info()[2] file = sys.stderr while True: f = tb.tb_frame lineno = tb.tb_lineno tb = tb.tb_next if tb is not None: continue co = f.f_code filename = co.co_filename name = co.co_name file.write(' File "%s", line %d, in %s\n' % (filename,lineno,name)) line = linecache.getline(filename, lineno) if line: file.write(' %s\n' % line.strip()) break # The following method is for debugging unit tests from a Python prompt: def debug(args=""): """Debug your unit tests with the post mortem debugger. Just run the debug function with a string containing command-line arguments. (The function uses a cheesy parser, aka split. ;) For example, to debug the tests in package Zope.App.DublinCore: import test test.debug('Zope.App.DublinCore') At the first failure or error, an exception will be raised. At that point, you can use pdb's post-mortem debugger: import pdb pdb.pm() """ process_args(["", "-d"] + args.split()) if __name__ == "__main__": process_args() bsddb3-6.2.7/Lib3/0000775000175000017500000000000013617133044013312 5ustar jceajcea00000000000000bsddb3-6.2.7/Lib3/bsddb/0000775000175000017500000000000013617133044014370 5ustar jceajcea00000000000000bsddb3-6.2.7/Lib3/bsddb/dbtables.py0000664000175000017500000007300013316237767016537 0ustar jceajcea00000000000000#----------------------------------------------------------------------- # # Copyright (C) 2000, 2001 by Autonomous Zone Industries # Copyright (C) 2002 Gregory P. Smith # # License: This is free software. You may use this software for any # purpose including modification/redistribution, so long as # this header remains intact and that you do not claim any # rights of ownership or authorship of this software. This # software has been tested, but no warranty is expressed or # implied. # # -- Gregory P. Smith # This provides a simple database table interface built on top of # the Python Berkeley DB 3 interface. # import re import sys import copy import random import struct if sys.version_info[0] >= 3 : import pickle else : import warnings with warnings.catch_warnings() : warnings.filterwarnings("ignore", category=DeprecationWarning) import pickle as pickle from bsddb3 import db class TableDBError(Exception): pass class TableAlreadyExists(TableDBError): pass class Cond: """This condition matches everything""" def __call__(self, s): return 1 class ExactCond(Cond): """Acts as an exact match condition function""" def __init__(self, strtomatch): self.strtomatch = strtomatch def __call__(self, s): return s == self.strtomatch class PrefixCond(Cond): """Acts as a condition function for matching a string prefix""" def __init__(self, prefix): self.prefix = prefix def __call__(self, s): return s[:len(self.prefix)] == self.prefix class PostfixCond(Cond): """Acts as a condition function for matching a string postfix""" def __init__(self, postfix): self.postfix = postfix def __call__(self, s): return s[-len(self.postfix):] == self.postfix class LikeCond(Cond): """ Acts as a function that will match using an SQL 'LIKE' style string. Case insensitive and % signs are wild cards. This isn't perfect but it should work for the simple common cases. """ def __init__(self, likestr, re_flags=re.IGNORECASE): # escape python re characters chars_to_escape = '.*+()[]?' for char in chars_to_escape : likestr = likestr.replace(char, '\\'+char) # convert %s to wildcards self.likestr = likestr.replace('%', '.*') self.re = re.compile('^'+self.likestr+'$', re_flags) def __call__(self, s): return self.re.match(s) # # keys used to store database metadata # _table_names_key = '__TABLE_NAMES__' # list of the tables in this db _columns = '._COLUMNS__' # table_name+this key contains a list of columns def _columns_key(table): return table + _columns # # these keys are found within table sub databases # _data = '._DATA_.' # this+column+this+rowid key contains table data _rowid = '._ROWID_.' # this+rowid+this key contains a unique entry for each # row in the table. (no data is stored) _rowid_str_len = 8 # length in bytes of the unique rowid strings def _data_key(table, col, rowid): return table + _data + col + _data + rowid def _search_col_data_key(table, col): return table + _data + col + _data def _search_all_data_key(table): return table + _data def _rowid_key(table, rowid): return table + _rowid + rowid + _rowid def _search_rowid_key(table): return table + _rowid def contains_metastrings(s) : """Verify that the given string does not contain any metadata strings that might interfere with dbtables database operation. """ if (s.find(_table_names_key) >= 0 or s.find(_columns) >= 0 or s.find(_data) >= 0 or s.find(_rowid) >= 0): # Then return 1 else: return 0 class bsdTableDB : def __init__(self, filename, dbhome, create=0, truncate=0, mode=0o600, recover=0, dbflags=0): """bsdTableDB(filename, dbhome, create=0, truncate=0, mode=0600) Open database name in the dbhome Berkeley DB directory. Use keyword arguments when calling this constructor. """ self.db = None myflags = db.DB_THREAD if create: myflags |= db.DB_CREATE flagsforenv = (db.DB_INIT_MPOOL | db.DB_INIT_LOCK | db.DB_INIT_LOG | db.DB_INIT_TXN | dbflags) # DB_AUTO_COMMIT isn't a valid flag for env.open() try: dbflags |= db.DB_AUTO_COMMIT except AttributeError: pass if recover: flagsforenv = flagsforenv | db.DB_RECOVER self.env = db.DBEnv() # enable auto deadlock avoidance self.env.set_lk_detect(db.DB_LOCK_DEFAULT) self.env.open(dbhome, myflags | flagsforenv) if truncate: myflags |= db.DB_TRUNCATE self.db = db.DB(self.env) # this code relies on DBCursor.set* methods to raise exceptions # rather than returning None self.db.set_get_returns_none(1) # allow duplicate entries [warning: be careful w/ metadata] self.db.set_flags(db.DB_DUP) self.db.open(filename, db.DB_BTREE, dbflags | myflags, mode) self.dbfilename = filename if sys.version_info[0] >= 3 : class cursor_py3k(object) : def __init__(self, dbcursor) : self._dbcursor = dbcursor def close(self) : return self._dbcursor.close() def set_range(self, search) : v = self._dbcursor.set_range(bytes(search, "iso8859-1")) if v is not None : v = (v[0].decode("iso8859-1"), v[1].decode("iso8859-1")) return v def __next__(self) : v = getattr(self._dbcursor, "next")() if v is not None : v = (v[0].decode("iso8859-1"), v[1].decode("iso8859-1")) return v class db_py3k(object) : def __init__(self, db) : self._db = db def cursor(self, txn=None) : return cursor_py3k(self._db.cursor(txn=txn)) def has_key(self, key, txn=None) : return getattr(self._db,"has_key")(bytes(key, "iso8859-1"), txn=txn) def put(self, key, value, flags=0, txn=None) : key = bytes(key, "iso8859-1") if value is not None : value = bytes(value, "iso8859-1") return self._db.put(key, value, flags=flags, txn=txn) def put_bytes(self, key, value, txn=None) : key = bytes(key, "iso8859-1") return self._db.put(key, value, txn=txn) def get(self, key, txn=None, flags=0) : key = bytes(key, "iso8859-1") v = self._db.get(key, txn=txn, flags=flags) if v is not None : v = v.decode("iso8859-1") return v def get_bytes(self, key, txn=None, flags=0) : key = bytes(key, "iso8859-1") return self._db.get(key, txn=txn, flags=flags) def delete(self, key, txn=None) : key = bytes(key, "iso8859-1") return self._db.delete(key, txn=txn) def close (self) : return self._db.close() self.db = db_py3k(self.db) else : # Python 2.x pass # Initialize the table names list if this is a new database txn = self.env.txn_begin() try: if not getattr(self.db, "has_key")(_table_names_key, txn): getattr(self.db, "put_bytes", self.db.put) \ (_table_names_key, pickle.dumps([], 1), txn=txn) # Yes, bare except except: txn.abort() raise else: txn.commit() # TODO verify more of the database's metadata? self.__tablecolumns = {} def __del__(self): self.close() def close(self): if self.db is not None: self.db.close() self.db = None if self.env is not None: self.env.close() self.env = None def checkpoint(self, mins=0): self.env.txn_checkpoint(mins) def sync(self): self.db.sync() def _db_print(self) : """Print the database to stdout for debugging""" print("******** Printing raw database for debugging ********") cur = self.db.cursor() try: key, data = cur.first() while 1: print(repr({key: data})) next = next(cur) if next: key, data = next else: cur.close() return except db.DBNotFoundError: cur.close() def CreateTable(self, table, columns): """CreateTable(table, columns) - Create a new table in the database. raises TableDBError if it already exists or for other DB errors. """ assert isinstance(columns, list) txn = None try: # checking sanity of the table and column names here on # table creation will prevent problems elsewhere. if contains_metastrings(table): raise ValueError( "bad table name: contains reserved metastrings") for column in columns : if contains_metastrings(column): raise ValueError( "bad column name: contains reserved metastrings") columnlist_key = _columns_key(table) if getattr(self.db, "has_key")(columnlist_key): raise TableAlreadyExists("table already exists") txn = self.env.txn_begin() # store the table's column info getattr(self.db, "put_bytes", self.db.put)(columnlist_key, pickle.dumps(columns, 1), txn=txn) # add the table name to the tablelist tablelist = pickle.loads(getattr(self.db, "get_bytes", self.db.get) (_table_names_key, txn=txn, flags=db.DB_RMW)) tablelist.append(table) # delete 1st, in case we opened with DB_DUP self.db.delete(_table_names_key, txn=txn) getattr(self.db, "put_bytes", self.db.put)(_table_names_key, pickle.dumps(tablelist, 1), txn=txn) txn.commit() txn = None except db.DBError as dberror: if txn: txn.abort() if sys.version_info < (2, 6) : raise TableDBError(dberror[1]) else : raise TableDBError(dberror.args[1]) def ListTableColumns(self, table): """Return a list of columns in the given table. [] if the table doesn't exist. """ assert isinstance(table, str) if contains_metastrings(table): raise ValueError("bad table name: contains reserved metastrings") columnlist_key = _columns_key(table) if not getattr(self.db, "has_key")(columnlist_key): return [] pickledcolumnlist = getattr(self.db, "get_bytes", self.db.get)(columnlist_key) if pickledcolumnlist: return pickle.loads(pickledcolumnlist) else: return [] def ListTables(self): """Return a list of tables in this database.""" pickledtablelist = getattr(self.db, "get_bytes", self.db.get)(_table_names_key) if pickledtablelist: return pickle.loads(pickledtablelist) else: return [] def CreateOrExtendTable(self, table, columns): """CreateOrExtendTable(table, columns) Create a new table in the database. If a table of this name already exists, extend it to have any additional columns present in the given list as well as all of its current columns. """ assert isinstance(columns, list) try: self.CreateTable(table, columns) except TableAlreadyExists: # the table already existed, add any new columns txn = None try: columnlist_key = _columns_key(table) txn = self.env.txn_begin() # load the current column list oldcolumnlist = pickle.loads( getattr(self.db, "get_bytes", self.db.get)(columnlist_key, txn=txn, flags=db.DB_RMW)) # create a hash table for fast lookups of column names in the # loop below oldcolumnhash = {} for c in oldcolumnlist: oldcolumnhash[c] = c # create a new column list containing both the old and new # column names newcolumnlist = copy.copy(oldcolumnlist) for c in columns: if not c in oldcolumnhash: newcolumnlist.append(c) # store the table's new extended column list if newcolumnlist != oldcolumnlist : # delete the old one first since we opened with DB_DUP self.db.delete(columnlist_key, txn=txn) getattr(self.db, "put_bytes", self.db.put)(columnlist_key, pickle.dumps(newcolumnlist, 1), txn=txn) txn.commit() txn = None self.__load_column_info(table) except db.DBError as dberror: if txn: txn.abort() if sys.version_info < (2, 6) : raise TableDBError(dberror[1]) else : raise TableDBError(dberror.args[1]) def __load_column_info(self, table) : """initialize the self.__tablecolumns dict""" # check the column names try: tcolpickles = getattr(self.db, "get_bytes", self.db.get)(_columns_key(table)) except db.DBNotFoundError: raise TableDBError("unknown table: %r" % (table,)) if not tcolpickles: raise TableDBError("unknown table: %r" % (table,)) self.__tablecolumns[table] = pickle.loads(tcolpickles) def __new_rowid(self, table, txn) : """Create a new unique row identifier""" unique = 0 while not unique: # Generate a random 64-bit row ID string # (note: might have <64 bits of true randomness # but it's plenty for our database id needs!) blist = [] for x in range(_rowid_str_len): blist.append(random.randint(0,255)) newid = struct.pack('B'*_rowid_str_len, *blist) if sys.version_info[0] >= 3 : newid = newid.decode("iso8859-1") # 8 bits # Guarantee uniqueness by adding this key to the database try: self.db.put(_rowid_key(table, newid), None, txn=txn, flags=db.DB_NOOVERWRITE) except db.DBKeyExistError: pass else: unique = 1 return newid def Insert(self, table, rowdict) : """Insert(table, datadict) - Insert a new row into the table using the keys+values from rowdict as the column values. """ txn = None try: if not getattr(self.db, "has_key")(_columns_key(table)): raise TableDBError("unknown table") # check the validity of each column name if not table in self.__tablecolumns: self.__load_column_info(table) for column in list(rowdict.keys()) : if not self.__tablecolumns[table].count(column): raise TableDBError("unknown column: %r" % (column,)) # get a unique row identifier for this row txn = self.env.txn_begin() rowid = self.__new_rowid(table, txn=txn) # insert the row values into the table database for column, dataitem in list(rowdict.items()): # store the value self.db.put(_data_key(table, column, rowid), dataitem, txn=txn) txn.commit() txn = None except db.DBError as dberror: # WIBNI we could just abort the txn and re-raise the exception? # But no, because TableDBError is not related to DBError via # inheritance, so it would be backwards incompatible. Do the next # best thing. info = sys.exc_info() if txn: txn.abort() self.db.delete(_rowid_key(table, rowid)) if sys.version_info < (2, 6) : raise TableDBError(dberror[1]).with_traceback(info[2]) else : raise TableDBError(dberror.args[1]).with_traceback(info[2]) def Modify(self, table, conditions={}, mappings={}): """Modify(table, conditions={}, mappings={}) - Modify items in rows matching 'conditions' using mapping functions in 'mappings' * table - the table name * conditions - a dictionary keyed on column names containing a condition callable expecting the data string as an argument and returning a boolean. * mappings - a dictionary keyed on column names containing a condition callable expecting the data string as an argument and returning the new string for that column. """ try: matching_rowids = self.__Select(table, [], conditions) # modify only requested columns columns = list(mappings.keys()) for rowid in list(matching_rowids.keys()): txn = None try: for column in columns: txn = self.env.txn_begin() # modify the requested column try: dataitem = self.db.get( _data_key(table, column, rowid), txn=txn) self.db.delete( _data_key(table, column, rowid), txn=txn) except db.DBNotFoundError: # XXXXXXX row key somehow didn't exist, assume no # error dataitem = None dataitem = mappings[column](dataitem) if dataitem is not None: self.db.put( _data_key(table, column, rowid), dataitem, txn=txn) txn.commit() txn = None # catch all exceptions here since we call unknown callables except: if txn: txn.abort() raise except db.DBError as dberror: if sys.version_info < (2, 6) : raise TableDBError(dberror[1]) else : raise TableDBError(dberror.args[1]) def Delete(self, table, conditions={}): """Delete(table, conditions) - Delete items matching the given conditions from the table. * conditions - a dictionary keyed on column names containing condition functions expecting the data string as an argument and returning a boolean. """ try: matching_rowids = self.__Select(table, [], conditions) # delete row data from all columns columns = self.__tablecolumns[table] for rowid in list(matching_rowids.keys()): txn = None try: txn = self.env.txn_begin() for column in columns: # delete the data key try: self.db.delete(_data_key(table, column, rowid), txn=txn) except db.DBNotFoundError: # XXXXXXX column may not exist, assume no error pass try: self.db.delete(_rowid_key(table, rowid), txn=txn) except db.DBNotFoundError: # XXXXXXX row key somehow didn't exist, assume no error pass txn.commit() txn = None except db.DBError as dberror: if txn: txn.abort() raise except db.DBError as dberror: if sys.version_info < (2, 6) : raise TableDBError(dberror[1]) else : raise TableDBError(dberror.args[1]) def Select(self, table, columns, conditions={}): """Select(table, columns, conditions) - retrieve specific row data Returns a list of row column->value mapping dictionaries. * columns - a list of which column data to return. If columns is None, all columns will be returned. * conditions - a dictionary keyed on column names containing callable conditions expecting the data string as an argument and returning a boolean. """ try: if not table in self.__tablecolumns: self.__load_column_info(table) if columns is None: columns = self.__tablecolumns[table] matching_rowids = self.__Select(table, columns, conditions) except db.DBError as dberror: if sys.version_info < (2, 6) : raise TableDBError(dberror[1]) else : raise TableDBError(dberror.args[1]) # return the matches as a list of dictionaries return list(matching_rowids.values()) def __Select(self, table, columns, conditions): """__Select() - Used to implement Select and Delete (above) Returns a dictionary keyed on rowids containing dicts holding the row data for columns listed in the columns param that match the given conditions. * conditions is a dictionary keyed on column names containing callable conditions expecting the data string as an argument and returning a boolean. """ # check the validity of each column name if not table in self.__tablecolumns: self.__load_column_info(table) if columns is None: columns = self.tablecolumns[table] for column in (columns + list(conditions.keys())): if not self.__tablecolumns[table].count(column): raise TableDBError("unknown column: %r" % (column,)) # keyed on rows that match so far, containings dicts keyed on # column names containing the data for that row and column. matching_rowids = {} # keys are rowids that do not match rejected_rowids = {} # attempt to sort the conditions in such a way as to minimize full # column lookups def cmp_conditions(atuple, btuple): a = atuple[1] b = btuple[1] if type(a) is type(b): # Needed for python 3. "cmp" vanished in 3.0.1 def cmp(a, b) : if a==b : return 0 if a 0: for rowid, rowdata in list(matching_rowids.items()): for column in columns: if column in rowdata: continue try: rowdata[column] = self.db.get( _data_key(table, column, rowid)) except db.DBError as dberror: if sys.version_info < (2, 6) : if dberror[0] != db.DB_NOTFOUND: raise else : if dberror.args[0] != db.DB_NOTFOUND: raise rowdata[column] = None # return the matches return matching_rowids def Drop(self, table): """Remove an entire table from the database""" txn = None try: txn = self.env.txn_begin() # delete the column list self.db.delete(_columns_key(table), txn=txn) cur = self.db.cursor(txn) # delete all keys containing this tables column and row info table_key = _search_all_data_key(table) while 1: try: key, data = cur.set_range(table_key) except db.DBNotFoundError: break # only delete items in this table if key[:len(table_key)] != table_key: break cur.delete() # delete all rowids used by this table table_key = _search_rowid_key(table) while 1: try: key, data = cur.set_range(table_key) except db.DBNotFoundError: break # only delete items in this table if key[:len(table_key)] != table_key: break cur.delete() cur.close() # delete the tablename from the table name list tablelist = pickle.loads( getattr(self.db, "get_bytes", self.db.get)(_table_names_key, txn=txn, flags=db.DB_RMW)) try: tablelist.remove(table) except ValueError: # hmm, it wasn't there, oh well, that's what we want. pass # delete 1st, incase we opened with DB_DUP self.db.delete(_table_names_key, txn=txn) getattr(self.db, "put_bytes", self.db.put)(_table_names_key, pickle.dumps(tablelist, 1), txn=txn) txn.commit() txn = None if table in self.__tablecolumns: del self.__tablecolumns[table] except db.DBError as dberror: if txn: txn.abort() raise TableDBError(dberror.args[1]) bsddb3-6.2.7/Lib3/bsddb/dbrecio.py0000664000175000017500000001227413316237770016366 0ustar jceajcea00000000000000 """ File-like objects that read from or write to a bsddb record. This implements (nearly) all stdio methods. f = DBRecIO(db, key, txn=None) f.close() # explicitly release resources held flag = f.isatty() # always false pos = f.tell() # get current position f.seek(pos) # set current position f.seek(pos, mode) # mode 0: absolute; 1: relative; 2: relative to EOF buf = f.read() # read until EOF buf = f.read(n) # read up to n bytes f.truncate([size]) # truncate file at to at most size (default: current pos) f.write(buf) # write at current position f.writelines(list) # for line in list: f.write(line) Notes: - fileno() is left unimplemented so that code which uses it triggers an exception early. - There's a simple test set (see end of this file) - not yet updated for DBRecIO. - readline() is not implemented yet. From: Itamar Shtull-Trauring """ import errno import string class DBRecIO: def __init__(self, db, key, txn=None): self.db = db self.key = key self.txn = txn self.len = None self.pos = 0 self.closed = 0 self.softspace = 0 def close(self): if not self.closed: self.closed = 1 del self.db, self.txn def isatty(self): if self.closed: raise ValueError("I/O operation on closed file") return 0 def seek(self, pos, mode = 0): if self.closed: raise ValueError("I/O operation on closed file") if mode == 1: pos = pos + self.pos elif mode == 2: pos = pos + self.len self.pos = max(0, pos) def tell(self): if self.closed: raise ValueError("I/O operation on closed file") return self.pos def read(self, n = -1): if self.closed: raise ValueError("I/O operation on closed file") if n < 0: newpos = self.len else: newpos = min(self.pos+n, self.len) dlen = newpos - self.pos r = self.db.get(self.key, txn=self.txn, dlen=dlen, doff=self.pos) self.pos = newpos return r __fixme = """ def readline(self, length=None): if self.closed: raise ValueError, "I/O operation on closed file" if self.buflist: self.buf = self.buf + string.joinfields(self.buflist, '') self.buflist = [] i = string.find(self.buf, '\n', self.pos) if i < 0: newpos = self.len else: newpos = i+1 if length is not None: if self.pos + length < newpos: newpos = self.pos + length r = self.buf[self.pos:newpos] self.pos = newpos return r def readlines(self, sizehint = 0): total = 0 lines = [] line = self.readline() while line: lines.append(line) total += len(line) if 0 < sizehint <= total: break line = self.readline() return lines """ def truncate(self, size=None): if self.closed: raise ValueError("I/O operation on closed file") if size is None: size = self.pos elif size < 0: raise IOError(errno.EINVAL, "Negative size not allowed") elif size < self.pos: self.pos = size self.db.put(self.key, "", txn=self.txn, dlen=self.len-size, doff=size) def write(self, s): if self.closed: raise ValueError("I/O operation on closed file") if not s: return if self.pos > self.len: self.buflist.append('\0'*(self.pos - self.len)) self.len = self.pos newpos = self.pos + len(s) self.db.put(self.key, s, txn=self.txn, dlen=len(s), doff=self.pos) self.pos = newpos def writelines(self, list): self.write(string.joinfields(list, '')) def flush(self): if self.closed: raise ValueError("I/O operation on closed file") """ # A little test suite def _test(): import sys if sys.argv[1:]: file = sys.argv[1] else: file = '/etc/passwd' lines = open(file, 'r').readlines() text = open(file, 'r').read() f = StringIO() for line in lines[:-2]: f.write(line) f.writelines(lines[-2:]) if f.getvalue() != text: raise RuntimeError, 'write failed' length = f.tell() print 'File length =', length f.seek(len(lines[0])) f.write(lines[1]) f.seek(0) print 'First line =', repr(f.readline()) here = f.tell() line = f.readline() print 'Second line =', repr(line) f.seek(-len(line), 1) line2 = f.read(len(line)) if line != line2: raise RuntimeError, 'bad result after seek back' f.seek(len(line2), 1) list = f.readlines() line = list[-1] f.seek(f.tell() - len(line)) line2 = f.read() if line != line2: raise RuntimeError, 'bad result after seek back from EOF' print 'Read', len(list), 'more lines' print 'File length =', f.tell() if f.tell() != length: raise RuntimeError, 'bad length' f.close() if __name__ == '__main__': _test() """ bsddb3-6.2.7/Lib3/bsddb/__init__.py0000664000175000017500000003466313617056347016527 0ustar jceajcea00000000000000#---------------------------------------------------------------------- # Copyright (c) 1999-2001, Digital Creations, Fredericksburg, VA, USA # and Andrew Kuchling. All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: # # o Redistributions of source code must retain the above copyright # notice, this list of conditions, and the disclaimer that follows. # # o Redistributions in binary form must reproduce the above copyright # notice, this list of conditions, and the following disclaimer in # the documentation and/or other materials provided with the # distribution. # # o Neither the name of Digital Creations nor the names of its # contributors may be used to endorse or promote products derived # from this software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY DIGITAL CREATIONS AND CONTRIBUTORS *AS # IS* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED # TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A # PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL DIGITAL # CREATIONS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, # BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS # OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND # ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR # TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE # USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH # DAMAGE. #---------------------------------------------------------------------- """Support for Berkeley DB 4.3 through 5.3 with a simple interface. For the full featured object oriented interface use the bsddb.db module instead. It mirrors the Oracle Berkeley DB C API. """ import sys absolute_import = (sys.version_info[0] >= 3) try: if absolute_import : from . import _pybsddb else : import _pybsddb from bsddb3.dbutils import DeadlockWrap as _DeadlockWrap except ImportError: # Remove ourselves from sys.modules import sys del sys.modules[__name__] raise # bsddb3 calls it db, but provide _db for backwards compatibility db = _db = _pybsddb __version__ = db.__version__ error = db.DBError # So bsddb.error will mean something... #---------------------------------------------------------------------- import sys, os from weakref import ref if (sys.version_info[0] >= 3): from collections.abc import MutableMapping else: from collections import MutableMapping class _iter_mixin(MutableMapping): def _make_iter_cursor(self): cur = _DeadlockWrap(self.db.cursor) key = id(cur) self._cursor_refs[key] = ref(cur, self._gen_cref_cleaner(key)) return cur def _gen_cref_cleaner(self, key): # use generate the function for the weakref callback here # to ensure that we do not hold a strict reference to cur # in the callback. return lambda ref: self._cursor_refs.pop(key, None) def __iter__(self): self._kill_iteration = False self._in_iter += 1 try: try: cur = self._make_iter_cursor() # FIXME-20031102-greg: race condition. cursor could # be closed by another thread before this call. # since we're only returning keys, we call the cursor # methods with flags=0, dlen=0, dofs=0 key = _DeadlockWrap(cur.first, 0,0,0)[0] yield key next = getattr(cur, "next") while 1: try: key = _DeadlockWrap(next, 0,0,0)[0] yield key except _db.DBCursorClosedError: if self._kill_iteration: raise RuntimeError('Database changed size ' 'during iteration.') cur = self._make_iter_cursor() # FIXME-20031101-greg: race condition. cursor could # be closed by another thread before this call. _DeadlockWrap(cur.set, key,0,0,0) next = getattr(cur, "next") except _db.DBNotFoundError: pass except _db.DBCursorClosedError: # the database was modified during iteration. abort. pass finally : self._in_iter -= 1 def iteritems(self): if not self.db: return self._kill_iteration = False self._in_iter += 1 try: try: cur = self._make_iter_cursor() # FIXME-20031102-greg: race condition. cursor could # be closed by another thread before this call. kv = _DeadlockWrap(cur.first) key = kv[0] yield kv next = getattr(cur, "next") while 1: try: kv = _DeadlockWrap(next) key = kv[0] yield kv except _db.DBCursorClosedError: if self._kill_iteration: raise RuntimeError('Database changed size ' 'during iteration.') cur = self._make_iter_cursor() # FIXME-20031101-greg: race condition. cursor could # be closed by another thread before this call. _DeadlockWrap(cur.set, key,0,0,0) next = getattr(cur, "next") except _db.DBNotFoundError: pass except _db.DBCursorClosedError: # the database was modified during iteration. abort. pass finally : self._in_iter -= 1 class _DBWithCursor(_iter_mixin): """ A simple wrapper around DB that makes it look like the bsddbobject in the old module. It uses a cursor as needed to provide DB traversal. """ def __init__(self, db): self.db = db self.db.set_get_returns_none(0) # FIXME-20031101-greg: I believe there is still the potential # for deadlocks in a multithreaded environment if someone # attempts to use the any of the cursor interfaces in one # thread while doing a put or delete in another thread. The # reason is that _checkCursor and _closeCursors are not atomic # operations. Doing our own locking around self.dbc, # self.saved_dbc_key and self._cursor_refs could prevent this. # TODO: A test case demonstrating the problem needs to be written. # self.dbc is a DBCursor object used to implement the # first/next/previous/last/set_location methods. self.dbc = None self.saved_dbc_key = None # a collection of all DBCursor objects currently allocated # by the _iter_mixin interface. self._cursor_refs = {} self._in_iter = 0 self._kill_iteration = False def __del__(self): self.close() def _checkCursor(self): if self.dbc is None: self.dbc = _DeadlockWrap(self.db.cursor) if self.saved_dbc_key is not None: _DeadlockWrap(self.dbc.set, self.saved_dbc_key) self.saved_dbc_key = None # This method is needed for all non-cursor DB calls to avoid # Berkeley DB deadlocks (due to being opened with DB_INIT_LOCK # and DB_THREAD to be thread safe) when intermixing database # operations that use the cursor internally with those that don't. def _closeCursors(self, save=1): if self.dbc: c = self.dbc self.dbc = None if save: try: self.saved_dbc_key = _DeadlockWrap(c.current, 0,0,0)[0] except db.DBError: pass _DeadlockWrap(c.close) del c for cref in list(self._cursor_refs.values()): c = cref() if c is not None: _DeadlockWrap(c.close) def _checkOpen(self): if self.db is None: raise error("BSDDB object has already been closed") def isOpen(self): return self.db is not None def __len__(self): self._checkOpen() return _DeadlockWrap(lambda: len(self.db)) # len(self.db) def __repr__(self) : if self.isOpen() : return repr(dict(_DeadlockWrap(self.db.items))) return repr(dict()) def __getitem__(self, key): self._checkOpen() return _DeadlockWrap(lambda: self.db[key]) # self.db[key] def __setitem__(self, key, value): self._checkOpen() self._closeCursors() if self._in_iter and key not in self: self._kill_iteration = True def wrapF(): self.db[key] = value _DeadlockWrap(wrapF) # self.db[key] = value def __delitem__(self, key): self._checkOpen() self._closeCursors() if self._in_iter and key in self: self._kill_iteration = True def wrapF(): del self.db[key] _DeadlockWrap(wrapF) # del self.db[key] def close(self): self._closeCursors(save=0) if self.dbc is not None: _DeadlockWrap(self.dbc.close) v = 0 if self.db is not None: v = _DeadlockWrap(self.db.close) self.dbc = None self.db = None return v def keys(self): self._checkOpen() return _DeadlockWrap(self.db.keys) def has_key(self, key): self._checkOpen() return _DeadlockWrap(self.db.has_key, key) def set_location(self, key): self._checkOpen() self._checkCursor() return _DeadlockWrap(self.dbc.set_range, key) def __next__(self): # Renamed by "2to3" self._checkOpen() self._checkCursor() rv = _DeadlockWrap(getattr(self.dbc, "next")) return rv if sys.version_info[0] >= 3 : # For "2to3" conversion next = __next__ def previous(self): self._checkOpen() self._checkCursor() rv = _DeadlockWrap(self.dbc.prev) return rv def first(self): self._checkOpen() # fix 1725856: don't needlessly try to restore our cursor position self.saved_dbc_key = None self._checkCursor() rv = _DeadlockWrap(self.dbc.first) return rv def last(self): self._checkOpen() # fix 1725856: don't needlessly try to restore our cursor position self.saved_dbc_key = None self._checkCursor() rv = _DeadlockWrap(self.dbc.last) return rv def sync(self): self._checkOpen() return _DeadlockWrap(self.db.sync) #---------------------------------------------------------------------- # Compatibility object factory functions def hashopen(file, flag='c', mode=0o666, pgsize=None, ffactor=None, nelem=None, cachesize=None, lorder=None, hflags=0): flags = _checkflag(flag, file) e = _openDBEnv(cachesize) d = db.DB(e) d.set_flags(hflags) if pgsize is not None: d.set_pagesize(pgsize) if lorder is not None: d.set_lorder(lorder) if ffactor is not None: d.set_h_ffactor(ffactor) if nelem is not None: d.set_h_nelem(nelem) d.open(file, db.DB_HASH, flags, mode) return _DBWithCursor(d) #---------------------------------------------------------------------- def btopen(file, flag='c', mode=0o666, btflags=0, cachesize=None, maxkeypage=None, minkeypage=None, pgsize=None, lorder=None): flags = _checkflag(flag, file) e = _openDBEnv(cachesize) d = db.DB(e) if pgsize is not None: d.set_pagesize(pgsize) if lorder is not None: d.set_lorder(lorder) d.set_flags(btflags) if minkeypage is not None: d.set_bt_minkey(minkeypage) if maxkeypage is not None: d.set_bt_maxkey(maxkeypage) d.open(file, db.DB_BTREE, flags, mode) return _DBWithCursor(d) #---------------------------------------------------------------------- def rnopen(file, flag='c', mode=0o666, rnflags=0, cachesize=None, pgsize=None, lorder=None, rlen=None, delim=None, source=None, pad=None): flags = _checkflag(flag, file) e = _openDBEnv(cachesize) d = db.DB(e) if pgsize is not None: d.set_pagesize(pgsize) if lorder is not None: d.set_lorder(lorder) d.set_flags(rnflags) if delim is not None: d.set_re_delim(delim) if rlen is not None: d.set_re_len(rlen) if source is not None: d.set_re_source(source) if pad is not None: d.set_re_pad(pad) d.open(file, db.DB_RECNO, flags, mode) return _DBWithCursor(d) #---------------------------------------------------------------------- def _openDBEnv(cachesize): e = db.DBEnv() if cachesize is not None: if cachesize >= 20480: e.set_cachesize(0, cachesize) else: raise error("cachesize must be >= 20480") e.set_lk_detect(db.DB_LOCK_DEFAULT) e.open('.', db.DB_PRIVATE | db.DB_CREATE | db.DB_THREAD | db.DB_INIT_LOCK | db.DB_INIT_MPOOL) return e def _checkflag(flag, file): if flag == 'r': flags = db.DB_RDONLY elif flag == 'rw': flags = 0 elif flag == 'w': flags = db.DB_CREATE elif flag == 'c': flags = db.DB_CREATE elif flag == 'n': flags = db.DB_CREATE #flags = db.DB_CREATE | db.DB_TRUNCATE # we used db.DB_TRUNCATE flag for this before but Berkeley DB # 4.2.52 changed to disallowed truncate with txn environments. if file is not None and os.path.isfile(file): os.unlink(file) else: raise error("flags should be one of 'r', 'w', 'c' or 'n'") return flags | db.DB_THREAD #---------------------------------------------------------------------- # This is a silly little hack that allows apps to continue to use the # DB_THREAD flag even on systems without threads without freaking out # Berkeley DB. # # This assumes that if Python was built with thread support then # Berkeley DB was too. try: # 2to3 automatically changes "import thread" to "import _thread" import _thread as T del T except ImportError: db.DB_THREAD = 0 #---------------------------------------------------------------------- bsddb3-6.2.7/Lib3/bsddb/test/0000775000175000017500000000000013617133045015350 5ustar jceajcea00000000000000bsddb3-6.2.7/Lib3/bsddb/test/test_all.py0000664000175000017500000005071013617051201017525 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """Run all test cases. """ import sys import os import unittest import bsddb3 as bsddb if sys.version_info[0] >= 3 : charset = "iso8859-1" # Full 8 bit class logcursor_py3k(object) : def __init__(self, env) : self._logcursor = env.log_cursor() def __getattr__(self, v) : return getattr(self._logcursor, v) def __next__(self) : v = getattr(self._logcursor, "next")() if v is not None : v = (v[0], v[1].decode(charset)) return v next = __next__ def first(self) : v = self._logcursor.first() if v is not None : v = (v[0], v[1].decode(charset)) return v def last(self) : v = self._logcursor.last() if v is not None : v = (v[0], v[1].decode(charset)) return v def prev(self) : v = self._logcursor.prev() if v is not None : v = (v[0], v[1].decode(charset)) return v def current(self) : v = self._logcursor.current() if v is not None : v = (v[0], v[1].decode(charset)) return v def set(self, lsn) : v = self._logcursor.set(lsn) if v is not None : v = (v[0], v[1].decode(charset)) return v class cursor_py3k(object) : def __init__(self, db, *args, **kwargs) : self._dbcursor = db.cursor(*args, **kwargs) def __getattr__(self, v) : return getattr(self._dbcursor, v) def _fix(self, v) : if v is None : return None key, value = v if isinstance(key, bytes) : key = key.decode(charset) return (key, value.decode(charset)) def __next__(self, flags=0, dlen=-1, doff=-1) : v = getattr(self._dbcursor, "next")(flags=flags, dlen=dlen, doff=doff) return self._fix(v) next = __next__ def previous(self) : v = self._dbcursor.previous() return self._fix(v) def last(self) : v = self._dbcursor.last() return self._fix(v) def set(self, k) : if isinstance(k, str) : k = bytes(k, charset) v = self._dbcursor.set(k) return self._fix(v) def set_recno(self, num) : v = self._dbcursor.set_recno(num) return self._fix(v) def set_range(self, k, dlen=-1, doff=-1) : if isinstance(k, str) : k = bytes(k, charset) v = self._dbcursor.set_range(k, dlen=dlen, doff=doff) return self._fix(v) def dup(self, flags=0) : cursor = self._dbcursor.dup(flags) return dup_cursor_py3k(cursor) def next_dup(self) : v = self._dbcursor.next_dup() return self._fix(v) def next_nodup(self) : v = self._dbcursor.next_nodup() return self._fix(v) def put(self, key, data, flags=0, dlen=-1, doff=-1) : if isinstance(key, str) : key = bytes(key, charset) if isinstance(data, str) : value = bytes(data, charset) return self._dbcursor.put(key, data, flags=flags, dlen=dlen, doff=doff) def current(self, flags=0, dlen=-1, doff=-1) : v = self._dbcursor.current(flags=flags, dlen=dlen, doff=doff) return self._fix(v) def first(self, flags=0, dlen=-1, doff=-1) : v = self._dbcursor.first(flags=flags, dlen=dlen, doff=doff) return self._fix(v) def pget(self, key=None, data=None, flags=0) : # Incorrect because key can be a bare number, # but enough to pass testsuite if isinstance(key, int) and (data is None) and (flags == 0) : flags = key key = None if isinstance(key, str) : key = bytes(key, charset) if isinstance(data, int) and (flags==0) : flags = data data = None if isinstance(data, str) : data = bytes(data, charset) v=self._dbcursor.pget(key=key, data=data, flags=flags) if v is not None : v1, v2, v3 = v if isinstance(v1, bytes) : v1 = v1.decode(charset) if isinstance(v2, bytes) : v2 = v2.decode(charset) v = (v1, v2, v3.decode(charset)) return v def join_item(self) : v = self._dbcursor.join_item() if v is not None : v = v.decode(charset) return v def get(self, *args, **kwargs) : l = len(args) if l == 2 : k, f = args if isinstance(k, str) : k = bytes(k, "iso8859-1") args = (k, f) elif l == 3 : k, d, f = args if isinstance(k, str) : k = bytes(k, charset) if isinstance(d, str) : d = bytes(d, charset) args =(k, d, f) v = self._dbcursor.get(*args, **kwargs) if v is not None : k, v = v if isinstance(k, bytes) : k = k.decode(charset) v = (k, v.decode(charset)) return v def get_both(self, key, value) : if isinstance(key, str) : key = bytes(key, charset) if isinstance(value, str) : value = bytes(value, charset) v=self._dbcursor.get_both(key, value) return self._fix(v) class dup_cursor_py3k(cursor_py3k) : def __init__(self, dbcursor) : self._dbcursor = dbcursor class DB_py3k(object) : def __init__(self, *args, **kwargs) : args2=[] for i in args : if isinstance(i, DBEnv_py3k) : i = i._dbenv args2.append(i) args = tuple(args2) for k, v in list(kwargs.items()) : if isinstance(v, DBEnv_py3k) : kwargs[k] = v._dbenv self._db = bsddb._db.DB_orig(*args, **kwargs) def __contains__(self, k) : if isinstance(k, str) : k = bytes(k, charset) return getattr(self._db, "has_key")(k) def __getitem__(self, k) : if isinstance(k, str) : k = bytes(k, charset) v = self._db[k] if v is not None : v = v.decode(charset) return v def __setitem__(self, k, v) : if isinstance(k, str) : k = bytes(k, charset) if isinstance(v, str) : v = bytes(v, charset) self._db[k] = v def __delitem__(self, k) : if isinstance(k, str) : k = bytes(k, charset) del self._db[k] def __getattr__(self, v) : return getattr(self._db, v) def __len__(self) : return len(self._db) def has_key(self, k, txn=None) : if isinstance(k, str) : k = bytes(k, charset) return self._db.has_key(k, txn=txn) def set_re_delim(self, c) : if isinstance(c, str) : # We can use a numeric value byte too c = bytes(c, charset) return self._db.set_re_delim(c) def set_re_pad(self, c) : if isinstance(c, str) : # We can use a numeric value byte too c = bytes(c, charset) return self._db.set_re_pad(c) def get_re_source(self) : source = self._db.get_re_source() return source.decode(charset) def put(self, key, data, txn=None, flags=0, dlen=-1, doff=-1) : if isinstance(key, str) : key = bytes(key, charset) if isinstance(data, str) : value = bytes(data, charset) return self._db.put(key, data, flags=flags, txn=txn, dlen=dlen, doff=doff) def append(self, value, txn=None) : if isinstance(value, str) : value = bytes(value, charset) return self._db.append(value, txn=txn) def get_size(self, key) : if isinstance(key, str) : key = bytes(key, charset) return self._db.get_size(key) def exists(self, key, *args, **kwargs) : if isinstance(key, str) : key = bytes(key, charset) return self._db.exists(key, *args, **kwargs) def get(self, key, default="MagicCookie", txn=None, flags=0, dlen=-1, doff=-1) : if isinstance(key, str) : key = bytes(key, charset) if default != "MagicCookie" : # Magic for 'test_get_none.py' v=self._db.get(key, default=default, txn=txn, flags=flags, dlen=dlen, doff=doff) else : v=self._db.get(key, txn=txn, flags=flags, dlen=dlen, doff=doff) if (v is not None) and isinstance(v, bytes) : v = v.decode(charset) return v def pget(self, key, txn=None) : if isinstance(key, str) : key = bytes(key, charset) v=self._db.pget(key, txn=txn) if v is not None : v1, v2 = v if isinstance(v1, bytes) : v1 = v1.decode(charset) v = (v1, v2.decode(charset)) return v def get_both(self, key, value, txn=None, flags=0) : if isinstance(key, str) : key = bytes(key, charset) if isinstance(value, str) : value = bytes(value, charset) v=self._db.get_both(key, value, txn=txn, flags=flags) if v is not None : v = v.decode(charset) return v def delete(self, key, txn=None) : if isinstance(key, str) : key = bytes(key, charset) return self._db.delete(key, txn=txn) def compact(self, **kwargs) : if isinstance(kwargs.get('start'), str) : kwargs['start'] = bytes(kwargs['start'], charset) if isinstance(kwargs.get('stop'), str) : kwargs['stop'] = bytes(kwargs['stop'], charset) return self._db.compact(**kwargs) def keys(self) : k = list(self._db.keys()) if len(k) and isinstance(k[0], bytes) : return [i.decode(charset) for i in list(self._db.keys())] else : return k def items(self) : data = list(self._db.items()) if not len(data) : return data data2 = [] for k, v in data : if isinstance(k, bytes) : k = k.decode(charset) data2.append((k, v.decode(charset))) return data2 def associate(self, secondarydb, callback, flags=0, txn=None) : class associate_callback(object) : def __init__(self, callback) : self._callback = callback def callback(self, key, data) : if isinstance(key, str) : key = key.decode(charset) data = data.decode(charset) key = self._callback(key, data) if (key != bsddb._db.DB_DONOTINDEX) : if isinstance(key, str) : key = bytes(key, charset) elif isinstance(key, list) : key2 = [] for i in key : if isinstance(i, str) : i = bytes(i, charset) key2.append(i) key = key2 return key return self._db.associate(secondarydb._db, associate_callback(callback).callback, flags=flags, txn=txn) def cursor(self, txn=None, flags=0) : return cursor_py3k(self._db, txn=txn, flags=flags) def join(self, cursor_list) : cursor_list = [i._dbcursor for i in cursor_list] return dup_cursor_py3k(self._db.join(cursor_list)) class DBEnv_py3k(object) : def __init__(self, *args, **kwargs) : self._dbenv = bsddb._db.DBEnv_orig(*args, **kwargs) def __getattr__(self, v) : return getattr(self._dbenv, v) def log_cursor(self, flags=0) : return logcursor_py3k(self._dbenv) def get_lg_dir(self) : return self._dbenv.get_lg_dir().decode(charset) def get_tmp_dir(self) : return self._dbenv.get_tmp_dir().decode(charset) def get_data_dirs(self) : return tuple( (i.decode(charset) for i in self._dbenv.get_data_dirs())) class DBSequence_py3k(object) : def __init__(self, db, *args, **kwargs) : self._db=db self._dbsequence = bsddb._db.DBSequence_orig(db._db, *args, **kwargs) def __getattr__(self, v) : return getattr(self._dbsequence, v) def open(self, key, *args, **kwargs) : return self._dbsequence.open(bytes(key, charset), *args, **kwargs) def get_key(self) : return self._dbsequence.get_key().decode(charset) def get_dbp(self) : return self._db bsddb._db.DBEnv_orig = bsddb._db.DBEnv bsddb._db.DB_orig = bsddb._db.DB bsddb._db.DBSequence_orig = bsddb._db.DBSequence def do_proxy_db_py3k(flag) : flag2 = do_proxy_db_py3k.flag do_proxy_db_py3k.flag = flag if flag : bsddb.DBEnv = bsddb.db.DBEnv = bsddb._db.DBEnv = DBEnv_py3k bsddb.DB = bsddb.db.DB = bsddb._db.DB = DB_py3k bsddb._db.DBSequence = DBSequence_py3k else : bsddb.DBEnv = bsddb.db.DBEnv = bsddb._db.DBEnv = bsddb._db.DBEnv_orig bsddb.DB = bsddb.db.DB = bsddb._db.DB = bsddb._db.DB_orig bsddb._db.DBSequence = bsddb._db.DBSequence_orig return flag2 do_proxy_db_py3k.flag = False do_proxy_db_py3k(True) from bsddb3 import db, dbtables, dbutils, dbshelve, \ hashopen, btopen, rnopen, dbobj if sys.version_info[0] < 3 : from test import test_support else : from test import support as test_support try: if sys.version_info[0] < 3 : from threading import Thread, currentThread del Thread, currentThread else : from threading import Thread, current_thread del Thread, current_thread have_threads = True except ImportError: have_threads = False verbose = 0 if 'verbose' in sys.argv: verbose = 1 sys.argv.remove('verbose') if 'silent' in sys.argv: # take care of old flag, just in case verbose = 0 sys.argv.remove('silent') def print_versions(): print() print('-=' * 38) print(db.DB_VERSION_STRING) print('bsddb.db.version(): %s' % (db.version(), )) if db.version() >= (5, 0) : print('bsddb.db.full_version(): %s' %repr(db.full_version())) print('bsddb.db.__version__: %s' % db.__version__) # Workaround for allowing generating an EGGs as a ZIP files. suffix="__" print('py module: %s' % getattr(bsddb, "__file"+suffix)) print('extension module: %s' % getattr(bsddb, "__file"+suffix)) print('Test working dir: %s' % get_test_path_prefix()) import platform print('python version: %s %s' % \ (sys.version.replace("\r", "").replace("\n", ""), \ platform.architecture()[0])) print('My pid: %s' % os.getpid()) print('-=' * 38) def get_new_path(name) : get_new_path.mutex.acquire() try : import os path=os.path.join(get_new_path.prefix, name+"_"+str(os.getpid())+"_"+str(get_new_path.num)) get_new_path.num+=1 finally : get_new_path.mutex.release() return path def get_new_environment_path() : path=get_new_path("environment") import os try: os.makedirs(path,mode=0o700) except os.error: test_support.rmtree(path) os.makedirs(path) return path def get_new_database_path() : path=get_new_path("database") import os if os.path.exists(path) : os.remove(path) return path # This path can be overriden via "set_test_path_prefix()". import os, os.path get_new_path.prefix=os.path.join(os.environ.get("TMPDIR", os.path.join(os.sep,"tmp")), "z-Berkeley_DB") get_new_path.num=0 def get_test_path_prefix() : return get_new_path.prefix def set_test_path_prefix(path) : get_new_path.prefix=path def remove_test_path_directory() : test_support.rmtree(get_new_path.prefix) if have_threads : import threading get_new_path.mutex=threading.Lock() del threading else : class Lock(object) : def acquire(self) : pass def release(self) : pass get_new_path.mutex=Lock() del Lock class PrintInfoFakeTest(unittest.TestCase): def testPrintVersions(self): print_versions() # This little hack is for when this module is run as main and all the # other modules import it so they will still be able to get the right # verbose setting. It's confusing but it works. if sys.version_info[0] < 3 : from . import test_all test_all.verbose = verbose else : import sys print("Work to do!", file=sys.stderr) def suite(module_prefix='', timing_check=None): test_modules = [ 'test_associate', 'test_basics', 'test_dbenv', 'test_db', 'test_compare', 'test_compat', 'test_cursor_pget_bug', 'test_dbobj', 'test_dbshelve', 'test_dbtables', 'test_distributed_transactions', 'test_early_close', 'test_fileid', 'test_get_none', 'test_join', 'test_lock', 'test_misc', 'test_pickle', 'test_queue', 'test_recno', 'test_replication', 'test_sequence', 'test_thread', ] alltests = unittest.TestSuite() for name in test_modules: #module = __import__(name) # Do it this way so that suite may be called externally via # python's Lib/test/test_bsddb3. module = __import__(module_prefix+name, globals(), locals(), name) alltests.addTest(module.test_suite()) if timing_check: alltests.addTest(unittest.makeSuite(timing_check)) return alltests def test_suite(): suite = unittest.TestSuite() suite.addTest(unittest.makeSuite(PrintInfoFakeTest)) return suite if __name__ == '__main__': print_versions() unittest.main(defaultTest='suite') bsddb3-6.2.7/Lib3/bsddb/test/test_thread.py0000664000175000017500000004153213617051167020241 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """TestCases for multi-threaded access to a DB. """ import os import sys import time import errno from random import random DASH = '-' try: WindowsError except NameError: class WindowsError(Exception): pass import unittest from .test_all import db, dbutils, test_support, verbose, have_threads, \ get_new_environment_path, get_new_database_path if have_threads : from threading import Thread if sys.version_info[0] < 3 : from threading import currentThread else : from threading import current_thread as currentThread #---------------------------------------------------------------------- class BaseThreadedTestCase(unittest.TestCase): dbtype = db.DB_UNKNOWN # must be set in derived class dbopenflags = 0 dbsetflags = 0 envflags = 0 def setUp(self): if verbose: dbutils._deadlock_VerboseFile = sys.stdout self.homeDir = get_new_environment_path() self.env = db.DBEnv() self.setEnvOpts() self.env.open(self.homeDir, self.envflags | db.DB_CREATE) self.filename = self.__class__.__name__ + '.db' self.d = db.DB(self.env) if self.dbsetflags: self.d.set_flags(self.dbsetflags) self.d.open(self.filename, self.dbtype, self.dbopenflags|db.DB_CREATE) def tearDown(self): self.d.close() self.env.close() test_support.rmtree(self.homeDir) def setEnvOpts(self): pass def makeData(self, key): return DASH.join([key] * 5) #---------------------------------------------------------------------- class ConcurrentDataStoreBase(BaseThreadedTestCase): dbopenflags = db.DB_THREAD envflags = db.DB_THREAD | db.DB_INIT_CDB | db.DB_INIT_MPOOL readers = 0 # derived class should set writers = 0 records = 1000 def test01_1WriterMultiReaders(self): if verbose: print('\n', '-=' * 30) print("Running %s.test01_1WriterMultiReaders..." % \ self.__class__.__name__) keys=list(range(self.records)) import random random.shuffle(keys) records_per_writer=self.records//self.writers readers_per_writer=self.readers//self.writers self.assertEqual(self.records,self.writers*records_per_writer) self.assertEqual(self.readers,self.writers*readers_per_writer) self.assertTrue((records_per_writer%readers_per_writer)==0) readers = [] for x in range(self.readers): rt = Thread(target = self.readerThread, args = (self.d, x), name = 'reader %d' % x, )#verbose = verbose) if sys.version_info[0] < 3 : rt.setDaemon(True) else : rt.daemon = True readers.append(rt) writers=[] for x in range(self.writers): a=keys[records_per_writer*x:records_per_writer*(x+1)] a.sort() # Generate conflicts b=readers[readers_per_writer*x:readers_per_writer*(x+1)] wt = Thread(target = self.writerThread, args = (self.d, a, b), name = 'writer %d' % x, )#verbose = verbose) writers.append(wt) for t in writers: if sys.version_info[0] < 3 : t.setDaemon(True) else : t.daemon = True t.start() for t in writers: t.join() for t in readers: t.join() def writerThread(self, d, keys, readers): if sys.version_info[0] < 3 : name = currentThread().getName() else : name = currentThread().name if verbose: print("%s: creating records %d - %d" % (name, start, stop)) count=len(keys)//len(readers) count2=count for x in keys : key = '%04d' % x dbutils.DeadlockWrap(d.put, key, self.makeData(key), max_retries=12) if verbose and x % 100 == 0: print("%s: records %d - %d finished" % (name, start, x)) count2-=1 if not count2 : readers.pop().start() count2=count if verbose: print("%s: finished creating records" % name) if verbose: print("%s: thread finished" % name) def readerThread(self, d, readerNum): if sys.version_info[0] < 3 : name = currentThread().getName() else : name = currentThread().name for i in range(5) : c = d.cursor() count = 0 rec = c.first() while rec: count += 1 key, data = rec self.assertEqual(self.makeData(key), data) rec = next(c) if verbose: print("%s: found %d records" % (name, count)) c.close() if verbose: print("%s: thread finished" % name) class BTreeConcurrentDataStore(ConcurrentDataStoreBase): dbtype = db.DB_BTREE writers = 2 readers = 10 records = 1000 class HashConcurrentDataStore(ConcurrentDataStoreBase): dbtype = db.DB_HASH writers = 2 readers = 10 records = 1000 #---------------------------------------------------------------------- class SimpleThreadedBase(BaseThreadedTestCase): dbopenflags = db.DB_THREAD envflags = db.DB_THREAD | db.DB_INIT_MPOOL | db.DB_INIT_LOCK readers = 10 writers = 2 records = 1000 def setEnvOpts(self): self.env.set_lk_detect(db.DB_LOCK_DEFAULT) def test02_SimpleLocks(self): if verbose: print('\n', '-=' * 30) print("Running %s.test02_SimpleLocks..." % self.__class__.__name__) keys=list(range(self.records)) import random random.shuffle(keys) records_per_writer=self.records//self.writers readers_per_writer=self.readers//self.writers self.assertEqual(self.records,self.writers*records_per_writer) self.assertEqual(self.readers,self.writers*readers_per_writer) self.assertTrue((records_per_writer%readers_per_writer)==0) readers = [] for x in range(self.readers): rt = Thread(target = self.readerThread, args = (self.d, x), name = 'reader %d' % x, )#verbose = verbose) if sys.version_info[0] < 3 : rt.setDaemon(True) else : rt.daemon = True readers.append(rt) writers = [] for x in range(self.writers): a=keys[records_per_writer*x:records_per_writer*(x+1)] a.sort() # Generate conflicts b=readers[readers_per_writer*x:readers_per_writer*(x+1)] wt = Thread(target = self.writerThread, args = (self.d, a, b), name = 'writer %d' % x, )#verbose = verbose) writers.append(wt) for t in writers: if sys.version_info[0] < 3 : t.setDaemon(True) else : t.daemon = True t.start() for t in writers: t.join() for t in readers: t.join() def writerThread(self, d, keys, readers): if sys.version_info[0] < 3 : name = currentThread().getName() else : name = currentThread().name if verbose: print("%s: creating records %d - %d" % (name, start, stop)) count=len(keys)//len(readers) count2=count for x in keys : key = '%04d' % x dbutils.DeadlockWrap(d.put, key, self.makeData(key), max_retries=12) if verbose and x % 100 == 0: print("%s: records %d - %d finished" % (name, start, x)) count2-=1 if not count2 : readers.pop().start() count2=count if verbose: print("%s: thread finished" % name) def readerThread(self, d, readerNum): if sys.version_info[0] < 3 : name = currentThread().getName() else : name = currentThread().name c = d.cursor() count = 0 rec = dbutils.DeadlockWrap(c.first, max_retries=10) while rec: count += 1 key, data = rec self.assertEqual(self.makeData(key), data) rec = dbutils.DeadlockWrap(c.__next__, max_retries=10) if verbose: print("%s: found %d records" % (name, count)) c.close() if verbose: print("%s: thread finished" % name) class BTreeSimpleThreaded(SimpleThreadedBase): dbtype = db.DB_BTREE class HashSimpleThreaded(SimpleThreadedBase): dbtype = db.DB_HASH #---------------------------------------------------------------------- class ThreadedTransactionsBase(BaseThreadedTestCase): dbopenflags = db.DB_THREAD | db.DB_AUTO_COMMIT envflags = (db.DB_THREAD | db.DB_INIT_MPOOL | db.DB_INIT_LOCK | db.DB_INIT_LOG | db.DB_INIT_TXN ) readers = 0 writers = 0 records = 2000 txnFlag = 0 def setEnvOpts(self): #self.env.set_lk_detect(db.DB_LOCK_DEFAULT) pass def test03_ThreadedTransactions(self): if verbose: print('\n', '-=' * 30) print("Running %s.test03_ThreadedTransactions..." % \ self.__class__.__name__) keys=list(range(self.records)) import random random.shuffle(keys) records_per_writer=self.records//self.writers readers_per_writer=self.readers//self.writers self.assertEqual(self.records,self.writers*records_per_writer) self.assertEqual(self.readers,self.writers*readers_per_writer) self.assertTrue((records_per_writer%readers_per_writer)==0) readers=[] for x in range(self.readers): rt = Thread(target = self.readerThread, args = (self.d, x), name = 'reader %d' % x, )#verbose = verbose) if sys.version_info[0] < 3 : rt.setDaemon(True) else : rt.daemon = True readers.append(rt) writers = [] for x in range(self.writers): a=keys[records_per_writer*x:records_per_writer*(x+1)] b=readers[readers_per_writer*x:readers_per_writer*(x+1)] wt = Thread(target = self.writerThread, args = (self.d, a, b), name = 'writer %d' % x, )#verbose = verbose) writers.append(wt) dt = Thread(target = self.deadlockThread) if sys.version_info[0] < 3 : dt.setDaemon(True) else : dt.daemon = True dt.start() for t in writers: if sys.version_info[0] < 3 : t.setDaemon(True) else : t.daemon = True t.start() for t in writers: t.join() for t in readers: t.join() self.doLockDetect = False dt.join() def writerThread(self, d, keys, readers): if sys.version_info[0] < 3 : name = currentThread().getName() else : name = currentThread().name count=len(keys)//len(readers) while len(keys): try: txn = self.env.txn_begin(None, self.txnFlag) keys2=keys[:count] for x in keys2 : key = '%04d' % x d.put(key, self.makeData(key), txn) if verbose and x % 100 == 0: print("%s: records %d - %d finished" % (name, start, x)) txn.commit() keys=keys[count:] readers.pop().start() except (db.DBLockDeadlockError, db.DBLockNotGrantedError) as val: if verbose: print("%s: Aborting transaction (%s)" % (name, val.args[1])) txn.abort() if verbose: print("%s: thread finished" % name) def readerThread(self, d, readerNum): if sys.version_info[0] < 3 : name = currentThread().getName() else : name = currentThread().name finished = False while not finished: try: txn = self.env.txn_begin(None, self.txnFlag) c = d.cursor(txn) count = 0 rec = c.first() while rec: count += 1 key, data = rec self.assertEqual(self.makeData(key), data) rec = next(c) if verbose: print("%s: found %d records" % (name, count)) c.close() txn.commit() finished = True except (db.DBLockDeadlockError, db.DBLockNotGrantedError) as val: if verbose: print("%s: Aborting transaction (%s)" % (name, val.args[1])) c.close() txn.abort() if verbose: print("%s: thread finished" % name) def deadlockThread(self): self.doLockDetect = True while self.doLockDetect: time.sleep(0.05) try: aborted = self.env.lock_detect( db.DB_LOCK_RANDOM, db.DB_LOCK_CONFLICT) if verbose and aborted: print("deadlock: Aborted %d deadlocked transaction(s)" \ % aborted) except db.DBError: pass class BTreeThreadedTransactions(ThreadedTransactionsBase): dbtype = db.DB_BTREE writers = 2 readers = 10 records = 1000 class HashThreadedTransactions(ThreadedTransactionsBase): dbtype = db.DB_HASH writers = 2 readers = 10 records = 1000 class BTreeThreadedNoWaitTransactions(ThreadedTransactionsBase): dbtype = db.DB_BTREE writers = 2 readers = 10 records = 1000 txnFlag = db.DB_TXN_NOWAIT class HashThreadedNoWaitTransactions(ThreadedTransactionsBase): dbtype = db.DB_HASH writers = 2 readers = 10 records = 1000 txnFlag = db.DB_TXN_NOWAIT #---------------------------------------------------------------------- def test_suite(): suite = unittest.TestSuite() if have_threads: suite.addTest(unittest.makeSuite(BTreeConcurrentDataStore)) suite.addTest(unittest.makeSuite(HashConcurrentDataStore)) suite.addTest(unittest.makeSuite(BTreeSimpleThreaded)) suite.addTest(unittest.makeSuite(HashSimpleThreaded)) suite.addTest(unittest.makeSuite(BTreeThreadedTransactions)) suite.addTest(unittest.makeSuite(HashThreadedTransactions)) suite.addTest(unittest.makeSuite(BTreeThreadedNoWaitTransactions)) suite.addTest(unittest.makeSuite(HashThreadedNoWaitTransactions)) else: print("Threads not available, skipping thread tests.") return suite if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib3/bsddb/test/test_get_none.py0000664000175000017500000000750213617051200020553 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """ TestCases for checking set_get_returns_none. """ import os, string import unittest from .test_all import db, verbose, get_new_database_path #---------------------------------------------------------------------- class GetReturnsNoneTestCase(unittest.TestCase): def setUp(self): self.filename = get_new_database_path() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_get_returns_none(self): d = db.DB() d.open(self.filename, db.DB_BTREE, db.DB_CREATE) d.set_get_returns_none(1) for x in string.ascii_letters: d.put(x, x * 40) data = d.get('bad key') self.assertEqual(data, None) data = d.get(string.ascii_letters[0]) self.assertEqual(data, string.ascii_letters[0]*40) count = 0 c = d.cursor() rec = c.first() while rec: count = count + 1 rec = next(c) self.assertEqual(rec, None) self.assertEqual(count, len(string.ascii_letters)) c.close() d.close() def test02_get_raises_exception(self): d = db.DB() d.open(self.filename, db.DB_BTREE, db.DB_CREATE) d.set_get_returns_none(0) for x in string.ascii_letters: d.put(x, x * 40) self.assertRaises(db.DBNotFoundError, d.get, 'bad key') self.assertRaises(KeyError, d.get, 'bad key') data = d.get(string.ascii_letters[0]) self.assertEqual(data, string.ascii_letters[0]*40) count = 0 exceptionHappened = 0 c = d.cursor() rec = c.first() while rec: count = count + 1 try: rec = next(c) except db.DBNotFoundError: # end of the records exceptionHappened = 1 break self.assertNotEqual(rec, None) self.assertTrue(exceptionHappened) self.assertEqual(count, len(string.ascii_letters)) c.close() d.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(GetReturnsNoneTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib3/bsddb/test/test_basics.py0000664000175000017500000010720513617051173020233 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """ Basic TestCases for BTree and hash DBs, with and without a DBEnv, with various DB flags, etc. """ import os import errno import string from pprint import pprint import unittest import time import sys from .test_all import db, test_support, verbose, get_new_environment_path, \ get_new_database_path DASH = '-' #---------------------------------------------------------------------- class VersionTestCase(unittest.TestCase): def test00_version(self): info = db.version() if verbose: print('\n', '-=' * 20) print('bsddb.db.version(): %s' % (info, )) print(db.DB_VERSION_STRING) print('-=' * 20) self.assertEqual(info, (db.DB_VERSION_MAJOR, db.DB_VERSION_MINOR, db.DB_VERSION_PATCH)) #---------------------------------------------------------------------- class BasicTestCase(unittest.TestCase): dbtype = db.DB_UNKNOWN # must be set in derived class cachesize = (0, 1024*1024, 1) dbopenflags = 0 dbsetflags = 0 dbmode = 0o660 dbname = None useEnv = 0 envflags = 0 envsetflags = 0 _numKeys = 1002 # PRIVATE. NOTE: must be an even value def setUp(self): if self.useEnv: self.homeDir=get_new_environment_path() try: self.env = db.DBEnv() self.env.set_lg_max(1024*1024) self.env.set_tx_max(30) self._t = int(time.time()) self.env.set_tx_timestamp(self._t) self.env.set_flags(self.envsetflags, 1) self.env.open(self.homeDir, self.envflags | db.DB_CREATE) self.filename = "test" # Yes, a bare except is intended, since we're re-raising the exc. except: test_support.rmtree(self.homeDir) raise else: self.env = None self.filename = get_new_database_path() # create and open the DB self.d = db.DB(self.env) if not self.useEnv : self.d.set_cachesize(*self.cachesize) cachesize = self.d.get_cachesize() self.assertEqual(cachesize[0], self.cachesize[0]) self.assertEqual(cachesize[2], self.cachesize[2]) # Berkeley DB expands the cache 25% accounting overhead, # if the cache is small. self.assertEqual(125, int(100.0*cachesize[1]/self.cachesize[1])) self.d.set_flags(self.dbsetflags) if self.dbname: self.d.open(self.filename, self.dbname, self.dbtype, self.dbopenflags|db.DB_CREATE, self.dbmode) else: self.d.open(self.filename, # try out keyword args mode = self.dbmode, dbtype = self.dbtype, flags = self.dbopenflags|db.DB_CREATE) if not self.useEnv: self.assertRaises(db.DBInvalidArgError, self.d.set_cachesize, *self.cachesize) self.populateDB() def tearDown(self): self.d.close() if self.env is not None: self.env.close() test_support.rmtree(self.homeDir) else: os.remove(self.filename) def populateDB(self, _txn=None): d = self.d for x in range(self._numKeys//2): key = '%04d' % (self._numKeys - x) # insert keys in reverse order data = self.makeData(key) d.put(key, data, _txn) d.put('empty value', '', _txn) for x in range(self._numKeys//2-1): key = '%04d' % x # and now some in forward order data = self.makeData(key) d.put(key, data, _txn) if _txn: _txn.commit() num = len(d) if verbose: print("created %d records" % num) def makeData(self, key): return DASH.join([key] * 5) #---------------------------------------- def test01_GetsAndPuts(self): d = self.d if verbose: print('\n', '-=' * 30) print("Running %s.test01_GetsAndPuts..." % self.__class__.__name__) for key in ['0001', '0100', '0400', '0700', '0999']: data = d.get(key) if verbose: print(data) self.assertEqual(d.get('0321'), '0321-0321-0321-0321-0321') # By default non-existent keys return None... self.assertEqual(d.get('abcd'), None) # ...but they raise exceptions in other situations. Call # set_get_returns_none() to change it. try: d.delete('abcd') except db.DBNotFoundError as val: self.assertEqual(val.args[0], db.DB_NOTFOUND) if verbose: print(val) else: self.fail("expected exception") d.put('abcd', 'a new record') self.assertEqual(d.get('abcd'), 'a new record') d.put('abcd', 'same key') if self.dbsetflags & db.DB_DUP: self.assertEqual(d.get('abcd'), 'a new record') else: self.assertEqual(d.get('abcd'), 'same key') try: d.put('abcd', 'this should fail', flags=db.DB_NOOVERWRITE) except db.DBKeyExistError as val: self.assertEqual(val.args[0], db.DB_KEYEXIST) if verbose: print(val) else: self.fail("expected exception") if self.dbsetflags & db.DB_DUP: self.assertEqual(d.get('abcd'), 'a new record') else: self.assertEqual(d.get('abcd'), 'same key') d.sync() d.close() del d self.d = db.DB(self.env) if self.dbname: self.d.open(self.filename, self.dbname) else: self.d.open(self.filename) d = self.d self.assertEqual(d.get('0321'), '0321-0321-0321-0321-0321') if self.dbsetflags & db.DB_DUP: self.assertEqual(d.get('abcd'), 'a new record') else: self.assertEqual(d.get('abcd'), 'same key') rec = d.get_both('0555', '0555-0555-0555-0555-0555') if verbose: print(rec) self.assertEqual(d.get_both('0555', 'bad data'), None) # test default value data = d.get('bad key', 'bad data') self.assertEqual(data, 'bad data') # any object can pass through data = d.get('bad key', self) self.assertEqual(data, self) s = d.stat() self.assertEqual(type(s), type({})) if verbose: print('d.stat() returned this dictionary:') pprint(s) #---------------------------------------- def test02_DictionaryMethods(self): d = self.d if verbose: print('\n', '-=' * 30) print("Running %s.test02_DictionaryMethods..." % \ self.__class__.__name__) for key in ['0002', '0101', '0401', '0701', '0998']: data = d[key] self.assertEqual(data, self.makeData(key)) if verbose: print(data) self.assertEqual(len(d), self._numKeys) keys = list(d.keys()) self.assertEqual(len(keys), self._numKeys) self.assertEqual(type(keys), type([])) d['new record'] = 'a new record' self.assertEqual(len(d), self._numKeys+1) keys = list(d.keys()) self.assertEqual(len(keys), self._numKeys+1) d['new record'] = 'a replacement record' self.assertEqual(len(d), self._numKeys+1) keys = list(d.keys()) self.assertEqual(len(keys), self._numKeys+1) if verbose: print("the first 10 keys are:") pprint(keys[:10]) self.assertEqual(d['new record'], 'a replacement record') # We check also the positional parameter self.assertEqual(d.has_key('0001', None), 1) # We check also the keyword parameter self.assertEqual(d.has_key('spam', txn=None), 0) items = list(d.items()) self.assertEqual(len(items), self._numKeys+1) self.assertEqual(type(items), type([])) self.assertEqual(type(items[0]), type(())) self.assertEqual(len(items[0]), 2) if verbose: print("the first 10 items are:") pprint(items[:10]) values = list(d.values()) self.assertEqual(len(values), self._numKeys+1) self.assertEqual(type(values), type([])) if verbose: print("the first 10 values are:") pprint(values[:10]) #---------------------------------------- def test02b_SequenceMethods(self): d = self.d for key in ['0002', '0101', '0401', '0701', '0998']: data = d[key] self.assertEqual(data, self.makeData(key)) if verbose: print(data) self.assertTrue(hasattr(d, "__contains__")) self.assertTrue("0401" in d) self.assertFalse("1234" in d) #---------------------------------------- def test03_SimpleCursorStuff(self, get_raises_error=0, set_raises_error=0): if verbose: print('\n', '-=' * 30) print("Running %s.test03_SimpleCursorStuff (get_error %s, set_error %s)..." % \ (self.__class__.__name__, get_raises_error, set_raises_error)) if self.env and self.dbopenflags & db.DB_AUTO_COMMIT: txn = self.env.txn_begin() else: txn = None c = self.d.cursor(txn=txn) rec = c.first() count = 0 while rec is not None: count = count + 1 if verbose and count % 100 == 0: print(rec) try: rec = next(c) except db.DBNotFoundError as val: if get_raises_error: self.assertEqual(val.args[0], db.DB_NOTFOUND) if verbose: print(val) rec = None else: self.fail("unexpected DBNotFoundError") self.assertEqual(c.get_current_size(), len(c.current()[1]), "%s != len(%r)" % (c.get_current_size(), c.current()[1])) self.assertEqual(count, self._numKeys) rec = c.last() count = 0 while rec is not None: count = count + 1 if verbose and count % 100 == 0: print(rec) try: rec = c.prev() except db.DBNotFoundError as val: if get_raises_error: self.assertEqual(val.args[0], db.DB_NOTFOUND) if verbose: print(val) rec = None else: self.fail("unexpected DBNotFoundError") self.assertEqual(count, self._numKeys) rec = c.set('0505') rec2 = c.current() self.assertEqual(rec, rec2) self.assertEqual(rec[0], '0505') self.assertEqual(rec[1], self.makeData('0505')) self.assertEqual(c.get_current_size(), len(rec[1])) # make sure we get empty values properly rec = c.set('empty value') self.assertEqual(rec[1], '') self.assertEqual(c.get_current_size(), 0) try: n = c.set('bad key') except db.DBNotFoundError as val: self.assertEqual(val.args[0], db.DB_NOTFOUND) if verbose: print(val) else: if set_raises_error: self.fail("expected exception") if n is not None: self.fail("expected None: %r" % (n,)) rec = c.get_both('0404', self.makeData('0404')) self.assertEqual(rec, ('0404', self.makeData('0404'))) try: n = c.get_both('0404', 'bad data') except db.DBNotFoundError as val: self.assertEqual(val.args[0], db.DB_NOTFOUND) if verbose: print(val) else: if get_raises_error: self.fail("expected exception") if n is not None: self.fail("expected None: %r" % (n,)) if self.d.get_type() == db.DB_BTREE: rec = c.set_range('011') if verbose: print("searched for '011', found: ", rec) rec = c.set_range('011',dlen=0,doff=0) if verbose: print("searched (partial) for '011', found: ", rec) if rec[1] != '': self.fail('expected empty data portion') ev = c.set_range('empty value') if verbose: print("search for 'empty value' returned", ev) if ev[1] != '': self.fail('empty value lookup failed') c.set('0499') c.delete() try: rec = c.current() except db.DBKeyEmptyError as val: if get_raises_error: self.assertEqual(val.args[0], db.DB_KEYEMPTY) if verbose: print(val) else: self.fail("unexpected DBKeyEmptyError") else: if get_raises_error: self.fail('DBKeyEmptyError exception expected') next(c) c2 = c.dup(db.DB_POSITION) self.assertEqual(c.current(), c2.current()) c2.put('', 'a new value', db.DB_CURRENT) self.assertEqual(c.current(), c2.current()) self.assertEqual(c.current()[1], 'a new value') c2.put('', 'er', db.DB_CURRENT, dlen=0, doff=5) self.assertEqual(c2.current()[1], 'a newer value') c.close() c2.close() if txn: txn.commit() # time to abuse the closed cursors and hope we don't crash methods_to_test = { 'current': (), 'delete': (), 'dup': (db.DB_POSITION,), 'first': (), 'get': (0,), 'next': (), 'prev': (), 'last': (), 'put':('', 'spam', db.DB_CURRENT), 'set': ("0505",), } for method, args in list(methods_to_test.items()): try: if verbose: print("attempting to use a closed cursor's %s method" % \ method) # a bug may cause a NULL pointer dereference... getattr(c, method)(*args) except db.DBError as val: self.assertEqual(val.args[0], 0) if verbose: print(val) else: self.fail("no exception raised when using a buggy cursor's" "%s method" % method) # # free cursor referencing a closed database, it should not barf: # oldcursor = self.d.cursor(txn=txn) self.d.close() # this would originally cause a segfault when the cursor for a # closed database was cleaned up. it should not anymore. # SF pybsddb bug id 667343 del oldcursor def test03b_SimpleCursorWithoutGetReturnsNone0(self): # same test but raise exceptions instead of returning None if verbose: print('\n', '-=' * 30) print("Running %s.test03b_SimpleCursorStuffWithoutGetReturnsNone..." % \ self.__class__.__name__) old = self.d.set_get_returns_none(0) self.assertEqual(old, 2) self.test03_SimpleCursorStuff(get_raises_error=1, set_raises_error=1) def test03b_SimpleCursorWithGetReturnsNone1(self): # same test but raise exceptions instead of returning None if verbose: print('\n', '-=' * 30) print("Running %s.test03b_SimpleCursorStuffWithoutGetReturnsNone..." % \ self.__class__.__name__) old = self.d.set_get_returns_none(1) self.test03_SimpleCursorStuff(get_raises_error=0, set_raises_error=1) def test03c_SimpleCursorGetReturnsNone2(self): # same test but raise exceptions instead of returning None if verbose: print('\n', '-=' * 30) print("Running %s.test03c_SimpleCursorStuffWithoutSetReturnsNone..." % \ self.__class__.__name__) old = self.d.set_get_returns_none(1) self.assertEqual(old, 2) old = self.d.set_get_returns_none(2) self.assertEqual(old, 1) self.test03_SimpleCursorStuff(get_raises_error=0, set_raises_error=0) def test03d_SimpleCursorPriority(self) : c = self.d.cursor() c.set_priority(db.DB_PRIORITY_VERY_LOW) # Positional self.assertEqual(db.DB_PRIORITY_VERY_LOW, c.get_priority()) c.set_priority(priority=db.DB_PRIORITY_HIGH) # Keyword self.assertEqual(db.DB_PRIORITY_HIGH, c.get_priority()) c.close() #---------------------------------------- def test04_PartialGetAndPut(self): d = self.d if verbose: print('\n', '-=' * 30) print("Running %s.test04_PartialGetAndPut..." % \ self.__class__.__name__) key = "partialTest" data = "1" * 1000 + "2" * 1000 d.put(key, data) self.assertEqual(d.get(key), data) self.assertEqual(d.get(key, dlen=20, doff=990), ("1" * 10) + ("2" * 10)) d.put("partialtest2", ("1" * 30000) + "robin" ) self.assertEqual(d.get("partialtest2", dlen=5, doff=30000), "robin") # There seems to be a bug in DB here... Commented out the test for # now. ##self.assertEqual(d.get("partialtest2", dlen=5, doff=30010), "") if self.dbsetflags != db.DB_DUP: # Partial put with duplicate records requires a cursor d.put(key, "0000", dlen=2000, doff=0) self.assertEqual(d.get(key), "0000") d.put(key, "1111", dlen=1, doff=2) self.assertEqual(d.get(key), "0011110") #---------------------------------------- def test05_GetSize(self): d = self.d if verbose: print('\n', '-=' * 30) print("Running %s.test05_GetSize..." % self.__class__.__name__) for i in range(1, 50000, 500): key = "size%s" % i #print "before ", i, d.put(key, "1" * i) #print "after", self.assertEqual(d.get_size(key), i) #print "done" #---------------------------------------- def test06_Truncate(self): d = self.d if verbose: print('\n', '-=' * 30) print("Running %s.test06_Truncate..." % self.__class__.__name__) d.put("abcde", "ABCDE"); num = d.truncate() self.assertTrue(num >= 1, "truncate returned <= 0 on non-empty database") num = d.truncate() self.assertEqual(num, 0, "truncate on empty DB returned nonzero (%r)" % (num,)) #---------------------------------------- def test07_verify(self): # Verify bug solved in 4.7.3pre8 self.d.close() d = db.DB(self.env) d.verify(self.filename) #---------------------------------------- def test08_exists(self) : self.d.put("abcde", "ABCDE") self.assertTrue(self.d.exists("abcde") == True, "DB->exists() returns wrong value") self.assertTrue(self.d.exists("x") == False, "DB->exists() returns wrong value") #---------------------------------------- def test_compact(self) : d = self.d self.assertEqual(0, d.compact(flags=db.DB_FREELIST_ONLY)) self.assertEqual(0, d.compact(flags=db.DB_FREELIST_ONLY)) d.put("abcde", "ABCDE"); d.put("bcde", "BCDE"); d.put("abc", "ABC"); d.put("monty", "python"); d.delete("abc") d.delete("bcde") d.compact(start='abcde', stop='monty', txn=None, compact_fillpercent=42, compact_pages=1, compact_timeout=50000000, flags=db.DB_FREELIST_ONLY|db.DB_FREE_SPACE) #---------------------------------------- #---------------------------------------------------------------------- class BasicBTreeTestCase(BasicTestCase): dbtype = db.DB_BTREE class BasicHashTestCase(BasicTestCase): dbtype = db.DB_HASH class BasicBTreeWithThreadFlagTestCase(BasicTestCase): dbtype = db.DB_BTREE dbopenflags = db.DB_THREAD class BasicHashWithThreadFlagTestCase(BasicTestCase): dbtype = db.DB_HASH dbopenflags = db.DB_THREAD class BasicWithEnvTestCase(BasicTestCase): dbopenflags = db.DB_THREAD useEnv = 1 envflags = db.DB_THREAD | db.DB_INIT_MPOOL | db.DB_INIT_LOCK #---------------------------------------- def test09_EnvRemoveAndRename(self): if not self.env: return if verbose: print('\n', '-=' * 30) print("Running %s.test09_EnvRemoveAndRename..." % self.__class__.__name__) # can't rename or remove an open DB self.d.close() newname = self.filename + '.renamed' self.env.dbrename(self.filename, None, newname) self.env.dbremove(newname) #---------------------------------------- class BasicBTreeWithEnvTestCase(BasicWithEnvTestCase): dbtype = db.DB_BTREE class BasicHashWithEnvTestCase(BasicWithEnvTestCase): dbtype = db.DB_HASH #---------------------------------------------------------------------- class BasicTransactionTestCase(BasicTestCase): if sys.version_info < (2, 7) : def assertIn(self, a, b, msg=None) : return self.assertTrue(a in b, msg=msg) dbopenflags = db.DB_THREAD | db.DB_AUTO_COMMIT useEnv = 1 envflags = (db.DB_THREAD | db.DB_INIT_MPOOL | db.DB_INIT_LOCK | db.DB_INIT_TXN) envsetflags = db.DB_AUTO_COMMIT def tearDown(self): self.txn.commit() BasicTestCase.tearDown(self) def populateDB(self): txn = self.env.txn_begin() BasicTestCase.populateDB(self, _txn=txn) self.txn = self.env.txn_begin() def test06_Transactions(self): d = self.d if verbose: print('\n', '-=' * 30) print("Running %s.test06_Transactions..." % self.__class__.__name__) self.assertEqual(d.get('new rec', txn=self.txn), None) d.put('new rec', 'this is a new record', self.txn) self.assertEqual(d.get('new rec', txn=self.txn), 'this is a new record') self.txn.abort() self.assertEqual(d.get('new rec'), None) self.txn = self.env.txn_begin() self.assertEqual(d.get('new rec', txn=self.txn), None) d.put('new rec', 'this is a new record', self.txn) self.assertEqual(d.get('new rec', txn=self.txn), 'this is a new record') self.txn.commit() self.assertEqual(d.get('new rec'), 'this is a new record') self.txn = self.env.txn_begin() c = d.cursor(self.txn) rec = c.first() count = 0 while rec is not None: count = count + 1 if verbose and count % 100 == 0: print(rec) rec = next(c) self.assertEqual(count, self._numKeys+1) c.close() # Cursors *MUST* be closed before commit! self.txn.commit() # flush pending updates self.env.txn_checkpoint (0, 0, 0) statDict = self.env.log_stat(0); self.assertIn('magic', statDict) self.assertIn('version', statDict) self.assertIn('cur_file', statDict) self.assertIn('region_nowait', statDict) # must have at least one log file present: logs = self.env.log_archive(db.DB_ARCH_ABS | db.DB_ARCH_LOG) self.assertNotEqual(logs, None) for log in logs: if verbose: print('log file: ' + log) logs = self.env.log_archive(db.DB_ARCH_REMOVE) self.assertTrue(not logs) self.txn = self.env.txn_begin() #---------------------------------------- def test08_exists(self) : txn = self.env.txn_begin() self.d.put("abcde", "ABCDE", txn=txn) txn.commit() txn = self.env.txn_begin() self.assertTrue(self.d.exists("abcde", txn=txn) == True, "DB->exists() returns wrong value") self.assertTrue(self.d.exists("x", txn=txn) == False, "DB->exists() returns wrong value") txn.abort() #---------------------------------------- def test09_TxnTruncate(self): d = self.d if verbose: print('\n', '-=' * 30) print("Running %s.test09_TxnTruncate..." % self.__class__.__name__) d.put("abcde", "ABCDE"); txn = self.env.txn_begin() num = d.truncate(txn) self.assertTrue(num >= 1, "truncate returned <= 0 on non-empty database") num = d.truncate(txn) self.assertEqual(num, 0, "truncate on empty DB returned nonzero (%r)" % (num,)) txn.commit() #---------------------------------------- def test10_TxnLateUse(self): txn = self.env.txn_begin() txn.abort() try: txn.abort() except db.DBError as e: pass else: raise RuntimeError("DBTxn.abort() called after DB_TXN no longer valid w/o an exception") txn = self.env.txn_begin() txn.commit() try: txn.commit() except db.DBError as e: pass else: raise RuntimeError("DBTxn.commit() called after DB_TXN no longer valid w/o an exception") #---------------------------------------- def test_txn_name(self) : txn=self.env.txn_begin() self.assertEqual(txn.get_name(), "") txn.set_name("XXYY") self.assertEqual(txn.get_name(), "XXYY") txn.set_name("ABC") self.assertEqual(txn.get_name(), "ABC") txn.abort() #---------------------------------------- def test_txn_set_timeout(self) : txn=self.env.txn_begin() txn.set_timeout(1234567, db.DB_SET_LOCK_TIMEOUT) txn.set_timeout(2345678, flags=db.DB_SET_TXN_TIMEOUT) txn.abort() #---------------------------------------- def test_get_tx_max(self) : self.assertEqual(self.env.get_tx_max(), 30) def test_get_tx_timestamp(self) : self.assertEqual(self.env.get_tx_timestamp(), self._t) class BTreeTransactionTestCase(BasicTransactionTestCase): dbtype = db.DB_BTREE class HashTransactionTestCase(BasicTransactionTestCase): dbtype = db.DB_HASH #---------------------------------------------------------------------- class BTreeRecnoTestCase(BasicTestCase): dbtype = db.DB_BTREE dbsetflags = db.DB_RECNUM def test09_RecnoInBTree(self): d = self.d if verbose: print('\n', '-=' * 30) print("Running %s.test09_RecnoInBTree..." % self.__class__.__name__) rec = d.get(200) self.assertEqual(type(rec), type(())) self.assertEqual(len(rec), 2) if verbose: print("Record #200 is ", rec) c = d.cursor() c.set('0200') num = c.get_recno() self.assertEqual(type(num), type(1)) if verbose: print("recno of d['0200'] is ", num) rec = c.current() self.assertEqual(c.set_recno(num), rec) c.close() class BTreeRecnoWithThreadFlagTestCase(BTreeRecnoTestCase): dbopenflags = db.DB_THREAD #---------------------------------------------------------------------- class BasicDUPTestCase(BasicTestCase): dbsetflags = db.DB_DUP def test10_DuplicateKeys(self): d = self.d if verbose: print('\n', '-=' * 30) print("Running %s.test10_DuplicateKeys..." % \ self.__class__.__name__) d.put("dup0", "before") for x in "The quick brown fox jumped over the lazy dog.".split(): d.put("dup1", x) d.put("dup2", "after") data = d.get("dup1") self.assertEqual(data, "The") if verbose: print(data) c = d.cursor() rec = c.set("dup1") self.assertEqual(rec, ('dup1', 'The')) next_reg = next(c) self.assertEqual(next_reg, ('dup1', 'quick')) rec = c.set("dup1") count = c.count() self.assertEqual(count, 9) next_dup = c.next_dup() self.assertEqual(next_dup, ('dup1', 'quick')) rec = c.set('dup1') while rec is not None: if verbose: print(rec) rec = c.next_dup() c.set('dup1') rec = c.next_nodup() self.assertNotEqual(rec[0], 'dup1') if verbose: print(rec) c.close() class BTreeDUPTestCase(BasicDUPTestCase): dbtype = db.DB_BTREE class HashDUPTestCase(BasicDUPTestCase): dbtype = db.DB_HASH class BTreeDUPWithThreadTestCase(BasicDUPTestCase): dbtype = db.DB_BTREE dbopenflags = db.DB_THREAD class HashDUPWithThreadTestCase(BasicDUPTestCase): dbtype = db.DB_HASH dbopenflags = db.DB_THREAD #---------------------------------------------------------------------- class BasicMultiDBTestCase(BasicTestCase): dbname = 'first' def otherType(self): if self.dbtype == db.DB_BTREE: return db.DB_HASH else: return db.DB_BTREE def test11_MultiDB(self): d1 = self.d if verbose: print('\n', '-=' * 30) print("Running %s.test11_MultiDB..." % self.__class__.__name__) d2 = db.DB(self.env) d2.open(self.filename, "second", self.dbtype, self.dbopenflags|db.DB_CREATE) d3 = db.DB(self.env) d3.open(self.filename, "third", self.otherType(), self.dbopenflags|db.DB_CREATE) for x in "The quick brown fox jumped over the lazy dog".split(): d2.put(x, self.makeData(x)) for x in string.ascii_letters: d3.put(x, x*70) d1.sync() d2.sync() d3.sync() d1.close() d2.close() d3.close() self.d = d1 = d2 = d3 = None self.d = d1 = db.DB(self.env) d1.open(self.filename, self.dbname, flags = self.dbopenflags) d2 = db.DB(self.env) d2.open(self.filename, "second", flags = self.dbopenflags) d3 = db.DB(self.env) d3.open(self.filename, "third", flags = self.dbopenflags) c1 = d1.cursor() c2 = d2.cursor() c3 = d3.cursor() count = 0 rec = c1.first() while rec is not None: count = count + 1 if verbose and (count % 50) == 0: print(rec) rec = next(c1) self.assertEqual(count, self._numKeys) count = 0 rec = c2.first() while rec is not None: count = count + 1 if verbose: print(rec) rec = next(c2) self.assertEqual(count, 9) count = 0 rec = c3.first() while rec is not None: count = count + 1 if verbose: print(rec) rec = next(c3) self.assertEqual(count, len(string.ascii_letters)) c1.close() c2.close() c3.close() d2.close() d3.close() # Strange things happen if you try to use Multiple DBs per file without a # DBEnv with MPOOL and LOCKing... class BTreeMultiDBTestCase(BasicMultiDBTestCase): dbtype = db.DB_BTREE dbopenflags = db.DB_THREAD useEnv = 1 envflags = db.DB_THREAD | db.DB_INIT_MPOOL | db.DB_INIT_LOCK class HashMultiDBTestCase(BasicMultiDBTestCase): dbtype = db.DB_HASH dbopenflags = db.DB_THREAD useEnv = 1 envflags = db.DB_THREAD | db.DB_INIT_MPOOL | db.DB_INIT_LOCK class PrivateObject(unittest.TestCase) : def tearDown(self) : del self.obj def test01_DefaultIsNone(self) : self.assertEqual(self.obj.get_private(), None) def test02_assignment(self) : a = "example of private object" self.obj.set_private(a) b = self.obj.get_private() self.assertTrue(a is b) # Object identity def test03_leak_assignment(self) : a = "example of private object" refcount = sys.getrefcount(a) self.obj.set_private(a) self.assertEqual(refcount+1, sys.getrefcount(a)) self.obj.set_private(None) self.assertEqual(refcount, sys.getrefcount(a)) def test04_leak_GC(self) : a = "example of private object" refcount = sys.getrefcount(a) self.obj.set_private(a) self.obj = None self.assertEqual(refcount, sys.getrefcount(a)) class DBEnvPrivateObject(PrivateObject) : def setUp(self) : self.obj = db.DBEnv() class DBPrivateObject(PrivateObject) : def setUp(self) : self.obj = db.DB() class CrashAndBurn(unittest.TestCase) : #def test01_OpenCrash(self) : # # See http://bugs.python.org/issue3307 # self.assertRaises(db.DBInvalidArgError, db.DB, None, 65535) if db.version() < (4, 8) : def test02_DBEnv_dealloc(self): # http://bugs.python.org/issue3885 import gc self.assertRaises(db.DBInvalidArgError, db.DBEnv, ~db.DB_RPCCLIENT) gc.collect() #---------------------------------------------------------------------- #---------------------------------------------------------------------- def test_suite(): suite = unittest.TestSuite() suite.addTest(unittest.makeSuite(VersionTestCase)) suite.addTest(unittest.makeSuite(BasicBTreeTestCase)) suite.addTest(unittest.makeSuite(BasicHashTestCase)) suite.addTest(unittest.makeSuite(BasicBTreeWithThreadFlagTestCase)) suite.addTest(unittest.makeSuite(BasicHashWithThreadFlagTestCase)) suite.addTest(unittest.makeSuite(BasicBTreeWithEnvTestCase)) suite.addTest(unittest.makeSuite(BasicHashWithEnvTestCase)) suite.addTest(unittest.makeSuite(BTreeTransactionTestCase)) suite.addTest(unittest.makeSuite(HashTransactionTestCase)) suite.addTest(unittest.makeSuite(BTreeRecnoTestCase)) suite.addTest(unittest.makeSuite(BTreeRecnoWithThreadFlagTestCase)) suite.addTest(unittest.makeSuite(BTreeDUPTestCase)) suite.addTest(unittest.makeSuite(HashDUPTestCase)) suite.addTest(unittest.makeSuite(BTreeDUPWithThreadTestCase)) suite.addTest(unittest.makeSuite(HashDUPWithThreadTestCase)) suite.addTest(unittest.makeSuite(BTreeMultiDBTestCase)) suite.addTest(unittest.makeSuite(HashMultiDBTestCase)) suite.addTest(unittest.makeSuite(DBEnvPrivateObject)) suite.addTest(unittest.makeSuite(DBPrivateObject)) suite.addTest(unittest.makeSuite(CrashAndBurn)) return suite if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib3/bsddb/test/test_lock.py0000664000175000017500000001722013617051161017711 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """ TestCases for testing the locking sub-system. """ import time import unittest from .test_all import db, test_support, verbose, have_threads, \ get_new_environment_path, get_new_database_path if have_threads : from threading import Thread import sys if sys.version_info[0] < 3 : from threading import currentThread else : from threading import current_thread as currentThread #---------------------------------------------------------------------- class LockingTestCase(unittest.TestCase): def setUp(self): self.homeDir = get_new_environment_path() self.env = db.DBEnv() self.env.open(self.homeDir, db.DB_THREAD | db.DB_INIT_MPOOL | db.DB_INIT_LOCK | db.DB_CREATE) def tearDown(self): self.env.close() test_support.rmtree(self.homeDir) def test01_simple(self): if verbose: print('\n', '-=' * 30) print("Running %s.test01_simple..." % self.__class__.__name__) anID = self.env.lock_id() if verbose: print("locker ID: %s" % anID) lock = self.env.lock_get(anID, "some locked thing", db.DB_LOCK_WRITE) if verbose: print("Aquired lock: %s" % lock) self.env.lock_put(lock) if verbose: print("Released lock: %s" % lock) self.env.lock_id_free(anID) def test02_threaded(self): if verbose: print('\n', '-=' * 30) print("Running %s.test02_threaded..." % self.__class__.__name__) threads = [] threads.append(Thread(target = self.theThread, args=(db.DB_LOCK_WRITE,))) threads.append(Thread(target = self.theThread, args=(db.DB_LOCK_READ,))) threads.append(Thread(target = self.theThread, args=(db.DB_LOCK_READ,))) threads.append(Thread(target = self.theThread, args=(db.DB_LOCK_WRITE,))) threads.append(Thread(target = self.theThread, args=(db.DB_LOCK_READ,))) threads.append(Thread(target = self.theThread, args=(db.DB_LOCK_READ,))) threads.append(Thread(target = self.theThread, args=(db.DB_LOCK_WRITE,))) threads.append(Thread(target = self.theThread, args=(db.DB_LOCK_WRITE,))) threads.append(Thread(target = self.theThread, args=(db.DB_LOCK_WRITE,))) for t in threads: import sys if sys.version_info[0] < 3 : t.setDaemon(True) else : t.daemon = True t.start() for t in threads: t.join() def test03_lock_timeout(self): self.env.set_timeout(0, db.DB_SET_LOCK_TIMEOUT) self.assertEqual(self.env.get_timeout(db.DB_SET_LOCK_TIMEOUT), 0) self.env.set_timeout(0, db.DB_SET_TXN_TIMEOUT) self.assertEqual(self.env.get_timeout(db.DB_SET_TXN_TIMEOUT), 0) self.env.set_timeout(123456, db.DB_SET_LOCK_TIMEOUT) self.assertEqual(self.env.get_timeout(db.DB_SET_LOCK_TIMEOUT), 123456) self.env.set_timeout(7890123, db.DB_SET_TXN_TIMEOUT) self.assertEqual(self.env.get_timeout(db.DB_SET_TXN_TIMEOUT), 7890123) def test04_lock_timeout2(self): self.env.set_timeout(0, db.DB_SET_LOCK_TIMEOUT) self.env.set_timeout(0, db.DB_SET_TXN_TIMEOUT) self.env.set_timeout(123456, db.DB_SET_LOCK_TIMEOUT) self.env.set_timeout(7890123, db.DB_SET_TXN_TIMEOUT) def deadlock_detection() : while not deadlock_detection.end : deadlock_detection.count = \ self.env.lock_detect(db.DB_LOCK_EXPIRE) if deadlock_detection.count : while not deadlock_detection.end : pass break time.sleep(0.01) deadlock_detection.end=False deadlock_detection.count=0 t=Thread(target=deadlock_detection) import sys if sys.version_info[0] < 3 : t.setDaemon(True) else : t.daemon = True t.start() self.env.set_timeout(100000, db.DB_SET_LOCK_TIMEOUT) anID = self.env.lock_id() anID2 = self.env.lock_id() self.assertNotEqual(anID, anID2) lock = self.env.lock_get(anID, "shared lock", db.DB_LOCK_WRITE) start_time=time.time() self.assertRaises(db.DBLockNotGrantedError, self.env.lock_get,anID2, "shared lock", db.DB_LOCK_READ) end_time=time.time() deadlock_detection.end=True # Floating point rounding self.assertTrue((end_time-start_time) >= 0.0999) self.env.lock_put(lock) t.join() self.env.lock_id_free(anID) self.env.lock_id_free(anID2) self.assertTrue(deadlock_detection.count>0) def theThread(self, lockType): import sys if sys.version_info[0] < 3 : name = currentThread().getName() else : name = currentThread().name if lockType == db.DB_LOCK_WRITE: lt = "write" else: lt = "read" anID = self.env.lock_id() if verbose: print("%s: locker ID: %s" % (name, anID)) for i in range(1000) : lock = self.env.lock_get(anID, "some locked thing", lockType) if verbose: print("%s: Aquired %s lock: %s" % (name, lt, lock)) self.env.lock_put(lock) if verbose: print("%s: Released %s lock: %s" % (name, lt, lock)) self.env.lock_id_free(anID) #---------------------------------------------------------------------- def test_suite(): suite = unittest.TestSuite() if have_threads: suite.addTest(unittest.makeSuite(LockingTestCase)) else: suite.addTest(unittest.makeSuite(LockingTestCase, 'test01')) return suite if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib3/bsddb/test/test_dbobj.py0000664000175000017500000000767213617051170020053 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ import os, string import unittest from .test_all import db, dbobj, test_support, get_new_environment_path, \ get_new_database_path #---------------------------------------------------------------------- class dbobjTestCase(unittest.TestCase): """Verify that dbobj.DB and dbobj.DBEnv work properly""" db_name = 'test-dbobj.db' def setUp(self): self.homeDir = get_new_environment_path() def tearDown(self): if hasattr(self, 'db'): del self.db if hasattr(self, 'env'): del self.env test_support.rmtree(self.homeDir) def test01_both(self): class TestDBEnv(dbobj.DBEnv): pass class TestDB(dbobj.DB): def put(self, key, *args, **kwargs): key = key.upper() # call our parent classes put method with an upper case key return dbobj.DB.put(self, key, *args, **kwargs) self.env = TestDBEnv() self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL) self.db = TestDB(self.env) self.db.open(self.db_name, db.DB_HASH, db.DB_CREATE) self.db.put('spam', 'eggs') self.assertEqual(self.db.get('spam'), None, "overridden dbobj.DB.put() method failed [1]") self.assertEqual(self.db.get('SPAM'), 'eggs', "overridden dbobj.DB.put() method failed [2]") self.db.close() self.env.close() def test02_dbobj_dict_interface(self): self.env = dbobj.DBEnv() self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL) self.db = dbobj.DB(self.env) self.db.open(self.db_name+'02', db.DB_HASH, db.DB_CREATE) # __setitem__ self.db['spam'] = 'eggs' # __len__ self.assertEqual(len(self.db), 1) # __getitem__ self.assertEqual(self.db['spam'], 'eggs') # __del__ del self.db['spam'] self.assertEqual(self.db.get('spam'), None, "dbobj __del__ failed") self.db.close() self.env.close() def test03_dbobj_type_before_open(self): # Ensure this doesn't cause a segfault. self.assertRaises(db.DBInvalidArgError, db.DB().type) #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(dbobjTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib3/bsddb/test/test_pickle.py0000664000175000017500000000701313617051165020233 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ import os import pickle import sys if sys.version_info[0] < 3 : try: import pickle except ImportError: cPickle = None else : cPickle = None import unittest from .test_all import db, test_support, get_new_environment_path, get_new_database_path #---------------------------------------------------------------------- class pickleTestCase(unittest.TestCase): """Verify that DBError can be pickled and unpickled""" db_name = 'test-dbobj.db' def setUp(self): self.homeDir = get_new_environment_path() def tearDown(self): if hasattr(self, 'db'): del self.db if hasattr(self, 'env'): del self.env test_support.rmtree(self.homeDir) def _base_test_pickle_DBError(self, pickle): self.env = db.DBEnv() self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL) self.db = db.DB(self.env) self.db.open(self.db_name, db.DB_HASH, db.DB_CREATE) self.db.put('spam', 'eggs') self.assertEqual(self.db['spam'], 'eggs') try: self.db.put('spam', 'ham', flags=db.DB_NOOVERWRITE) except db.DBError as egg: pickledEgg = pickle.dumps(egg) #print repr(pickledEgg) rottenEgg = pickle.loads(pickledEgg) if rottenEgg.args != egg.args or type(rottenEgg) != type(egg): raise Exception(rottenEgg, '!=', egg) else: raise Exception("where's my DBError exception?!?") self.db.close() self.env.close() def test01_pickle_DBError(self): self._base_test_pickle_DBError(pickle=pickle) if cPickle: def test02_cPickle_DBError(self): self._base_test_pickle_DBError(pickle=cPickle) #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(pickleTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib3/bsddb/test/test_early_close.py0000664000175000017500000001772313617051164021275 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """TestCases for checking that it does not segfault when a DBEnv object is closed before its DB objects. """ import os, sys import unittest from .test_all import db, test_support, verbose, get_new_environment_path, get_new_database_path # We're going to get warnings in this module about trying to close the db when # its env is already closed. Let's just ignore those. try: import warnings except ImportError: pass else: warnings.filterwarnings('ignore', message='DB could not be closed in', category=RuntimeWarning) #---------------------------------------------------------------------- class DBEnvClosedEarlyCrash(unittest.TestCase): def setUp(self): self.homeDir = get_new_environment_path() self.filename = "test" def tearDown(self): test_support.rmtree(self.homeDir) def test01_close_dbenv_before_db(self): dbenv = db.DBEnv() dbenv.open(self.homeDir, db.DB_INIT_CDB| db.DB_CREATE |db.DB_THREAD|db.DB_INIT_MPOOL, 0o666) d = db.DB(dbenv) d2 = db.DB(dbenv) d.open(self.filename, db.DB_BTREE, db.DB_CREATE | db.DB_THREAD, 0o666) self.assertRaises(db.DBNoSuchFileError, d2.open, self.filename+"2", db.DB_BTREE, db.DB_THREAD, 0o666) d.put("test","this is a test") self.assertEqual(d.get("test"), "this is a test", "put!=get") dbenv.close() # This "close" should close the child db handle also self.assertRaises(db.DBError, d.get, "test") def test02_close_dbenv_before_dbcursor(self): dbenv = db.DBEnv() dbenv.open(self.homeDir, db.DB_INIT_CDB| db.DB_CREATE |db.DB_THREAD|db.DB_INIT_MPOOL, 0o666) d = db.DB(dbenv) d.open(self.filename, db.DB_BTREE, db.DB_CREATE | db.DB_THREAD, 0o666) d.put("test","this is a test") d.put("test2","another test") d.put("test3","another one") self.assertEqual(d.get("test"), "this is a test", "put!=get") c=d.cursor() c.first() next(c) d.close() # This "close" should close the child db handle also # db.close should close the child cursor self.assertRaises(db.DBError,c.__next__) d = db.DB(dbenv) d.open(self.filename, db.DB_BTREE, db.DB_CREATE | db.DB_THREAD, 0o666) c=d.cursor() c.first() next(c) dbenv.close() # The "close" should close the child db handle also, with cursors self.assertRaises(db.DBError, c.__next__) def test03_close_db_before_dbcursor_without_env(self): import os.path path=os.path.join(self.homeDir,self.filename) d = db.DB() d.open(path, db.DB_BTREE, db.DB_CREATE | db.DB_THREAD, 0o666) d.put("test","this is a test") d.put("test2","another test") d.put("test3","another one") self.assertEqual(d.get("test"), "this is a test", "put!=get") c=d.cursor() c.first() next(c) d.close() # The "close" should close the child db handle also self.assertRaises(db.DBError, c.__next__) def test04_close_massive(self): dbenv = db.DBEnv() dbenv.open(self.homeDir, db.DB_INIT_CDB| db.DB_CREATE |db.DB_THREAD|db.DB_INIT_MPOOL, 0o666) dbs=[db.DB(dbenv) for i in range(16)] cursors=[] for i in dbs : i.open(self.filename, db.DB_BTREE, db.DB_CREATE | db.DB_THREAD, 0o666) dbs[10].put("test","this is a test") dbs[10].put("test2","another test") dbs[10].put("test3","another one") self.assertEqual(dbs[4].get("test"), "this is a test", "put!=get") for i in dbs : cursors.extend([i.cursor() for j in range(32)]) for i in dbs[::3] : i.close() for i in cursors[::3] : i.close() # Check for missing exception in DB! (after DB close) self.assertRaises(db.DBError, dbs[9].get, "test") # Check for missing exception in DBCursor! (after DB close) self.assertRaises(db.DBError, cursors[101].first) cursors[80].first() next(cursors[80]) dbenv.close() # This "close" should close the child db handle also # Check for missing exception! (after DBEnv close) self.assertRaises(db.DBError, cursors[80].__next__) def test05_close_dbenv_delete_db_success(self): dbenv = db.DBEnv() dbenv.open(self.homeDir, db.DB_INIT_CDB| db.DB_CREATE |db.DB_THREAD|db.DB_INIT_MPOOL, 0o666) d = db.DB(dbenv) d.open(self.filename, db.DB_BTREE, db.DB_CREATE | db.DB_THREAD, 0o666) dbenv.close() # This "close" should close the child db handle also del d try: import gc except ImportError: gc = None if gc: # force d.__del__ [DB_dealloc] to be called gc.collect() def test06_close_txn_before_dup_cursor(self) : dbenv = db.DBEnv() dbenv.open(self.homeDir,db.DB_INIT_TXN | db.DB_INIT_MPOOL | db.DB_INIT_LOG | db.DB_CREATE) d = db.DB(dbenv) txn = dbenv.txn_begin() d.open(self.filename, dbtype = db.DB_HASH, flags = db.DB_CREATE, txn=txn) d.put("XXX", "yyy", txn=txn) txn.commit() txn = dbenv.txn_begin() c1 = d.cursor(txn) c2 = c1.dup() self.assertEqual(("XXX", "yyy"), c1.first()) # Not interested in warnings about implicit close. import warnings with warnings.catch_warnings() : warnings.filterwarnings("ignore") txn.commit() self.assertRaises(db.DBCursorClosedError, c2.first) def test07_close_db_before_sequence(self): import os.path path=os.path.join(self.homeDir,self.filename) d = db.DB() d.open(path, db.DB_BTREE, db.DB_CREATE | db.DB_THREAD, 0o666) dbs=db.DBSequence(d) d.close() # This "close" should close the child DBSequence also dbs.close() # If not closed, core dump (in Berkeley DB 4.6.*) #---------------------------------------------------------------------- def test_suite(): suite = unittest.TestSuite() suite.addTest(unittest.makeSuite(DBEnvClosedEarlyCrash)) return suite if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib3/bsddb/test/test_compare.py0000664000175000017500000004013413617051205020406 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """ TestCases for python DB duplicate and Btree key comparison function. """ import sys, os, re from . import test_all from io import StringIO import unittest from .test_all import db, dbshelve, test_support, \ get_new_environment_path, get_new_database_path # Needed for python 3. "cmp" vanished in 3.0.1 def cmp(a, b) : if a==b : return 0 if a All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """TestCases for using the DB.join and DBCursor.join_item methods. """ import os import unittest from .test_all import db, dbshelve, test_support, verbose, \ get_new_environment_path, get_new_database_path #---------------------------------------------------------------------- ProductIndex = [ ('apple', "Convenience Store"), ('blueberry', "Farmer's Market"), ('shotgun', "S-Mart"), # Aisle 12 ('pear', "Farmer's Market"), ('chainsaw', "S-Mart"), # "Shop smart. Shop S-Mart!" ('strawberry', "Farmer's Market"), ] ColorIndex = [ ('blue', "blueberry"), ('red', "apple"), ('red', "chainsaw"), ('red', "strawberry"), ('yellow', "peach"), ('yellow', "pear"), ('black', "shotgun"), ] class JoinTestCase(unittest.TestCase): keytype = '' def setUp(self): self.filename = self.__class__.__name__ + '.db' self.homeDir = get_new_environment_path() self.env = db.DBEnv() self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL | db.DB_INIT_LOCK ) def tearDown(self): self.env.close() test_support.rmtree(self.homeDir) def test01_join(self): if verbose: print('\n', '-=' * 30) print("Running %s.test01_join..." % \ self.__class__.__name__) # create and populate primary index priDB = db.DB(self.env) priDB.open(self.filename, "primary", db.DB_BTREE, db.DB_CREATE) list(map(lambda t, priDB=priDB: priDB.put(*t), ProductIndex)) # create and populate secondary index secDB = db.DB(self.env) secDB.set_flags(db.DB_DUP | db.DB_DUPSORT) secDB.open(self.filename, "secondary", db.DB_BTREE, db.DB_CREATE) list(map(lambda t, secDB=secDB: secDB.put(*t), ColorIndex)) sCursor = None jCursor = None try: # lets look up all of the red Products sCursor = secDB.cursor() # Don't do the .set() in an assert, or you can get a bogus failure # when running python -O tmp = sCursor.set('red') self.assertTrue(tmp) # FIXME: jCursor doesn't properly hold a reference to its # cursors, if they are closed before jcursor is used it # can cause a crash. jCursor = priDB.join([sCursor]) if jCursor.get(0) != ('apple', "Convenience Store"): self.fail("join cursor positioned wrong") if jCursor.join_item() != 'chainsaw': self.fail("DBCursor.join_item returned wrong item") if jCursor.get(0)[0] != 'strawberry': self.fail("join cursor returned wrong thing") if jCursor.get(0): # there were only three red items to return self.fail("join cursor returned too many items") finally: if jCursor: jCursor.close() if sCursor: sCursor.close() priDB.close() secDB.close() def test_suite(): suite = unittest.TestSuite() suite.addTest(unittest.makeSuite(JoinTestCase)) return suite bsddb3-6.2.7/Lib3/bsddb/test/test_misc.py0000664000175000017500000001455113617051160017717 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """Miscellaneous bsddb module test cases """ import os, sys import unittest from .test_all import db, dbshelve, hashopen, test_support, get_new_environment_path, get_new_database_path #---------------------------------------------------------------------- class MiscTestCase(unittest.TestCase): def setUp(self): self.filename = get_new_database_path() self.homeDir = get_new_environment_path() def tearDown(self): test_support.unlink(self.filename) test_support.rmtree(self.homeDir) def test01_badpointer(self): dbs = dbshelve.open(self.filename) dbs.close() self.assertRaises(db.DBError, dbs.get, "foo") def test02_db_home(self): env = db.DBEnv() # check for crash fixed when db_home is used before open() self.assertTrue(env.db_home is None) env.open(self.homeDir, db.DB_CREATE) if sys.version_info[0] < 3 : self.assertEqual(self.homeDir, env.db_home) else : self.assertEqual(bytes(self.homeDir, "ascii"), env.db_home) def test03_repr_closed_db(self): db = hashopen(self.filename) db.close() rp = repr(db) self.assertEqual(rp, "{}") def test04_repr_db(self) : db = hashopen(self.filename) d = {} for i in range(100) : db[repr(i)] = repr(100*i) d[repr(i)] = repr(100*i) db.close() db = hashopen(self.filename) rp = repr(sorted(db.items())) rd = repr(sorted(d.items())) self.assertEqual(rp, rd) db.close() # http://sourceforge.net/tracker/index.php?func=detail&aid=1708868&group_id=13900&atid=313900 # # See the bug report for details. # # The problem was that make_key_dbt() was not allocating a copy of # string keys but FREE_DBT() was always being told to free it when the # database was opened with DB_THREAD. def test05_double_free_make_key_dbt(self): try: db1 = db.DB() db1.open(self.filename, None, db.DB_BTREE, db.DB_CREATE | db.DB_THREAD) curs = db1.cursor() t = curs.get("/foo", db.DB_SET) # double free happened during exit from DBC_get finally: db1.close() test_support.unlink(self.filename) def test06_key_with_null_bytes(self): try: db1 = db.DB() db1.open(self.filename, None, db.DB_HASH, db.DB_CREATE) db1['a'] = 'eh?' db1['a\x00'] = 'eh zed.' db1['a\x00a'] = 'eh zed eh?' db1['aaa'] = 'eh eh eh!' keys = list(db1.keys()) keys.sort() self.assertEqual(['a', 'a\x00', 'a\x00a', 'aaa'], keys) self.assertEqual(db1['a'], 'eh?') self.assertEqual(db1['a\x00'], 'eh zed.') self.assertEqual(db1['a\x00a'], 'eh zed eh?') self.assertEqual(db1['aaa'], 'eh eh eh!') finally: db1.close() test_support.unlink(self.filename) def test07_DB_set_flags_persists(self): try: db1 = db.DB() db1.set_flags(db.DB_DUPSORT) db1.open(self.filename, db.DB_HASH, db.DB_CREATE) db1['a'] = 'eh' db1['a'] = 'A' self.assertEqual([('a', 'A')], list(db1.items())) db1.put('a', 'Aa') self.assertEqual([('a', 'A'), ('a', 'Aa')], list(db1.items())) db1.close() db1 = db.DB() # no set_flags call, we're testing that it reads and obeys # the flags on open. db1.open(self.filename, db.DB_HASH) self.assertEqual([('a', 'A'), ('a', 'Aa')], list(db1.items())) # if it read the flags right this will replace all values # for key 'a' instead of adding a new one. (as a dict should) db1['a'] = 'new A' self.assertEqual([('a', 'new A')], list(db1.items())) finally: db1.close() test_support.unlink(self.filename) def test08_ExceptionTypes(self) : self.assertTrue(issubclass(db.DBError, Exception)) for i, j in list(db.__dict__.items()) : if i.startswith("DB") and i.endswith("Error") : self.assertTrue(issubclass(j, db.DBError), msg=i) if i not in ("DBKeyEmptyError", "DBNotFoundError") : self.assertFalse(issubclass(j, KeyError), msg=i) # This two exceptions have two bases self.assertTrue(issubclass(db.DBKeyEmptyError, KeyError)) self.assertTrue(issubclass(db.DBNotFoundError, KeyError)) #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(MiscTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib3/bsddb/test/test_compat.py0000664000175000017500000001402413617051163020245 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """ Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import os, string import unittest from .test_all import db, hashopen, btopen, rnopen, verbose, \ get_new_database_path class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = get_new_database_path() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = "The quick brown fox jumped over the lazy dog.".split() if verbose: print("\nTesting: rnopen") f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print('%s %s %s' % getTest) self.assertEqual(getTest[1], 'quick', 'data mismatch!') rv = f.set_location(3) if rv != (3, 'brown'): self.fail('recno database set_location failed: '+repr(rv)) f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print(rec) try: rec = next(f) except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print('\nTesting: ', what) f = factory(self.filename, 'c') if verbose: print('creation...') # truth test if f: if verbose: print("truth test: true") else: if verbose: print("truth test: false") f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' # 'e' intentionally left out f['f'] = 'Python' if verbose: print('%s %s %s' % (f['a'], f['b'], f['c'])) if verbose: print('key ordering...') start = f.set_location(f.first()[0]) if start != ('0', ''): self.fail("incorrect first() result: "+repr(start)) while 1: try: rec = next(f) except KeyError: self.assertEqual(rec, f.last(), 'Error, last <> last!') f.previous() break if verbose: print(rec) self.assertTrue('f' in f, 'Error, missing key!') # test that set_location() returns the next nearest key, value # on btree databases and raises KeyError on others. if factory == btopen: e = f.set_location('e') if e != ('f', 'Python'): self.fail('wrong key,value returned: '+repr(e)) else: try: e = f.set_location('e') except KeyError: pass else: self.fail("set_location on non-existent key did not raise KeyError") f.sync() f.close() # truth test try: if f: if verbose: print("truth test: true") else: if verbose: print("truth test: false") except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print('modification...') f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print('access...') for key in list(f.keys()): word = f[key] if verbose: print(word) def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib3/bsddb/test/test_recno.py0000664000175000017500000002332013617051166020072 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """TestCases for exercising a Recno DB. """ import os, sys import errno from pprint import pprint import string import unittest from .test_all import db, test_support, verbose, get_new_environment_path, get_new_database_path #---------------------------------------------------------------------- class SimpleRecnoTestCase(unittest.TestCase): if sys.version_info < (2, 7) : def assertIsInstance(self, obj, datatype, msg=None) : return self.assertEqual(type(obj), datatype, msg=msg) def assertGreaterEqual(self, a, b, msg=None) : return self.assertTrue(a>=b, msg=msg) def setUp(self): self.filename = get_new_database_path() self.homeDir = None def tearDown(self): test_support.unlink(self.filename) if self.homeDir: test_support.rmtree(self.homeDir) def test01_basic(self): d = db.DB() get_returns_none = d.set_get_returns_none(2) d.set_get_returns_none(get_returns_none) d.open(self.filename, db.DB_RECNO, db.DB_CREATE) for x in string.ascii_letters: recno = d.append(x * 60) self.assertIsInstance(recno, int) self.assertGreaterEqual(recno, 1) if verbose: print(recno, end=' ') if verbose: print() stat = d.stat() if verbose: pprint(stat) for recno in range(1, len(d)+1): data = d[recno] if verbose: print(data) self.assertIsInstance(data, str) self.assertEqual(data, d.get(recno)) try: data = d[0] # This should raise a KeyError!?!?! except db.DBInvalidArgError as val: self.assertEqual(val.args[0], db.EINVAL) if verbose: print(val) else: self.fail("expected exception") # test that has_key raises DB exceptions (fixed in pybsddb 4.3.2) try: 0 in d except db.DBError as val: pass else: self.fail("has_key did not raise a proper exception") try: data = d[100] except KeyError: pass else: self.fail("expected exception") try: data = d.get(100) except db.DBNotFoundError as val: if get_returns_none: self.fail("unexpected exception") else: self.assertEqual(data, None) keys = list(d.keys()) if verbose: print(keys) self.assertIsInstance(keys, list) self.assertIsInstance(keys[0], int) self.assertEqual(len(keys), len(d)) items = list(d.items()) if verbose: pprint(items) self.assertIsInstance(items, list) self.assertIsInstance(items[0], tuple) self.assertEqual(len(items[0]), 2) self.assertIsInstance(items[0][0], int) self.assertIsInstance(items[0][1], str) self.assertEqual(len(items), len(d)) self.assertTrue(25 in d) del d[25] self.assertFalse(25 in d) d.delete(13) self.assertFalse(13 in d) data = d.get_both(26, "z" * 60) self.assertEqual(data, "z" * 60, 'was %r' % data) if verbose: print(data) fd = d.fd() if verbose: print(fd) c = d.cursor() rec = c.first() while rec: if verbose: print(rec) rec = next(c) c.set(50) rec = c.current() if verbose: print(rec) c.put(-1, "a replacement record", db.DB_CURRENT) c.set(50) rec = c.current() self.assertEqual(rec, (50, "a replacement record")) if verbose: print(rec) rec = c.set_range(30) if verbose: print(rec) # test that non-existent key lookups work (and that # DBC_set_range doesn't have a memleak under valgrind) rec = c.set_range(999999) self.assertEqual(rec, None) if verbose: print(rec) c.close() d.close() d = db.DB() d.open(self.filename) c = d.cursor() # put a record beyond the consecutive end of the recno's d[100] = "way out there" self.assertEqual(d[100], "way out there") try: data = d[99] except KeyError: pass else: self.fail("expected exception") try: d.get(99) except db.DBKeyEmptyError as val: if get_returns_none: self.fail("unexpected DBKeyEmptyError exception") else: self.assertEqual(val.args[0], db.DB_KEYEMPTY) if verbose: print(val) else: if not get_returns_none: self.fail("expected exception") rec = c.set(40) while rec: if verbose: print(rec) rec = next(c) c.close() d.close() def test02_WithSource(self): """ A Recno file that is given a "backing source file" is essentially a simple ASCII file. Normally each record is delimited by \n and so is just a line in the file, but you can set a different record delimiter if needed. """ homeDir = get_new_environment_path() self.homeDir = homeDir source = os.path.join(homeDir, 'test_recno.txt') if not os.path.isdir(homeDir): os.mkdir(homeDir) f = open(source, 'w') # create the file f.close() d = db.DB() # This is the default value, just checking if both int d.set_re_delim(0x0A) d.set_re_delim('\n') # and char can be used... d.set_re_source(source) d.open(self.filename, db.DB_RECNO, db.DB_CREATE) data = "The quick brown fox jumped over the lazy dog".split() for datum in data: d.append(datum) d.sync() d.close() # get the text from the backing source f = open(source, 'r') text = f.read() f.close() text = text.strip() if verbose: print(text) print(data) print(text.split('\n')) self.assertEqual(text.split('\n'), data) # open as a DB again d = db.DB() d.set_re_source(source) d.open(self.filename, db.DB_RECNO) d[3] = 'reddish-brown' d[8] = 'comatose' d.sync() d.close() f = open(source, 'r') text = f.read() f.close() text = text.strip() if verbose: print(text) print(text.split('\n')) self.assertEqual(text.split('\n'), "The quick reddish-brown fox jumped over the comatose dog".split()) def test03_FixedLength(self): d = db.DB() d.set_re_len(40) # fixed length records, 40 bytes long d.set_re_pad('-') # sets the pad character... d.set_re_pad(45) # ...test both int and char d.open(self.filename, db.DB_RECNO, db.DB_CREATE) for x in string.ascii_letters: d.append(x * 35) # These will be padded d.append('.' * 40) # this one will be exact try: # this one will fail d.append('bad' * 20) except db.DBInvalidArgError as val: self.assertEqual(val.args[0], db.EINVAL) if verbose: print(val) else: self.fail("expected exception") c = d.cursor() rec = c.first() while rec: if verbose: print(rec) rec = next(c) c.close() d.close() def test04_get_size_empty(self) : d = db.DB() d.open(self.filename, dbtype=db.DB_RECNO, flags=db.DB_CREATE) row_id = d.append(' ') self.assertEqual(1, d.get_size(key=row_id)) row_id = d.append('') self.assertEqual(0, d.get_size(key=row_id)) #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(SimpleRecnoTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib3/bsddb/test/test_associate.py0000664000175000017500000004040113617051174020735 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """ TestCases for DB.associate. """ import sys, os, string import time from pprint import pprint import unittest from .test_all import db, dbshelve, test_support, verbose, have_threads, \ get_new_environment_path #---------------------------------------------------------------------- musicdata = { 1 : ("Bad English", "The Price Of Love", "Rock"), 2 : ("DNA featuring Suzanne Vega", "Tom's Diner", "Rock"), 3 : ("George Michael", "Praying For Time", "Rock"), 4 : ("Gloria Estefan", "Here We Are", "Rock"), 5 : ("Linda Ronstadt", "Don't Know Much", "Rock"), 6 : ("Michael Bolton", "How Am I Supposed To Live Without You", "Blues"), 7 : ("Paul Young", "Oh Girl", "Rock"), 8 : ("Paula Abdul", "Opposites Attract", "Rock"), 9 : ("Richard Marx", "Should've Known Better", "Rock"), 10: ("Rod Stewart", "Forever Young", "Rock"), 11: ("Roxette", "Dangerous", "Rock"), 12: ("Sheena Easton", "The Lover In Me", "Rock"), 13: ("Sinead O'Connor", "Nothing Compares 2 U", "Rock"), 14: ("Stevie B.", "Because I Love You", "Rock"), 15: ("Taylor Dayne", "Love Will Lead You Back", "Rock"), 16: ("The Bangles", "Eternal Flame", "Rock"), 17: ("Wilson Phillips", "Release Me", "Rock"), 18: ("Billy Joel", "Blonde Over Blue", "Rock"), 19: ("Billy Joel", "Famous Last Words", "Rock"), 20: ("Billy Joel", "Lullabye (Goodnight, My Angel)", "Rock"), 21: ("Billy Joel", "The River Of Dreams", "Rock"), 22: ("Billy Joel", "Two Thousand Years", "Rock"), 23: ("Janet Jackson", "Alright", "Rock"), 24: ("Janet Jackson", "Black Cat", "Rock"), 25: ("Janet Jackson", "Come Back To Me", "Rock"), 26: ("Janet Jackson", "Escapade", "Rock"), 27: ("Janet Jackson", "Love Will Never Do (Without You)", "Rock"), 28: ("Janet Jackson", "Miss You Much", "Rock"), 29: ("Janet Jackson", "Rhythm Nation", "Rock"), 30: ("Janet Jackson", "State Of The World", "Rock"), 31: ("Janet Jackson", "The Knowledge", "Rock"), 32: ("Spyro Gyra", "End of Romanticism", "Jazz"), 33: ("Spyro Gyra", "Heliopolis", "Jazz"), 34: ("Spyro Gyra", "Jubilee", "Jazz"), 35: ("Spyro Gyra", "Little Linda", "Jazz"), 36: ("Spyro Gyra", "Morning Dance", "Jazz"), 37: ("Spyro Gyra", "Song for Lorraine", "Jazz"), 38: ("Yes", "Owner Of A Lonely Heart", "Rock"), 39: ("Yes", "Rhythm Of Love", "Rock"), 40: ("Cusco", "Dream Catcher", "New Age"), 41: ("Cusco", "Geronimos Laughter", "New Age"), 42: ("Cusco", "Ghost Dance", "New Age"), 43: ("Blue Man Group", "Drumbone", "New Age"), 44: ("Blue Man Group", "Endless Column", "New Age"), 45: ("Blue Man Group", "Klein Mandelbrot", "New Age"), 46: ("Kenny G", "Silhouette", "Jazz"), 47: ("Sade", "Smooth Operator", "Jazz"), 48: ("David Arkenstone", "Papillon (On The Wings Of The Butterfly)", "New Age"), 49: ("David Arkenstone", "Stepping Stars", "New Age"), 50: ("David Arkenstone", "Carnation Lily Lily Rose", "New Age"), 51: ("David Lanz", "Behind The Waterfall", "New Age"), 52: ("David Lanz", "Cristofori's Dream", "New Age"), 53: ("David Lanz", "Heartsounds", "New Age"), 54: ("David Lanz", "Leaves on the Seine", "New Age"), 99: ("unknown artist", "Unnamed song", "Unknown"), } #---------------------------------------------------------------------- class AssociateErrorTestCase(unittest.TestCase): def setUp(self): self.filename = self.__class__.__name__ + '.db' self.homeDir = get_new_environment_path() self.env = db.DBEnv() self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL) def tearDown(self): self.env.close() self.env = None test_support.rmtree(self.homeDir) def test00_associateDBError(self): if verbose: print('\n', '-=' * 30) print("Running %s.test00_associateDBError..." % \ self.__class__.__name__) dupDB = db.DB(self.env) dupDB.set_flags(db.DB_DUP) dupDB.open(self.filename, "primary", db.DB_BTREE, db.DB_CREATE) secDB = db.DB(self.env) secDB.open(self.filename, "secondary", db.DB_BTREE, db.DB_CREATE) # dupDB has been configured to allow duplicates, it can't # associate with a secondary. Berkeley DB will return an error. try: def f(a,b): return a+b dupDB.associate(secDB, f) except db.DBError: # good secDB.close() dupDB.close() else: secDB.close() dupDB.close() self.fail("DBError exception was expected") #---------------------------------------------------------------------- class AssociateTestCase(unittest.TestCase): keytype = '' envFlags = 0 dbFlags = 0 def setUp(self): self.filename = self.__class__.__name__ + '.db' self.homeDir = get_new_environment_path() self.env = db.DBEnv() self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL | db.DB_INIT_LOCK | db.DB_THREAD | self.envFlags) def tearDown(self): self.closeDB() self.env.close() self.env = None test_support.rmtree(self.homeDir) def addDataToDB(self, d, txn=None): for key, value in list(musicdata.items()): if type(self.keytype) == type(''): key = "%02d" % key d.put(key, '|'.join(value), txn=txn) def createDB(self, txn=None): self.cur = None self.secDB = None self.primary = db.DB(self.env) self.primary.set_get_returns_none(2) self.primary.open(self.filename, "primary", self.dbtype, db.DB_CREATE | db.DB_THREAD | self.dbFlags, txn=txn) def closeDB(self): if self.cur: self.cur.close() self.cur = None if self.secDB: self.secDB.close() self.secDB = None self.primary.close() self.primary = None def getDB(self): return self.primary def _associateWithDB(self, getGenre): self.createDB() self.secDB = db.DB(self.env) self.secDB.set_flags(db.DB_DUP) self.secDB.set_get_returns_none(2) self.secDB.open(self.filename, "secondary", db.DB_BTREE, db.DB_CREATE | db.DB_THREAD | self.dbFlags) self.getDB().associate(self.secDB, getGenre) self.addDataToDB(self.getDB()) self.finish_test(self.secDB) def test01_associateWithDB(self): if verbose: print('\n', '-=' * 30) print("Running %s.test01_associateWithDB..." % \ self.__class__.__name__) return self._associateWithDB(self.getGenre) def _associateAfterDB(self, getGenre) : self.createDB() self.addDataToDB(self.getDB()) self.secDB = db.DB(self.env) self.secDB.set_flags(db.DB_DUP) self.secDB.open(self.filename, "secondary", db.DB_BTREE, db.DB_CREATE | db.DB_THREAD | self.dbFlags) # adding the DB_CREATE flag will cause it to index existing records self.getDB().associate(self.secDB, getGenre, db.DB_CREATE) self.finish_test(self.secDB) def test02_associateAfterDB(self): if verbose: print('\n', '-=' * 30) print("Running %s.test02_associateAfterDB..." % \ self.__class__.__name__) return self._associateAfterDB(self.getGenre) def test03_associateWithDB(self): if verbose: print('\n', '-=' * 30) print("Running %s.test03_associateWithDB..." % \ self.__class__.__name__) return self._associateWithDB(self.getGenreList) def test04_associateAfterDB(self): if verbose: print('\n', '-=' * 30) print("Running %s.test04_associateAfterDB..." % \ self.__class__.__name__) return self._associateAfterDB(self.getGenreList) def finish_test(self, secDB, txn=None): # 'Blues' should not be in the secondary database vals = secDB.pget('Blues', txn=txn) self.assertEqual(vals, None, vals) vals = secDB.pget('Unknown', txn=txn) self.assertTrue(vals[0] == 99 or vals[0] == '99', vals) vals[1].index('Unknown') vals[1].index('Unnamed') vals[1].index('unknown') if verbose: print("Primary key traversal:") self.cur = self.getDB().cursor(txn) count = 0 rec = self.cur.first() while rec is not None: if type(self.keytype) == type(''): self.assertTrue(int(rec[0])) # for primary db, key is a number else: self.assertTrue(rec[0] and type(rec[0]) == type(0)) count = count + 1 if verbose: print(rec) rec = getattr(self.cur, "next")() self.assertEqual(count, len(musicdata)) # all items accounted for if verbose: print("Secondary key traversal:") self.cur = secDB.cursor(txn) count = 0 # test cursor pget vals = self.cur.pget('Unknown', flags=db.DB_LAST) self.assertTrue(vals[1] == 99 or vals[1] == '99', vals) self.assertEqual(vals[0], 'Unknown') vals[2].index('Unknown') vals[2].index('Unnamed') vals[2].index('unknown') vals = self.cur.pget('Unknown', data='wrong value', flags=db.DB_GET_BOTH) self.assertEqual(vals, None, vals) rec = self.cur.first() self.assertEqual(rec[0], "Jazz") while rec is not None: count = count + 1 if verbose: print(rec) rec = getattr(self.cur, "next")() # all items accounted for EXCEPT for 1 with "Blues" genre self.assertEqual(count, len(musicdata)-1) self.cur = None def getGenre(self, priKey, priData): self.assertEqual(type(priData), type("")) genre = priData.split('|')[2] if verbose: print('getGenre key: %r data: %r' % (priKey, priData)) if genre == 'Blues': return db.DB_DONOTINDEX else: return genre def getGenreList(self, priKey, PriData) : v = self.getGenre(priKey, PriData) if type(v) == type("") : v = [v] return v #---------------------------------------------------------------------- class AssociateHashTestCase(AssociateTestCase): dbtype = db.DB_HASH class AssociateBTreeTestCase(AssociateTestCase): dbtype = db.DB_BTREE class AssociateRecnoTestCase(AssociateTestCase): dbtype = db.DB_RECNO keytype = 0 #---------------------------------------------------------------------- class AssociateBTreeTxnTestCase(AssociateBTreeTestCase): envFlags = db.DB_INIT_TXN dbFlags = 0 def txn_finish_test(self, sDB, txn): try: self.finish_test(sDB, txn=txn) finally: if self.cur: self.cur.close() self.cur = None if txn: txn.commit() def test13_associate_in_transaction(self): if verbose: print('\n', '-=' * 30) print("Running %s.test13_associateAutoCommit..." % \ self.__class__.__name__) txn = self.env.txn_begin() try: self.createDB(txn=txn) self.secDB = db.DB(self.env) self.secDB.set_flags(db.DB_DUP) self.secDB.set_get_returns_none(2) self.secDB.open(self.filename, "secondary", db.DB_BTREE, db.DB_CREATE | db.DB_THREAD, txn=txn) self.getDB().associate(self.secDB, self.getGenre, txn=txn) self.addDataToDB(self.getDB(), txn=txn) except: txn.abort() raise self.txn_finish_test(self.secDB, txn=txn) #---------------------------------------------------------------------- class ShelveAssociateTestCase(AssociateTestCase): def createDB(self): self.primary = dbshelve.open(self.filename, dbname="primary", dbenv=self.env, filetype=self.dbtype) def addDataToDB(self, d): for key, value in list(musicdata.items()): if type(self.keytype) == type(''): key = "%02d" % key d.put(key, value) # save the value as is this time def getGenre(self, priKey, priData): self.assertEqual(type(priData), type(())) if verbose: print('getGenre key: %r data: %r' % (priKey, priData)) genre = priData[2] if genre == 'Blues': return db.DB_DONOTINDEX else: return genre class ShelveAssociateHashTestCase(ShelveAssociateTestCase): dbtype = db.DB_HASH class ShelveAssociateBTreeTestCase(ShelveAssociateTestCase): dbtype = db.DB_BTREE class ShelveAssociateRecnoTestCase(ShelveAssociateTestCase): dbtype = db.DB_RECNO keytype = 0 #---------------------------------------------------------------------- class ThreadedAssociateTestCase(AssociateTestCase): def addDataToDB(self, d): t1 = Thread(target = self.writer1, args = (d, )) t2 = Thread(target = self.writer2, args = (d, )) t1.setDaemon(True) t2.setDaemon(True) t1.start() t2.start() t1.join() t2.join() def writer1(self, d): for key, value in list(musicdata.items()): if type(self.keytype) == type(''): key = "%02d" % key d.put(key, '|'.join(value)) def writer2(self, d): for x in range(100, 600): key = 'z%2d' % x value = [key] * 4 d.put(key, '|'.join(value)) class ThreadedAssociateHashTestCase(ShelveAssociateTestCase): dbtype = db.DB_HASH class ThreadedAssociateBTreeTestCase(ShelveAssociateTestCase): dbtype = db.DB_BTREE class ThreadedAssociateRecnoTestCase(ShelveAssociateTestCase): dbtype = db.DB_RECNO keytype = 0 #---------------------------------------------------------------------- def test_suite(): suite = unittest.TestSuite() suite.addTest(unittest.makeSuite(AssociateErrorTestCase)) suite.addTest(unittest.makeSuite(AssociateHashTestCase)) suite.addTest(unittest.makeSuite(AssociateBTreeTestCase)) suite.addTest(unittest.makeSuite(AssociateRecnoTestCase)) suite.addTest(unittest.makeSuite(AssociateBTreeTxnTestCase)) suite.addTest(unittest.makeSuite(ShelveAssociateHashTestCase)) suite.addTest(unittest.makeSuite(ShelveAssociateBTreeTestCase)) suite.addTest(unittest.makeSuite(ShelveAssociateRecnoTestCase)) if have_threads: suite.addTest(unittest.makeSuite(ThreadedAssociateHashTestCase)) suite.addTest(unittest.makeSuite(ThreadedAssociateBTreeTestCase)) suite.addTest(unittest.makeSuite(ThreadedAssociateRecnoTestCase)) return suite if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib3/bsddb/test/test_dbtables.py0000664000175000017500000003600513316240001020530 0ustar jceajcea00000000000000#!/usr/bin/env python # #----------------------------------------------------------------------- # A test suite for the table interface built on bsddb.db #----------------------------------------------------------------------- # # Copyright (C) 2000, 2001 by Autonomous Zone Industries # Copyright (C) 2002 Gregory P. Smith # # March 20, 2000 # # License: This is free software. You may use this software for any # purpose including modification/redistribution, so long as # this header remains intact and that you do not claim any # rights of ownership or authorship of this software. This # software has been tested, but no warranty is expressed or # implied. # # -- Gregory P. Smith # import os, re, sys if sys.version_info[0] < 3 : try: import pickle pickle = cPickle except ImportError: import pickle else : import pickle import unittest from .test_all import db, dbtables, test_support, verbose, \ get_new_environment_path, get_new_database_path #---------------------------------------------------------------------- class TableDBTestCase(unittest.TestCase): db_name = 'test-table.db' def setUp(self): import sys if sys.version_info[0] >= 3 : from .test_all import do_proxy_db_py3k self._flag_proxy_db_py3k = do_proxy_db_py3k(False) self.testHomeDir = get_new_environment_path() self.tdb = dbtables.bsdTableDB( filename='tabletest.db', dbhome=self.testHomeDir, create=1) def tearDown(self): self.tdb.close() import sys if sys.version_info[0] >= 3 : from .test_all import do_proxy_db_py3k do_proxy_db_py3k(self._flag_proxy_db_py3k) test_support.rmtree(self.testHomeDir) def test01(self): tabname = "test01" colname = 'cool numbers' try: self.tdb.Drop(tabname) except dbtables.TableDBError: pass self.tdb.CreateTable(tabname, [colname]) import sys if sys.version_info[0] < 3 : self.tdb.Insert(tabname, {colname: pickle.dumps(3.14159, 1)}) else : self.tdb.Insert(tabname, {colname: pickle.dumps(3.14159, 1).decode("iso8859-1")}) # 8 bits if verbose: self.tdb._db_print() values = self.tdb.Select( tabname, [colname], conditions={colname: None}) import sys if sys.version_info[0] < 3 : colval = pickle.loads(values[0][colname]) else : colval = pickle.loads(bytes(values[0][colname], "iso8859-1")) self.assertTrue(colval > 3.141) self.assertTrue(colval < 3.142) def test02(self): tabname = "test02" col0 = 'coolness factor' col1 = 'but can it fly?' col2 = 'Species' import sys if sys.version_info[0] < 3 : testinfo = [ {col0: pickle.dumps(8, 1), col1: 'no', col2: 'Penguin'}, {col0: pickle.dumps(-1, 1), col1: 'no', col2: 'Turkey'}, {col0: pickle.dumps(9, 1), col1: 'yes', col2: 'SR-71A Blackbird'} ] else : testinfo = [ {col0: pickle.dumps(8, 1).decode("iso8859-1"), col1: 'no', col2: 'Penguin'}, {col0: pickle.dumps(-1, 1).decode("iso8859-1"), col1: 'no', col2: 'Turkey'}, {col0: pickle.dumps(9, 1).decode("iso8859-1"), col1: 'yes', col2: 'SR-71A Blackbird'} ] try: self.tdb.Drop(tabname) except dbtables.TableDBError: pass self.tdb.CreateTable(tabname, [col0, col1, col2]) for row in testinfo : self.tdb.Insert(tabname, row) import sys if sys.version_info[0] < 3 : values = self.tdb.Select(tabname, [col2], conditions={col0: lambda x: pickle.loads(x) >= 8}) else : values = self.tdb.Select(tabname, [col2], conditions={col0: lambda x: pickle.loads(bytes(x, "iso8859-1")) >= 8}) self.assertEqual(len(values), 2) if values[0]['Species'] == 'Penguin' : self.assertEqual(values[1]['Species'], 'SR-71A Blackbird') elif values[0]['Species'] == 'SR-71A Blackbird' : self.assertEqual(values[1]['Species'], 'Penguin') else : if verbose: print("values= %r" % (values,)) raise RuntimeError("Wrong values returned!") def test03(self): tabname = "test03" try: self.tdb.Drop(tabname) except dbtables.TableDBError: pass if verbose: print('...before CreateTable...') self.tdb._db_print() self.tdb.CreateTable(tabname, ['a', 'b', 'c', 'd', 'e']) if verbose: print('...after CreateTable...') self.tdb._db_print() self.tdb.Drop(tabname) if verbose: print('...after Drop...') self.tdb._db_print() self.tdb.CreateTable(tabname, ['a', 'b', 'c', 'd', 'e']) try: self.tdb.Insert(tabname, {'a': "", 'e': pickle.dumps([{4:5, 6:7}, 'foo'], 1), 'f': "Zero"}) self.fail('Expected an exception') except dbtables.TableDBError: pass try: self.tdb.Select(tabname, [], conditions={'foo': '123'}) self.fail('Expected an exception') except dbtables.TableDBError: pass self.tdb.Insert(tabname, {'a': '42', 'b': "bad", 'c': "meep", 'e': 'Fuzzy wuzzy was a bear'}) self.tdb.Insert(tabname, {'a': '581750', 'b': "good", 'd': "bla", 'c': "black", 'e': 'fuzzy was here'}) self.tdb.Insert(tabname, {'a': '800000', 'b': "good", 'd': "bla", 'c': "black", 'e': 'Fuzzy wuzzy is a bear'}) if verbose: self.tdb._db_print() # this should return two rows values = self.tdb.Select(tabname, ['b', 'a', 'd'], conditions={'e': re.compile('wuzzy').search, 'a': re.compile('^[0-9]+$').match}) self.assertEqual(len(values), 2) # now lets delete one of them and try again self.tdb.Delete(tabname, conditions={'b': dbtables.ExactCond('good')}) values = self.tdb.Select( tabname, ['a', 'd', 'b'], conditions={'e': dbtables.PrefixCond('Fuzzy')}) self.assertEqual(len(values), 1) self.assertEqual(values[0]['d'], None) values = self.tdb.Select(tabname, ['b'], conditions={'c': lambda c: c == 'meep'}) self.assertEqual(len(values), 1) self.assertEqual(values[0]['b'], "bad") def test04_MultiCondSelect(self): tabname = "test04_MultiCondSelect" try: self.tdb.Drop(tabname) except dbtables.TableDBError: pass self.tdb.CreateTable(tabname, ['a', 'b', 'c', 'd', 'e']) try: self.tdb.Insert(tabname, {'a': "", 'e': pickle.dumps([{4:5, 6:7}, 'foo'], 1), 'f': "Zero"}) self.fail('Expected an exception') except dbtables.TableDBError: pass self.tdb.Insert(tabname, {'a': "A", 'b': "B", 'c': "C", 'd': "D", 'e': "E"}) self.tdb.Insert(tabname, {'a': "-A", 'b': "-B", 'c': "-C", 'd': "-D", 'e': "-E"}) self.tdb.Insert(tabname, {'a': "A-", 'b': "B-", 'c': "C-", 'd': "D-", 'e': "E-"}) if verbose: self.tdb._db_print() # This select should return 0 rows. it is designed to test # the bug identified and fixed in sourceforge bug # 590449 # (Big Thanks to "Rob Tillotson (n9mtb)" for tracking this down # and supplying a fix!! This one caused many headaches to say # the least...) values = self.tdb.Select(tabname, ['b', 'a', 'd'], conditions={'e': dbtables.ExactCond('E'), 'a': dbtables.ExactCond('A'), 'd': dbtables.PrefixCond('-') } ) self.assertEqual(len(values), 0, values) def test_CreateOrExtend(self): tabname = "test_CreateOrExtend" self.tdb.CreateOrExtendTable( tabname, ['name', 'taste', 'filling', 'alcohol content', 'price']) try: self.tdb.Insert(tabname, {'taste': 'crap', 'filling': 'no', 'is it Guinness?': 'no'}) self.fail("Insert should've failed due to bad column name") except: pass self.tdb.CreateOrExtendTable(tabname, ['name', 'taste', 'is it Guinness?']) # these should both succeed as the table should contain the union of both sets of columns. self.tdb.Insert(tabname, {'taste': 'crap', 'filling': 'no', 'is it Guinness?': 'no'}) self.tdb.Insert(tabname, {'taste': 'great', 'filling': 'yes', 'is it Guinness?': 'yes', 'name': 'Guinness'}) def test_CondObjs(self): tabname = "test_CondObjs" self.tdb.CreateTable(tabname, ['a', 'b', 'c', 'd', 'e', 'p']) self.tdb.Insert(tabname, {'a': "the letter A", 'b': "the letter B", 'c': "is for cookie"}) self.tdb.Insert(tabname, {'a': "is for aardvark", 'e': "the letter E", 'c': "is for cookie", 'd': "is for dog"}) self.tdb.Insert(tabname, {'a': "the letter A", 'e': "the letter E", 'c': "is for cookie", 'p': "is for Python"}) values = self.tdb.Select( tabname, ['p', 'e'], conditions={'e': dbtables.PrefixCond('the l')}) self.assertEqual(len(values), 2, values) self.assertEqual(values[0]['e'], values[1]['e'], values) self.assertNotEqual(values[0]['p'], values[1]['p'], values) values = self.tdb.Select( tabname, ['d', 'a'], conditions={'a': dbtables.LikeCond('%aardvark%')}) self.assertEqual(len(values), 1, values) self.assertEqual(values[0]['d'], "is for dog", values) self.assertEqual(values[0]['a'], "is for aardvark", values) values = self.tdb.Select(tabname, None, {'b': dbtables.Cond(), 'e':dbtables.LikeCond('%letter%'), 'a':dbtables.PrefixCond('is'), 'd':dbtables.ExactCond('is for dog'), 'c':dbtables.PrefixCond('is for'), 'p':lambda s: not s}) self.assertEqual(len(values), 1, values) self.assertEqual(values[0]['d'], "is for dog", values) self.assertEqual(values[0]['a'], "is for aardvark", values) def test_Delete(self): tabname = "test_Delete" self.tdb.CreateTable(tabname, ['x', 'y', 'z']) # prior to 2001-05-09 there was a bug where Delete() would # fail if it encountered any rows that did not have values in # every column. # Hunted and Squashed by (Jukka Santala - donwulff@nic.fi) self.tdb.Insert(tabname, {'x': 'X1', 'y':'Y1'}) self.tdb.Insert(tabname, {'x': 'X2', 'y':'Y2', 'z': 'Z2'}) self.tdb.Delete(tabname, conditions={'x': dbtables.PrefixCond('X')}) values = self.tdb.Select(tabname, ['y'], conditions={'x': dbtables.PrefixCond('X')}) self.assertEqual(len(values), 0) def test_Modify(self): tabname = "test_Modify" self.tdb.CreateTable(tabname, ['Name', 'Type', 'Access']) self.tdb.Insert(tabname, {'Name': 'Index to MP3 files.doc', 'Type': 'Word', 'Access': '8'}) self.tdb.Insert(tabname, {'Name': 'Nifty.MP3', 'Access': '1'}) self.tdb.Insert(tabname, {'Type': 'Unknown', 'Access': '0'}) def set_type(type): if type is None: return 'MP3' return type def increment_access(count): return str(int(count)+1) def remove_value(value): return None self.tdb.Modify(tabname, conditions={'Access': dbtables.ExactCond('0')}, mappings={'Access': remove_value}) self.tdb.Modify(tabname, conditions={'Name': dbtables.LikeCond('%MP3%')}, mappings={'Type': set_type}) self.tdb.Modify(tabname, conditions={'Name': dbtables.LikeCond('%')}, mappings={'Access': increment_access}) try: self.tdb.Modify(tabname, conditions={'Name': dbtables.LikeCond('%')}, mappings={'Access': 'What is your quest?'}) except TypeError: # success, the string value in mappings isn't callable pass else: raise RuntimeError("why was TypeError not raised for bad callable?") # Delete key in select conditions values = self.tdb.Select( tabname, None, conditions={'Type': dbtables.ExactCond('Unknown')}) self.assertEqual(len(values), 1, values) self.assertEqual(values[0]['Name'], None, values) self.assertEqual(values[0]['Access'], None, values) # Modify value by select conditions values = self.tdb.Select( tabname, None, conditions={'Name': dbtables.ExactCond('Nifty.MP3')}) self.assertEqual(len(values), 1, values) self.assertEqual(values[0]['Type'], "MP3", values) self.assertEqual(values[0]['Access'], "2", values) # Make sure change applied only to select conditions values = self.tdb.Select( tabname, None, conditions={'Name': dbtables.LikeCond('%doc%')}) self.assertEqual(len(values), 1, values) self.assertEqual(values[0]['Type'], "Word", values) self.assertEqual(values[0]['Access'], "9", values) def test_suite(): suite = unittest.TestSuite() suite.addTest(unittest.makeSuite(TableDBTestCase)) return suite if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib3/bsddb/test/test_fileid.py0000664000175000017500000000652613617051162020225 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """TestCase for reseting File ID. """ import os import shutil import unittest from .test_all import db, test_support, get_new_environment_path, get_new_database_path class FileidResetTestCase(unittest.TestCase): def setUp(self): self.db_path_1 = get_new_database_path() self.db_path_2 = get_new_database_path() self.db_env_path = get_new_environment_path() def test_fileid_reset(self): # create DB 1 self.db1 = db.DB() self.db1.open(self.db_path_1, dbtype=db.DB_HASH, flags=(db.DB_CREATE|db.DB_EXCL)) self.db1.put('spam', 'eggs') self.db1.close() shutil.copy(self.db_path_1, self.db_path_2) self.db2 = db.DB() self.db2.open(self.db_path_2, dbtype=db.DB_HASH) self.db2.put('spam', 'spam') self.db2.close() self.db_env = db.DBEnv() self.db_env.open(self.db_env_path, db.DB_CREATE|db.DB_INIT_MPOOL) # use fileid_reset() here self.db_env.fileid_reset(self.db_path_2) self.db1 = db.DB(self.db_env) self.db1.open(self.db_path_1, dbtype=db.DB_HASH, flags=db.DB_RDONLY) self.assertEqual(self.db1.get('spam'), 'eggs') self.db2 = db.DB(self.db_env) self.db2.open(self.db_path_2, dbtype=db.DB_HASH, flags=db.DB_RDONLY) self.assertEqual(self.db2.get('spam'), 'spam') self.db1.close() self.db2.close() self.db_env.close() def tearDown(self): test_support.unlink(self.db_path_1) test_support.unlink(self.db_path_2) test_support.rmtree(self.db_env_path) def test_suite(): suite = unittest.TestSuite() suite.addTest(unittest.makeSuite(FileidResetTestCase)) return suite if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib3/bsddb/test/test_distributed_transactions.py0000664000175000017500000001435113617051206024075 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """TestCases for distributed transactions. """ import os import unittest from .test_all import db, test_support, get_new_environment_path, \ get_new_database_path from .test_all import verbose #---------------------------------------------------------------------- class DBTxn_distributed(unittest.TestCase): num_txns=1234 nosync=True must_open_db=False def _create_env(self, must_open_db) : self.dbenv = db.DBEnv() self.dbenv.set_tx_max(self.num_txns) self.dbenv.set_lk_max_lockers(self.num_txns*2) self.dbenv.set_lk_max_locks(self.num_txns*2) self.dbenv.set_lk_max_objects(self.num_txns*2) if self.nosync : self.dbenv.set_flags(db.DB_TXN_NOSYNC,True) self.dbenv.open(self.homeDir, db.DB_CREATE | db.DB_THREAD | db.DB_RECOVER | db.DB_INIT_TXN | db.DB_INIT_LOG | db.DB_INIT_MPOOL | db.DB_INIT_LOCK, 0o666) self.db = db.DB(self.dbenv) self.db.set_re_len(db.DB_GID_SIZE) if must_open_db : txn=self.dbenv.txn_begin() self.db.open(self.filename, db.DB_QUEUE, db.DB_CREATE | db.DB_THREAD, 0o666, txn=txn) txn.commit() def setUp(self) : self.homeDir = get_new_environment_path() self.filename = "test" return self._create_env(must_open_db=True) def _destroy_env(self): if self.nosync : self.dbenv.log_flush() self.db.close() self.dbenv.close() def tearDown(self): self._destroy_env() test_support.rmtree(self.homeDir) def _recreate_env(self,must_open_db) : self._destroy_env() self._create_env(must_open_db) def test01_distributed_transactions(self) : txns=set() adapt = lambda x : x import sys if sys.version_info[0] >= 3 : adapt = lambda x : bytes(x, "ascii") # Create transactions, "prepare" them, and # let them be garbage collected. for i in range(self.num_txns) : txn = self.dbenv.txn_begin() gid = "%%%dd" %db.DB_GID_SIZE gid = adapt(gid %i) self.db.put(i, gid, txn=txn, flags=db.DB_APPEND) txns.add(gid) txn.prepare(gid) del txn self._recreate_env(self.must_open_db) # Get "to be recovered" transactions but # let them be garbage collected. recovered_txns=self.dbenv.txn_recover() self.assertEqual(self.num_txns,len(recovered_txns)) for gid,txn in recovered_txns : self.assertTrue(gid in txns) del txn del recovered_txns self._recreate_env(self.must_open_db) # Get "to be recovered" transactions. Commit, abort and # discard them. recovered_txns=self.dbenv.txn_recover() self.assertEqual(self.num_txns,len(recovered_txns)) discard_txns=set() committed_txns=set() state=0 for gid,txn in recovered_txns : if state==0 or state==1: committed_txns.add(gid) txn.commit() elif state==2 : txn.abort() elif state==3 : txn.discard() discard_txns.add(gid) state=-1 state+=1 del txn del recovered_txns self._recreate_env(self.must_open_db) # Verify the discarded transactions are still # around, and dispose them. recovered_txns=self.dbenv.txn_recover() self.assertEqual(len(discard_txns),len(recovered_txns)) for gid,txn in recovered_txns : txn.abort() del txn del recovered_txns self._recreate_env(must_open_db=True) # Be sure there are not pending transactions. # Check also database size. recovered_txns=self.dbenv.txn_recover() self.assertTrue(len(recovered_txns)==0) self.assertEqual(len(committed_txns),self.db.stat()["nkeys"]) class DBTxn_distributedSYNC(DBTxn_distributed): nosync=False class DBTxn_distributed_must_open_db(DBTxn_distributed): must_open_db=True class DBTxn_distributedSYNC_must_open_db(DBTxn_distributed): nosync=False must_open_db=True #---------------------------------------------------------------------- def test_suite(): suite = unittest.TestSuite() suite.addTest(unittest.makeSuite(DBTxn_distributed)) suite.addTest(unittest.makeSuite(DBTxn_distributedSYNC)) suite.addTest(unittest.makeSuite(DBTxn_distributed_must_open_db)) suite.addTest(unittest.makeSuite(DBTxn_distributedSYNC_must_open_db)) return suite if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib3/bsddb/test/test_dbenv.py0000664000175000017500000004647313617051177020102 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ import unittest import os, glob from .test_all import db, test_support, get_new_environment_path, \ get_new_database_path #---------------------------------------------------------------------- class DBEnv(unittest.TestCase): def setUp(self): self.homeDir = get_new_environment_path() self.env = db.DBEnv() def tearDown(self): self.env.close() del self.env test_support.rmtree(self.homeDir) class DBEnv_general(DBEnv) : def test_get_open_flags(self) : flags = db.DB_CREATE | db.DB_INIT_MPOOL self.env.open(self.homeDir, flags) self.assertEqual(flags, self.env.get_open_flags()) def test_get_open_flags2(self) : flags = db.DB_CREATE | db.DB_INIT_MPOOL | \ db.DB_INIT_LOCK | db.DB_THREAD self.env.open(self.homeDir, flags) self.assertEqual(flags, self.env.get_open_flags()) def test_lk_partitions(self) : for i in [10, 20, 40] : self.env.set_lk_partitions(i) self.assertEqual(i, self.env.get_lk_partitions()) def test_getset_intermediate_dir_mode(self) : self.assertEqual(None, self.env.get_intermediate_dir_mode()) for mode in ["rwx------", "rw-rw-rw-", "rw-r--r--"] : self.env.set_intermediate_dir_mode(mode) self.assertEqual(mode, self.env.get_intermediate_dir_mode()) self.assertRaises(db.DBInvalidArgError, self.env.set_intermediate_dir_mode, "abcde") def test_thread(self) : for i in [16, 100, 1000] : self.env.set_thread_count(i) self.assertEqual(i, self.env.get_thread_count()) def test_cache_max(self) : for size in [64, 128] : size = size*1024*1024 # Megabytes self.env.set_cache_max(0, size) size2 = self.env.get_cache_max() self.assertEqual(0, size2[0]) self.assertTrue(size <= size2[1]) self.assertTrue(2*size > size2[1]) def test_mutex_stat(self) : self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL | db.DB_INIT_LOCK) stat = self.env.mutex_stat() self.assertTrue("mutex_inuse_max" in stat) def test_lg_filemode(self) : for i in [0o600, 0o660, 0o666] : self.env.set_lg_filemode(i) self.assertEqual(i, self.env.get_lg_filemode()) def test_mp_max_openfd(self) : for i in [17, 31, 42] : self.env.set_mp_max_openfd(i) self.assertEqual(i, self.env.get_mp_max_openfd()) def test_mp_max_write(self) : for i in [100, 200, 300] : for j in [1, 2, 3] : j *= 1000000 self.env.set_mp_max_write(i, j) v=self.env.get_mp_max_write() self.assertEqual((i, j), v) def test_invalid_txn(self) : # This environment doesn't support transactions self.assertRaises(db.DBInvalidArgError, self.env.txn_begin) def test_mp_mmapsize(self) : for i in [16, 32, 64] : i *= 1024*1024 self.env.set_mp_mmapsize(i) self.assertEqual(i, self.env.get_mp_mmapsize()) def test_tmp_dir(self) : for i in ["a", "bb", "ccc"] : self.env.set_tmp_dir(i) self.assertEqual(i, self.env.get_tmp_dir()) def test_flags(self) : self.env.set_flags(db.DB_AUTO_COMMIT, 1) self.assertEqual(db.DB_AUTO_COMMIT, self.env.get_flags()) self.env.set_flags(db.DB_TXN_NOSYNC, 1) self.assertEqual(db.DB_AUTO_COMMIT | db.DB_TXN_NOSYNC, self.env.get_flags()) self.env.set_flags(db.DB_AUTO_COMMIT, 0) self.assertEqual(db.DB_TXN_NOSYNC, self.env.get_flags()) self.env.set_flags(db.DB_TXN_NOSYNC, 0) self.assertEqual(0, self.env.get_flags()) def test_lk_max_objects(self) : for i in [1000, 2000, 3000] : self.env.set_lk_max_objects(i) self.assertEqual(i, self.env.get_lk_max_objects()) def test_lk_max_locks(self) : for i in [1000, 2000, 3000] : self.env.set_lk_max_locks(i) self.assertEqual(i, self.env.get_lk_max_locks()) def test_lk_max_lockers(self) : for i in [1000, 2000, 3000] : self.env.set_lk_max_lockers(i) self.assertEqual(i, self.env.get_lk_max_lockers()) def test_lg_regionmax(self) : for i in [128, 256, 1000] : i = i*1024*1024 self.env.set_lg_regionmax(i) j = self.env.get_lg_regionmax() self.assertTrue(i <= j) self.assertTrue(2*i > j) def test_lk_detect(self) : flags= [db.DB_LOCK_DEFAULT, db.DB_LOCK_EXPIRE, db.DB_LOCK_MAXLOCKS, db.DB_LOCK_MINLOCKS, db.DB_LOCK_MINWRITE, db.DB_LOCK_OLDEST, db.DB_LOCK_RANDOM, db.DB_LOCK_YOUNGEST] flags.append(db.DB_LOCK_MAXWRITE) for i in flags : self.env.set_lk_detect(i) self.assertEqual(i, self.env.get_lk_detect()) def test_lg_dir(self) : for i in ["a", "bb", "ccc", "dddd"] : self.env.set_lg_dir(i) self.assertEqual(i, self.env.get_lg_dir()) def test_lg_bsize(self) : log_size = 70*1024 self.env.set_lg_bsize(log_size) self.assertTrue(self.env.get_lg_bsize() >= log_size) self.assertTrue(self.env.get_lg_bsize() < 4*log_size) self.env.set_lg_bsize(4*log_size) self.assertTrue(self.env.get_lg_bsize() >= 4*log_size) def test_setget_data_dirs(self) : dirs = ("a", "b", "c", "d") for i in dirs : self.env.set_data_dir(i) self.assertEqual(dirs, self.env.get_data_dirs()) def test_setget_cachesize(self) : cachesize = (0, 512*1024*1024, 3) self.env.set_cachesize(*cachesize) self.assertEqual(cachesize, self.env.get_cachesize()) cachesize = (0, 1*1024*1024, 5) self.env.set_cachesize(*cachesize) cachesize2 = self.env.get_cachesize() self.assertEqual(cachesize[0], cachesize2[0]) self.assertEqual(cachesize[2], cachesize2[2]) # Berkeley DB expands the cache 25% accounting overhead, # if the cache is small. self.assertEqual(125, int(100.0*cachesize2[1]/cachesize[1])) # You can not change configuration after opening # the environment. self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL) cachesize = (0, 2*1024*1024, 1) self.assertRaises(db.DBInvalidArgError, self.env.set_cachesize, *cachesize) cachesize3 = self.env.get_cachesize() self.assertEqual(cachesize2[0], cachesize3[0]) self.assertEqual(cachesize2[2], cachesize3[2]) # In Berkeley DB 5.1, the cachesize can change when opening the Env self.assertTrue(cachesize2[1] <= cachesize3[1]) def test_set_cachesize_dbenv_db(self) : # You can not configure the cachesize using # the database handle, if you are using an environment. d = db.DB(self.env) self.assertRaises(db.DBInvalidArgError, d.set_cachesize, 0, 1024*1024, 1) def test_setget_shm_key(self) : shm_key=137 self.env.set_shm_key(shm_key) self.assertEqual(shm_key, self.env.get_shm_key()) self.env.set_shm_key(shm_key+1) self.assertEqual(shm_key+1, self.env.get_shm_key()) # You can not change configuration after opening # the environment. self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL) # If we try to reconfigure cache after opening the # environment, core dump. self.assertRaises(db.DBInvalidArgError, self.env.set_shm_key, shm_key) self.assertEqual(shm_key+1, self.env.get_shm_key()) def test_mutex_setget_max(self) : v = self.env.mutex_get_max() v2 = v*2+1 self.env.mutex_set_max(v2) self.assertEqual(v2, self.env.mutex_get_max()) self.env.mutex_set_max(v) self.assertEqual(v, self.env.mutex_get_max()) # You can not change configuration after opening # the environment. self.env.open(self.homeDir, db.DB_CREATE) self.assertRaises(db.DBInvalidArgError, self.env.mutex_set_max, v2) def test_mutex_setget_increment(self) : v = self.env.mutex_get_increment() v2 = 127 self.env.mutex_set_increment(v2) self.assertEqual(v2, self.env.mutex_get_increment()) self.env.mutex_set_increment(v) self.assertEqual(v, self.env.mutex_get_increment()) # You can not change configuration after opening # the environment. self.env.open(self.homeDir, db.DB_CREATE) self.assertRaises(db.DBInvalidArgError, self.env.mutex_set_increment, v2) def test_mutex_setget_tas_spins(self) : self.env.mutex_set_tas_spins(0) # Default = BDB decides v = self.env.mutex_get_tas_spins() v2 = v*2+1 self.env.mutex_set_tas_spins(v2) self.assertEqual(v2, self.env.mutex_get_tas_spins()) self.env.mutex_set_tas_spins(v) self.assertEqual(v, self.env.mutex_get_tas_spins()) # In this case, you can change configuration # after opening the environment. self.env.open(self.homeDir, db.DB_CREATE) self.env.mutex_set_tas_spins(v2) def test_mutex_setget_align(self) : v = self.env.mutex_get_align() v2 = 64 if v == 64 : v2 = 128 self.env.mutex_set_align(v2) self.assertEqual(v2, self.env.mutex_get_align()) # Requires a nonzero power of two self.assertRaises(db.DBInvalidArgError, self.env.mutex_set_align, 0) self.assertRaises(db.DBInvalidArgError, self.env.mutex_set_align, 17) self.env.mutex_set_align(2*v2) self.assertEqual(2*v2, self.env.mutex_get_align()) # You can not change configuration after opening # the environment. self.env.open(self.homeDir, db.DB_CREATE) self.assertRaises(db.DBInvalidArgError, self.env.mutex_set_align, v2) class DBEnv_log(DBEnv) : def setUp(self): DBEnv.setUp(self) self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL | db.DB_INIT_LOG) def test_log_file(self) : log_file = self.env.log_file((1, 1)) self.assertEqual("log.0000000001", log_file[-14:]) # The version with transactions is checked in other test object def test_log_printf(self) : msg = "This is a test..." self.env.log_printf(msg) logc = self.env.log_cursor() self.assertTrue(msg in (logc.last()[1])) if db.version() >= (4, 7) : def test_log_config(self) : self.env.log_set_config(db.DB_LOG_DSYNC | db.DB_LOG_ZERO, 1) self.assertTrue(self.env.log_get_config(db.DB_LOG_DSYNC)) self.assertTrue(self.env.log_get_config(db.DB_LOG_ZERO)) self.env.log_set_config(db.DB_LOG_ZERO, 0) self.assertTrue(self.env.log_get_config(db.DB_LOG_DSYNC)) self.assertFalse(self.env.log_get_config(db.DB_LOG_ZERO)) class DBEnv_log_txn(DBEnv) : def setUp(self): DBEnv.setUp(self) self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL | db.DB_INIT_LOG | db.DB_INIT_TXN) if db.version() < (5, 2) : def test_tx_max(self) : txns=[] def tx() : for i in range(self.env.get_tx_max()) : txns.append(self.env.txn_begin()) tx() self.assertRaises(MemoryError, tx) # Abort the transactions before garbage collection, # to avoid "warnings". for i in txns : i.abort() # The version without transactions is checked in other test object def test_log_printf(self) : msg = "This is a test..." txn = self.env.txn_begin() self.env.log_printf(msg, txn=txn) txn.commit() logc = self.env.log_cursor() logc.last() # Skip the commit self.assertTrue(msg in (logc.prev()[1])) msg = "This is another test..." txn = self.env.txn_begin() self.env.log_printf(msg, txn=txn) txn.abort() # Do not store the new message logc.last() # Skip the abort self.assertTrue(msg not in (logc.prev()[1])) msg = "This is a third test..." txn = self.env.txn_begin() self.env.log_printf(msg, txn=txn) txn.commit() # Do not store the new message logc.last() # Skip the commit self.assertTrue(msg in (logc.prev()[1])) class DBEnv_memp(DBEnv): def setUp(self): DBEnv.setUp(self) self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL | db.DB_INIT_LOG) self.db = db.DB(self.env) self.db.open("test", db.DB_HASH, db.DB_CREATE, 0o660) def tearDown(self): self.db.close() del self.db DBEnv.tearDown(self) def test_memp_1_trickle(self) : self.db.put("hi", "bye") self.assertTrue(self.env.memp_trickle(100) > 0) # Preserve the order, do "memp_trickle" test first def test_memp_2_sync(self) : self.db.put("hi", "bye") self.env.memp_sync() # Full flush # Nothing to do... self.assertTrue(self.env.memp_trickle(100) == 0) self.db.put("hi", "bye2") self.env.memp_sync((1, 0)) # NOP, probably # Something to do... or not self.assertTrue(self.env.memp_trickle(100) >= 0) self.db.put("hi", "bye3") self.env.memp_sync((123, 99)) # Full flush # Nothing to do... self.assertTrue(self.env.memp_trickle(100) == 0) def test_memp_stat_1(self) : stats = self.env.memp_stat() # No param self.assertTrue(len(stats)==2) self.assertTrue("cache_miss" in stats[0]) stats = self.env.memp_stat(db.DB_STAT_CLEAR) # Positional param self.assertTrue("cache_miss" in stats[0]) stats = self.env.memp_stat(flags=0) # Keyword param self.assertTrue("cache_miss" in stats[0]) def test_memp_stat_2(self) : stats=self.env.memp_stat()[1] self.assertTrue(len(stats))==1 self.assertTrue("test" in stats) self.assertTrue("page_in" in stats["test"]) class DBEnv_logcursor(DBEnv): def setUp(self): DBEnv.setUp(self) self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL | db.DB_INIT_LOG | db.DB_INIT_TXN) txn = self.env.txn_begin() self.db = db.DB(self.env) self.db.open("test", db.DB_HASH, db.DB_CREATE, 0o660, txn=txn) txn.commit() for i in ["2", "8", "20"] : txn = self.env.txn_begin() self.db.put(key = i, data = i*int(i), txn=txn) txn.commit() def tearDown(self): self.db.close() del self.db DBEnv.tearDown(self) def _check_return(self, value) : self.assertTrue(isinstance(value, tuple)) self.assertEqual(len(value), 2) self.assertTrue(isinstance(value[0], tuple)) self.assertEqual(len(value[0]), 2) self.assertTrue(isinstance(value[0][0], int)) self.assertTrue(isinstance(value[0][1], int)) self.assertTrue(isinstance(value[1], str)) # Preserve test order def test_1_first(self) : logc = self.env.log_cursor() v = logc.first() self._check_return(v) self.assertTrue((1, 1) < v[0]) self.assertTrue(len(v[1])>0) def test_2_last(self) : logc = self.env.log_cursor() lsn_first = logc.first()[0] v = logc.last() self._check_return(v) self.assertTrue(lsn_first < v[0]) def test_3_next(self) : logc = self.env.log_cursor() lsn_last = logc.last()[0] self.assertEqual(next(logc), None) lsn_first = logc.first()[0] v = next(logc) self._check_return(v) self.assertTrue(lsn_first < v[0]) self.assertTrue(lsn_last > v[0]) v2 = next(logc) self.assertTrue(v2[0] > v[0]) self.assertTrue(lsn_last > v2[0]) v3 = next(logc) self.assertTrue(v3[0] > v2[0]) self.assertTrue(lsn_last > v3[0]) def test_4_prev(self) : logc = self.env.log_cursor() lsn_first = logc.first()[0] self.assertEqual(logc.prev(), None) lsn_last = logc.last()[0] v = logc.prev() self._check_return(v) self.assertTrue(lsn_first < v[0]) self.assertTrue(lsn_last > v[0]) v2 = logc.prev() self.assertTrue(v2[0] < v[0]) self.assertTrue(lsn_first < v2[0]) v3 = logc.prev() self.assertTrue(v3[0] < v2[0]) self.assertTrue(lsn_first < v3[0]) def test_5_current(self) : logc = self.env.log_cursor() logc.first() v = next(logc) self.assertEqual(v, logc.current()) def test_6_set(self) : logc = self.env.log_cursor() logc.first() v = next(logc) self.assertNotEqual(v, next(logc)) self.assertNotEqual(v, next(logc)) self.assertEqual(v, logc.set(v[0])) def test_explicit_close(self) : logc = self.env.log_cursor() logc.close() self.assertRaises(db.DBCursorClosedError, logc.__next__) def test_implicit_close(self) : logc = [self.env.log_cursor() for i in range(10)] self.env.close() # This close should close too all its tree for i in logc : self.assertRaises(db.DBCursorClosedError, i.__next__) def test_suite(): suite = unittest.TestSuite() suite.addTest(unittest.makeSuite(DBEnv_general)) suite.addTest(unittest.makeSuite(DBEnv_memp)) suite.addTest(unittest.makeSuite(DBEnv_logcursor)) suite.addTest(unittest.makeSuite(DBEnv_log)) suite.addTest(unittest.makeSuite(DBEnv_log_txn)) return suite if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib3/bsddb/test/test_dbshelve.py0000664000175000017500000003146213617051155020564 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """ TestCases for checking dbShelve objects. """ import os, string, sys import random import unittest from .test_all import db, dbshelve, test_support, verbose, \ get_new_environment_path, get_new_database_path #---------------------------------------------------------------------- # We want the objects to be comparable so we can test dbshelve.values # later on. class DataClass: def __init__(self): self.value = random.random() def __repr__(self) : # For Python 3.0 comparison return "DataClass %f" %self.value def __cmp__(self, other): # For Python 2.x comparison return cmp(self.value, other) class DBShelveTestCase(unittest.TestCase): if sys.version_info < (2, 7) : def assertIn(self, a, b, msg=None) : return self.assertTrue(a in b, msg=msg) def setUp(self): if sys.version_info[0] >= 3 : from .test_all import do_proxy_db_py3k self._flag_proxy_db_py3k = do_proxy_db_py3k(False) self.filename = get_new_database_path() self.do_open() def tearDown(self): if sys.version_info[0] >= 3 : from .test_all import do_proxy_db_py3k do_proxy_db_py3k(self._flag_proxy_db_py3k) self.do_close() test_support.unlink(self.filename) def mk(self, key): """Turn key into an appropriate key type for this db""" # override in child class for RECNO if sys.version_info[0] < 3 : return key else : return bytes(key, "iso8859-1") # 8 bits def populateDB(self, d): for x in string.ascii_letters: d[self.mk('S' + x)] = 10 * x # add a string d[self.mk('I' + x)] = ord(x) # add an integer d[self.mk('L' + x)] = [x] * 10 # add a list inst = DataClass() # add an instance inst.S = 10 * x inst.I = ord(x) inst.L = [x] * 10 d[self.mk('O' + x)] = inst # overridable in derived classes to affect how the shelf is created/opened def do_open(self): self.d = dbshelve.open(self.filename) # and closed... def do_close(self): self.d.close() def test01_basics(self): if verbose: print('\n', '-=' * 30) print("Running %s.test01_basics..." % self.__class__.__name__) self.populateDB(self.d) self.d.sync() self.do_close() self.do_open() d = self.d l = len(d) k = list(d.keys()) s = d.stat() f = d.fd() if verbose: print("length:", l) print("keys:", k) print("stats:", s) self.assertEqual(0, self.mk('bad key') in d) self.assertEqual(1, self.mk('IA') in d) self.assertEqual(1, self.mk('OA') in d) d.delete(self.mk('IA')) del d[self.mk('OA')] self.assertEqual(0, self.mk('IA') in d) self.assertEqual(0, self.mk('OA') in d) self.assertEqual(len(d), l-2) values = [] for key in list(d.keys()): value = d[key] values.append(value) if verbose: print("%s: %s" % (key, value)) self.checkrec(key, value) dbvalues = list(d.values()) self.assertEqual(len(dbvalues), len(list(d.keys()))) # XXX: Convert all to strings. Please, improve values.sort(key=lambda x : str(x)) dbvalues.sort(key=lambda x : str(x)) self.assertEqual(repr(values), repr(dbvalues)) items = list(d.items()) self.assertEqual(len(items), len(values)) for key, value in items: self.checkrec(key, value) self.assertEqual(d.get(self.mk('bad key')), None) self.assertEqual(d.get(self.mk('bad key'), None), None) self.assertEqual(d.get(self.mk('bad key'), 'a string'), 'a string') self.assertEqual(d.get(self.mk('bad key'), [1, 2, 3]), [1, 2, 3]) d.set_get_returns_none(0) self.assertRaises(db.DBNotFoundError, d.get, self.mk('bad key')) d.set_get_returns_none(1) d.put(self.mk('new key'), 'new data') self.assertEqual(d.get(self.mk('new key')), 'new data') self.assertEqual(d[self.mk('new key')], 'new data') def test02_cursors(self): if verbose: print('\n', '-=' * 30) print("Running %s.test02_cursors..." % self.__class__.__name__) self.populateDB(self.d) d = self.d count = 0 c = d.cursor() rec = c.first() while rec is not None: count = count + 1 if verbose: print(rec) key, value = rec self.checkrec(key, value) # Hack to avoid conversion by 2to3 tool rec = getattr(c, "next")() del c self.assertEqual(count, len(d)) count = 0 c = d.cursor() rec = c.last() while rec is not None: count = count + 1 if verbose: print(rec) key, value = rec self.checkrec(key, value) rec = c.prev() self.assertEqual(count, len(d)) c.set(self.mk('SS')) key, value = c.current() self.checkrec(key, value) del c def test03_append(self): # NOTE: this is overridden in RECNO subclass, don't change its name. if verbose: print('\n', '-=' * 30) print("Running %s.test03_append..." % self.__class__.__name__) self.assertRaises(dbshelve.DBShelveError, self.d.append, 'unit test was here') def test04_iterable(self) : self.populateDB(self.d) d = self.d keys = list(d.keys()) keyset = set(keys) self.assertEqual(len(keyset), len(keys)) for key in d : self.assertIn(key, keyset) keyset.remove(key) self.assertEqual(len(keyset), 0) def checkrec(self, key, value): # override this in a subclass if the key type is different if sys.version_info[0] >= 3 : if isinstance(key, bytes) : key = key.decode("iso8859-1") # 8 bits x = key[1] if key[0] == 'S': self.assertEqual(type(value), str) self.assertEqual(value, 10 * x) elif key[0] == 'I': self.assertEqual(type(value), int) self.assertEqual(value, ord(x)) elif key[0] == 'L': self.assertEqual(type(value), list) self.assertEqual(value, [x] * 10) elif key[0] == 'O': if sys.version_info[0] < 3 : from types import InstanceType self.assertEqual(type(value), InstanceType) else : self.assertEqual(type(value), DataClass) self.assertEqual(value.S, 10 * x) self.assertEqual(value.I, ord(x)) self.assertEqual(value.L, [x] * 10) else: self.assertTrue(0, 'Unknown key type, fix the test') #---------------------------------------------------------------------- class BasicShelveTestCase(DBShelveTestCase): def do_open(self): self.d = dbshelve.DBShelf() self.d.open(self.filename, self.dbtype, self.dbflags) def do_close(self): self.d.close() class BTreeShelveTestCase(BasicShelveTestCase): dbtype = db.DB_BTREE dbflags = db.DB_CREATE class HashShelveTestCase(BasicShelveTestCase): dbtype = db.DB_HASH dbflags = db.DB_CREATE class ThreadBTreeShelveTestCase(BasicShelveTestCase): dbtype = db.DB_BTREE dbflags = db.DB_CREATE | db.DB_THREAD class ThreadHashShelveTestCase(BasicShelveTestCase): dbtype = db.DB_HASH dbflags = db.DB_CREATE | db.DB_THREAD #---------------------------------------------------------------------- class BasicEnvShelveTestCase(DBShelveTestCase): def do_open(self): self.env = db.DBEnv() self.env.open(self.homeDir, self.envflags | db.DB_INIT_MPOOL | db.DB_CREATE) self.filename = os.path.split(self.filename)[1] self.d = dbshelve.DBShelf(self.env) self.d.open(self.filename, self.dbtype, self.dbflags) def do_close(self): self.d.close() self.env.close() def setUp(self) : self.homeDir = get_new_environment_path() DBShelveTestCase.setUp(self) def tearDown(self): if sys.version_info[0] >= 3 : from .test_all import do_proxy_db_py3k do_proxy_db_py3k(self._flag_proxy_db_py3k) self.do_close() test_support.rmtree(self.homeDir) class EnvBTreeShelveTestCase(BasicEnvShelveTestCase): envflags = 0 dbtype = db.DB_BTREE dbflags = db.DB_CREATE class EnvHashShelveTestCase(BasicEnvShelveTestCase): envflags = 0 dbtype = db.DB_HASH dbflags = db.DB_CREATE class EnvThreadBTreeShelveTestCase(BasicEnvShelveTestCase): envflags = db.DB_THREAD dbtype = db.DB_BTREE dbflags = db.DB_CREATE | db.DB_THREAD class EnvThreadHashShelveTestCase(BasicEnvShelveTestCase): envflags = db.DB_THREAD dbtype = db.DB_HASH dbflags = db.DB_CREATE | db.DB_THREAD #---------------------------------------------------------------------- # test cases for a DBShelf in a RECNO DB. class RecNoShelveTestCase(BasicShelveTestCase): dbtype = db.DB_RECNO dbflags = db.DB_CREATE def setUp(self): BasicShelveTestCase.setUp(self) # pool to assign integer key values out of self.key_pool = list(range(1, 5000)) self.key_map = {} # map string keys to the number we gave them self.intkey_map = {} # reverse map of above def mk(self, key): if key not in self.key_map: self.key_map[key] = self.key_pool.pop(0) self.intkey_map[self.key_map[key]] = key return self.key_map[key] def checkrec(self, intkey, value): key = self.intkey_map[intkey] BasicShelveTestCase.checkrec(self, key, value) def test03_append(self): if verbose: print('\n', '-=' * 30) print("Running %s.test03_append..." % self.__class__.__name__) self.d[1] = 'spam' self.d[5] = 'eggs' self.assertEqual(6, self.d.append('spam')) self.assertEqual(7, self.d.append('baked beans')) self.assertEqual('spam', self.d.get(6)) self.assertEqual('spam', self.d.get(1)) self.assertEqual('baked beans', self.d.get(7)) self.assertEqual('eggs', self.d.get(5)) #---------------------------------------------------------------------- def test_suite(): suite = unittest.TestSuite() suite.addTest(unittest.makeSuite(DBShelveTestCase)) suite.addTest(unittest.makeSuite(BTreeShelveTestCase)) suite.addTest(unittest.makeSuite(HashShelveTestCase)) suite.addTest(unittest.makeSuite(ThreadBTreeShelveTestCase)) suite.addTest(unittest.makeSuite(ThreadHashShelveTestCase)) suite.addTest(unittest.makeSuite(EnvBTreeShelveTestCase)) suite.addTest(unittest.makeSuite(EnvHashShelveTestCase)) suite.addTest(unittest.makeSuite(EnvThreadBTreeShelveTestCase)) suite.addTest(unittest.makeSuite(EnvThreadHashShelveTestCase)) suite.addTest(unittest.makeSuite(RecNoShelveTestCase)) return suite if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib3/bsddb/test/test_db.py0000664000175000017500000001623213617051171017351 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ import unittest import os, glob from .test_all import db, test_support, get_new_environment_path, \ get_new_database_path #---------------------------------------------------------------------- class DB(unittest.TestCase): def setUp(self): self.path = get_new_database_path() self.db = db.DB() def tearDown(self): self.db.close() del self.db test_support.unlink(self.path) class DB_general(DB) : def test_get_open_flags(self) : self.db.open(self.path, dbtype=db.DB_HASH, flags = db.DB_CREATE) self.assertEqual(db.DB_CREATE, self.db.get_open_flags()) def test_get_open_flags2(self) : self.db.open(self.path, dbtype=db.DB_HASH, flags = db.DB_CREATE | db.DB_THREAD) self.assertEqual(db.DB_CREATE | db.DB_THREAD, self.db.get_open_flags()) def test_get_dbname_filename(self) : self.db.open(self.path, dbtype=db.DB_HASH, flags = db.DB_CREATE) self.assertEqual((self.path, None), self.db.get_dbname()) def test_get_dbname_filename_database(self) : name = "jcea-random-name" self.db.open(self.path, dbname=name, dbtype=db.DB_HASH, flags = db.DB_CREATE) self.assertEqual((self.path, name), self.db.get_dbname()) def test_bt_minkey(self) : for i in [17, 108, 1030] : self.db.set_bt_minkey(i) self.assertEqual(i, self.db.get_bt_minkey()) def test_lorder(self) : self.db.set_lorder(1234) self.assertEqual(1234, self.db.get_lorder()) self.db.set_lorder(4321) self.assertEqual(4321, self.db.get_lorder()) self.assertRaises(db.DBInvalidArgError, self.db.set_lorder, 9182) def test_priority(self) : flags = [db.DB_PRIORITY_VERY_LOW, db.DB_PRIORITY_LOW, db.DB_PRIORITY_DEFAULT, db.DB_PRIORITY_HIGH, db.DB_PRIORITY_VERY_HIGH] for flag in flags : self.db.set_priority(flag) self.assertEqual(flag, self.db.get_priority()) def test_get_transactional(self) : self.assertFalse(self.db.get_transactional()) self.db.open(self.path, dbtype=db.DB_HASH, flags = db.DB_CREATE) self.assertFalse(self.db.get_transactional()) class DB_hash(DB) : def test_h_ffactor(self) : for ffactor in [4, 16, 256] : self.db.set_h_ffactor(ffactor) self.assertEqual(ffactor, self.db.get_h_ffactor()) def test_h_nelem(self) : for nelem in [1, 2, 4] : nelem = nelem*1024*1024 # Millions self.db.set_h_nelem(nelem) self.assertEqual(nelem, self.db.get_h_nelem()) def test_pagesize(self) : for i in range(9, 17) : # From 512 to 65536 i = 1< All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ import unittest import os from .test_all import db, test_support, get_new_environment_path, get_new_database_path class DBSequenceTest(unittest.TestCase): def setUp(self): self.int_32_max = 0x100000000 self.homeDir = get_new_environment_path() self.filename = "test" self.dbenv = db.DBEnv() self.dbenv.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL, 0o666) self.d = db.DB(self.dbenv) self.d.open(self.filename, db.DB_BTREE, db.DB_CREATE, 0o666) def tearDown(self): if hasattr(self, 'seq'): self.seq.close() del self.seq if hasattr(self, 'd'): self.d.close() del self.d if hasattr(self, 'dbenv'): self.dbenv.close() del self.dbenv test_support.rmtree(self.homeDir) def test_get(self): self.seq = db.DBSequence(self.d, flags=0) start_value = 10 * self.int_32_max self.assertEqual(0xA00000000, start_value) self.assertEqual(None, self.seq.initial_value(start_value)) self.assertEqual(None, self.seq.open(key='id', txn=None, flags=db.DB_CREATE)) self.assertEqual(start_value, self.seq.get(5)) self.assertEqual(start_value + 5, self.seq.get()) def test_remove(self): self.seq = db.DBSequence(self.d, flags=0) self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE)) self.assertEqual(None, self.seq.remove(txn=None, flags=0)) del self.seq def test_get_key(self): self.seq = db.DBSequence(self.d, flags=0) key = 'foo' self.assertEqual(None, self.seq.open(key=key, txn=None, flags=db.DB_CREATE)) self.assertEqual(key, self.seq.get_key()) def test_get_dbp(self): self.seq = db.DBSequence(self.d, flags=0) self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE)) self.assertEqual(self.d, self.seq.get_dbp()) def test_cachesize(self): self.seq = db.DBSequence(self.d, flags=0) cashe_size = 10 self.assertEqual(None, self.seq.set_cachesize(cashe_size)) self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE)) self.assertEqual(cashe_size, self.seq.get_cachesize()) def test_flags(self): self.seq = db.DBSequence(self.d, flags=0) flag = db.DB_SEQ_WRAP; self.assertEqual(None, self.seq.set_flags(flag)) self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE)) self.assertEqual(flag, self.seq.get_flags() & flag) def test_range(self): self.seq = db.DBSequence(self.d, flags=0) seq_range = (10 * self.int_32_max, 11 * self.int_32_max - 1) self.assertEqual(None, self.seq.set_range(seq_range)) self.seq.initial_value(seq_range[0]) self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE)) self.assertEqual(seq_range, self.seq.get_range()) def test_stat(self): self.seq = db.DBSequence(self.d, flags=0) self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE)) stat = self.seq.stat() for param in ('nowait', 'min', 'max', 'value', 'current', 'flags', 'cache_size', 'last_value', 'wait'): self.assertTrue(param in stat, "parameter %s isn't in stat info" % param) # This code checks a crash solved in Berkeley DB 4.7 def test_stat_crash(self) : d=db.DB() d.open(None,dbtype=db.DB_HASH,flags=db.DB_CREATE) # In RAM seq = db.DBSequence(d, flags=0) self.assertRaises(db.DBNotFoundError, seq.open, key='id', txn=None, flags=0) self.assertRaises(db.DBInvalidArgError, seq.stat) d.close() def test_64bits(self) : # We don't use both extremes because they are problematic value_plus=(1<<63)-2 self.assertEqual(9223372036854775806,value_plus) value_minus=(-1<<63)+1 # Two complement self.assertEqual(-9223372036854775807,value_minus) self.seq = db.DBSequence(self.d, flags=0) self.assertEqual(None, self.seq.initial_value(value_plus-1)) self.assertEqual(None, self.seq.open(key='id', txn=None, flags=db.DB_CREATE)) self.assertEqual(value_plus-1, self.seq.get(1)) self.assertEqual(value_plus, self.seq.get(1)) self.seq.remove(txn=None, flags=0) self.seq = db.DBSequence(self.d, flags=0) self.assertEqual(None, self.seq.initial_value(value_minus)) self.assertEqual(None, self.seq.open(key='id', txn=None, flags=db.DB_CREATE)) self.assertEqual(value_minus, self.seq.get(1)) self.assertEqual(value_minus+1, self.seq.get(1)) def test_multiple_close(self): self.seq = db.DBSequence(self.d) self.seq.close() # You can close a Sequence multiple times self.seq.close() self.seq.close() def test_suite(): suite = unittest.TestSuite() suite.addTest(unittest.makeSuite(DBSequenceTest)) return suite if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib3/bsddb/test/test_replication.py0000664000175000017500000005202613617051157021302 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """TestCases for distributed transactions. """ import os import time import unittest from .test_all import db, test_support, have_threads, verbose, \ get_new_environment_path, get_new_database_path #---------------------------------------------------------------------- class DBReplication(unittest.TestCase) : def setUp(self) : self.homeDirMaster = get_new_environment_path() self.homeDirClient = get_new_environment_path() self.dbenvMaster = db.DBEnv() self.dbenvClient = db.DBEnv() # Must use "DB_THREAD" because the Replication Manager will # be executed in other threads but will use the same environment. # http://forums.oracle.com/forums/thread.jspa?threadID=645788&tstart=0 self.dbenvMaster.open(self.homeDirMaster, db.DB_CREATE | db.DB_INIT_TXN | db.DB_INIT_LOG | db.DB_INIT_MPOOL | db.DB_INIT_LOCK | db.DB_INIT_REP | db.DB_RECOVER | db.DB_THREAD, 0o666) self.dbenvClient.open(self.homeDirClient, db.DB_CREATE | db.DB_INIT_TXN | db.DB_INIT_LOG | db.DB_INIT_MPOOL | db.DB_INIT_LOCK | db.DB_INIT_REP | db.DB_RECOVER | db.DB_THREAD, 0o666) self.confirmed_master=self.client_startupdone=False def confirmed_master(a,b,c) : if b==db.DB_EVENT_REP_MASTER : self.confirmed_master=True def client_startupdone(a,b,c) : if b==db.DB_EVENT_REP_STARTUPDONE : self.client_startupdone=True self.dbenvMaster.set_event_notify(confirmed_master) self.dbenvClient.set_event_notify(client_startupdone) #self.dbenvMaster.set_verbose(db.DB_VERB_REPLICATION, True) #self.dbenvMaster.set_verbose(db.DB_VERB_FILEOPS_ALL, True) #self.dbenvClient.set_verbose(db.DB_VERB_REPLICATION, True) #self.dbenvClient.set_verbose(db.DB_VERB_FILEOPS_ALL, True) self.dbMaster = self.dbClient = None def tearDown(self): if self.dbClient : self.dbClient.close() if self.dbMaster : self.dbMaster.close() # Here we assign dummy event handlers to allow GC of the test object. # Since the dummy handler doesn't use any outer scope variable, it # doesn't keep any reference to the test object. def dummy(*args) : pass self.dbenvMaster.set_event_notify(dummy) self.dbenvClient.set_event_notify(dummy) self.dbenvClient.close() self.dbenvMaster.close() test_support.rmtree(self.homeDirClient) test_support.rmtree(self.homeDirMaster) class DBReplicationManager(DBReplication) : def test01_basic_replication(self) : master_port = test_support.find_unused_port() client_port = test_support.find_unused_port() if db.version() >= (5, 2) : self.site = self.dbenvMaster.repmgr_site("127.0.0.1", master_port) self.site.set_config(db.DB_GROUP_CREATOR, True) self.site.set_config(db.DB_LOCAL_SITE, True) self.site2 = self.dbenvMaster.repmgr_site("127.0.0.1", client_port) self.site3 = self.dbenvClient.repmgr_site("127.0.0.1", master_port) self.site3.set_config(db.DB_BOOTSTRAP_HELPER, True) self.site4 = self.dbenvClient.repmgr_site("127.0.0.1", client_port) self.site4.set_config(db.DB_LOCAL_SITE, True) d = { db.DB_BOOTSTRAP_HELPER: [False, False, True, False], db.DB_GROUP_CREATOR: [True, False, False, False], db.DB_LEGACY: [False, False, False, False], db.DB_LOCAL_SITE: [True, False, False, True], db.DB_REPMGR_PEER: [False, False, False, False ], } for i, j in list(d.items()) : for k, v in \ zip([self.site, self.site2, self.site3, self.site4], j) : if v : self.assertTrue(k.get_config(i)) else : self.assertFalse(k.get_config(i)) self.assertNotEqual(self.site.get_eid(), self.site2.get_eid()) self.assertNotEqual(self.site3.get_eid(), self.site4.get_eid()) for i, j in zip([self.site, self.site2, self.site3, self.site4], \ [master_port, client_port, master_port, client_port]) : addr = i.get_address() self.assertEqual(addr, ("127.0.0.1", j)) for i in [self.site, self.site2] : self.assertEqual(i.get_address(), self.dbenvMaster.repmgr_site_by_eid(i.get_eid()).get_address()) for i in [self.site3, self.site4] : self.assertEqual(i.get_address(), self.dbenvClient.repmgr_site_by_eid(i.get_eid()).get_address()) else : self.dbenvMaster.repmgr_set_local_site("127.0.0.1", master_port) self.dbenvClient.repmgr_set_local_site("127.0.0.1", client_port) self.dbenvMaster.repmgr_add_remote_site("127.0.0.1", client_port) self.dbenvClient.repmgr_add_remote_site("127.0.0.1", master_port) self.dbenvMaster.rep_set_nsites(2) self.dbenvClient.rep_set_nsites(2) self.dbenvMaster.rep_set_priority(10) self.dbenvClient.rep_set_priority(0) self.dbenvMaster.rep_set_timeout(db.DB_REP_CONNECTION_RETRY,100123) self.dbenvClient.rep_set_timeout(db.DB_REP_CONNECTION_RETRY,100321) self.assertEqual(self.dbenvMaster.rep_get_timeout( db.DB_REP_CONNECTION_RETRY), 100123) self.assertEqual(self.dbenvClient.rep_get_timeout( db.DB_REP_CONNECTION_RETRY), 100321) self.dbenvMaster.rep_set_timeout(db.DB_REP_ELECTION_TIMEOUT, 100234) self.dbenvClient.rep_set_timeout(db.DB_REP_ELECTION_TIMEOUT, 100432) self.assertEqual(self.dbenvMaster.rep_get_timeout( db.DB_REP_ELECTION_TIMEOUT), 100234) self.assertEqual(self.dbenvClient.rep_get_timeout( db.DB_REP_ELECTION_TIMEOUT), 100432) self.dbenvMaster.rep_set_timeout(db.DB_REP_ELECTION_RETRY, 100345) self.dbenvClient.rep_set_timeout(db.DB_REP_ELECTION_RETRY, 100543) self.assertEqual(self.dbenvMaster.rep_get_timeout( db.DB_REP_ELECTION_RETRY), 100345) self.assertEqual(self.dbenvClient.rep_get_timeout( db.DB_REP_ELECTION_RETRY), 100543) self.dbenvMaster.repmgr_set_ack_policy(db.DB_REPMGR_ACKS_ALL) self.dbenvClient.repmgr_set_ack_policy(db.DB_REPMGR_ACKS_ALL) self.dbenvMaster.repmgr_start(1, db.DB_REP_MASTER); self.dbenvClient.repmgr_start(1, db.DB_REP_CLIENT); self.assertEqual(self.dbenvMaster.rep_get_nsites(),2) self.assertEqual(self.dbenvClient.rep_get_nsites(),2) self.assertEqual(self.dbenvMaster.rep_get_priority(),10) self.assertEqual(self.dbenvClient.rep_get_priority(),0) self.assertEqual(self.dbenvMaster.repmgr_get_ack_policy(), db.DB_REPMGR_ACKS_ALL) self.assertEqual(self.dbenvClient.repmgr_get_ack_policy(), db.DB_REPMGR_ACKS_ALL) # The timeout is necessary in BDB 4.5, since DB_EVENT_REP_STARTUPDONE # is not generated if the master has no new transactions. # This is solved in BDB 4.6 (#15542). import time timeout = time.time()+10 while (time.time() All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ """ TestCases for exercising a Queue DB. """ import os, string from pprint import pprint import unittest from .test_all import db, verbose, get_new_database_path #---------------------------------------------------------------------- class SimpleQueueTestCase(unittest.TestCase): def setUp(self): self.filename = get_new_database_path() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_basic(self): # Basic Queue tests using the deprecated DBCursor.consume method. if verbose: print('\n', '-=' * 30) print("Running %s.test01_basic..." % self.__class__.__name__) d = db.DB() d.set_re_len(40) # Queues must be fixed length d.open(self.filename, db.DB_QUEUE, db.DB_CREATE) if verbose: print("before appends" + '-' * 30) pprint(d.stat()) for x in string.ascii_letters: d.append(x * 40) self.assertEqual(len(d), len(string.ascii_letters)) d.put(100, "some more data") d.put(101, "and some more ") d.put(75, "out of order") d.put(1, "replacement data") self.assertEqual(len(d), len(string.ascii_letters)+3) if verbose: print("before close" + '-' * 30) pprint(d.stat()) d.close() del d d = db.DB() d.open(self.filename) if verbose: print("after open" + '-' * 30) pprint(d.stat()) # Test "txn" as a positional parameter d.append("one more", None) # Test "txn" as a keyword parameter d.append("another one", txn=None) c = d.cursor() if verbose: print("after append" + '-' * 30) pprint(d.stat()) rec = c.consume() while rec: if verbose: print(rec) rec = c.consume() c.close() if verbose: print("after consume loop" + '-' * 30) pprint(d.stat()) self.assertEqual(len(d), 0, \ "if you see this message then you need to rebuild " \ "Berkeley DB 3.1.17 with the patch in patches/qam_stat.diff") d.close() def test02_basicPost32(self): # Basic Queue tests using the new DB.consume method in DB 3.2+ # (No cursor needed) if verbose: print('\n', '-=' * 30) print("Running %s.test02_basicPost32..." % self.__class__.__name__) d = db.DB() d.set_re_len(40) # Queues must be fixed length d.open(self.filename, db.DB_QUEUE, db.DB_CREATE) if verbose: print("before appends" + '-' * 30) pprint(d.stat()) for x in string.ascii_letters: d.append(x * 40) self.assertEqual(len(d), len(string.ascii_letters)) d.put(100, "some more data") d.put(101, "and some more ") d.put(75, "out of order") d.put(1, "replacement data") self.assertEqual(len(d), len(string.ascii_letters)+3) if verbose: print("before close" + '-' * 30) pprint(d.stat()) d.close() del d d = db.DB() d.open(self.filename) #d.set_get_returns_none(true) if verbose: print("after open" + '-' * 30) pprint(d.stat()) d.append("one more") if verbose: print("after append" + '-' * 30) pprint(d.stat()) rec = d.consume() while rec: if verbose: print(rec) rec = d.consume() if verbose: print("after consume loop" + '-' * 30) pprint(d.stat()) d.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(SimpleQueueTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib3/bsddb/test/test_cursor_pget_bug.py0000664000175000017500000000665013617051203022154 0ustar jceajcea00000000000000""" Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ import unittest import os, glob from .test_all import db, test_support, get_new_environment_path, \ get_new_database_path #---------------------------------------------------------------------- class pget_bugTestCase(unittest.TestCase): """Verify that cursor.pget works properly""" db_name = 'test-cursor_pget.db' def setUp(self): self.homeDir = get_new_environment_path() self.env = db.DBEnv() self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL) self.primary_db = db.DB(self.env) self.primary_db.open(self.db_name, 'primary', db.DB_BTREE, db.DB_CREATE) self.secondary_db = db.DB(self.env) self.secondary_db.set_flags(db.DB_DUP) self.secondary_db.open(self.db_name, 'secondary', db.DB_BTREE, db.DB_CREATE) self.primary_db.associate(self.secondary_db, lambda key, data: data) self.primary_db.put('salad', 'eggs') self.primary_db.put('spam', 'ham') self.primary_db.put('omelet', 'eggs') def tearDown(self): self.secondary_db.close() self.primary_db.close() self.env.close() del self.secondary_db del self.primary_db del self.env test_support.rmtree(self.homeDir) def test_pget(self): cursor = self.secondary_db.cursor() self.assertEqual(('eggs', 'salad', 'eggs'), cursor.pget(key='eggs', flags=db.DB_SET)) self.assertEqual(('eggs', 'omelet', 'eggs'), cursor.pget(db.DB_NEXT_DUP)) self.assertEqual(None, cursor.pget(db.DB_NEXT_DUP)) self.assertEqual(('ham', 'spam', 'ham'), cursor.pget('ham', 'spam', flags=db.DB_SET)) self.assertEqual(None, cursor.pget(db.DB_NEXT_DUP)) cursor.close() def test_suite(): return unittest.makeSuite(pget_bugTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') bsddb3-6.2.7/Lib3/bsddb/test/__init__.py0000664000175000017500000000000013316237760017454 0ustar jceajcea00000000000000bsddb3-6.2.7/Lib3/bsddb/dbshelve.py0000664000175000017500000002477013617056346016561 0ustar jceajcea00000000000000#!/usr/bin/env python #------------------------------------------------------------------------ # Copyright (c) 1997-2001 by Total Control Software # All Rights Reserved #------------------------------------------------------------------------ # # Module Name: dbShelve.py # # Description: A reimplementation of the standard shelve.py that # forces the use of cPickle, and DB. # # Creation Date: 11/3/97 3:39:04PM # # License: This is free software. You may use this software for any # purpose including modification/redistribution, so long as # this header remains intact and that you do not claim any # rights of ownership or authorship of this software. This # software has been tested, but no warranty is expressed or # implied. # # 13-Dec-2000: Updated to be used with the new bsddb3 package. # Added DBShelfCursor class. # #------------------------------------------------------------------------ """Manage shelves of pickled objects using bsddb database files for the storage. """ #------------------------------------------------------------------------ import sys absolute_import = (sys.version_info[0] >= 3) if absolute_import : from . import db else : from . import db if sys.version_info[0] >= 3 : import pickle # Will be converted to "pickle" by "2to3" else : import warnings with warnings.catch_warnings() : warnings.filterwarnings("ignore", category=DeprecationWarning) import pickle HIGHEST_PROTOCOL = pickle.HIGHEST_PROTOCOL def _dumps(object, protocol): return pickle.dumps(object, protocol=protocol) if (sys.version_info[0] >= 3): from collections.abc import MutableMapping else: from collections import MutableMapping #------------------------------------------------------------------------ def open(filename, flags=db.DB_CREATE, mode=0o660, filetype=db.DB_HASH, dbenv=None, dbname=None): """ A simple factory function for compatibility with the standard shelve.py module. It can be used like this, where key is a string and data is a pickleable object: from bsddb import dbshelve db = dbshelve.open(filename) db[key] = data db.close() """ if type(flags) == type(''): sflag = flags if sflag == 'r': flags = db.DB_RDONLY elif sflag == 'rw': flags = 0 elif sflag == 'w': flags = db.DB_CREATE elif sflag == 'c': flags = db.DB_CREATE elif sflag == 'n': flags = db.DB_TRUNCATE | db.DB_CREATE else: raise db.DBError("flags should be one of 'r', 'w', 'c' or 'n' or use the bsddb.db.DB_* flags") d = DBShelf(dbenv) d.open(filename, dbname, filetype, flags, mode) return d #--------------------------------------------------------------------------- class DBShelveError(db.DBError): pass class DBShelf(MutableMapping): """A shelf to hold pickled objects, built upon a bsddb DB object. It automatically pickles/unpickles data objects going to/from the DB. """ def __init__(self, dbenv=None): self.db = db.DB(dbenv) self._closed = True if HIGHEST_PROTOCOL: self.protocol = HIGHEST_PROTOCOL else: self.protocol = 1 def __del__(self): self.close() def __getattr__(self, name): """Many methods we can just pass through to the DB object. (See below) """ return getattr(self.db, name) #----------------------------------- # Dictionary access methods def __len__(self): return len(self.db) def __getitem__(self, key): data = self.db[key] return pickle.loads(data) def __setitem__(self, key, value): data = _dumps(value, self.protocol) self.db[key] = data def __delitem__(self, key): del self.db[key] def keys(self, txn=None): if txn is not None: return self.db.keys(txn) else: return list(self.db.keys()) def __iter__(self) : # XXX: Load all keys in memory :-( for k in list(self.db.keys()) : yield k # Do this when "DB" support iteration # Or is it enough to pass thru "getattr"? # # def __iter__(self) : # return self.db.__iter__() def open(self, *args, **kwargs): self.db.open(*args, **kwargs) self._closed = False def close(self, *args, **kwargs): self.db.close(*args, **kwargs) self._closed = True def __repr__(self): if self._closed: return '' % (id(self)) else: return repr(dict(iter(self.items()))) def items(self, txn=None): if txn is not None: items = self.db.items(txn) else: items = list(self.db.items()) newitems = [] for k, v in items: newitems.append( (k, pickle.loads(v)) ) return newitems def values(self, txn=None): if txn is not None: values = self.db.values(txn) else: values = list(self.db.values()) return list(map(pickle.loads, values)) #----------------------------------- # Other methods def __append(self, value, txn=None): data = _dumps(value, self.protocol) return self.db.append(data, txn) def append(self, value, txn=None): if self.get_type() == db.DB_RECNO: return self.__append(value, txn=txn) raise DBShelveError("append() only supported when dbshelve opened with filetype=dbshelve.db.DB_RECNO") def associate(self, secondaryDB, callback, flags=0): def _shelf_callback(priKey, priData, realCallback=callback): # Safe in Python 2.x because expresion short circuit if sys.version_info[0] < 3 or isinstance(priData, bytes) : data = pickle.loads(priData) else : data = pickle.loads(bytes(priData, "iso8859-1")) # 8 bits return realCallback(priKey, data) return self.db.associate(secondaryDB, _shelf_callback, flags) #def get(self, key, default=None, txn=None, flags=0): def get(self, *args, **kw): # We do it with *args and **kw so if the default value wasn't # given nothing is passed to the extension module. That way # an exception can be raised if set_get_returns_none is turned # off. data = self.db.get(*args, **kw) try: return pickle.loads(data) except (EOFError, TypeError, pickle.UnpicklingError): return data # we may be getting the default value, or None, # so it doesn't need unpickled. def get_both(self, key, value, txn=None, flags=0): data = _dumps(value, self.protocol) data = self.db.get(key, data, txn, flags) return pickle.loads(data) def cursor(self, txn=None, flags=0): c = DBShelfCursor(self.db.cursor(txn, flags)) c.protocol = self.protocol return c def put(self, key, value, txn=None, flags=0): data = _dumps(value, self.protocol) return self.db.put(key, data, txn, flags) def join(self, cursorList, flags=0): raise NotImplementedError #---------------------------------------------- # Methods allowed to pass-through to self.db # # close, delete, fd, get_byteswapped, get_type, has_key, # key_range, open, remove, rename, stat, sync, # upgrade, verify, and all set_* methods. #--------------------------------------------------------------------------- class DBShelfCursor: """ """ def __init__(self, cursor): self.dbc = cursor def __del__(self): self.close() def __getattr__(self, name): """Some methods we can just pass through to the cursor object. (See below)""" return getattr(self.dbc, name) #---------------------------------------------- def dup(self, flags=0): c = DBShelfCursor(self.dbc.dup(flags)) c.protocol = self.protocol return c def put(self, key, value, flags=0): data = _dumps(value, self.protocol) return self.dbc.put(key, data, flags) def get(self, *args): count = len(args) # a method overloading hack method = getattr(self, 'get_%d' % count) method(*args) def get_1(self, flags): rec = self.dbc.get(flags) return self._extract(rec) def get_2(self, key, flags): rec = self.dbc.get(key, flags) return self._extract(rec) def get_3(self, key, value, flags): data = _dumps(value, self.protocol) rec = self.dbc.get(key, flags) return self._extract(rec) def current(self, flags=0): return self.get_1(flags|db.DB_CURRENT) def first(self, flags=0): return self.get_1(flags|db.DB_FIRST) def last(self, flags=0): return self.get_1(flags|db.DB_LAST) def next(self, flags=0): return self.get_1(flags|db.DB_NEXT) def prev(self, flags=0): return self.get_1(flags|db.DB_PREV) def consume(self, flags=0): return self.get_1(flags|db.DB_CONSUME) def next_dup(self, flags=0): return self.get_1(flags|db.DB_NEXT_DUP) def next_nodup(self, flags=0): return self.get_1(flags|db.DB_NEXT_NODUP) def prev_nodup(self, flags=0): return self.get_1(flags|db.DB_PREV_NODUP) def get_both(self, key, value, flags=0): data = _dumps(value, self.protocol) rec = self.dbc.get_both(key, flags) return self._extract(rec) def set(self, key, flags=0): rec = self.dbc.set(key, flags) return self._extract(rec) def set_range(self, key, flags=0): rec = self.dbc.set_range(key, flags) return self._extract(rec) def set_recno(self, recno, flags=0): rec = self.dbc.set_recno(recno, flags) return self._extract(rec) set_both = get_both def _extract(self, rec): if rec is None: return None else: key, data = rec # Safe in Python 2.x because expresion short circuit if sys.version_info[0] < 3 or isinstance(data, bytes) : return key, pickle.loads(data) else : return key, pickle.loads(bytes(data, "iso8859-1")) # 8 bits #---------------------------------------------- # Methods allowed to pass-through to self.dbc # # close, count, delete, get_recno, join_item #--------------------------------------------------------------------------- bsddb3-6.2.7/Lib3/bsddb/dbobj.py0000664000175000017500000002540413617056463016040 0ustar jceajcea00000000000000#------------------------------------------------------------------------- # This file contains real Python object wrappers for DB and DBEnv # C "objects" that can be usefully subclassed. The previous SWIG # based interface allowed this thanks to SWIG's shadow classes. # -- Gregory P. Smith #------------------------------------------------------------------------- # # (C) Copyright 2001 Autonomous Zone Industries # # License: This is free software. You may use this software for any # purpose including modification/redistribution, so long as # this header remains intact and that you do not claim any # rights of ownership or authorship of this software. This # software has been tested, but no warranty is expressed or # implied. # # # TODO it would be *really nice* to have an automatic shadow class populator # so that new methods don't need to be added here manually after being # added to _bsddb.c. # import sys absolute_import = (sys.version_info[0] >= 3) if absolute_import : from . import db else : from . import db if (sys.version_info[0] >= 3): from collections.abc import MutableMapping else: from collections import MutableMapping class DBEnv: def __init__(self, *args, **kwargs): self._cobj = db.DBEnv(*args, **kwargs) def close(self, *args, **kwargs): return self._cobj.close(*args, **kwargs) def open(self, *args, **kwargs): return self._cobj.open(*args, **kwargs) def remove(self, *args, **kwargs): return self._cobj.remove(*args, **kwargs) def set_shm_key(self, *args, **kwargs): return self._cobj.set_shm_key(*args, **kwargs) def set_cachesize(self, *args, **kwargs): return self._cobj.set_cachesize(*args, **kwargs) def set_data_dir(self, *args, **kwargs): return self._cobj.set_data_dir(*args, **kwargs) def set_flags(self, *args, **kwargs): return self._cobj.set_flags(*args, **kwargs) def set_lg_bsize(self, *args, **kwargs): return self._cobj.set_lg_bsize(*args, **kwargs) def set_lg_dir(self, *args, **kwargs): return self._cobj.set_lg_dir(*args, **kwargs) def set_lg_max(self, *args, **kwargs): return self._cobj.set_lg_max(*args, **kwargs) def set_lk_detect(self, *args, **kwargs): return self._cobj.set_lk_detect(*args, **kwargs) def set_lk_max_locks(self, *args, **kwargs): return self._cobj.set_lk_max_locks(*args, **kwargs) def set_lk_max_lockers(self, *args, **kwargs): return self._cobj.set_lk_max_lockers(*args, **kwargs) def set_lk_max_objects(self, *args, **kwargs): return self._cobj.set_lk_max_objects(*args, **kwargs) def set_mp_mmapsize(self, *args, **kwargs): return self._cobj.set_mp_mmapsize(*args, **kwargs) def set_timeout(self, *args, **kwargs): return self._cobj.set_timeout(*args, **kwargs) def set_tmp_dir(self, *args, **kwargs): return self._cobj.set_tmp_dir(*args, **kwargs) def txn_begin(self, *args, **kwargs): return self._cobj.txn_begin(*args, **kwargs) def txn_checkpoint(self, *args, **kwargs): return self._cobj.txn_checkpoint(*args, **kwargs) def txn_stat(self, *args, **kwargs): return self._cobj.txn_stat(*args, **kwargs) def set_tx_max(self, *args, **kwargs): return self._cobj.set_tx_max(*args, **kwargs) def set_tx_timestamp(self, *args, **kwargs): return self._cobj.set_tx_timestamp(*args, **kwargs) def lock_detect(self, *args, **kwargs): return self._cobj.lock_detect(*args, **kwargs) def lock_get(self, *args, **kwargs): return self._cobj.lock_get(*args, **kwargs) def lock_id(self, *args, **kwargs): return self._cobj.lock_id(*args, **kwargs) def lock_put(self, *args, **kwargs): return self._cobj.lock_put(*args, **kwargs) def lock_stat(self, *args, **kwargs): return self._cobj.lock_stat(*args, **kwargs) def log_archive(self, *args, **kwargs): return self._cobj.log_archive(*args, **kwargs) def set_get_returns_none(self, *args, **kwargs): return self._cobj.set_get_returns_none(*args, **kwargs) def log_stat(self, *args, **kwargs): return self._cobj.log_stat(*args, **kwargs) def dbremove(self, *args, **kwargs): return self._cobj.dbremove(*args, **kwargs) def dbrename(self, *args, **kwargs): return self._cobj.dbrename(*args, **kwargs) def set_encrypt(self, *args, **kwargs): return self._cobj.set_encrypt(*args, **kwargs) def fileid_reset(self, *args, **kwargs): return self._cobj.fileid_reset(*args, **kwargs) def lsn_reset(self, *args, **kwargs): return self._cobj.lsn_reset(*args, **kwargs) class DB(MutableMapping): def __init__(self, dbenv, *args, **kwargs): # give it the proper DBEnv C object that its expecting self._cobj = db.DB(*((dbenv._cobj,) + args), **kwargs) # TODO are there other dict methods that need to be overridden? def __len__(self): return len(self._cobj) def __getitem__(self, arg): return self._cobj[arg] def __setitem__(self, key, value): self._cobj[key] = value def __delitem__(self, arg): del self._cobj[arg] def __iter__(self) : return self._cobj.__iter__() def append(self, *args, **kwargs): return self._cobj.append(*args, **kwargs) def associate(self, *args, **kwargs): return self._cobj.associate(*args, **kwargs) def close(self, *args, **kwargs): return self._cobj.close(*args, **kwargs) def consume(self, *args, **kwargs): return self._cobj.consume(*args, **kwargs) def consume_wait(self, *args, **kwargs): return self._cobj.consume_wait(*args, **kwargs) def cursor(self, *args, **kwargs): return self._cobj.cursor(*args, **kwargs) def delete(self, *args, **kwargs): return self._cobj.delete(*args, **kwargs) def fd(self, *args, **kwargs): return self._cobj.fd(*args, **kwargs) def get(self, *args, **kwargs): return self._cobj.get(*args, **kwargs) def pget(self, *args, **kwargs): return self._cobj.pget(*args, **kwargs) def get_both(self, *args, **kwargs): return self._cobj.get_both(*args, **kwargs) def get_byteswapped(self, *args, **kwargs): return self._cobj.get_byteswapped(*args, **kwargs) def get_size(self, *args, **kwargs): return self._cobj.get_size(*args, **kwargs) def get_type(self, *args, **kwargs): return self._cobj.get_type(*args, **kwargs) def join(self, *args, **kwargs): return self._cobj.join(*args, **kwargs) def key_range(self, *args, **kwargs): return self._cobj.key_range(*args, **kwargs) def has_key(self, *args, **kwargs): return self._cobj.has_key(*args, **kwargs) def items(self, *args, **kwargs): return self._cobj.items(*args, **kwargs) def keys(self, *args, **kwargs): return self._cobj.keys(*args, **kwargs) def open(self, *args, **kwargs): return self._cobj.open(*args, **kwargs) def put(self, *args, **kwargs): return self._cobj.put(*args, **kwargs) def remove(self, *args, **kwargs): return self._cobj.remove(*args, **kwargs) def rename(self, *args, **kwargs): return self._cobj.rename(*args, **kwargs) def set_bt_minkey(self, *args, **kwargs): return self._cobj.set_bt_minkey(*args, **kwargs) def set_bt_compare(self, *args, **kwargs): return self._cobj.set_bt_compare(*args, **kwargs) def set_cachesize(self, *args, **kwargs): return self._cobj.set_cachesize(*args, **kwargs) def set_dup_compare(self, *args, **kwargs) : return self._cobj.set_dup_compare(*args, **kwargs) def set_flags(self, *args, **kwargs): return self._cobj.set_flags(*args, **kwargs) def set_h_ffactor(self, *args, **kwargs): return self._cobj.set_h_ffactor(*args, **kwargs) def set_h_nelem(self, *args, **kwargs): return self._cobj.set_h_nelem(*args, **kwargs) def set_lorder(self, *args, **kwargs): return self._cobj.set_lorder(*args, **kwargs) def set_pagesize(self, *args, **kwargs): return self._cobj.set_pagesize(*args, **kwargs) def set_re_delim(self, *args, **kwargs): return self._cobj.set_re_delim(*args, **kwargs) def set_re_len(self, *args, **kwargs): return self._cobj.set_re_len(*args, **kwargs) def set_re_pad(self, *args, **kwargs): return self._cobj.set_re_pad(*args, **kwargs) def set_re_source(self, *args, **kwargs): return self._cobj.set_re_source(*args, **kwargs) def set_q_extentsize(self, *args, **kwargs): return self._cobj.set_q_extentsize(*args, **kwargs) def stat(self, *args, **kwargs): return self._cobj.stat(*args, **kwargs) def sync(self, *args, **kwargs): return self._cobj.sync(*args, **kwargs) def type(self, *args, **kwargs): return self._cobj.type(*args, **kwargs) def upgrade(self, *args, **kwargs): return self._cobj.upgrade(*args, **kwargs) def values(self, *args, **kwargs): return self._cobj.values(*args, **kwargs) def verify(self, *args, **kwargs): return self._cobj.verify(*args, **kwargs) def set_get_returns_none(self, *args, **kwargs): return self._cobj.set_get_returns_none(*args, **kwargs) def set_encrypt(self, *args, **kwargs): return self._cobj.set_encrypt(*args, **kwargs) class DBSequence: def __init__(self, *args, **kwargs): self._cobj = db.DBSequence(*args, **kwargs) def close(self, *args, **kwargs): return self._cobj.close(*args, **kwargs) def get(self, *args, **kwargs): return self._cobj.get(*args, **kwargs) def get_dbp(self, *args, **kwargs): return self._cobj.get_dbp(*args, **kwargs) def get_key(self, *args, **kwargs): return self._cobj.get_key(*args, **kwargs) def init_value(self, *args, **kwargs): return self._cobj.init_value(*args, **kwargs) def open(self, *args, **kwargs): return self._cobj.open(*args, **kwargs) def remove(self, *args, **kwargs): return self._cobj.remove(*args, **kwargs) def stat(self, *args, **kwargs): return self._cobj.stat(*args, **kwargs) def set_cachesize(self, *args, **kwargs): return self._cobj.set_cachesize(*args, **kwargs) def set_flags(self, *args, **kwargs): return self._cobj.set_flags(*args, **kwargs) def set_range(self, *args, **kwargs): return self._cobj.set_range(*args, **kwargs) def get_cachesize(self, *args, **kwargs): return self._cobj.get_cachesize(*args, **kwargs) def get_flags(self, *args, **kwargs): return self._cobj.get_flags(*args, **kwargs) def get_range(self, *args, **kwargs): return self._cobj.get_range(*args, **kwargs) bsddb3-6.2.7/Lib3/bsddb/dbutils.py0000664000175000017500000000553013316237762016423 0ustar jceajcea00000000000000#------------------------------------------------------------------------ # # Copyright (C) 2000 Autonomous Zone Industries # # License: This is free software. You may use this software for any # purpose including modification/redistribution, so long as # this header remains intact and that you do not claim any # rights of ownership or authorship of this software. This # software has been tested, but no warranty is expressed or # implied. # # Author: Gregory P. Smith # # Note: I don't know how useful this is in reality since when a # DBLockDeadlockError happens the current transaction is supposed to be # aborted. If it doesn't then when the operation is attempted again # the deadlock is still happening... # --Robin # #------------------------------------------------------------------------ # # import the time.sleep function in a namespace safe way to allow # "from bsddb.dbutils import *" # from time import sleep as _sleep import sys absolute_import = (sys.version_info[0] >= 3) if absolute_import : from . import db else : from . import db # always sleep at least N seconds between retrys _deadlock_MinSleepTime = 1.0/128 # never sleep more than N seconds between retrys _deadlock_MaxSleepTime = 3.14159 # Assign a file object to this for a "sleeping" message to be written to it # each retry _deadlock_VerboseFile = None def DeadlockWrap(function, *_args, **_kwargs): """DeadlockWrap(function, *_args, **_kwargs) - automatically retries function in case of a database deadlock. This is a function intended to be used to wrap database calls such that they perform retrys with exponentially backing off sleeps in between when a DBLockDeadlockError exception is raised. A 'max_retries' parameter may optionally be passed to prevent it from retrying forever (in which case the exception will be reraised). d = DB(...) d.open(...) DeadlockWrap(d.put, "foo", data="bar") # set key "foo" to "bar" """ sleeptime = _deadlock_MinSleepTime max_retries = _kwargs.get('max_retries', -1) if 'max_retries' in _kwargs: del _kwargs['max_retries'] while True: try: return function(*_args, **_kwargs) except db.DBLockDeadlockError: if _deadlock_VerboseFile: _deadlock_VerboseFile.write( 'dbutils.DeadlockWrap: sleeping %1.3f\n' % sleeptime) _sleep(sleeptime) # exponential backoff in the sleep time sleeptime *= 2 if sleeptime > _deadlock_MaxSleepTime: sleeptime = _deadlock_MaxSleepTime max_retries -= 1 if max_retries == -1: raise #------------------------------------------------------------------------ bsddb3-6.2.7/Lib3/bsddb/db.py0000664000175000017500000000422413316237760015337 0ustar jceajcea00000000000000#---------------------------------------------------------------------- # Copyright (c) 1999-2001, Digital Creations, Fredericksburg, VA, USA # and Andrew Kuchling. All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: # # o Redistributions of source code must retain the above copyright # notice, this list of conditions, and the disclaimer that follows. # # o Redistributions in binary form must reproduce the above copyright # notice, this list of conditions, and the following disclaimer in # the documentation and/or other materials provided with the # distribution. # # o Neither the name of Digital Creations nor the names of its # contributors may be used to endorse or promote products derived # from this software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY DIGITAL CREATIONS AND CONTRIBUTORS *AS # IS* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED # TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A # PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL DIGITAL # CREATIONS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, # BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS # OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND # ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR # TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE # USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH # DAMAGE. #---------------------------------------------------------------------- # This module is just a placeholder for possible future expansion, in # case we ever want to augment the stuff in _db in any way. For now # it just simply imports everything from _db. import sys absolute_import = (sys.version_info[0] >= 3) if not absolute_import : from _pybsddb import * from _pybsddb import __version__ else : from ._pybsddb import * from ._pybsddb import __version__ bsddb3-6.2.7/ChangeLog0000664000175000017500000012135013617117345014303 0ustar jceajcea00000000000000As seen in https://superuser.com/questions/997154/python-and-berkeley-db-versions-in-redhat-enterprise-linux-6-6-6-7-and-7-x RHEL6 has Python 2.6 and BDB 4.7. Supported until July 31, 2017 (RHEL 6.7). RHEL7 has Python 2.7 and BDB 5.3. Includes legacy BDB 4.7 for compatibility, not used by the system. Ubuntu 12.04: Python 2.7, BDB 4.8 (legacy), BDB 5.1 used by the system. Supported until 2017. Ubuntu 16.04: Python 2.7, Python 3.5. BDB 5.3. Supported until 2021. Ubuntu 18.04: Python 2.7, Python 3.6. BDB 5.3. Supported until 2023. Pkgsrc 19.4.0 has BDB 4.8, 5,3 and 6.2. TODO: Implement PEP 384 (Stable API) 6.2.7: * Update copyright notices. * https links. * Fix Python 3 deprecation warning. Notified by Arthur Gautier. * Fix compilation Python 3.8 deprecation warnings. * Fix compilation Python 3.9 deprecation warnings. * Python 3.8 and 3.9 are explicitly supported. 6.2.6: * Correctly detect Berkeley DB when installed via Homebrew on Mac OS X. Patch by Matthew Peveler. * Python 3.6 and 3.7 are explicitly supported. 6.2.5: * We should be able to install inside a PYPY virtualenv. Reported by Zhihao Yuan. 6.2.4: * More complete fix for pkgsrc. 6.2.3: * Update copyright notices. * Solve a conflict between different installations of Berkeley DB on some pkgsrc configurations. 6.2.2: * Correctly detect Berkeley DB installations in SmartOS native zones. * "Probably" (not tested) correctly detect Berkeley DB in pkgsrc systems. 6.2.1: * Correctly detect Berkeley DB installations in modern 64 bits Debians. 6.2.0: * Support Berkeley DB 6.2.x. * Declare Python 3.5 support for PyPI. * Drop support for Python 3.2. If you need compatibility with that version, you can keep using old releases of these bindings. * Drop support for Berkeley DB 5.0, 5.2 and 6.0. If you need compatibility with those versions, you can keep using old releases of these bindings. 6.1.1: * Compatibility with Python 3.5. * Code cleanup after dropping Python 2.4/2.5 support. * PGP key changed. * Support for DB_FORCESYNCENV flag in "DB_ENV.close()". * Support for DB_LOG_NOSYNC flag in "DB_ENV.log_set_config()". * Fix tests under Windows. See https://bugs.python.org/issue22943 . * Solve an incorrect parameter verification with the "DB.compact()" method call. * Solve a compilation warning when compiling the bindings for Python 3.5 and Berkeley DB 4.8, 5.0 or 5.1. 6.1.0: * Support Berkeley DB 6.1.x. * Solve a ResourceWarning when compiling. * Drop support for Python 2.4, 2.5 and 3.1. If you need compatibility with those versions, you can keep using old releases of these bindings. * Drop support for Berkeley DB 4.3, 4.4, 4.5, 4.6. If you need compatibility with those versions, you can keep using old releases of these bindings. * From now on, our support reference is Red Hat Enterprise Linux 6. * Drop modules attributes "cvsid". * Drop (hidden) $Id$ keyword in the documentation. 6.0.1: * Clarification of license. Thanks to Jan Staněk for bringing this issue up. This work is now explicitly licensed under 3-clause BSD license. * Fixed a long standing bug (August 2008, rev 9fd52748fa59) on "dbtables.py". Notified by Maxime Labelle. * If you want to link with Oracle Berkeley DB 6.0, you will need to create the environment variable 'YES_I_HAVE_THE_RIGHT_TO_USE_THIS_BERKELEY_DB_VERSION' to signal to the pybsddb that you are legal. To be legal, your code MUST be AGPL3 *OR* you have to buy a commercial license from Oracle. If you are not legally entitled to use Berkeley DB 6.0 and you have previous versions of Berkeley DB on your system, you can a) delete Berkeley DB 6.0 and try again, OR b) instruct pybsddb to use a previous Berkeley DB version, using environment variables or command line options. Sorry for the inconvenience. I am trying to protect you. Some details: https://forums.oracle.com/message/11184885 http://lists.debian.org/debian-legal/2013/07/ 6.0.0: * Support Berkeley DB 6.0.x. * HEADS UP: If you are using "bsddb3._bsddb" in your code, for example for exceptions, change it to "bsddb3._db". * Print test working directory when running the testsuite. You can control it using "TMPDIR" environment variable. Defaults to "/tmp/z-Berkeley_DB/". * Support for "DB_EVENT_REP_AUTOTAKEOVER_FAILED" event. * Support for "DB_REPMGR_ISVIEW", "DB_DBT_BLOB", "DB_LOG_BLOB", "DB_STREAM_READ", "DB_STREAM_WRITE" and "DB_STREAM_SYNC_WRITE" flags. * Some DB_SEQUENCE function signatures changed in Berkeley DB 6.0.x. * Erratic behaviour of "DBEnv->rep_elect()" because a typo. * The testsuite prints Python bitness (32/64). * Tests compatible with hash randomization, default in Python 3.3. See http://bugs.python.org/issue13703 . * Errors when trying to calculate the length of a DB were masked, and an unuseful and unrelated exception was raised. * Code cleanup since pybsddb is not in the Python 3.x stdlib anymore, and the version in Python 2.6/2.7 is being maintained separately. * Improvements to documentation generation. 5.3.0: * Support Berkeley DB 5.3.x. * Drop support for Berkeley DB 4.2 and Python 2.3. Our reference is Red Hat Enterprise Linux 5, until march 2014. After that, RHEL6 has Python 2.6 and BDB 4.7. * According to http://superuser.com/questions/189931/python-and-berkeley-db-versions-in-redhat-enterprise-linux-3-4-5-and-upcoming-6 : * RHEL3: Python 2.2.3, BDB 4.1.25 * RHEL4: Python 2.3.4, BDB 4.2.52 * RHEL5: Python 2.4.3, BDB 4.3.29 * RHEL6: Python 2.6.2, BDB 4.7.25 * Support for "DBEnv->set_intermediate_dir()", available in Berkeley DB 4.3-4.6. Patch by Garret Cooper. * Support for "DB->set_dup_compare()". Original patches by Nikita M. Kozlovsky and Ben Schmeckpeper. * Fixed a testsuite compatibility problem with BDB 5.2. * If we are running Solaris or derivatives, and 64bit python, try to find the library under "/usr/local/Berkeley.*.*/64/". * Solaris 10 Update 10 exposes a very old race condition in the replication master election tests. Some details in https://forums.oracle.com/forums/thread.jspa?messageID=9902860 . Workaround proposed in a private email from Paula Bingham (Oracle), in 20110929. * When doing the full matrix test for a release, stop the verification if any test failed. 5.2.0: * Support for Berkeley DB 5.2. * Support for the newly available replication manager events: DB_EVENT_REP_SITE_ADDED, DB_EVENT_REP_SITE_REMOVED, DB_EVENT_REP_LOCAL_SITE_REMOVED, DB_EVENT_REP_CONNECT_BROKEN, DB_EVENT_REP_CONNECT_ESTD, DB_EVENT_REP_CONNECT_TRY_FAILED, DB_EVENT_REP_INIT_DONE. * New Object: "DB_SITE". Support for all its methods. * Parameters for "DB_SITE->set_config()": DB_BOOTSTRAP_HELPER, DB_GROUP_CREATOR, DB_LEGACY, DB_LOCAL_SITE, DB_REPMGR_PEER. * Support for some stuff in the new "Dynamic Environment Configuration": DB_MEM_LOCK, DB_MEM_LOCKOBJECT, DB_MEM_LOCKER, DB_MEM_LOGID, DB_MEM_TRANSACTION, DB_MEM_THREAD. * Add "bytes" to "DBEnv_memp_stat()". Original patch from Garrett Cooper. 5.1.2: * 5.1.1 install fails if the bsddb in the standard library is not installed, under Python 2.7. Reported by Arfrever Frehtes Taifersar Arahesis. * Since 5.0.0, we can't find 4.x libraries unless we specify a "--berkeley-db=/path/to/bsddb" option. Reported by Wen Heping. * Support "DB_ENV->get_open_flags()", "DB_ENV->set_intermediate_dir_mode()", "DB_ENV->get_intermediate_dir_mode()". * Support "DB->get_dbname()", "DB->get_open_flags()". * Support "db_full_version()". * Document "version()". This top-level function has been supported forever. * Bugfix when calling "DB->get_size()" on a zero length record. Reported by Austin Bingham. * 'assertEquals()' is deprecated in Python 3.2. * 'assert_()' is deprecated in Python 3.2. * Solved 'ResourceWarning' under Python 3.2. 5.1.1: * Recent pre-releases of Python 3.2 issue ResourceWarnings about fileshandles deallocated without being closed first. Fix testsuite. * Current "*.pyc" and "*.pyo" cleaning is not working in a PEP 3147 world ("__pycache__"). I don't think this code is actually necessary anymore. Deleted. * Python 2.7.0 deprecates CObject incorrectly. See Python issue #9675. * Testsuite for "DB->get_transactional()" should not create databases outside the TMP directory, neither leave the files behind. * If something happens while creating the CObject/Capsule object, keep going, even without exporting the C API, instead of crashing. * Support for "DB_FORCESYNC", "DB_FAILCHK", "DB_SET_REG_TIMEOUT", "DB_TXN_BULK", "DB_HOTBACKUP_IN_PROGRESS". * Support "DB_EVENT_REG_ALIVE", "DB_EVENT_REG_PANIC", "DB_EVENT_REP_DUPMASTER", "DB_REPMGR_CONF_ELECTIONS", "DB_EVENT_REP_ELECTION_FAILED", "DB_EVENT_REP_MASTER_FAILURE". * Support for "DB_VERB_REP_ELECT", "DB_VERB_REP_LEASE", "DB_VERB_REP_MISC", "DB_VERB_REP_MSGS", "DB_VERB_REP_SYNC", "DB_VERB_REP_SYSTEM", "DB_VERB_REPMGR_CONNFAIL", "DB_VERB_REPMGR_MISC". * Support for "DB_STAT_LOCK_CONF", "DB_STAT_LOCK_LOCKERS", "DB_STAT_LOCK_OBJECTS", "DB_STAT_LOCK_PARAMS". * Support for "DB_REP_CONF_INMEM". * Support for "DB_TIMEOUT ". * Support for "DB_CURSOR_BULK". 5.1.0: * Support for Berkeley DB 5.1. * Drop support for Berkeley DB 4.1. Our reference is Red Hat Enterprise Linux 4, until February 2012. After that, RHEL5 has Python 2.4 and BDB 4.3. * According to http://superuser.com/questions/189931/python-and-berkeley-db-versions-in-redhat-enterprise-linux-3-4-5-and-upcoming-6 : * RHEL3: Python 2.2.3, BDB 4.1.25 * RHEL4: Python 2.3.4, BDB 4.2.52 * RHEL5: Python 2.4.3, BDB 4.3.29 * RHEL6: Python 2.6.2, BDB 4.7.25 (Currently in BETA) * Include documentation source (*.rst) in the EGG. * Include processed HTML documentation in the EGG. * Update the external links in documentation, since Oracle changed its web structure. * Some link fixes for external documentation. * Links added in the documentation to Oracle Berkeley DB programmer reference. * Support for "DB->get_transactional()". * Support for "DB_REPMGR_ACKS_ALL_AVAILABLE". 5.0.0: * Support for Berkeley DB 5.0. * Drop support for Python 3.0. * Now you can use TMPDIR env variable to override default test directory ("/tmp"). * Versioning of C API. If you use the code from C, please check the bsddb_api->api_version number against PYBSDDB_API_VERSION macro. * In C code, the bsddb_api->dbsequence_type component is always available, even if the Berkeley DB version used doesn't support sequences. In that case, the component will be NULL. * In C code, "DBSequenceObject_Check()" macro always exists, even if the Berkeley DB version used doesn't suport sequences. In that case, the test macro always returns "false". * For a long time, the API has been accesible via C using "_bsddb.api" or "_pybsddb.api". If you are using Python >=2.7, you acquire access to that API via the new Capsule protocol (see "bsddb.h"). If you use the C API and upgrade to Python 2.7 and up, you must update the access code (see "bsddb.h"). The Capsule protocol is not supported in Python 3.0, but pybsddb 5.0.x doesn't support Python 3.0 anymore. * Capsule support was buggy. The string passed in to PyCapsule_New() must outlive the capsule. (Larry Hastings) * Solve an "Overflow" warning in the testsuite running under python 2.3. * When doing a complete full-matrix test, any warning will be considered an error. 4.8.4: * When doing the full matrix testing with python >=2.6, we activate the deprecation warnings (py3k). * Split dependencies in the Replication testsuite. * Help the Gargabe Collection freeing resources when the replication testsuite is completed. * Import warning when used as stdlib "bsddb" instead of pybsddb project as "bsddb3", when using python >=2.6 and py3k warnings are active. * Old regression: dbshelve objects are iterable again. The bug was introduced in pybsddb 4.7.2. Added relevant testcases. * Patches ported from Python developers: * Memory leaks: #7808 - http://bugs.python.org/issue7808 - Florent Xicluna * Floating point rounding in testcases: #5073 - http://bugs.python.org/issue5073 - Mark Dickinson * Orthograpy: #5341 - http://bugs.python.org/issue5341 * Py3k warnings in Python >=2.6: #7092 - http://bugs.python.org/issue7092 * Correct path for tests: #7269 - http://bugs.python.org/issue7269 - Florent Xicluna * Shebang: benjamin.peterson * Use new Python 2.7 assert()'s: Florent Xicluna * Solve a spurious stdlib warning in python >=2.6 with -3 flags. * Remove "DBIncompleteError", for sure this time. There were traces in "dbtables", in some tests and in the docs. * The DBKeyEmptyError exception raised by the library is not the same DBKeyEmptyError available in the lib. So the raised exception was uncatchable unless you catch DBError. And you can not identify it. * Solved last point, document that DBKeyEmptyError exception derives also from KeyError, just like DBNotFoundError exception. * Update documentation to describe all exceptions provided by this module. 4.8.3: * "bsddb.h" inclusion in PYPI is inconsistent. Solved. * Support for "DB_ENV->mutex_stat()", "DB_ENV->mutex_stat_print()", "DB->stat_print()", "DB_ENV->lock_stat_print()", "DB_ENV->log_stat_print()", "DB_ENV->stat_print()", "DB_ENV->memp_stat()" and "DB_ENV->memp_stat_print()". * Support for "DB_ENV->get_tmp_dir()". * Support for "DB_STAT_SUBSYSTEM", "DB_STAT_MEMP_HASH" flags. * Support for "DB_ENV->set_mp_max_openfd()", "DB_ENV->get_mp_max_openfd()", "DB_ENV->set_mp_max_write()", "DB_ENV->get_mp_max_write()", "DB_ENV->get_mp_mmapsize()". * New DataType: DBLogCursor. If you are using the C api, you could need to recompile your code because the changes in the api interface structure. * Support for "DB_ENV->log_file()", "DB_ENV->log_printf()". * Solve a core dump if something bad happens while trying to create a transaction object. * We protect ourselves of failures in creation of Locks and Sequences objects. * EGG file is a ZIP file again, not a directory. This requires that any program importing the module can write in the ".python-eggs" of its user. * Keeping a cached copy of the database stats is a bad idea if we have several processes working together. We drop all this code. So "len()" will require a database scanning always, not only when there is any write. If you need an accurate and fast "len()", the application must keep that information manually in a database register. 4.8.2: * Support for "DB_OVERWRITE_DUP", "DB_FOREIGN_ABORT", "DB_FOREIGN_CASCADE", "DB_FOREIGN_NULLIFY", "DB_PRINTABLE", "DB_INORDER" flags. * Support for "DB_FOREIGN_CONFLICT" exception. * Support for "DB_ENV->memp_trickle()", "DB_ENV->memp_sync()", "DB_ENV->get_lg_bsize()", "DB_ENV->get_lg_dir()", "DB_ENV->get_lg_filemode()", "DB_ENV->set_lg_filemode()", "DB_ENV->get_lk_detect()", "DB_ENV->get_lg_regionmax()", "DB_ENV->get_lk_max_lockers()", "DB_ENV->set_lk_max_locks()", "DB_ENV->get_lk_max_objects()", "DB_ENV->set_lk_partitions()", "DB_ENV->get_lk_partitions()", "DB_ENV->get_flags()", "DB_ENV->set_cache_max()", "DB_ENV->get_cache_max()", "DB_ENV->set_thread_count()", "DB_ENV->get_thread_count()", "DB_ENV->log_set_config()", "DB_ENV->log_get_config()" functions. * Support for "DB->get_h_ffactor()", "DB->set_h_nelem()", "DB->get_h_nelem()", "DB->get_lorder()", "DB->get_pagesize()", "DB->get_re_pad()", "DB->get_re_len()", "DB->get_re_delim()", "DB->get_flags()", "DB->get_bt_minkey()", "DB->set_priority()", "DB->get_priority()", "DB->set_q_extentsize()", "DB->get_q_extentsize()", "DB->set_re_source()", "DB->get_re_source()" functions. * Unlock the Python GIL when doing "DB_ENV->db_home_get()". This is slower, because the function is very fast so we add overhead, but it is called very infrequently and we do the change for consistency. 4.8.1: * Support for "DB_ENV->mutex_set_align()" and "DB_ENV->mutex_get_align()". * Support for "DB_ENV->mutex_set_increment()" and "DB_ENV->mutex_get_increment()". * Support for "DB_ENV->mutex_set_tas_spins()" and "DB_ENV->mutex_get_tas_spins()". * Support for "DB_ENV->get_encrypt_flags()". * Support for "DB->get_encrypt_flags()". * Support for "DB_ENV->get_shm_key()". * Support for "DB_ENV->get_cachesize()". * Support for "DB->get_cachesize()". * Support for "DB_ENV->get_data_dirs()". * Testsuite compatibility with recent releases of Python 3.0 and 3.1, where cPickle has been removed. * Compatibility with development versions of Python 2.7 and 3.2 (r76123). * For a long time, the API has been accesible via C using "_bsddb.api" or "_pybsddb.api". If you are using Python 3.2 or up, you acquire access to that API via the new Capsule protocol (see "bsddb.h"). If you use the C API and upgrade to Python 3.2 and up, you must update the access code (see "bsddb.h"). 4.8.0: * Support for Berkeley DB 4.8. * Compatibility with Python 3.1. * The "DB_XIDDATASIZE" constant has been renamed to "DB_GID_SIZE". Update your code!. If linked to BDB 4.8, only "DB_GID_SIZE" is defined. If linked to previous BDB versions, we keep "DB_XIDDATASIZE" but define "DB_GID_SIZE" too, to be the same value. So, new code can use the updated constant when used against old BDB releases. * "DB_XA_CREATE" is removed. BDB 4.8 has eliminated XA Resource Manager support. * Drop support for Berkeley DB 4.0. Our reference is Red Hat Enterprise Linux 3, until October 2010. After that, RHEL4 has Python 2.3 and BDB 4.2. * Remove "DBIncompleteError" exception. It was only used in BDB 4.0. * Remove "DB_INCOMPLETE", "DB_CHECKPOINT", "DB_CURLSN". They came from BDB 4.0 too. * RPC is dropped in Berkeley DB 4.8. The bindings still keep the API if you link to previous BDB releases. * In recno/queue databases, "set_re_delim()" and "set_re_pad()" require a byte instead of a unicode char, under Python3. * Support for "DB_ENV->mutex_set_max()" and "DB_ENV->mutex_get_max()". 4.7.6: * Compatibility with Python 3.0.1. * Add support for "DB_ENV->stat()" and "DB_ENV->stat_print()". * Add support for "DB_ENV->rep_set_clockskew()" and "DB_ENV->rep_get_clockskew()". The binding support for base replication is now complete. * "DB.has_key()" used to return 0 or 1. Changed to return True or False instead. Check your code!. * As requested by several users, implement "DB.__contains__()", to allow constructions like "if key in DB" without iterating over the entire database. But, BEWARE, this test is not protected by transactions!. This is the same problem we already have with "DB.has_key()". * Change "DBSequence.init_value()" to "DBSequence.initial_value()", for consistence with Berkeley DB real method name. This could require minimal changes in your code. The documentation was right. Noted by "anan". * Implements "DBCursor->prev_dup()". * Add support for "DB_GET_BOTH_RANGE", "DB_PREV_DUP", and "DB_IGNORE_LEASE" flags. * Export exception "DBRepLeaseExpiredError". * Add support for "DB_PRIORITY_VERY_LOW", "DB_PRIORITY_LOW", "DB_PRIORITY_DEFAULT", "DB_PRIORITY_HIGH", "DB_PRIORITY_VERY_HIGH", and "DB_PRIORITY_UNCHANGED" flags. * Add support for "DBCursor->set_priority()" and "DBCursor->get_priority()". The binding support for cursors is now complete. 4.7.5: * Add support for "DB_EID_INVALID" and "DB_EID_BROADCAST" flags. * Add support for "DB_SEQUENCE->stat_print()". The binding support for "DB_SEQUENCE" is now complete. * Add support for "DB_ENV->txn_stat_print()". * Add support for "DB_ENV->get_timeout()". * Document that "DB_ENV->txn_stat()" accepts a flag. * Unlock the GIL when doing "DB_ENV->set_tx_max()" and "DB_ENV->set_tx_timestamp()". * Add support for "DB_ENV->get_tx_max()". * Add support for "DB_ENV->get_tx_timestamp()". * Add support for "DB_TXN_WAIT" flag. * Add support for "DB_TXN->set_timeout()". * Add support for "DB_TXN->set_name()" and "DB_TXN->get_name()". Under Python 3.0, the name is an Unicode string. The binding support for "DB_TXN" is now complete. * Add support for "DB_REP_PERMANENT", "DB_REP_CONF_NOAUTOINIT", "DB_REP_CONF_DELAYCLIENT", "DB_REP_CONF_BULK", "DB_REP_CONF_NOWAIT", "DB_REP_LEASE_EXPIRED", "DB_REP_CONF_LEASE", "DB_REPMGR_CONF_2SITE_STRICT", "DB_REP_ANYWHERE", "DB_REP_NOBUFFER" and "DB_REP_REREQUEST" flags. 4.7.4: * Under Python 3.0, "bsddb.db.DB_VERSION_STRING", "bsddb.db.__version__" and "bsddb.db.cvsid" must return (unicode) strings instead of bytes. Solved. * Use the new (20081018) trove classifiers in PyPI to identify Python supported versions. * In "DB_ENV->rep_set_timeout()" and "DB_ENV->rep_get_timeout()", support flags "DB_REP_LEASE_TIMEOUT". * In "DB_ENV->rep_set_timeout()" and "DB_ENV->rep_get_timeout()", support flags "DB_REP_HEARTBEAT_MONITOR" and "DB_REP_HEARTBEAT_SEND". These flags are used in the Replication Manager framework, ignored if using Base Replication. * Implements "DB->exists()". * Add support for "DB_IMMUTABLE_KEY" flag. * Add support for "DB_REP_LOCKOUT" exception. * Support returning a list of strings in "associate()" callback. (Kung Phu) * Testsuite and Python 3.0 compatibility for "associate()" returning a list. In particular, in Python 3.0 the list must contain bytes. * Implements "DBEnv->fileid_reset()". (Duncan Findlay) * Implements "DB->compact()". (Gregory P. Smith) Berkeley DB 4.6 implementation is buggy, so we only support this function from Berkeley DB 4.7 and newer. We also support related flags "DB_FREELIST_ONLY" and "DB_FREE_SPACE". 4.7.3: (Python 2.6 release. First release with Python 3.0 support) * "private" is a keyword in C++. (Duncan Grisby) * setup.py should install "bsddb.h". (Duncan Grisby) * "DB_remove" memory corruption & crash. (Duncan Grisby) * Under Python 3.0, you can't use string keys/values, but bytes ones. Print the right error message. * "DB.has_key()" allowed transactions as a positional parameter. We allow, now, transactions as a keyword parameter also, as documented. * Correct "DB.associate()" parameter order in the documentation. * "DB.append()" recognizes "txn" both as a positional and a keyword parameter. * Small fix in "dbshelve" for compatibility with Python 3.0. * A lot of changes in "dbtables" for compatibility with Python 3.0. * Huge work making the testsuite compatible with Python 3.0. * In some cases the C module returned Unicode strings under Python 3.0. It should return "bytes", ALWAYS. Solved. * Remove a dict.has_key() use to silence a warning raised under Python2.6 -3 parameter. Python SVN r65391, Brett Cannon. * Solve some memory leaks - Neal Norwitz * If DBEnv creation fails, library can crash. (Victor Stinner) * Raising exceptions while doing a garbage collection will kill the interpreter. (Victor Stinner) * Crash in "DB.verify()". Noted by solsTiCe d'Hiver. 4.7.2: * Solved a race condition in Replication Manager testcode. * Changing any python code, automatically regenerates the Python3 version. The master version is Python2. * Compatibility with Python 3.0. * Solved a crash when DB handle creation fails. STINNER Victor - http://bugs.python.org/issue3307 * Improve internal error checking, as suggested by Neal Norwitz when reviewing commit 63207 in Python SVN. * Routines without parameters should be defined so, as suggested by Neal Norwitz when reviewing commit 63207 in Python SVN. The resulting code is (marginally) faster, smaller and clearer. * Routines with a simple object parameter are defines so, as suggested by Neal Norwitz when reviewing commit 63207 in Python SVN. The resulting code is (marginally) faster, smaller and clearer. * Routines taking objects as arguments can parse them better, as suggested by Neal Norwitz when reviewing commit 63207 in Python SVN. The resulting code is (marginally) faster, smaller and clearer. * Improve testsuite behaviour under MS Windows. * Use ABC (Abstract Base Classes) under Python 2.6 and 3.0. * Support for "relative imports". * Replication testcode behaves better in heavily loaded machines. 4.7.1: * Workaround a problem with un-initialized threads with the replication callback. * Export "DBRepUnavailError" exception. * Get rid of Berkeley DB 3.3 support. Rationale: http://mailman.jcea.es/pipermail/pybsddb/2008-March/000019.html * Better integration between Python test framework and bsddb3. * Improved Python 3.0 support in the C code. * Iteration over the database, using the legacy interface, now raises a RuntimeError if the database changes while iterating. http://bugs.python.org/issue2669 - gregory.p.smith * Create "set_private()" and "get_private()" methods for DB and DBEnv objects, to allow applications to link an arbitrary object to a DB/DBEnv. Useful for callbacks. * Support some more base replication calls: "DB_ENV->rep_start", "DB_ENV->rep_sync", "DB_ENV->rep_set_config", "DB_ENV->rep_get_config", "DB_ENV->rep_set_limit", "DB_ENV->rep_get_limit", "DB_ENV->rep_set_request", "DB_ENV->rep_get_request". * Support more base replication calls: "DB_ENV->rep_elect", "DB_ENV->rep_set_transport" and "DB_ENV->rep_process_message". Support also related flags. 4.7.0: * Support for Berkeley DB 4.7. * Support "DB_ENV->log_set_config", and related flags. * Complete the Berkeley DB Replication Manager support: "DB_ENV->repmgr_site_list" and related flags. "DB_ENV->repmgr_stat", "DB_ENV->repmgr_stat_print" and related flags. * Solved an old crash when building with debug python. (Neal Norwitz) * Extend the testsuite driver to check also against Python 2.6 (a3). * Support for RPC client service. 4.6.4: * Basic support for Berkeley DB Replication Manager. * Support for a few replication calls, for benefice of Berkeley DB Replication Manager: "DB_ENV->rep_set_priority", "DB_ENV->rep_get_priority", "DB_ENV->rep_set_nsites", "DB_ENV->rep_get_nsites", "DB_ENV->rep_set_timeout", "DB_ENV->rep_get_timeout". * Implemented "DB_ENV->set_event_notify" and related flags. * Export flags related to replication timeouts. * Export "DBRepHandleDeadError" exception. * Implemented "DB_ENV->set_verbose", "DB_ENV->get_verbose" and related flags. * Implemented "DB_ENV->get_lg_max". * Improved performance and coverage of following tests: lock, threaded ConcurrentDataStore, threaded simple locks, threaded transactions. * New exported flags: "DB_LOCK_EXPIRE" and "DB_LOCK_MAXWRITE". 4.6.3: * Be sure all DBEnv/DB paths in the TestSuite are generated in a way compatible with launching the tests in multiple threads/processes. * Move all the "assert" in the TestSuite to the version in the framework. This is very convenient, for example, to generate the final report, or better automation. * Implements "dbenv.log_flush()". * Regression: bug when creating a transaction and its parent is explicitly set to 'None'. * Regression: bug when duplicationg cursors. Solved. * Provide "dbenv.txn_recover()" and "txn.discard()", for fully support recovery of distributed transactions. Any user of this service should use Berkeley DB 4.5 or up. * If a transaction is in "prepare" or "recover" state, we MUST NOT abort it implicitly if the transaction goes out of scope, it is garbaged collected, etc. Better to leak than sorry. * In the previous case, we don't show any warning either. * Export "DB_XIDDATASIZE", for GID of distributed transactions. * If "db_seq_t" and PY_LONG_LONG are not compatible, compiler should show a warning while compiling, and the generated code would be incorrect but safe to use. No crash. Added sanity check in the testunit to verify this is not the case, and the datatypes are 64 bit width in fact. * Solve a compilation warning when including "bsddb.h" in other projects. (George Feinberg) 4.6.2: * Support for MVCC (MultiVersion Concurrency Control). * Support for DB_DSYNC_LOG, DB_DSYNC_DB and DB_OVERWRITE flags. * Move old documentation to ReST format. This is important for several reasons, notably to be able to integrate the documentation "as is" in python official docs (from Python 2.6). * Don't include Berkeley DB documentation. Link to the online version. * DBSequence objects documented. * DBSequence.get_key() didn't check for parameters. Fixed. * If a DB is closed, its children DBSequences will be closed also. * To be consistent with other close methods, you can call "DBSequence.close()" several times without error. * If a Sequence is opened inside a transaction, it will be automatically closed if the transaction is aborted. If the transaction is committed and it is actually a subtransaction, the sequence will be inherited by the parent transaction. * Be sure "db_seq_t" and "long long" are compatible. **Disabled because MS Windows issues to be investigated.** * Documented the already available DBEnv methods: "dbremove", "dbrename", "set_encrypt", "set_timeout", "set_shm_key", "lock_id_free", "set_tx_timestamp", "lsn_reset" and "log_stat". * Completed and documented "DBEnv.txn_stat()". * Completed and documented "DBEnv.lock_stat()". * Documented the already available DB methods: "set_encrypt", "pget". * Completed documentation of DB methods: "associate", "open". * Completed and documented "DB.stat()". * Documented the already available DBCursor methods: "pget" (several flavours). * Completed documentation of DBCursor methods: "consume", "join_item". 4.6.1: (first release from Jesus Cea Avion) * 'egg' (setuptools) support. * Environments, database handles and cursors are maintained in a logical tree. Closing any element of the tree, implicitly closes its children. * Transactions are managed in a logical tree. When aborting transactions, enclosed db handles, cursors and transactions, are closed. If transaction commits, the enclosed db handles are "inherited" by the parent transaction/environment. * Solved a bug when a DBEnv goes out of scope without closing first. * Add transactions to the management of closing of nested objects. (not completed yet!) * Fix memory leaks. * Previous versions were inconsistent when key or value were "" (the null string), according to opening the database in thread safe mode or not. In one case the lib gives "" and in the other it gives None. 4.6.0: * Adds support for compiling and linking with BerkeleyDB 4.6.21. * Fixes a double free bug with DBCursor.get and friends. Based on submitted pybsddb patch #1708868. (jjjhhhll) * Adds a basic C API to the module so that other extensions or third party modules can access types directly. Based on pybsddb patch #1551895. (Duncan Grisby) * bsddb.dbshelve now uses the most recent cPickle protocol, based on pybsddb patch #1551443. (w_barnes) * Fix the bsddb.dbshelve.DBShelf append method to work for RECNO dbs. * Fix Bug #477182 - Load the database flags at database open time so that opening a database previously created with the DB_DUP or DB_DUPSORT flag set will keep the proper behavior on subsequent opens. Specifically dictionary assignment to a DB object. It will now replace all values for a given key when the database allows duplicate values. DB users should use DB.put(k, v) when they want to store duplicates; not DB[k] = v. This only works with BerkeleyDB >= 4.2. * Add the DBEnv.lock_id_free method. * Removes any remnants of support for Python older than 2.1. * Removes any remnants of support for BerkeleyDB 3.2. 4.5.0: * Adds supports for compiling and linking with BerkeleyDB 4.5 * Python Bug #1599782: Fix segfault on bsddb.db.DB().type() due to releasing the GIL when it shouldn't. (nnorowitz) * Fixes a bug with bsddb.DB.stat where the flags and txn keyword arguments are transposed. * change test cases to use tempfile.gettempdir() 4.4.5: * pybsddb Bug #1527939: bsddb module DBEnv dbremove and dbrename methods now allow their database parameter to be None as the sleepycat API allows. 4.4.4: * fix DBCursor.pget() bug with keyword argument names when no data= is supplied [SF pybsddb bug #1477863] * add support for DBSequence objects [patch #1466734] * support DBEnv.log_stat() method on BerkeleyDB >= 4.0 [patch #1494885] * support DBEnv.lsn_reset() method on BerkeleyDB >= 4.4 [patch #1494902] * add DB_ARCH_REMOVE flag and fix DBEnv.log_archive() to accept it without potentially following an uninitialized pointer. 4.4.3: * fix DBEnv.set_tx_timestamp to not crash on Win64 platforms (thomas.wouters) * tons of memory leak fixes all over the code (thomas.wouters) * fixes ability to unpickle DBError (and children) exceptions 4.4.2: * Wrap the DBEnv.set_tx_timeout method * fix problem when DBEnv deleted before Txn sf bug #1413192 (Neal Norwitz) 4.4.1: * sf.net patch 1407992 - fixes associate tests on BerkeleyDB 3.3 thru 4.1 (contributed by Neal Norwitz) 4.4.0: * Added support for compiling and linking with BerkeleyDB 4.4.20. 4.3.3: * NOTICE: set_bt_compare() callback function arguments CHANGED to only require two arguments (left, right) rather than (db, left, right). * DB.associate() would crash when a DBError occurred. fixed. [pybsddb SF bug id 1215432]. 4.3.2: * the has_key() method was not raising a DBError when a database error had occurred. [SF patch id 1212590] * added a wrapper for the DBEnv.set_lg_regionmax method [SF patch id 1212590] * DBKeyEmptyError now derives from KeyError just like DBNotFoundError. * internally everywhere DB_NOTFOUND was checked for has been updated to also check for DB_KEYEMPTY. This fixes the semantics of a couple operations on recno and queue databases to be more intuitive and results in less unexpected DBKeyEmptyError exceptions being raised. 4.3.1: * Added support for DB.set_bt_compare() method to use a user supplied python comparison function taking (db, left, right) args as the database's B-Tree comparison function. 4.3.0: * Added support for building properly against BerkeleyDB 4.3.21. * fixed bug introduced in 4.2.8 that prevent the module from compiling against BerkeleyDB 3.2 (which doesn't support pget). * setup.py was cleaned up a bit to search for and find the latest version of the correct combo of db.h and libdb. 4.2.9: * DB keys() values() and items() methods were ignoring their optional txn parameter. This would lead to deadlocks in applications needing those to be transaction protected. 4.2.8: * Adds support for DB and DBCursor pget methods. Based on a patch submitted to the mailing list by Ian Ward * Added weakref support to all bsddb.db objects. * Make DBTxn objects automatically call abort() in their destructor if not yet finalized and raise a RuntimeWarning to that effect. 4.2.7: * fix an error with the legacy interface relying on the DB_TRUNCATE flag that changed behaviour to not work in a locking environment with BerkeleyDB 4.2.52. [SF bug id 897820] * fixed memory leaks in DB.get, DBC.set_range and potentially several other methods that would occur primarily when using queue | recno format databases with integer keys. [SF patch id 967763] 4.2.6: * the DB.has_key method was not honoring its txn parameter to perform its lookup within the specified (optional) transaction. fixed. [SF bug id 914019] 4.2.5: * Fixed a bug in the compatibility interface set_location() method where it would not properly search to the next nearest key when used on BTree databases. [SF bug id 788421] * Fixed a bug in the compatibility interface set_location() method where it could crash when looking up keys in a hash or recno format database due to an incorrect free(). 4.2.4: * changed DB and DBEnv set_get_returns_none() default from 1 to 2. * cleaned up compatibility iterator interface. 4.2.3: * the legacy compatibility dict-like interface now support iterators and generators and allows multithreaded access to the database. * fixed a tuple memory leak when raising "object has been closed" exceptions for DB, DBEnv and DBCursor objects. I doubt much previous code triggered this. * use of a closed DBCursor now raises a DBCursorClosedError exception subclass of DBError rather than a boring old DBError. 4.2.2: * added DBCursor.get_current_size() method to return the length in bytes of the value pointed to by the cursor without reading the actual data. 4.2.1: * Standalone pybsddb builds now use a _pybsddb dynamic/shared library rather than _bsddb. This allows for pybsddb to be built, installed and used on python >= 2.3 which includes an older version of pybsddb as its bsddb library. 4.2.0: * Can now compile and link with BerkeleyDB 4.2.x (when its released). * the legacy bsddb module supports the iterator interface on python 2.3. 4.1.x: * Support the DBEnv.set_shm_key() method. * Fixed setup.py include/{db4,db3} header file searching (SF bug #789740). 4.1.6: * Extended DB & DBEnv set_get_returns_none functionality to take a "level" instead of a boolean flag. The boolean 0 and 1 values still have the same effect. A value of 2 extends the "return None instead of raising an exception" behaviour to the DBCursor set methods. This will become the default behaviour in pybsddb 4.2. * Updated documentation for set_get_returns_none. Regenerated the stale html docs from the text documentation. * Fixed a typo in DBCursor.join_item method that made it crash instead of returning a value. Obviously nobody uses it. Wrote a test case for join and join_item. * Added the dbobj wrapper for DBEnv set_timeout method. * Updated README.txt 4.1.5: * Added the DBEnv.set_timeout method. 4.1.4: * rebuilt the windows 4.1.3 package, the original package was corrupt due to bad ram on my build host. 4.1.3 - 2003-02-02: * code cleanup to use python 2.x features in .py files * the standalone pybsddb distribution will install a module called bsddb3 while the module included with python >= 2.3 will be known as bsddb. 4.1.2 - 2003-01-17: * Shared all .py and .c source with the Python project. * Fixed DBTxn objects to raise an exception if they are used after the underlying DB_TXN handle becomes invalid. (rather than potentially causing a segfault) * Fixed module to work when compiled against a python without thread support. * Do not attempt to double-close DB cursor's whos underlying DB has already been closed (fixes a segfault). * Close DB objects when DB.open fails to prevent an exception about databases still being open when calling DBEnv.close. 4.1.1 - 2002-12-20: * Fixed a memory leak when raising exceptions from the database library. Debugged and fixed by Josh Hoyt . Thanks! (sourceforge patch 656517) 4.1.0 - 2002-12-13: * Updated our version number to track the latest BerkeleyDB interface version that we support. * Simplified the build and test process. Now you should just be able to say "python setup.py build" and "python setup.py install". Also added a nice test.py harness. Do "python test.py -h" for details. * The windows binary is build against BerkeleyDB 4.1.24 with current eight patches issued by Sleepycat applied. * REMINDER: BerkeleyDB 4.1 requires code changes if you use database transactions. See the upgrade docs on http://www.sleepycat.com/. 3.4.3 - 2002-10-18: * added support for BerkeleyDB 4.1: DB.open and DB.associate will now accept a txn keyword argument when using BerkeleyDB 4.1. DBEnv.dbremove, DBEnv.dbrename, DBEnv.set_encrypt and DB.set_encrypt methods have been exposed for 4.1. 3.4.2 - 2002-08-14: * dbtables.py: serious bug fix. The Select, Modify and Delete methods could all act upon rows that did not match all of the conditions. (bug # 590449) A test case was added. * dbutils.py: updated DeadlockWrap * test_threads.py: fixed to use dbutils.DeadlockWrap to catch and avoid DBLockDeadlockError exceptions during simple threading tests. 3.4.1: * fixed typo cut and paste bugs in test_dbsimple.py and test_threads.py * fixed bug with cursors where calling DBCursor.close() would cause the object's destructor __del__() method to raise an exception when it was called by the gc. * fixed a bug in associated callbacks that could cause a null pointer dereference when python threading had not yet been initialized. 3.4.0: * many bugfixes, its been a long while since a new package was created. * ChangeLog started. bsddb3-6.2.7/Modules/0000775000175000017500000000000013617133045014132 5ustar jceajcea00000000000000bsddb3-6.2.7/Modules/bsddb.h0000664000175000017500000002440113617105361015362 0ustar jceajcea00000000000000/*---------------------------------------------------------------------- Copyright (c) 1999-2001, Digital Creations, Fredericksburg, VA, USA and Andrew Kuchling. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: o Redistributions of source code must retain the above copyright notice, this list of conditions, and the disclaimer that follows. o Redistributions in binary form must reproduce the above copyright notice, this list of conditions, and the following disclaimer in the documentation and/or other materials provided with the distribution. o Neither the name of Digital Creations nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY DIGITAL CREATIONS AND CONTRIBUTORS *AS IS* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL DIGITAL CREATIONS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ------------------------------------------------------------------------*/ /* * Handwritten code to wrap version 3.x of the Berkeley DB library, * written to replace a SWIG-generated file. It has since been updated * to compile with Berkeley DB versions 3.2 through 4.2. * * This module was started by Andrew Kuchling to remove the dependency * on SWIG in a package by Gregory P. Smith who based his work on a * similar package by Robin Dunn which wrapped * Berkeley DB 2.7.x. * * Development of this module then returned full circle back to Robin Dunn * who worked on behalf of Digital Creations to complete the wrapping of * the DB 3.x API and to build a solid unit test suite. Robin has * since gone onto other projects (wxPython). * * Gregory P. Smith is once again the maintainer. * * Since January 2008, new maintainer is Jesus Cea . * Jesus Cea licenses this code to PSF under a Contributor Agreement. * * Use the pybsddb@jcea.es mailing list for all questions. * Things can change faster than the header of this file is updated. * * https://www.jcea.es/programacion/pybsddb.htm * * This module contains 8 types: * * DB (Database) * DBCursor (Database Cursor) * DBEnv (database environment) * DBTxn (An explicit database transaction) * DBLock (A lock handle) * DBSequence (Sequence) * DBSite (Site) * DBLogCursor (Log Cursor) * */ /* --------------------------------------------------------------------- */ /* * Portions of this module, associated unit tests and build scripts are the * result of a contract with The Written Word (http://thewrittenword.com/) * Many thanks go out to them for causing me to raise the bar on quality and * functionality, resulting in a better bsddb3 package for all of us to use. * * --Robin */ /* --------------------------------------------------------------------- */ /* * Work to split it up into a separate header and to add a C API was * contributed by Duncan Grisby . See here: * http://sourceforge.net/tracker/index.php?func=detail&aid=1551895&group_id=13900&atid=313900 */ /* --------------------------------------------------------------------- */ #ifndef _BSDDB_H_ #define _BSDDB_H_ #include /* 40 = 4.0, 33 = 3.3; this will break if the minor revision is > 9 */ #define DBVER (DB_VERSION_MAJOR * 10 + DB_VERSION_MINOR) #if DB_VERSION_MINOR > 9 #error "eek! DBVER can't handle minor versions > 9" #endif #define PY_BSDDB_VERSION "6.2.7" /* Python object definitions */ struct behaviourFlags { /* What is the default behaviour when DB->get or DBCursor->get returns a DB_NOTFOUND || DB_KEYEMPTY error? Return None or raise an exception? */ unsigned int getReturnsNone : 1; /* What is the default behaviour for DBCursor.set* methods when DBCursor->get * returns a DB_NOTFOUND || DB_KEYEMPTY error? Return None or raise? */ unsigned int cursorSetReturnsNone : 1; }; struct DBObject; /* Forward declaration */ struct DBCursorObject; /* Forward declaration */ struct DBLogCursorObject; /* Forward declaration */ struct DBTxnObject; /* Forward declaration */ struct DBSequenceObject; /* Forward declaration */ #if (DBVER >= 53) struct DBSiteObject; /* Forward declaration */ #endif typedef struct { PyObject_HEAD DB_ENV* db_env; u_int32_t flags; /* saved flags from open() */ int closed; struct behaviourFlags moduleFlags; PyObject* event_notifyCallback; struct DBObject *children_dbs; struct DBTxnObject *children_txns; struct DBLogCursorObject *children_logcursors; #if (DBVER >= 53) struct DBSiteObject *children_sites; #endif PyObject *private_obj; PyObject *rep_transport; PyObject *in_weakreflist; /* List of weak references */ } DBEnvObject; typedef struct DBObject { PyObject_HEAD DB* db; DBEnvObject* myenvobj; /* PyObject containing the DB_ENV */ u_int32_t flags; /* saved flags from open() */ u_int32_t setflags; /* saved flags from set_flags() */ struct behaviourFlags moduleFlags; struct DBTxnObject *txn; struct DBCursorObject *children_cursors; struct DBSequenceObject *children_sequences; struct DBObject **sibling_prev_p; struct DBObject *sibling_next; struct DBObject **sibling_prev_p_txn; struct DBObject *sibling_next_txn; PyObject* associateCallback; PyObject* btCompareCallback; PyObject* dupCompareCallback; int primaryDBType; PyObject *private_obj; PyObject *in_weakreflist; /* List of weak references */ } DBObject; typedef struct DBCursorObject { PyObject_HEAD DBC* dbc; struct DBCursorObject **sibling_prev_p; struct DBCursorObject *sibling_next; struct DBCursorObject **sibling_prev_p_txn; struct DBCursorObject *sibling_next_txn; DBObject* mydb; struct DBTxnObject *txn; PyObject *in_weakreflist; /* List of weak references */ } DBCursorObject; typedef struct DBTxnObject { PyObject_HEAD DB_TXN* txn; DBEnvObject* env; int flag_prepare; struct DBTxnObject *parent_txn; struct DBTxnObject **sibling_prev_p; struct DBTxnObject *sibling_next; struct DBTxnObject *children_txns; struct DBObject *children_dbs; struct DBSequenceObject *children_sequences; struct DBCursorObject *children_cursors; PyObject *in_weakreflist; /* List of weak references */ } DBTxnObject; typedef struct DBLogCursorObject { PyObject_HEAD DB_LOGC* logc; DBEnvObject* env; struct DBLogCursorObject **sibling_prev_p; struct DBLogCursorObject *sibling_next; PyObject *in_weakreflist; /* List of weak references */ } DBLogCursorObject; #if (DBVER >= 53) typedef struct DBSiteObject { PyObject_HEAD DB_SITE *site; DBEnvObject *env; struct DBSiteObject **sibling_prev_p; struct DBSiteObject *sibling_next; PyObject *in_weakreflist; /* List of weak references */ } DBSiteObject; #endif typedef struct { PyObject_HEAD DB_LOCK lock; int lock_initialized; /* Signal if we actually have a lock */ PyObject *in_weakreflist; /* List of weak references */ } DBLockObject; typedef struct DBSequenceObject { PyObject_HEAD DB_SEQUENCE* sequence; DBObject* mydb; struct DBTxnObject *txn; struct DBSequenceObject **sibling_prev_p; struct DBSequenceObject *sibling_next; struct DBSequenceObject **sibling_prev_p_txn; struct DBSequenceObject *sibling_next_txn; PyObject *in_weakreflist; /* List of weak references */ } DBSequenceObject; /* API structure for use by C code */ /* To access the structure from an external module, use code like the following (error checking missed out for clarity): // If you are using Python before 2.7: BSDDB_api* bsddb_api; PyObject* mod; PyObject* cobj; mod = PyImport_ImportModule("bsddb3._pybsddb"); cobj = PyObject_GetAttrString(mod, "api"); bsddb_api = (BSDDB_api*)PyCObject_AsVoidPtr(cobj); Py_DECREF(cobj); Py_DECREF(mod); // If you are using Python 2.7 or up: (except Python 3.0, unsupported) BSDDB_api* bsddb_api; bsddb_api = (void **)PyCapsule_Import("bsddb3._pybsddb.api", 1); Check "api_version" number before trying to use the API. The structure's members must not be changed. */ #define PYBSDDB_API_VERSION 1 typedef struct { unsigned int api_version; /* Type objects */ PyTypeObject* db_type; PyTypeObject* dbcursor_type; PyTypeObject* dblogcursor_type; PyTypeObject* dbenv_type; PyTypeObject* dbtxn_type; PyTypeObject* dblock_type; PyTypeObject* dbsequence_type; /* Functions */ int (*makeDBError)(int err); } BSDDB_api; #ifndef COMPILING_BSDDB_C /* If not inside _bsddb.c, define type check macros that use the api structure. The calling code must have a value named bsddb_api pointing to the api structure. */ #define DBObject_Check(v) ((v)->ob_type == bsddb_api->db_type) #define DBCursorObject_Check(v) ((v)->ob_type == bsddb_api->dbcursor_type) #define DBEnvObject_Check(v) ((v)->ob_type == bsddb_api->dbenv_type) #define DBTxnObject_Check(v) ((v)->ob_type == bsddb_api->dbtxn_type) #define DBLockObject_Check(v) ((v)->ob_type == bsddb_api->dblock_type) #define DBSequenceObject_Check(v) \ ((bsddb_api->dbsequence_type) && \ ((v)->ob_type == bsddb_api->dbsequence_type)) #endif /* COMPILING_BSDDB_C */ #endif /* _BSDDB_H_ */ bsddb3-6.2.7/Modules/_bsddb.c0000644000175000017500000101754613617113056015527 0ustar jceajcea00000000000000/*---------------------------------------------------------------------- Copyright (c) 1999-2001, Digital Creations, Fredericksburg, VA, USA and Andrew Kuchling. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: o Redistributions of source code must retain the above copyright notice, this list of conditions, and the disclaimer that follows. o Redistributions in binary form must reproduce the above copyright notice, this list of conditions, and the following disclaimer in the documentation and/or other materials provided with the distribution. o Neither the name of Digital Creations nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY DIGITAL CREATIONS AND CONTRIBUTORS *AS IS* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL DIGITAL CREATIONS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ------------------------------------------------------------------------*/ /* * Handwritten code to wrap version 3.x of the Berkeley DB library, * written to replace a SWIG-generated file. It has since been updated * to compile with Berkeley DB versions 3.2 through 4.2. * * This module was started by Andrew Kuchling to remove the dependency * on SWIG in a package by Gregory P. Smith who based his work on a * similar package by Robin Dunn which wrapped * Berkeley DB 2.7.x. * * Development of this module then returned full circle back to Robin Dunn * who worked on behalf of Digital Creations to complete the wrapping of * the DB 3.x API and to build a solid unit test suite. Robin has * since gone onto other projects (wxPython). * * Gregory P. Smith was once again the maintainer. * * Since January 2008, new maintainer is Jesus Cea . * Jesus Cea licenses this code to PSF under a Contributor Agreement. * * Use the pybsddb@jcea.es mailing list for all questions. * Things can change faster than the header of this file is updated. * * https://www.jcea.es/programacion/pybsddb.htm * * This module contains 8 types: * * DB (Database) * DBCursor (Database Cursor) * DBEnv (database environment) * DBTxn (An explicit database transaction) * DBLock (A lock handle) * DBSequence (Sequence) * DBSite (Site) * DBLogCursor (Log Cursor) * */ /* --------------------------------------------------------------------- */ /* * Portions of this module, associated unit tests and build scripts are the * result of a contract with The Written Word (http://thewrittenword.com/) * Many thanks go out to them for causing me to raise the bar on quality and * functionality, resulting in a better bsddb3 package for all of us to use. * * --Robin */ /* --------------------------------------------------------------------- */ #include /* for offsetof() */ /* * https://python.readthedocs.io/en/stable/c-api/arg.html#strings-and-buffers */ #define PY_SSIZE_T_CLEAN #include #define COMPILING_BSDDB_C #include "bsddb.h" #undef COMPILING_BSDDB_C /* --------------------------------------------------------------------- */ /* Various macro definitions */ #if (PY_VERSION_HEX >= 0x03000000) #define NUMBER_Check PyLong_Check #define NUMBER_AsLong PyLong_AsLong #define NUMBER_FromLong PyLong_FromLong #define NUMBER_FromUnsignedLong PyLong_FromUnsignedLong #else #define NUMBER_Check PyInt_Check #define NUMBER_AsLong PyInt_AsLong #define NUMBER_FromLong PyInt_FromLong #define NUMBER_FromUnsignedLong PyInt_FromSize_t #endif #ifdef WITH_THREAD /* These are for when calling Python --> C */ #define MYDB_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS; #define MYDB_END_ALLOW_THREADS Py_END_ALLOW_THREADS; /* and these are for calling C --> Python */ #define MYDB_BEGIN_BLOCK_THREADS \ PyGILState_STATE __savestate = PyGILState_Ensure(); #define MYDB_END_BLOCK_THREADS \ PyGILState_Release(__savestate); #else /* Compiled without threads - avoid all this cruft */ #define MYDB_BEGIN_ALLOW_THREADS #define MYDB_END_ALLOW_THREADS #define MYDB_BEGIN_BLOCK_THREADS #define MYDB_END_BLOCK_THREADS #endif /* --------------------------------------------------------------------- */ /* Exceptions */ static PyObject* DBError; /* Base class, all others derive from this */ static PyObject* DBCursorClosedError; /* raised when trying to use a closed cursor object */ static PyObject* DBKeyEmptyError; /* DB_KEYEMPTY: also derives from KeyError */ static PyObject* DBKeyExistError; /* DB_KEYEXIST */ static PyObject* DBLockDeadlockError; /* DB_LOCK_DEADLOCK */ static PyObject* DBLockNotGrantedError; /* DB_LOCK_NOTGRANTED */ static PyObject* DBNotFoundError; /* DB_NOTFOUND: also derives from KeyError */ static PyObject* DBOldVersionError; /* DB_OLD_VERSION */ static PyObject* DBRunRecoveryError; /* DB_RUNRECOVERY */ static PyObject* DBVerifyBadError; /* DB_VERIFY_BAD */ static PyObject* DBNoServerError; /* DB_NOSERVER */ #if (DBVER < 53) static PyObject* DBNoServerHomeError; /* DB_NOSERVER_HOME */ static PyObject* DBNoServerIDError; /* DB_NOSERVER_ID */ #endif static PyObject* DBPageNotFoundError; /* DB_PAGE_NOTFOUND */ static PyObject* DBSecondaryBadError; /* DB_SECONDARY_BAD */ static PyObject* DBInvalidArgError; /* EINVAL */ static PyObject* DBAccessError; /* EACCES */ static PyObject* DBNoSpaceError; /* ENOSPC */ static PyObject* DBNoMemoryError; /* DB_BUFFER_SMALL */ static PyObject* DBAgainError; /* EAGAIN */ static PyObject* DBBusyError; /* EBUSY */ static PyObject* DBFileExistsError; /* EEXIST */ static PyObject* DBNoSuchFileError; /* ENOENT */ static PyObject* DBPermissionsError; /* EPERM */ static PyObject* DBRepHandleDeadError; /* DB_REP_HANDLE_DEAD */ static PyObject* DBRepLockoutError; /* DB_REP_LOCKOUT */ static PyObject* DBRepLeaseExpiredError; /* DB_REP_LEASE_EXPIRED */ static PyObject* DBForeignConflictError; /* DB_FOREIGN_CONFLICT */ static PyObject* DBRepUnavailError; /* DB_REP_UNAVAIL */ #if (DBVER < 48) #define DB_GID_SIZE DB_XIDDATASIZE #endif /* --------------------------------------------------------------------- */ /* Structure definitions */ /* Defaults for moduleFlags in DBEnvObject and DBObject. */ #define DEFAULT_GET_RETURNS_NONE 1 #define DEFAULT_CURSOR_SET_RETURNS_NONE 1 /* See comment in Python 2.6 "object.h" */ #ifndef staticforward #define staticforward static #endif #ifndef statichere #define statichere static #endif staticforward PyTypeObject DB_Type, DBCursor_Type, DBEnv_Type, DBTxn_Type, DBLock_Type, DBLogCursor_Type; staticforward PyTypeObject DBSequence_Type; #if (DBVER >= 53) staticforward PyTypeObject DBSite_Type; #endif #define DBObject_Check(v) (Py_TYPE(v) == &DB_Type) #define DBCursorObject_Check(v) (Py_TYPE(v) == &DBCursor_Type) #define DBLogCursorObject_Check(v) (Py_TYPE(v) == &DBLogCursor_Type) #define DBEnvObject_Check(v) (Py_TYPE(v) == &DBEnv_Type) #define DBTxnObject_Check(v) (Py_TYPE(v) == &DBTxn_Type) #define DBLockObject_Check(v) (Py_TYPE(v) == &DBLock_Type) #define DBSequenceObject_Check(v) (Py_TYPE(v) == &DBSequence_Type) #if (DBVER >= 53) #define DBSiteObject_Check(v) (Py_TYPE(v) == &DBSite_Type) #endif #define _DBC_close(dbc) dbc->close(dbc) #define _DBC_count(dbc,a,b) dbc->count(dbc,a,b) #define _DBC_del(dbc,a) dbc->del(dbc,a) #define _DBC_dup(dbc,a,b) dbc->dup(dbc,a,b) #define _DBC_get(dbc,a,b,c) dbc->get(dbc,a,b,c) #define _DBC_pget(dbc,a,b,c,d) dbc->pget(dbc,a,b,c,d) #define _DBC_put(dbc,a,b,c) dbc->put(dbc,a,b,c) /* --------------------------------------------------------------------- */ /* Utility macros and functions */ #define INSERT_IN_DOUBLE_LINKED_LIST(backlink,object) \ { \ object->sibling_next=backlink; \ object->sibling_prev_p=&(backlink); \ backlink=object; \ if (object->sibling_next) { \ object->sibling_next->sibling_prev_p=&(object->sibling_next); \ } \ } #define EXTRACT_FROM_DOUBLE_LINKED_LIST(object) \ { \ if (object->sibling_next) { \ object->sibling_next->sibling_prev_p=object->sibling_prev_p; \ } \ *(object->sibling_prev_p)=object->sibling_next; \ } #define EXTRACT_FROM_DOUBLE_LINKED_LIST_MAYBE_NULL(object) \ { \ if (object->sibling_next) { \ object->sibling_next->sibling_prev_p=object->sibling_prev_p; \ } \ if (object->sibling_prev_p) { \ *(object->sibling_prev_p)=object->sibling_next; \ } \ } #define INSERT_IN_DOUBLE_LINKED_LIST_TXN(backlink,object) \ { \ object->sibling_next_txn=backlink; \ object->sibling_prev_p_txn=&(backlink); \ backlink=object; \ if (object->sibling_next_txn) { \ object->sibling_next_txn->sibling_prev_p_txn= \ &(object->sibling_next_txn); \ } \ } #define EXTRACT_FROM_DOUBLE_LINKED_LIST_TXN(object) \ { \ if (object->sibling_next_txn) { \ object->sibling_next_txn->sibling_prev_p_txn= \ object->sibling_prev_p_txn; \ } \ *(object->sibling_prev_p_txn)=object->sibling_next_txn; \ } #define RETURN_IF_ERR() \ if (makeDBError(err)) { \ return NULL; \ } #define RETURN_NONE() Py_INCREF(Py_None); return Py_None; #define _CHECK_OBJECT_NOT_CLOSED(nonNull, pyErrObj, name) \ if ((nonNull) == NULL) { \ PyObject *errTuple = NULL; \ errTuple = Py_BuildValue("(is)", 0, #name " object has been closed"); \ if (errTuple) { \ PyErr_SetObject((pyErrObj), errTuple); \ Py_DECREF(errTuple); \ } \ return NULL; \ } #define CHECK_DB_NOT_CLOSED(dbobj) \ _CHECK_OBJECT_NOT_CLOSED(dbobj->db, DBError, DB) #define CHECK_ENV_NOT_CLOSED(env) \ _CHECK_OBJECT_NOT_CLOSED(env->db_env, DBError, DBEnv) #define CHECK_CURSOR_NOT_CLOSED(curs) \ _CHECK_OBJECT_NOT_CLOSED(curs->dbc, DBCursorClosedError, DBCursor) #define CHECK_LOGCURSOR_NOT_CLOSED(logcurs) \ _CHECK_OBJECT_NOT_CLOSED(logcurs->logc, DBCursorClosedError, DBLogCursor) #define CHECK_SEQUENCE_NOT_CLOSED(curs) \ _CHECK_OBJECT_NOT_CLOSED(curs->sequence, DBError, DBSequence) #if (DBVER >= 53) #define CHECK_SITE_NOT_CLOSED(db_site) \ _CHECK_OBJECT_NOT_CLOSED(db_site->site, DBError, DBSite) #endif #define CHECK_DBFLAG(mydb, flag) (((mydb)->flags & (flag)) || \ (((mydb)->myenvobj != NULL) && ((mydb)->myenvobj->flags & (flag)))) #define CLEAR_DBT(dbt) (memset(&(dbt), 0, sizeof(dbt))) #define FREE_DBT(dbt) if ((dbt.flags & (DB_DBT_MALLOC|DB_DBT_REALLOC)) && \ dbt.data != NULL) { free(dbt.data); dbt.data = NULL; } static int makeDBError(int err); /* Return the access method type of the DBObject */ static int _DB_get_type(DBObject* self) { DBTYPE type; int err; err = self->db->get_type(self->db, &type); if (makeDBError(err)) { return -1; } return type; } /* Create a DBT structure (containing key and data values) from Python strings. Returns 1 on success, 0 on an error. */ static int make_dbt(PyObject* obj, DBT* dbt) { Py_ssize_t size=0; CLEAR_DBT(*dbt); if (obj == Py_None) { /* no need to do anything, the structure has already been zeroed */ } else if (!PyArg_Parse(obj, "s#", &dbt->data, &size)) { PyErr_SetString(PyExc_TypeError, #if (PY_VERSION_HEX < 0x03000000) "Data values must be of type string or None."); #else "Data values must be of type bytes or None."); #endif return 0; } dbt->size = size; return 1; } /* Recno and Queue DBs can have integer keys. This function figures out what's been given, verifies that it's allowed, and then makes the DBT. Caller MUST call FREE_DBT(key) when done. */ static int make_key_dbt(DBObject* self, PyObject* keyobj, DBT* key, int* pflags) { db_recno_t recno; int type; CLEAR_DBT(*key); if (keyobj == Py_None) { type = _DB_get_type(self); if (type == -1) return 0; if (type == DB_RECNO || type == DB_QUEUE) { PyErr_SetString( PyExc_TypeError, "None keys not allowed for Recno and Queue DB's"); return 0; } /* no need to do anything, the structure has already been zeroed */ } else if (PyBytes_Check(keyobj)) { /* verify access method type */ type = _DB_get_type(self); if (type == -1) return 0; if (type == DB_RECNO || type == DB_QUEUE) { PyErr_SetString( PyExc_TypeError, #if (PY_VERSION_HEX < 0x03000000) "String keys not allowed for Recno and Queue DB's"); #else "Bytes keys not allowed for Recno and Queue DB's"); #endif return 0; } /* * NOTE(gps): I don't like doing a data copy here, it seems * wasteful. But without a clean way to tell FREE_DBT if it * should free key->data or not we have to. Other places in * the code check for DB_THREAD and forceably set DBT_MALLOC * when we otherwise would leave flags 0 to indicate that. */ key->data = malloc(PyBytes_GET_SIZE(keyobj)); if (key->data == NULL) { PyErr_SetString(PyExc_MemoryError, "Key memory allocation failed"); return 0; } memcpy(key->data, PyBytes_AS_STRING(keyobj), PyBytes_GET_SIZE(keyobj)); key->flags = DB_DBT_REALLOC; key->size = PyBytes_GET_SIZE(keyobj); } else if (NUMBER_Check(keyobj)) { /* verify access method type */ type = _DB_get_type(self); if (type == -1) return 0; if (type == DB_BTREE && pflags != NULL) { /* if BTREE then an Integer key is allowed with the * DB_SET_RECNO flag */ *pflags |= DB_SET_RECNO; } else if (type != DB_RECNO && type != DB_QUEUE) { PyErr_SetString( PyExc_TypeError, "Integer keys only allowed for Recno and Queue DB's"); return 0; } /* Make a key out of the requested recno, use allocated space so DB * will be able to realloc room for the real key if needed. */ recno = NUMBER_AsLong(keyobj); key->data = malloc(sizeof(db_recno_t)); if (key->data == NULL) { PyErr_SetString(PyExc_MemoryError, "Key memory allocation failed"); return 0; } key->ulen = key->size = sizeof(db_recno_t); memcpy(key->data, &recno, sizeof(db_recno_t)); key->flags = DB_DBT_REALLOC; } else { PyErr_Format(PyExc_TypeError, #if (PY_VERSION_HEX < 0x03000000) "String or Integer object expected for key, %s found", #else "Bytes or Integer object expected for key, %s found", #endif Py_TYPE(keyobj)->tp_name); return 0; } return 1; } /* Add partial record access to an existing DBT data struct. If dlen and doff are set, then the DB_DBT_PARTIAL flag will be set and the data storage/retrieval will be done using dlen and doff. */ static int add_partial_dbt(DBT* d, int dlen, int doff) { /* if neither were set we do nothing (-1 is the default value) */ if ((dlen == -1) && (doff == -1)) { return 1; } if ((dlen < 0) || (doff < 0)) { PyErr_SetString(PyExc_TypeError, "dlen and doff must both be >= 0"); return 0; } d->flags = d->flags | DB_DBT_PARTIAL; d->dlen = (unsigned int) dlen; d->doff = (unsigned int) doff; return 1; } /* a safe strcpy() without the zeroing behaviour and semantics of strncpy. */ /* TODO: make this use the native libc strlcpy() when available (BSD) */ unsigned int our_strlcpy(char* dest, const char* src, unsigned int n) { unsigned int srclen, copylen; srclen = strlen(src); if (n <= 0) return srclen; copylen = (srclen > n-1) ? n-1 : srclen; /* populate dest[0] thru dest[copylen-1] */ memcpy(dest, src, copylen); /* guarantee null termination */ dest[copylen] = 0; return srclen; } /* Callback used to save away more information about errors from the DB * library. */ static char _db_errmsg[1024]; static void _db_errorCallback(const DB_ENV *db_env, const char* prefix, const char* msg) { our_strlcpy(_db_errmsg, msg, sizeof(_db_errmsg)); } /* ** We need these functions because some results ** are undefined if pointer is NULL. Some other ** give None instead of "". ** ** This functions are static and will be ** -I hope- inlined. */ static const char *DummyString = "This string is a simple placeholder"; static PyObject *Build_PyString(const char *p,int s) { if (!p) { p=DummyString; assert(s==0); } return PyBytes_FromStringAndSize(p,s); } static PyObject *BuildValue_S(const void *p,int s) { if (!p) { p=DummyString; assert(s==0); } return PyBytes_FromStringAndSize(p, s); } static PyObject *BuildValue_SS(const void *p1,int s1,const void *p2,int s2) { PyObject *a, *b, *r; if (!p1) { p1=DummyString; assert(s1==0); } if (!p2) { p2=DummyString; assert(s2==0); } if (!(a = PyBytes_FromStringAndSize(p1, s1))) { return NULL; } if (!(b = PyBytes_FromStringAndSize(p2, s2))) { Py_DECREF(a); return NULL; } r = PyTuple_Pack(2, a, b) ; Py_DECREF(a); Py_DECREF(b); return r; } static PyObject *BuildValue_IS(int i,const void *p,int s) { PyObject *a, *r; if (!p) { p=DummyString; assert(s==0); } if (!(a = PyBytes_FromStringAndSize(p, s))) { return NULL; } r = Py_BuildValue("iO", i, a); Py_DECREF(a); return r; } static PyObject *BuildValue_LS(long l,const void *p,int s) { PyObject *a, *r; if (!p) { p=DummyString; assert(s==0); } if (!(a = PyBytes_FromStringAndSize(p, s))) { return NULL; } r = Py_BuildValue("lO", l, a); Py_DECREF(a); return r; } /* make a nice exception object to raise for errors. */ static int makeDBError(int err) { char errTxt[2048]; /* really big, just in case... */ PyObject *errObj = NULL; PyObject *errTuple = NULL; int exceptionRaised = 0; unsigned int bytes_left; switch (err) { case 0: /* successful, no error */ return 0; case DB_KEYEMPTY: errObj = DBKeyEmptyError; break; case DB_KEYEXIST: errObj = DBKeyExistError; break; case DB_LOCK_DEADLOCK: errObj = DBLockDeadlockError; break; case DB_LOCK_NOTGRANTED: errObj = DBLockNotGrantedError; break; case DB_NOTFOUND: errObj = DBNotFoundError; break; case DB_OLD_VERSION: errObj = DBOldVersionError; break; case DB_RUNRECOVERY: errObj = DBRunRecoveryError; break; case DB_VERIFY_BAD: errObj = DBVerifyBadError; break; case DB_NOSERVER: errObj = DBNoServerError; break; #if (DBVER < 53) case DB_NOSERVER_HOME: errObj = DBNoServerHomeError; break; case DB_NOSERVER_ID: errObj = DBNoServerIDError; break; #endif case DB_PAGE_NOTFOUND: errObj = DBPageNotFoundError; break; case DB_SECONDARY_BAD: errObj = DBSecondaryBadError; break; case DB_BUFFER_SMALL: errObj = DBNoMemoryError; break; case ENOMEM: errObj = PyExc_MemoryError; break; case EINVAL: errObj = DBInvalidArgError; break; case EACCES: errObj = DBAccessError; break; case ENOSPC: errObj = DBNoSpaceError; break; case EAGAIN: errObj = DBAgainError; break; case EBUSY : errObj = DBBusyError; break; case EEXIST: errObj = DBFileExistsError; break; case ENOENT: errObj = DBNoSuchFileError; break; case EPERM : errObj = DBPermissionsError; break; case DB_REP_HANDLE_DEAD : errObj = DBRepHandleDeadError; break; case DB_REP_LOCKOUT : errObj = DBRepLockoutError; break; case DB_REP_LEASE_EXPIRED : errObj = DBRepLeaseExpiredError; break; case DB_FOREIGN_CONFLICT : errObj = DBForeignConflictError; break; case DB_REP_UNAVAIL : errObj = DBRepUnavailError; break; default: errObj = DBError; break; } if (errObj != NULL) { bytes_left = our_strlcpy(errTxt, db_strerror(err), sizeof(errTxt)); /* Ensure that bytes_left never goes negative */ if (_db_errmsg[0] && bytes_left < (sizeof(errTxt) - 4)) { bytes_left = sizeof(errTxt) - bytes_left - 4 - 1; assert(bytes_left >= 0); strcat(errTxt, " -- "); strncat(errTxt, _db_errmsg, bytes_left); } _db_errmsg[0] = 0; errTuple = Py_BuildValue("(is)", err, errTxt); if (errTuple == NULL) { Py_DECREF(errObj); return !0; } PyErr_SetObject(errObj, errTuple); Py_DECREF(errTuple); } return ((errObj != NULL) || exceptionRaised); } /* set a type exception */ static void makeTypeError(char* expected, PyObject* found) { PyErr_Format(PyExc_TypeError, "Expected %s argument, %s found.", expected, Py_TYPE(found)->tp_name); } /* verify that an obj is either None or a DBTxn, and set the txn pointer */ static int checkTxnObj(PyObject* txnobj, DB_TXN** txn) { if (txnobj == Py_None || txnobj == NULL) { *txn = NULL; return 1; } if (DBTxnObject_Check(txnobj)) { *txn = ((DBTxnObject*)txnobj)->txn; return 1; } else makeTypeError("DBTxn", txnobj); return 0; } /* Delete a key from a database Returns 0 on success, -1 on an error. */ static int _DB_delete(DBObject* self, DB_TXN *txn, DBT *key, int flags) { int err; MYDB_BEGIN_ALLOW_THREADS; err = self->db->del(self->db, txn, key, 0); MYDB_END_ALLOW_THREADS; if (makeDBError(err)) { return -1; } return 0; } /* Store a key into a database Returns 0 on success, -1 on an error. */ static int _DB_put(DBObject* self, DB_TXN *txn, DBT *key, DBT *data, int flags) { int err; MYDB_BEGIN_ALLOW_THREADS; err = self->db->put(self->db, txn, key, data, flags); MYDB_END_ALLOW_THREADS; if (makeDBError(err)) { return -1; } return 0; } /* Get a key/data pair from a cursor */ static PyObject* _DBCursor_get(DBCursorObject* self, int extra_flags, PyObject *args, PyObject *kwargs, char *format) { int err; PyObject* retval = NULL; DBT key, data; int dlen = -1; int doff = -1; int flags = 0; static char* kwnames[] = { "flags", "dlen", "doff", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, format, kwnames, &flags, &dlen, &doff)) return NULL; CHECK_CURSOR_NOT_CLOSED(self); flags |= extra_flags; CLEAR_DBT(key); CLEAR_DBT(data); if (!add_partial_dbt(&data, dlen, doff)) return NULL; MYDB_BEGIN_ALLOW_THREADS; err = _DBC_get(self->dbc, &key, &data, flags); MYDB_END_ALLOW_THREADS; if ((err == DB_NOTFOUND || err == DB_KEYEMPTY) && self->mydb->moduleFlags.getReturnsNone) { Py_INCREF(Py_None); retval = Py_None; } else if (makeDBError(err)) { retval = NULL; } else { /* otherwise, success! */ /* if Recno or Queue, return the key as an Int */ switch (_DB_get_type(self->mydb)) { case -1: retval = NULL; break; case DB_RECNO: case DB_QUEUE: retval = BuildValue_IS(*((db_recno_t*)key.data), data.data, data.size); break; case DB_HASH: case DB_BTREE: default: retval = BuildValue_SS(key.data, key.size, data.data, data.size); break; } } return retval; } /* add an integer to a dictionary using the given name as a key */ static void _addIntToDict(PyObject* dict, char *name, int value) { PyObject* v = NUMBER_FromLong((long) value); if (!v || PyDict_SetItemString(dict, name, v)) PyErr_Clear(); Py_XDECREF(v); } #if (DBVER >= 61) /* add an unsigned integer to a dictionary using the given name as a key */ static void _addUnsignedIntToDict(PyObject* dict, char *name, unsigned int value) { PyObject* v = NUMBER_FromUnsignedLong((unsigned long) value); if (!v || PyDict_SetItemString(dict, name, v)) PyErr_Clear(); Py_XDECREF(v); } #endif /* The same, when the value is a time_t */ static void _addTimeTToDict(PyObject* dict, char *name, time_t value) { PyObject* v; /* if the value fits in regular int, use that. */ #ifdef PY_LONG_LONG if (sizeof(time_t) > sizeof(long)) v = PyLong_FromLongLong((PY_LONG_LONG) value); else #endif v = NUMBER_FromLong((long) value); if (!v || PyDict_SetItemString(dict, name, v)) PyErr_Clear(); Py_XDECREF(v); } /* add an db_seq_t to a dictionary using the given name as a key */ static void _addDb_seq_tToDict(PyObject* dict, char *name, db_seq_t value) { PyObject* v = PyLong_FromLongLong(value); if (!v || PyDict_SetItemString(dict, name, v)) PyErr_Clear(); Py_XDECREF(v); } static void _addDB_lsnToDict(PyObject* dict, char *name, DB_LSN value) { PyObject *v = Py_BuildValue("(ll)",value.file,value.offset); if (!v || PyDict_SetItemString(dict, name, v)) PyErr_Clear(); Py_XDECREF(v); } /* --------------------------------------------------------------------- */ /* Allocators and deallocators */ static DBObject* newDBObject(DBEnvObject* arg, int flags) { DBObject* self; DB_ENV* db_env = NULL; int err; self = PyObject_New(DBObject, &DB_Type); if (self == NULL) return NULL; self->flags = 0; self->setflags = 0; self->myenvobj = NULL; self->db = NULL; self->children_cursors = NULL; self->children_sequences = NULL; self->associateCallback = NULL; self->btCompareCallback = NULL; self->dupCompareCallback = NULL; self->primaryDBType = 0; Py_INCREF(Py_None); self->private_obj = Py_None; self->in_weakreflist = NULL; /* keep a reference to our python DBEnv object */ if (arg) { Py_INCREF(arg); self->myenvobj = arg; db_env = arg->db_env; INSERT_IN_DOUBLE_LINKED_LIST(self->myenvobj->children_dbs,self); } else { self->sibling_prev_p=NULL; self->sibling_next=NULL; } self->txn=NULL; self->sibling_prev_p_txn=NULL; self->sibling_next_txn=NULL; if (self->myenvobj) self->moduleFlags = self->myenvobj->moduleFlags; else self->moduleFlags.getReturnsNone = DEFAULT_GET_RETURNS_NONE; self->moduleFlags.cursorSetReturnsNone = DEFAULT_CURSOR_SET_RETURNS_NONE; MYDB_BEGIN_ALLOW_THREADS; err = db_create(&self->db, db_env, flags); if (self->db != NULL) { self->db->set_errcall(self->db, _db_errorCallback); self->db->app_private = (void*)self; } MYDB_END_ALLOW_THREADS; /* TODO add a weakref(self) to the self->myenvobj->open_child_weakrefs * list so that a DBEnv can refuse to close without aborting any open * DBTxns and closing any open DBs first. */ if (makeDBError(err)) { if (self->myenvobj) { Py_DECREF(self->myenvobj); self->myenvobj = NULL; } Py_DECREF(self); self = NULL; } return self; } /* Forward declaration */ static PyObject *DB_close_internal(DBObject* self, int flags, int do_not_close); static void DB_dealloc(DBObject* self) { PyObject *dummy; if (self->db != NULL) { dummy=DB_close_internal(self, 0, 0); /* ** Raising exceptions while doing ** garbage collection is a fatal error. */ if (dummy) Py_DECREF(dummy); else PyErr_Clear(); } if (self->in_weakreflist != NULL) { PyObject_ClearWeakRefs((PyObject *) self); } if (self->myenvobj) { Py_DECREF(self->myenvobj); self->myenvobj = NULL; } if (self->associateCallback != NULL) { Py_DECREF(self->associateCallback); self->associateCallback = NULL; } if (self->btCompareCallback != NULL) { Py_DECREF(self->btCompareCallback); self->btCompareCallback = NULL; } if (self->dupCompareCallback != NULL) { Py_DECREF(self->dupCompareCallback); self->dupCompareCallback = NULL; } Py_DECREF(self->private_obj); PyObject_Del(self); } static DBCursorObject* newDBCursorObject(DBC* dbc, DBTxnObject *txn, DBObject* db) { DBCursorObject* self = PyObject_New(DBCursorObject, &DBCursor_Type); if (self == NULL) return NULL; self->dbc = dbc; self->mydb = db; INSERT_IN_DOUBLE_LINKED_LIST(self->mydb->children_cursors,self); if (txn && ((PyObject *)txn!=Py_None)) { INSERT_IN_DOUBLE_LINKED_LIST_TXN(txn->children_cursors,self); self->txn=txn; } else { self->txn=NULL; } self->in_weakreflist = NULL; Py_INCREF(self->mydb); return self; } /* Forward declaration */ static PyObject *DBC_close_internal(DBCursorObject* self); static void DBCursor_dealloc(DBCursorObject* self) { PyObject *dummy; if (self->dbc != NULL) { dummy=DBC_close_internal(self); /* ** Raising exceptions while doing ** garbage collection is a fatal error. */ if (dummy) Py_DECREF(dummy); else PyErr_Clear(); } if (self->in_weakreflist != NULL) { PyObject_ClearWeakRefs((PyObject *) self); } Py_DECREF(self->mydb); PyObject_Del(self); } static DBLogCursorObject* newDBLogCursorObject(DB_LOGC* dblogc, DBEnvObject* env) { DBLogCursorObject* self; self = PyObject_New(DBLogCursorObject, &DBLogCursor_Type); if (self == NULL) return NULL; self->logc = dblogc; self->env = env; INSERT_IN_DOUBLE_LINKED_LIST(self->env->children_logcursors, self); self->in_weakreflist = NULL; Py_INCREF(self->env); return self; } /* Forward declaration */ static PyObject *DBLogCursor_close_internal(DBLogCursorObject* self); static void DBLogCursor_dealloc(DBLogCursorObject* self) { PyObject *dummy; if (self->logc != NULL) { dummy = DBLogCursor_close_internal(self); /* ** Raising exceptions while doing ** garbage collection is a fatal error. */ if (dummy) Py_DECREF(dummy); else PyErr_Clear(); } if (self->in_weakreflist != NULL) { PyObject_ClearWeakRefs((PyObject *) self); } Py_DECREF(self->env); PyObject_Del(self); } static DBEnvObject* newDBEnvObject(int flags) { int err; DBEnvObject* self = PyObject_New(DBEnvObject, &DBEnv_Type); if (self == NULL) return NULL; self->db_env = NULL; self->closed = 1; self->flags = flags; self->moduleFlags.getReturnsNone = DEFAULT_GET_RETURNS_NONE; self->moduleFlags.cursorSetReturnsNone = DEFAULT_CURSOR_SET_RETURNS_NONE; self->children_dbs = NULL; self->children_txns = NULL; self->children_logcursors = NULL ; #if (DBVER >= 53) self->children_sites = NULL; #endif Py_INCREF(Py_None); self->private_obj = Py_None; Py_INCREF(Py_None); self->rep_transport = Py_None; self->in_weakreflist = NULL; self->event_notifyCallback = NULL; MYDB_BEGIN_ALLOW_THREADS; err = db_env_create(&self->db_env, flags); MYDB_END_ALLOW_THREADS; if (makeDBError(err)) { Py_DECREF(self); self = NULL; } else { self->db_env->set_errcall(self->db_env, _db_errorCallback); self->db_env->app_private = self; } return self; } /* Forward declaration */ static PyObject *DBEnv_close_internal(DBEnvObject* self, int flags); static void DBEnv_dealloc(DBEnvObject* self) { PyObject *dummy; if (self->db_env) { dummy=DBEnv_close_internal(self, 0); /* ** Raising exceptions while doing ** garbage collection is a fatal error. */ if (dummy) Py_DECREF(dummy); else PyErr_Clear(); } Py_XDECREF(self->event_notifyCallback); self->event_notifyCallback = NULL; if (self->in_weakreflist != NULL) { PyObject_ClearWeakRefs((PyObject *) self); } Py_DECREF(self->private_obj); Py_DECREF(self->rep_transport); PyObject_Del(self); } static DBTxnObject* newDBTxnObject(DBEnvObject* myenv, DBTxnObject *parent, DB_TXN *txn, int flags) { int err; DB_TXN *parent_txn = NULL; DBTxnObject* self = PyObject_New(DBTxnObject, &DBTxn_Type); if (self == NULL) return NULL; self->in_weakreflist = NULL; self->children_txns = NULL; self->children_dbs = NULL; self->children_cursors = NULL; self->children_sequences = NULL; self->flag_prepare = 0; self->parent_txn = NULL; self->env = NULL; /* We initialize just in case "txn_begin" fails */ self->txn = NULL; if (parent && ((PyObject *)parent!=Py_None)) { parent_txn = parent->txn; } if (txn) { self->txn = txn; } else { MYDB_BEGIN_ALLOW_THREADS; err = myenv->db_env->txn_begin(myenv->db_env, parent_txn, &(self->txn), flags); MYDB_END_ALLOW_THREADS; if (makeDBError(err)) { /* Free object half initialized */ Py_DECREF(self); return NULL; } } /* Can't use 'parent' because could be 'parent==Py_None' */ if (parent_txn) { self->parent_txn = parent; Py_INCREF(parent); self->env = NULL; INSERT_IN_DOUBLE_LINKED_LIST(parent->children_txns, self); } else { self->parent_txn = NULL; Py_INCREF(myenv); self->env = myenv; INSERT_IN_DOUBLE_LINKED_LIST(myenv->children_txns, self); } return self; } /* Forward declaration */ static PyObject * DBTxn_abort_discard_internal(DBTxnObject* self, int discard); static void DBTxn_dealloc(DBTxnObject* self) { PyObject *dummy; if (self->txn) { int flag_prepare = self->flag_prepare; dummy=DBTxn_abort_discard_internal(self, 0); /* ** Raising exceptions while doing ** garbage collection is a fatal error. */ if (dummy) Py_DECREF(dummy); else PyErr_Clear(); if (!flag_prepare) { PyErr_Warn(PyExc_RuntimeWarning, "DBTxn aborted in destructor. No prior commit() or abort()."); } } if (self->in_weakreflist != NULL) { PyObject_ClearWeakRefs((PyObject *) self); } if (self->env) { Py_DECREF(self->env); } else { /* ** We can have "self->env==NULL" and "self->parent_txn==NULL" ** if something happens when creating the transaction object ** and we abort the object while half done. */ Py_XDECREF(self->parent_txn); } PyObject_Del(self); } static DBLockObject* newDBLockObject(DBEnvObject* myenv, u_int32_t locker, DBT* obj, db_lockmode_t lock_mode, int flags) { int err; DBLockObject* self = PyObject_New(DBLockObject, &DBLock_Type); if (self == NULL) return NULL; self->in_weakreflist = NULL; self->lock_initialized = 0; /* Just in case the call fails */ MYDB_BEGIN_ALLOW_THREADS; err = myenv->db_env->lock_get(myenv->db_env, locker, flags, obj, lock_mode, &self->lock); MYDB_END_ALLOW_THREADS; if (makeDBError(err)) { Py_DECREF(self); self = NULL; } else { self->lock_initialized = 1; } return self; } static void DBLock_dealloc(DBLockObject* self) { if (self->in_weakreflist != NULL) { PyObject_ClearWeakRefs((PyObject *) self); } /* TODO: is this lock held? should we release it? */ /* CAUTION: The lock can be not initialized if the creation has failed */ PyObject_Del(self); } static DBSequenceObject* newDBSequenceObject(DBObject* mydb, int flags) { int err; DBSequenceObject* self = PyObject_New(DBSequenceObject, &DBSequence_Type); if (self == NULL) return NULL; Py_INCREF(mydb); self->mydb = mydb; INSERT_IN_DOUBLE_LINKED_LIST(self->mydb->children_sequences,self); self->txn = NULL; self->in_weakreflist = NULL; self->sequence = NULL; /* Just in case the call fails */ MYDB_BEGIN_ALLOW_THREADS; err = db_sequence_create(&self->sequence, self->mydb->db, flags); MYDB_END_ALLOW_THREADS; if (makeDBError(err)) { Py_DECREF(self); self = NULL; } return self; } /* Forward declaration */ static PyObject *DBSequence_close_internal(DBSequenceObject* self, int flags, int do_not_close); static void DBSequence_dealloc(DBSequenceObject* self) { PyObject *dummy; if (self->sequence != NULL) { dummy=DBSequence_close_internal(self,0,0); /* ** Raising exceptions while doing ** garbage collection is a fatal error. */ if (dummy) Py_DECREF(dummy); else PyErr_Clear(); } if (self->in_weakreflist != NULL) { PyObject_ClearWeakRefs((PyObject *) self); } Py_DECREF(self->mydb); PyObject_Del(self); } #if (DBVER >= 53) static DBSiteObject* newDBSiteObject(DB_SITE* sitep, DBEnvObject* env) { DBSiteObject* self; self = PyObject_New(DBSiteObject, &DBSite_Type); if (self == NULL) return NULL; self->site = sitep; self->env = env; INSERT_IN_DOUBLE_LINKED_LIST(self->env->children_sites, self); self->in_weakreflist = NULL; Py_INCREF(self->env); return self; } /* Forward declaration */ static PyObject *DBSite_close_internal(DBSiteObject* self); static void DBSite_dealloc(DBSiteObject* self) { PyObject *dummy; if (self->site != NULL) { dummy = DBSite_close_internal(self); /* ** Raising exceptions while doing ** garbage collection is a fatal error. */ if (dummy) Py_DECREF(dummy); else PyErr_Clear(); } if (self->in_weakreflist != NULL) { PyObject_ClearWeakRefs((PyObject *) self); } Py_DECREF(self->env); PyObject_Del(self); } #endif /* --------------------------------------------------------------------- */ /* DB methods */ static PyObject* DB_append(DBObject* self, PyObject* args, PyObject* kwargs) { PyObject* txnobj = NULL; PyObject* dataobj; db_recno_t recno; DBT key, data; DB_TXN *txn = NULL; static char* kwnames[] = { "data", "txn", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:append", kwnames, &dataobj, &txnobj)) return NULL; CHECK_DB_NOT_CLOSED(self); /* make a dummy key out of a recno */ recno = 0; CLEAR_DBT(key); key.data = &recno; key.size = sizeof(recno); key.ulen = key.size; key.flags = DB_DBT_USERMEM; if (!make_dbt(dataobj, &data)) return NULL; if (!checkTxnObj(txnobj, &txn)) return NULL; if (-1 == _DB_put(self, txn, &key, &data, DB_APPEND)) return NULL; return NUMBER_FromLong(recno); } static int _db_associateCallback(DB* db, const DBT* priKey, const DBT* priData, DBT* secKey) { int retval = DB_DONOTINDEX; DBObject* secondaryDB = (DBObject*)db->app_private; PyObject* callback = secondaryDB->associateCallback; int type = secondaryDB->primaryDBType; PyObject* args; PyObject* result = NULL; if (callback != NULL) { MYDB_BEGIN_BLOCK_THREADS; if (type == DB_RECNO || type == DB_QUEUE) args = BuildValue_LS(*((db_recno_t*)priKey->data), priData->data, priData->size); else args = BuildValue_SS(priKey->data, priKey->size, priData->data, priData->size); if (args != NULL) { result = PyObject_CallObject(callback, args); } if (args == NULL || result == NULL) { PyErr_Print(); } else if (result == Py_None) { retval = DB_DONOTINDEX; } else if (NUMBER_Check(result)) { retval = NUMBER_AsLong(result); } else if (PyBytes_Check(result)) { char* data; Py_ssize_t size; CLEAR_DBT(*secKey); PyBytes_AsStringAndSize(result, &data, &size); secKey->flags = DB_DBT_APPMALLOC; /* DB will free */ secKey->data = malloc(size); /* TODO, check this */ if (secKey->data) { memcpy(secKey->data, data, size); secKey->size = size; retval = 0; } else { PyErr_SetString(PyExc_MemoryError, "malloc failed in _db_associateCallback"); PyErr_Print(); } } else if (PyList_Check(result)) { char* data; Py_ssize_t size; int i, listlen; DBT* dbts; listlen = PyList_Size(result); dbts = (DBT *)malloc(sizeof(DBT) * listlen); for (i=0; iassociate callback should be a list of strings."); #else "The list returned by DB->associate callback should be a list of bytes."); #endif PyErr_Print(); } PyBytes_AsStringAndSize( PyList_GetItem(result, i), &data, &size); CLEAR_DBT(dbts[i]); dbts[i].data = malloc(size); /* TODO, check this */ if (dbts[i].data) { memcpy(dbts[i].data, data, size); dbts[i].size = size; dbts[i].ulen = dbts[i].size; dbts[i].flags = DB_DBT_APPMALLOC; /* DB will free */ } else { PyErr_SetString(PyExc_MemoryError, "malloc failed in _db_associateCallback (list)"); PyErr_Print(); } } CLEAR_DBT(*secKey); secKey->data = dbts; secKey->size = listlen; secKey->flags = DB_DBT_APPMALLOC | DB_DBT_MULTIPLE; retval = 0; } else { PyErr_SetString( PyExc_TypeError, #if (PY_VERSION_HEX < 0x03000000) "DB associate callback should return DB_DONOTINDEX/string/list of strings."); #else "DB associate callback should return DB_DONOTINDEX/bytes/list of bytes."); #endif PyErr_Print(); } Py_XDECREF(args); Py_XDECREF(result); MYDB_END_BLOCK_THREADS; } return retval; } static PyObject* DB_associate(DBObject* self, PyObject* args, PyObject* kwargs) { int err, flags=0; DBObject* secondaryDB; PyObject* callback; PyObject *txnobj = NULL; DB_TXN *txn = NULL; static char* kwnames[] = {"secondaryDB", "callback", "flags", "txn", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|iO:associate", kwnames, &secondaryDB, &callback, &flags, &txnobj)) { return NULL; } if (!checkTxnObj(txnobj, &txn)) return NULL; CHECK_DB_NOT_CLOSED(self); if (!DBObject_Check(secondaryDB)) { makeTypeError("DB", (PyObject*)secondaryDB); return NULL; } CHECK_DB_NOT_CLOSED(secondaryDB); if (callback == Py_None) { callback = NULL; } else if (!PyCallable_Check(callback)) { makeTypeError("Callable", callback); return NULL; } /* Save a reference to the callback in the secondary DB. */ Py_XDECREF(secondaryDB->associateCallback); Py_XINCREF(callback); secondaryDB->associateCallback = callback; secondaryDB->primaryDBType = _DB_get_type(self); /* PyEval_InitThreads is called here due to a quirk in python 1.5 * - 2.2.1 (at least) according to Russell Williamson : * The global interepreter lock is not initialized until the first * thread is created using thread.start_new_thread() or fork() is * called. that would cause the ALLOW_THREADS here to segfault due * to a null pointer reference if no threads or child processes * have been created. This works around that and is a no-op if * threads have already been initialized. * (see pybsddb-users mailing list post on 2002-08-07) */ #ifdef WITH_THREAD PyEval_InitThreads(); #endif MYDB_BEGIN_ALLOW_THREADS; err = self->db->associate(self->db, txn, secondaryDB->db, _db_associateCallback, flags); MYDB_END_ALLOW_THREADS; if (err) { Py_XDECREF(secondaryDB->associateCallback); secondaryDB->associateCallback = NULL; secondaryDB->primaryDBType = 0; } RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DB_close_internal(DBObject* self, int flags, int do_not_close) { PyObject *dummy; int err = 0; if (self->db != NULL) { /* Can be NULL if db is not in an environment */ EXTRACT_FROM_DOUBLE_LINKED_LIST_MAYBE_NULL(self); if (self->txn) { EXTRACT_FROM_DOUBLE_LINKED_LIST_TXN(self); self->txn=NULL; } while(self->children_cursors) { dummy=DBC_close_internal(self->children_cursors); Py_XDECREF(dummy); } while(self->children_sequences) { dummy=DBSequence_close_internal(self->children_sequences,0,0); Py_XDECREF(dummy); } /* ** "do_not_close" is used to dispose all related objects in the ** tree, without actually releasing the "root" object. ** This is done, for example, because function calls like ** "DB.verify()" implicitly close the underlying handle. So ** the handle doesn't need to be closed, but related objects ** must be cleaned up. */ if (!do_not_close) { MYDB_BEGIN_ALLOW_THREADS; err = self->db->close(self->db, flags); MYDB_END_ALLOW_THREADS; self->db = NULL; } RETURN_IF_ERR(); } RETURN_NONE(); } static PyObject* DB_close(DBObject* self, PyObject* args) { int flags=0; if (!PyArg_ParseTuple(args,"|i:close", &flags)) return NULL; return DB_close_internal(self, flags, 0); } static PyObject* _DB_consume(DBObject* self, PyObject* args, PyObject* kwargs, int consume_flag) { int err, flags=0, type; PyObject* txnobj = NULL; PyObject* retval = NULL; DBT key, data; DB_TXN *txn = NULL; static char* kwnames[] = { "txn", "flags", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|Oi:consume", kwnames, &txnobj, &flags)) return NULL; CHECK_DB_NOT_CLOSED(self); type = _DB_get_type(self); if (type == -1) return NULL; if (type != DB_QUEUE) { PyErr_SetString(PyExc_TypeError, "Consume methods only allowed for Queue DB's"); return NULL; } if (!checkTxnObj(txnobj, &txn)) return NULL; CLEAR_DBT(key); CLEAR_DBT(data); if (CHECK_DBFLAG(self, DB_THREAD)) { /* Tell Berkeley DB to malloc the return value (thread safe) */ data.flags = DB_DBT_MALLOC; key.flags = DB_DBT_MALLOC; } MYDB_BEGIN_ALLOW_THREADS; err = self->db->get(self->db, txn, &key, &data, flags|consume_flag); MYDB_END_ALLOW_THREADS; if ((err == DB_NOTFOUND || err == DB_KEYEMPTY) && self->moduleFlags.getReturnsNone) { err = 0; Py_INCREF(Py_None); retval = Py_None; } else if (!err) { retval = BuildValue_SS(key.data, key.size, data.data, data.size); FREE_DBT(key); FREE_DBT(data); } RETURN_IF_ERR(); return retval; } static PyObject* DB_consume(DBObject* self, PyObject* args, PyObject* kwargs, int consume_flag) { return _DB_consume(self, args, kwargs, DB_CONSUME); } static PyObject* DB_consume_wait(DBObject* self, PyObject* args, PyObject* kwargs, int consume_flag) { return _DB_consume(self, args, kwargs, DB_CONSUME_WAIT); } static PyObject* DB_cursor(DBObject* self, PyObject* args, PyObject* kwargs) { int err, flags=0; DBC* dbc; PyObject* txnobj = NULL; DB_TXN *txn = NULL; static char* kwnames[] = { "txn", "flags", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|Oi:cursor", kwnames, &txnobj, &flags)) return NULL; CHECK_DB_NOT_CLOSED(self); if (!checkTxnObj(txnobj, &txn)) return NULL; MYDB_BEGIN_ALLOW_THREADS; err = self->db->cursor(self->db, txn, &dbc, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return (PyObject*) newDBCursorObject(dbc, (DBTxnObject *)txnobj, self); } static PyObject* DB_delete(DBObject* self, PyObject* args, PyObject* kwargs) { PyObject* txnobj = NULL; int flags = 0; PyObject* keyobj; DBT key; DB_TXN *txn = NULL; static char* kwnames[] = { "key", "txn", "flags", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|Oi:delete", kwnames, &keyobj, &txnobj, &flags)) return NULL; CHECK_DB_NOT_CLOSED(self); if (!make_key_dbt(self, keyobj, &key, NULL)) return NULL; if (!checkTxnObj(txnobj, &txn)) { FREE_DBT(key); return NULL; } if (-1 == _DB_delete(self, txn, &key, 0)) { FREE_DBT(key); return NULL; } FREE_DBT(key); RETURN_NONE(); } static PyObject* DB_compact(DBObject* self, PyObject* args, PyObject* kwargs) { PyObject* txnobj = NULL; PyObject *startobj = NULL, *stopobj = NULL; int flags = 0; DB_TXN *txn = NULL; DBT *start_p = NULL, *stop_p = NULL; DBT start, stop; int err; DB_COMPACT c_data = { 0 }; static char* kwnames[] = { "txn", "start", "stop", "flags", "compact_fillpercent", "compact_pages", "compact_timeout", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOOiiiI:compact", kwnames, &txnobj, &startobj, &stopobj, &flags, &c_data.compact_fillpercent, &c_data.compact_pages, &c_data.compact_timeout)) return NULL; CHECK_DB_NOT_CLOSED(self); if (!checkTxnObj(txnobj, &txn)) { return NULL; } if (startobj) { if (!make_key_dbt(self, startobj, &start, NULL)) { return NULL; } start_p = &start; } if (stopobj) { if (!make_key_dbt(self, stopobj, &stop, NULL)) { if (startobj) FREE_DBT(start); return NULL; } stop_p = &stop; } MYDB_BEGIN_ALLOW_THREADS; err = self->db->compact(self->db, txn, start_p, stop_p, &c_data, flags, NULL); MYDB_END_ALLOW_THREADS; if (startobj) FREE_DBT(start); if (stopobj) FREE_DBT(stop); RETURN_IF_ERR(); return PyLong_FromUnsignedLong(c_data.compact_pages_truncated); } static PyObject* DB_fd(DBObject* self) { int err, the_fd; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->fd(self->db, &the_fd); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(the_fd); } static PyObject* DB_exists(DBObject* self, PyObject* args, PyObject* kwargs) { int err, flags=0; PyObject* txnobj = NULL; PyObject* keyobj; DBT key; DB_TXN *txn; static char* kwnames[] = {"key", "txn", "flags", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|Oi:exists", kwnames, &keyobj, &txnobj, &flags)) return NULL; CHECK_DB_NOT_CLOSED(self); if (!make_key_dbt(self, keyobj, &key, NULL)) return NULL; if (!checkTxnObj(txnobj, &txn)) { FREE_DBT(key); return NULL; } MYDB_BEGIN_ALLOW_THREADS; err = self->db->exists(self->db, txn, &key, flags); MYDB_END_ALLOW_THREADS; FREE_DBT(key); if (!err) { Py_INCREF(Py_True); return Py_True; } if ((err == DB_NOTFOUND || err == DB_KEYEMPTY)) { Py_INCREF(Py_False); return Py_False; } /* ** If we reach there, there was an error. The ** "return" should be unreachable. */ RETURN_IF_ERR(); assert(0); /* This coude SHOULD be unreachable */ return NULL; } static PyObject* DB_get(DBObject* self, PyObject* args, PyObject* kwargs) { int err, flags=0; PyObject* txnobj = NULL; PyObject* keyobj; PyObject* dfltobj = NULL; PyObject* retval = NULL; int dlen = -1; int doff = -1; DBT key, data; DB_TXN *txn = NULL; static char* kwnames[] = {"key", "default", "txn", "flags", "dlen", "doff", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOiii:get", kwnames, &keyobj, &dfltobj, &txnobj, &flags, &dlen, &doff)) return NULL; CHECK_DB_NOT_CLOSED(self); if (!make_key_dbt(self, keyobj, &key, &flags)) return NULL; if (!checkTxnObj(txnobj, &txn)) { FREE_DBT(key); return NULL; } CLEAR_DBT(data); if (CHECK_DBFLAG(self, DB_THREAD)) { /* Tell Berkeley DB to malloc the return value (thread safe) */ data.flags = DB_DBT_MALLOC; } if (!add_partial_dbt(&data, dlen, doff)) { FREE_DBT(key); return NULL; } MYDB_BEGIN_ALLOW_THREADS; err = self->db->get(self->db, txn, &key, &data, flags); MYDB_END_ALLOW_THREADS; if ((err == DB_NOTFOUND || err == DB_KEYEMPTY) && (dfltobj != NULL)) { err = 0; Py_INCREF(dfltobj); retval = dfltobj; } else if ((err == DB_NOTFOUND || err == DB_KEYEMPTY) && self->moduleFlags.getReturnsNone) { err = 0; Py_INCREF(Py_None); retval = Py_None; } else if (!err) { if (flags & DB_SET_RECNO) /* return both key and data */ retval = BuildValue_SS(key.data, key.size, data.data, data.size); else /* return just the data */ retval = Build_PyString(data.data, data.size); FREE_DBT(data); } FREE_DBT(key); RETURN_IF_ERR(); return retval; } static PyObject* DB_pget(DBObject* self, PyObject* args, PyObject* kwargs) { int err, flags=0; PyObject* txnobj = NULL; PyObject* keyobj; PyObject* dfltobj = NULL; PyObject* retval = NULL; int dlen = -1; int doff = -1; DBT key, pkey, data; DB_TXN *txn = NULL; static char* kwnames[] = {"key", "default", "txn", "flags", "dlen", "doff", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOiii:pget", kwnames, &keyobj, &dfltobj, &txnobj, &flags, &dlen, &doff)) return NULL; CHECK_DB_NOT_CLOSED(self); if (!make_key_dbt(self, keyobj, &key, &flags)) return NULL; if (!checkTxnObj(txnobj, &txn)) { FREE_DBT(key); return NULL; } CLEAR_DBT(data); if (CHECK_DBFLAG(self, DB_THREAD)) { /* Tell Berkeley DB to malloc the return value (thread safe) */ data.flags = DB_DBT_MALLOC; } if (!add_partial_dbt(&data, dlen, doff)) { FREE_DBT(key); return NULL; } CLEAR_DBT(pkey); pkey.flags = DB_DBT_MALLOC; MYDB_BEGIN_ALLOW_THREADS; err = self->db->pget(self->db, txn, &key, &pkey, &data, flags); MYDB_END_ALLOW_THREADS; if ((err == DB_NOTFOUND || err == DB_KEYEMPTY) && (dfltobj != NULL)) { err = 0; Py_INCREF(dfltobj); retval = dfltobj; } else if ((err == DB_NOTFOUND || err == DB_KEYEMPTY) && self->moduleFlags.getReturnsNone) { err = 0; Py_INCREF(Py_None); retval = Py_None; } else if (!err) { PyObject *pkeyObj; PyObject *dataObj; dataObj = Build_PyString(data.data, data.size); if (self->primaryDBType == DB_RECNO || self->primaryDBType == DB_QUEUE) pkeyObj = NUMBER_FromLong(*(int *)pkey.data); else pkeyObj = Build_PyString(pkey.data, pkey.size); if (flags & DB_SET_RECNO) /* return key , pkey and data */ { PyObject *keyObj; int type = _DB_get_type(self); if (type == DB_RECNO || type == DB_QUEUE) keyObj = NUMBER_FromLong(*(int *)key.data); else keyObj = Build_PyString(key.data, key.size); retval = PyTuple_Pack(3, keyObj, pkeyObj, dataObj); Py_DECREF(keyObj); } else /* return just the pkey and data */ { retval = PyTuple_Pack(2, pkeyObj, dataObj); } Py_DECREF(dataObj); Py_DECREF(pkeyObj); FREE_DBT(pkey); FREE_DBT(data); } FREE_DBT(key); RETURN_IF_ERR(); return retval; } /* Return size of entry */ static PyObject* DB_get_size(DBObject* self, PyObject* args, PyObject* kwargs) { int err, flags=0; PyObject* txnobj = NULL; PyObject* keyobj; PyObject* retval = NULL; DBT key, data; DB_TXN *txn = NULL; static char* kwnames[] = { "key", "txn", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:get_size", kwnames, &keyobj, &txnobj)) return NULL; CHECK_DB_NOT_CLOSED(self); if (!make_key_dbt(self, keyobj, &key, &flags)) return NULL; if (!checkTxnObj(txnobj, &txn)) { FREE_DBT(key); return NULL; } CLEAR_DBT(data); /* We don't allocate any memory, forcing a DB_BUFFER_SMALL error and thus getting the record size. */ data.flags = DB_DBT_USERMEM; data.ulen = 0; MYDB_BEGIN_ALLOW_THREADS; err = self->db->get(self->db, txn, &key, &data, flags); MYDB_END_ALLOW_THREADS; if ((err == DB_BUFFER_SMALL) || (err == 0)) { retval = NUMBER_FromLong((long)data.size); err = 0; } FREE_DBT(key); FREE_DBT(data); RETURN_IF_ERR(); return retval; } static PyObject* DB_get_both(DBObject* self, PyObject* args, PyObject* kwargs) { int err, flags=0; PyObject* txnobj = NULL; PyObject* keyobj; PyObject* dataobj; PyObject* retval = NULL; DBT key, data; void *orig_data; DB_TXN *txn = NULL; static char* kwnames[] = { "key", "data", "txn", "flags", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|Oi:get_both", kwnames, &keyobj, &dataobj, &txnobj, &flags)) return NULL; CHECK_DB_NOT_CLOSED(self); if (!make_key_dbt(self, keyobj, &key, NULL)) return NULL; if ( !make_dbt(dataobj, &data) || !checkTxnObj(txnobj, &txn) ) { FREE_DBT(key); return NULL; } flags |= DB_GET_BOTH; orig_data = data.data; if (CHECK_DBFLAG(self, DB_THREAD)) { /* Tell Berkeley DB to malloc the return value (thread safe) */ /* XXX(nnorwitz): At least 4.4.20 and 4.5.20 require this flag. */ data.flags = DB_DBT_MALLOC; } MYDB_BEGIN_ALLOW_THREADS; err = self->db->get(self->db, txn, &key, &data, flags); MYDB_END_ALLOW_THREADS; if ((err == DB_NOTFOUND || err == DB_KEYEMPTY) && self->moduleFlags.getReturnsNone) { err = 0; Py_INCREF(Py_None); retval = Py_None; } else if (!err) { /* XXX(nnorwitz): can we do: retval = dataobj; Py_INCREF(retval); */ retval = Build_PyString(data.data, data.size); /* Even though the flags require DB_DBT_MALLOC, data is not always allocated. 4.4: allocated, 4.5: *not* allocated. :-( */ if (data.data != orig_data) FREE_DBT(data); } FREE_DBT(key); RETURN_IF_ERR(); return retval; } static PyObject* DB_get_byteswapped(DBObject* self) { int err = 0; int retval = -1; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->get_byteswapped(self->db, &retval); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(retval); } static PyObject* DB_get_type(DBObject* self) { int type; CHECK_DB_NOT_CLOSED(self); type = _DB_get_type(self); if (type == -1) return NULL; return NUMBER_FromLong(type); } static PyObject* DB_join(DBObject* self, PyObject* args) { int err, flags=0; int length, x; PyObject* cursorsObj; DBC** cursors; DBC* dbc; if (!PyArg_ParseTuple(args,"O|i:join", &cursorsObj, &flags)) return NULL; CHECK_DB_NOT_CLOSED(self); if (!PySequence_Check(cursorsObj)) { PyErr_SetString(PyExc_TypeError, "Sequence of DBCursor objects expected"); return NULL; } length = PyObject_Length(cursorsObj); cursors = malloc((length+1) * sizeof(DBC*)); if (!cursors) { PyErr_NoMemory(); return NULL; } cursors[length] = NULL; for (x=0; xdbc; Py_DECREF(item); } MYDB_BEGIN_ALLOW_THREADS; err = self->db->join(self->db, cursors, &dbc, flags); MYDB_END_ALLOW_THREADS; free(cursors); RETURN_IF_ERR(); /* FIXME: this is a buggy interface. The returned cursor contains internal references to the passed in cursors but does not hold python references to them or prevent them from being closed prematurely. This can cause python to crash when things are done in the wrong order. */ return (PyObject*) newDBCursorObject(dbc, NULL, self); } static PyObject* DB_key_range(DBObject* self, PyObject* args, PyObject* kwargs) { int err, flags=0; PyObject* txnobj = NULL; PyObject* keyobj; DBT key; DB_TXN *txn = NULL; DB_KEY_RANGE range; static char* kwnames[] = { "key", "txn", "flags", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|Oi:key_range", kwnames, &keyobj, &txnobj, &flags)) return NULL; CHECK_DB_NOT_CLOSED(self); if (!make_dbt(keyobj, &key)) /* BTree only, don't need to allow for an int key */ return NULL; if (!checkTxnObj(txnobj, &txn)) return NULL; MYDB_BEGIN_ALLOW_THREADS; err = self->db->key_range(self->db, txn, &key, &range, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return Py_BuildValue("ddd", range.less, range.equal, range.greater); } static PyObject* DB_open(DBObject* self, PyObject* args, PyObject* kwargs) { int err, type = DB_UNKNOWN, flags=0, mode=0660; char* filename = NULL; char* dbname = NULL; PyObject *txnobj = NULL; DB_TXN *txn = NULL; /* with dbname */ static char* kwnames[] = { "filename", "dbname", "dbtype", "flags", "mode", "txn", NULL}; /* without dbname */ static char* kwnames_basic[] = { "filename", "dbtype", "flags", "mode", "txn", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "z|ziiiO:open", kwnames, &filename, &dbname, &type, &flags, &mode, &txnobj)) { PyErr_Clear(); type = DB_UNKNOWN; flags = 0; mode = 0660; filename = NULL; dbname = NULL; if (!PyArg_ParseTupleAndKeywords(args, kwargs,"z|iiiO:open", kwnames_basic, &filename, &type, &flags, &mode, &txnobj)) return NULL; } if (!checkTxnObj(txnobj, &txn)) return NULL; if (NULL == self->db) { PyObject *t = Py_BuildValue("(is)", 0, "Cannot call open() twice for DB object"); if (t) { PyErr_SetObject(DBError, t); Py_DECREF(t); } return NULL; } if (txn) { /* Can't use 'txnobj' because could be 'txnobj==Py_None' */ INSERT_IN_DOUBLE_LINKED_LIST_TXN(((DBTxnObject *)txnobj)->children_dbs,self); self->txn=(DBTxnObject *)txnobj; } else { self->txn=NULL; } MYDB_BEGIN_ALLOW_THREADS; err = self->db->open(self->db, txn, filename, dbname, type, flags, mode); MYDB_END_ALLOW_THREADS; if (makeDBError(err)) { PyObject *dummy; dummy=DB_close_internal(self, 0, 0); Py_XDECREF(dummy); return NULL; } self->db->get_flags(self->db, &self->setflags); self->flags = flags; RETURN_NONE(); } static PyObject* DB_put(DBObject* self, PyObject* args, PyObject* kwargs) { int flags=0; PyObject* txnobj = NULL; int dlen = -1; int doff = -1; PyObject* keyobj, *dataobj, *retval; DBT key, data; DB_TXN *txn = NULL; static char* kwnames[] = { "key", "data", "txn", "flags", "dlen", "doff", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|Oiii:put", kwnames, &keyobj, &dataobj, &txnobj, &flags, &dlen, &doff)) return NULL; CHECK_DB_NOT_CLOSED(self); if (!make_key_dbt(self, keyobj, &key, NULL)) return NULL; if ( !make_dbt(dataobj, &data) || !add_partial_dbt(&data, dlen, doff) || !checkTxnObj(txnobj, &txn) ) { FREE_DBT(key); return NULL; } if (-1 == _DB_put(self, txn, &key, &data, flags)) { FREE_DBT(key); return NULL; } if (flags & DB_APPEND) retval = NUMBER_FromLong(*((db_recno_t*)key.data)); else { retval = Py_None; Py_INCREF(retval); } FREE_DBT(key); return retval; } static PyObject* DB_remove(DBObject* self, PyObject* args, PyObject* kwargs) { char* filename; char* database = NULL; int err, flags=0; static char* kwnames[] = { "filename", "dbname", "flags", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|zi:remove", kwnames, &filename, &database, &flags)) return NULL; CHECK_DB_NOT_CLOSED(self); EXTRACT_FROM_DOUBLE_LINKED_LIST_MAYBE_NULL(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->remove(self->db, filename, database, flags); MYDB_END_ALLOW_THREADS; self->db = NULL; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DB_rename(DBObject* self, PyObject* args) { char* filename; char* database; char* newname; int err, flags=0; if (!PyArg_ParseTuple(args, "sss|i:rename", &filename, &database, &newname, &flags)) return NULL; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->rename(self->db, filename, database, newname, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DB_get_private(DBObject* self) { /* We can give out the private field even if db is closed */ Py_INCREF(self->private_obj); return self->private_obj; } static PyObject* DB_set_private(DBObject* self, PyObject* private_obj) { /* We can set the private field even if db is closed */ Py_DECREF(self->private_obj); Py_INCREF(private_obj); self->private_obj = private_obj; RETURN_NONE(); } static PyObject* DB_set_priority(DBObject* self, PyObject* args) { int err, priority; if (!PyArg_ParseTuple(args,"i:set_priority", &priority)) return NULL; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->set_priority(self->db, priority); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DB_get_priority(DBObject* self) { int err = 0; DB_CACHE_PRIORITY priority; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->get_priority(self->db, &priority); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(priority); } static PyObject* DB_get_dbname(DBObject* self) { int err; const char *filename, *dbname; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->get_dbname(self->db, &filename, &dbname); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); /* If "dbname==NULL", it is correctly converted to "None" */ return Py_BuildValue("(ss)", filename, dbname); } static PyObject* DB_get_open_flags(DBObject* self) { int err; unsigned int flags; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->get_open_flags(self->db, &flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(flags); } static PyObject* DB_set_q_extentsize(DBObject* self, PyObject* args) { int err; u_int32_t extentsize; if (!PyArg_ParseTuple(args,"i:set_q_extentsize", &extentsize)) return NULL; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->set_q_extentsize(self->db, extentsize); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DB_get_q_extentsize(DBObject* self) { int err = 0; u_int32_t extentsize; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->get_q_extentsize(self->db, &extentsize); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(extentsize); } static PyObject* DB_set_bt_minkey(DBObject* self, PyObject* args) { int err, minkey; if (!PyArg_ParseTuple(args,"i:set_bt_minkey", &minkey)) return NULL; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->set_bt_minkey(self->db, minkey); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DB_get_bt_minkey(DBObject* self) { int err; u_int32_t bt_minkey; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->get_bt_minkey(self->db, &bt_minkey); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(bt_minkey); } static int _default_cmp(const DBT *leftKey, const DBT *rightKey) { int res; int lsize = leftKey->size, rsize = rightKey->size; res = memcmp(leftKey->data, rightKey->data, lsize < rsize ? lsize : rsize); if (res == 0) { if (lsize < rsize) { res = -1; } else if (lsize > rsize) { res = 1; } } return res; } static int _db_compareCallback(DB* db, const DBT *leftKey, const DBT *rightKey #if (DBVER >= 61) , size_t *locp #endif ) { int res = 0; PyObject *args; PyObject *result = NULL; DBObject *self = (DBObject *)db->app_private; # if (DBVER >= 61) locp = NULL; /* As required by documentation */ #endif if (self == NULL || self->btCompareCallback == NULL) { MYDB_BEGIN_BLOCK_THREADS; PyErr_SetString(PyExc_TypeError, (self == 0 ? "DB_bt_compare db is NULL." : "DB_bt_compare callback is NULL.")); /* we're in a callback within the DB code, we can't raise */ PyErr_Print(); res = _default_cmp(leftKey, rightKey); MYDB_END_BLOCK_THREADS; } else { MYDB_BEGIN_BLOCK_THREADS; args = BuildValue_SS(leftKey->data, leftKey->size, rightKey->data, rightKey->size); if (args != NULL) { result = PyObject_CallObject(self->btCompareCallback, args); } if (args == NULL || result == NULL) { /* we're in a callback within the DB code, we can't raise */ PyErr_Print(); res = _default_cmp(leftKey, rightKey); } else if (NUMBER_Check(result)) { res = NUMBER_AsLong(result); } else { PyErr_SetString(PyExc_TypeError, "DB_bt_compare callback MUST return an int."); /* we're in a callback within the DB code, we can't raise */ PyErr_Print(); res = _default_cmp(leftKey, rightKey); } Py_XDECREF(args); Py_XDECREF(result); MYDB_END_BLOCK_THREADS; } return res; } static PyObject* DB_set_bt_compare(DBObject* self, PyObject* comparator) { int err; PyObject *tuple, *result; CHECK_DB_NOT_CLOSED(self); if (!PyCallable_Check(comparator)) { makeTypeError("Callable", comparator); return NULL; } /* * Perform a test call of the comparator function with two empty * string objects here. verify that it returns an int (0). * err if not. */ tuple = Py_BuildValue("(ss)", "", ""); result = PyObject_CallObject(comparator, tuple); Py_DECREF(tuple); if (result == NULL) return NULL; if (!NUMBER_Check(result)) { Py_DECREF(result); PyErr_SetString(PyExc_TypeError, "callback MUST return an int"); return NULL; } else if (NUMBER_AsLong(result) != 0) { Py_DECREF(result); PyErr_SetString(PyExc_TypeError, "callback failed to return 0 on two empty strings"); return NULL; } Py_DECREF(result); /* We don't accept multiple set_bt_compare operations, in order to * simplify the code. This would have no real use, as one cannot * change the function once the db is opened anyway */ if (self->btCompareCallback != NULL) { PyErr_SetString(PyExc_RuntimeError, "set_bt_compare() cannot be called more than once"); return NULL; } Py_INCREF(comparator); self->btCompareCallback = comparator; /* This is to workaround a problem with un-initialized threads (see comment in DB_associate) */ #ifdef WITH_THREAD PyEval_InitThreads(); #endif err = self->db->set_bt_compare(self->db, _db_compareCallback); if (err) { /* restore the old state in case of error */ Py_DECREF(comparator); self->btCompareCallback = NULL; } RETURN_IF_ERR(); RETURN_NONE(); } static int _db_dupCompareCallback(DB* db, const DBT *leftKey, const DBT *rightKey #if (DBVER >= 61) , size_t *locp #endif ) { int res = 0; PyObject *args; PyObject *result = NULL; DBObject *self = (DBObject *)db->app_private; #if (DBVER >= 61) locp = NULL; /* As required by documentation */ #endif if (self == NULL || self->dupCompareCallback == NULL) { MYDB_BEGIN_BLOCK_THREADS; PyErr_SetString(PyExc_TypeError, (self == 0 ? "DB_dup_compare db is NULL." : "DB_dup_compare callback is NULL.")); /* we're in a callback within the DB code, we can't raise */ PyErr_Print(); res = _default_cmp(leftKey, rightKey); MYDB_END_BLOCK_THREADS; } else { MYDB_BEGIN_BLOCK_THREADS; args = BuildValue_SS(leftKey->data, leftKey->size, rightKey->data, rightKey->size); if (args != NULL) { result = PyObject_CallObject(self->dupCompareCallback, args); } if (args == NULL || result == NULL) { /* we're in a callback within the DB code, we can't raise */ PyErr_Print(); res = _default_cmp(leftKey, rightKey); } else if (NUMBER_Check(result)) { res = NUMBER_AsLong(result); } else { PyErr_SetString(PyExc_TypeError, "DB_dup_compare callback MUST return an int."); /* we're in a callback within the DB code, we can't raise */ PyErr_Print(); res = _default_cmp(leftKey, rightKey); } Py_XDECREF(args); Py_XDECREF(result); MYDB_END_BLOCK_THREADS; } return res; } static PyObject* DB_set_dup_compare(DBObject* self, PyObject* comparator) { int err; PyObject *tuple, *result; CHECK_DB_NOT_CLOSED(self); if (!PyCallable_Check(comparator)) { makeTypeError("Callable", comparator); return NULL; } /* * Perform a test call of the comparator function with two empty * string objects here. verify that it returns an int (0). * err if not. */ tuple = Py_BuildValue("(ss)", "", ""); result = PyObject_CallObject(comparator, tuple); Py_DECREF(tuple); if (result == NULL) return NULL; if (!NUMBER_Check(result)) { Py_DECREF(result); PyErr_SetString(PyExc_TypeError, "callback MUST return an int"); return NULL; } else if (NUMBER_AsLong(result) != 0) { Py_DECREF(result); PyErr_SetString(PyExc_TypeError, "callback failed to return 0 on two empty strings"); return NULL; } Py_DECREF(result); /* We don't accept multiple set_dup_compare operations, in order to * simplify the code. This would have no real use, as one cannot * change the function once the db is opened anyway */ if (self->dupCompareCallback != NULL) { PyErr_SetString(PyExc_RuntimeError, "set_dup_compare() cannot be called more than once"); return NULL; } Py_INCREF(comparator); self->dupCompareCallback = comparator; /* This is to workaround a problem with un-initialized threads (see comment in DB_associate) */ #ifdef WITH_THREAD PyEval_InitThreads(); #endif err = self->db->set_dup_compare(self->db, _db_dupCompareCallback); if (err) { /* restore the old state in case of error */ Py_DECREF(comparator); self->dupCompareCallback = NULL; } RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DB_set_cachesize(DBObject* self, PyObject* args) { int err; int gbytes = 0, bytes = 0, ncache = 0; if (!PyArg_ParseTuple(args,"ii|i:set_cachesize", &gbytes,&bytes,&ncache)) return NULL; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->set_cachesize(self->db, gbytes, bytes, ncache); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DB_get_cachesize(DBObject* self) { int err; u_int32_t gbytes, bytes; int ncache; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->get_cachesize(self->db, &gbytes, &bytes, &ncache); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return Py_BuildValue("(iii)", gbytes, bytes, ncache); } static PyObject* DB_set_flags(DBObject* self, PyObject* args) { int err, flags; if (!PyArg_ParseTuple(args,"i:set_flags", &flags)) return NULL; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->set_flags(self->db, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); self->setflags |= flags; RETURN_NONE(); } static PyObject* DB_get_flags(DBObject* self) { int err; u_int32_t flags; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->get_flags(self->db, &flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(flags); } static PyObject* DB_get_transactional(DBObject* self) { int err; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->get_transactional(self->db); MYDB_END_ALLOW_THREADS; if(err == 0) { Py_INCREF(Py_False); return Py_False; } else if(err == 1) { Py_INCREF(Py_True); return Py_True; } /* ** If we reach there, there was an error. The ** "return" should be unreachable. */ RETURN_IF_ERR(); assert(0); /* This code SHOULD be unreachable */ return NULL; } static PyObject* DB_set_h_ffactor(DBObject* self, PyObject* args) { int err, ffactor; if (!PyArg_ParseTuple(args,"i:set_h_ffactor", &ffactor)) return NULL; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->set_h_ffactor(self->db, ffactor); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DB_get_h_ffactor(DBObject* self) { int err; u_int32_t ffactor; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->get_h_ffactor(self->db, &ffactor); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(ffactor); } static PyObject* DB_set_h_nelem(DBObject* self, PyObject* args) { int err, nelem; if (!PyArg_ParseTuple(args,"i:set_h_nelem", &nelem)) return NULL; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->set_h_nelem(self->db, nelem); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DB_get_h_nelem(DBObject* self) { int err; u_int32_t nelem; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->get_h_nelem(self->db, &nelem); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(nelem); } static PyObject* DB_set_lorder(DBObject* self, PyObject* args) { int err, lorder; if (!PyArg_ParseTuple(args,"i:set_lorder", &lorder)) return NULL; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->set_lorder(self->db, lorder); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DB_get_lorder(DBObject* self) { int err; int lorder; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->get_lorder(self->db, &lorder); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(lorder); } static PyObject* DB_set_pagesize(DBObject* self, PyObject* args) { int err, pagesize; if (!PyArg_ParseTuple(args,"i:set_pagesize", &pagesize)) return NULL; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->set_pagesize(self->db, pagesize); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DB_get_pagesize(DBObject* self) { int err; u_int32_t pagesize; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->get_pagesize(self->db, &pagesize); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(pagesize); } static PyObject* DB_set_re_delim(DBObject* self, PyObject* args) { int err; char delim; if (!PyArg_ParseTuple(args,"b:set_re_delim", &delim)) { PyErr_Clear(); if (!PyArg_ParseTuple(args,"c:set_re_delim", &delim)) return NULL; } CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->set_re_delim(self->db, delim); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DB_get_re_delim(DBObject* self) { int err, re_delim; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->get_re_delim(self->db, &re_delim); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(re_delim); } static PyObject* DB_set_re_len(DBObject* self, PyObject* args) { int err, len; if (!PyArg_ParseTuple(args,"i:set_re_len", &len)) return NULL; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->set_re_len(self->db, len); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DB_get_re_len(DBObject* self) { int err; u_int32_t re_len; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->get_re_len(self->db, &re_len); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(re_len); } static PyObject* DB_set_re_pad(DBObject* self, PyObject* args) { int err; char pad; if (!PyArg_ParseTuple(args,"b:set_re_pad", &pad)) { PyErr_Clear(); if (!PyArg_ParseTuple(args,"c:set_re_pad", &pad)) return NULL; } CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->set_re_pad(self->db, pad); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DB_get_re_pad(DBObject* self) { int err, re_pad; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->get_re_pad(self->db, &re_pad); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(re_pad); } static PyObject* DB_set_re_source(DBObject* self, PyObject* args) { int err; char *source; if (!PyArg_ParseTuple(args,"s:set_re_source", &source)) return NULL; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->set_re_source(self->db, source); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DB_get_re_source(DBObject* self) { int err; const char *source; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->get_re_source(self->db, &source); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return PyBytes_FromString(source); } static PyObject* DB_stat(DBObject* self, PyObject* args, PyObject* kwargs) { int err, flags = 0, type; void* sp; PyObject* d; PyObject* txnobj = NULL; DB_TXN *txn = NULL; static char* kwnames[] = { "flags", "txn", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|iO:stat", kwnames, &flags, &txnobj)) return NULL; if (!checkTxnObj(txnobj, &txn)) return NULL; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->stat(self->db, txn, &sp, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); /* Turn the stat structure into a dictionary */ type = _DB_get_type(self); if ((type == -1) || ((d = PyDict_New()) == NULL)) { free(sp); return NULL; } #define MAKE_HASH_ENTRY(name) _addIntToDict(d, #name, ((DB_HASH_STAT*)sp)->hash_##name) #define MAKE_BT_ENTRY(name) _addIntToDict(d, #name, ((DB_BTREE_STAT*)sp)->bt_##name) #define MAKE_QUEUE_ENTRY(name) _addIntToDict(d, #name, ((DB_QUEUE_STAT*)sp)->qs_##name) switch (type) { case DB_HASH: MAKE_HASH_ENTRY(magic); MAKE_HASH_ENTRY(version); MAKE_HASH_ENTRY(nkeys); MAKE_HASH_ENTRY(ndata); MAKE_HASH_ENTRY(pagecnt); MAKE_HASH_ENTRY(pagesize); MAKE_HASH_ENTRY(ffactor); MAKE_HASH_ENTRY(buckets); MAKE_HASH_ENTRY(free); MAKE_HASH_ENTRY(bfree); MAKE_HASH_ENTRY(bigpages); MAKE_HASH_ENTRY(big_bfree); MAKE_HASH_ENTRY(overflows); MAKE_HASH_ENTRY(ovfl_free); MAKE_HASH_ENTRY(dup); MAKE_HASH_ENTRY(dup_free); break; case DB_BTREE: case DB_RECNO: MAKE_BT_ENTRY(magic); MAKE_BT_ENTRY(version); MAKE_BT_ENTRY(nkeys); MAKE_BT_ENTRY(ndata); MAKE_BT_ENTRY(pagecnt); MAKE_BT_ENTRY(pagesize); MAKE_BT_ENTRY(minkey); MAKE_BT_ENTRY(re_len); MAKE_BT_ENTRY(re_pad); MAKE_BT_ENTRY(levels); MAKE_BT_ENTRY(int_pg); MAKE_BT_ENTRY(leaf_pg); MAKE_BT_ENTRY(dup_pg); MAKE_BT_ENTRY(over_pg); MAKE_BT_ENTRY(empty_pg); MAKE_BT_ENTRY(free); MAKE_BT_ENTRY(int_pgfree); MAKE_BT_ENTRY(leaf_pgfree); MAKE_BT_ENTRY(dup_pgfree); MAKE_BT_ENTRY(over_pgfree); break; case DB_QUEUE: MAKE_QUEUE_ENTRY(magic); MAKE_QUEUE_ENTRY(version); MAKE_QUEUE_ENTRY(nkeys); MAKE_QUEUE_ENTRY(ndata); MAKE_QUEUE_ENTRY(pagesize); MAKE_QUEUE_ENTRY(extentsize); MAKE_QUEUE_ENTRY(pages); MAKE_QUEUE_ENTRY(re_len); MAKE_QUEUE_ENTRY(re_pad); MAKE_QUEUE_ENTRY(pgfree); MAKE_QUEUE_ENTRY(first_recno); MAKE_QUEUE_ENTRY(cur_recno); break; default: PyErr_SetString(PyExc_TypeError, "Unknown DB type, unable to stat"); Py_DECREF(d); d = NULL; } #undef MAKE_HASH_ENTRY #undef MAKE_BT_ENTRY #undef MAKE_QUEUE_ENTRY free(sp); return d; } static PyObject* DB_stat_print(DBObject* self, PyObject* args, PyObject *kwargs) { int err; int flags=0; static char* kwnames[] = { "flags", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i:stat_print", kwnames, &flags)) { return NULL; } CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->stat_print(self->db, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DB_sync(DBObject* self, PyObject* args) { int err; int flags = 0; if (!PyArg_ParseTuple(args,"|i:sync", &flags )) return NULL; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->sync(self->db, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DB_truncate(DBObject* self, PyObject* args, PyObject* kwargs) { int err, flags=0; u_int32_t count=0; PyObject* txnobj = NULL; DB_TXN *txn = NULL; static char* kwnames[] = { "txn", "flags", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|Oi:cursor", kwnames, &txnobj, &flags)) return NULL; CHECK_DB_NOT_CLOSED(self); if (!checkTxnObj(txnobj, &txn)) return NULL; MYDB_BEGIN_ALLOW_THREADS; err = self->db->truncate(self->db, txn, &count, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(count); } static PyObject* DB_upgrade(DBObject* self, PyObject* args) { int err, flags=0; char *filename; if (!PyArg_ParseTuple(args,"s|i:upgrade", &filename, &flags)) return NULL; CHECK_DB_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db->upgrade(self->db, filename, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DB_verify(DBObject* self, PyObject* args, PyObject* kwargs) { int err, flags=0; char* fileName; char* dbName=NULL; char* outFileName=NULL; FILE* outFile=NULL; static char* kwnames[] = { "filename", "dbname", "outfile", "flags", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|zzi:verify", kwnames, &fileName, &dbName, &outFileName, &flags)) return NULL; CHECK_DB_NOT_CLOSED(self); if (outFileName) outFile = fopen(outFileName, "w"); /* XXX(nnorwitz): it should probably be an exception if outFile can't be opened. */ { /* DB.verify acts as a DB handle destructor (like close) */ PyObject *error; error=DB_close_internal(self, 0, 1); if (error) { return error; } } MYDB_BEGIN_ALLOW_THREADS; err = self->db->verify(self->db, fileName, dbName, outFile, flags); MYDB_END_ALLOW_THREADS; self->db = NULL; /* Implicit close; related objects already released */ if (outFile) fclose(outFile); RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DB_set_get_returns_none(DBObject* self, PyObject* args) { int flags=0; int oldValue=0; if (!PyArg_ParseTuple(args,"i:set_get_returns_none", &flags)) return NULL; CHECK_DB_NOT_CLOSED(self); if (self->moduleFlags.getReturnsNone) ++oldValue; if (self->moduleFlags.cursorSetReturnsNone) ++oldValue; self->moduleFlags.getReturnsNone = (flags >= 1); self->moduleFlags.cursorSetReturnsNone = (flags >= 2); return NUMBER_FromLong(oldValue); } static PyObject* DB_set_encrypt(DBObject* self, PyObject* args, PyObject* kwargs) { int err; u_int32_t flags=0; char *passwd = NULL; static char* kwnames[] = { "passwd", "flags", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|i:set_encrypt", kwnames, &passwd, &flags)) { return NULL; } MYDB_BEGIN_ALLOW_THREADS; err = self->db->set_encrypt(self->db, passwd, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DB_get_encrypt_flags(DBObject* self) { int err; u_int32_t flags; MYDB_BEGIN_ALLOW_THREADS; err = self->db->get_encrypt_flags(self->db, &flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(flags); } /*-------------------------------------------------------------- */ /* Mapping and Dictionary-like access routines */ Py_ssize_t DB_length(PyObject* _self) { int err; Py_ssize_t size = 0; void* sp; DBObject* self = (DBObject*)_self; if (self->db == NULL) { PyObject *t = Py_BuildValue("(is)", 0, "DB object has been closed"); if (t) { PyErr_SetObject(DBError, t); Py_DECREF(t); } return -1; } MYDB_BEGIN_ALLOW_THREADS; err = self->db->stat(self->db, /*txnid*/ NULL, &sp, 0); MYDB_END_ALLOW_THREADS; if (makeDBError(err)) { return -1; } /* All the stat structures have matching fields upto the ndata field, so we can use any of them for the type cast */ size = ((DB_BTREE_STAT*)sp)->bt_ndata; free(sp); return size; } PyObject* DB_subscript(DBObject* self, PyObject* keyobj) { int err; PyObject* retval; DBT key; DBT data; CHECK_DB_NOT_CLOSED(self); if (!make_key_dbt(self, keyobj, &key, NULL)) return NULL; CLEAR_DBT(data); if (CHECK_DBFLAG(self, DB_THREAD)) { /* Tell Berkeley DB to malloc the return value (thread safe) */ data.flags = DB_DBT_MALLOC; } MYDB_BEGIN_ALLOW_THREADS; err = self->db->get(self->db, NULL, &key, &data, 0); MYDB_END_ALLOW_THREADS; if (err == DB_NOTFOUND || err == DB_KEYEMPTY) { PyErr_SetObject(PyExc_KeyError, keyobj); retval = NULL; } else if (makeDBError(err)) { retval = NULL; } else { retval = Build_PyString(data.data, data.size); FREE_DBT(data); } FREE_DBT(key); return retval; } static int DB_ass_sub(DBObject* self, PyObject* keyobj, PyObject* dataobj) { DBT key, data; int retval; int flags = 0; if (self->db == NULL) { PyObject *t = Py_BuildValue("(is)", 0, "DB object has been closed"); if (t) { PyErr_SetObject(DBError, t); Py_DECREF(t); } return -1; } if (!make_key_dbt(self, keyobj, &key, NULL)) return -1; if (dataobj != NULL) { if (!make_dbt(dataobj, &data)) retval = -1; else { if (self->setflags & (DB_DUP|DB_DUPSORT)) /* dictionaries shouldn't have duplicate keys */ flags = DB_NOOVERWRITE; retval = _DB_put(self, NULL, &key, &data, flags); if ((retval == -1) && (self->setflags & (DB_DUP|DB_DUPSORT))) { /* try deleting any old record that matches and then PUT it * again... */ _DB_delete(self, NULL, &key, 0); PyErr_Clear(); retval = _DB_put(self, NULL, &key, &data, flags); } } } else { /* dataobj == NULL, so delete the key */ retval = _DB_delete(self, NULL, &key, 0); } FREE_DBT(key); return retval; } static PyObject* _DB_has_key(DBObject* self, PyObject* keyobj, PyObject* txnobj) { int err; DBT key; DB_TXN *txn = NULL; CHECK_DB_NOT_CLOSED(self); if (!make_key_dbt(self, keyobj, &key, NULL)) return NULL; if (!checkTxnObj(txnobj, &txn)) { FREE_DBT(key); return NULL; } MYDB_BEGIN_ALLOW_THREADS; err = self->db->exists(self->db, txn, &key, 0); MYDB_END_ALLOW_THREADS; FREE_DBT(key); /* ** DB_BUFFER_SMALL is only used if we use "get". ** We can drop it when we only use "exists", ** when we drop suport for Berkeley DB < 4.6. */ if (err == DB_BUFFER_SMALL || err == 0) { Py_INCREF(Py_True); return Py_True; } else if (err == DB_NOTFOUND || err == DB_KEYEMPTY) { Py_INCREF(Py_False); return Py_False; } makeDBError(err); return NULL; } static PyObject* DB_has_key(DBObject* self, PyObject* args, PyObject* kwargs) { PyObject* keyobj; PyObject* txnobj = NULL; static char* kwnames[] = {"key","txn", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:has_key", kwnames, &keyobj, &txnobj)) return NULL; return _DB_has_key(self, keyobj, txnobj); } static int DB_contains(DBObject* self, PyObject* keyobj) { PyObject* result; int result2 = 0; result = _DB_has_key(self, keyobj, NULL) ; if (result == NULL) { return -1; /* Propague exception */ } if (result != Py_False) { result2 = 1; } Py_DECREF(result); return result2; } #define _KEYS_LIST 1 #define _VALUES_LIST 2 #define _ITEMS_LIST 3 static PyObject* _DB_make_list(DBObject* self, DB_TXN* txn, int type) { int err, dbtype; DBT key; DBT data; DBC *cursor; PyObject* list; PyObject* item = NULL; CHECK_DB_NOT_CLOSED(self); CLEAR_DBT(key); CLEAR_DBT(data); dbtype = _DB_get_type(self); if (dbtype == -1) return NULL; list = PyList_New(0); if (list == NULL) return NULL; /* get a cursor */ MYDB_BEGIN_ALLOW_THREADS; err = self->db->cursor(self->db, txn, &cursor, 0); MYDB_END_ALLOW_THREADS; if (makeDBError(err)) { Py_DECREF(list); return NULL; } while (1) { /* use the cursor to traverse the DB, collecting items */ MYDB_BEGIN_ALLOW_THREADS; err = _DBC_get(cursor, &key, &data, DB_NEXT); MYDB_END_ALLOW_THREADS; if (err) { /* for any error, break out of the loop */ break; } switch (type) { case _KEYS_LIST: switch(dbtype) { case DB_BTREE: case DB_HASH: default: item = Build_PyString(key.data, key.size); break; case DB_RECNO: case DB_QUEUE: item = NUMBER_FromLong(*((db_recno_t*)key.data)); break; } break; case _VALUES_LIST: item = Build_PyString(data.data, data.size); break; case _ITEMS_LIST: switch(dbtype) { case DB_BTREE: case DB_HASH: default: item = BuildValue_SS(key.data, key.size, data.data, data.size); break; case DB_RECNO: case DB_QUEUE: item = BuildValue_IS(*((db_recno_t*)key.data), data.data, data.size); break; } break; default: PyErr_Format(PyExc_ValueError, "Unknown key type 0x%x", type); item = NULL; break; } if (item == NULL) { Py_DECREF(list); list = NULL; goto done; } if (PyList_Append(list, item)) { Py_DECREF(list); Py_DECREF(item); list = NULL; goto done; } Py_DECREF(item); } /* DB_NOTFOUND || DB_KEYEMPTY is okay, it means we got to the end */ if (err != DB_NOTFOUND && err != DB_KEYEMPTY && makeDBError(err)) { Py_DECREF(list); list = NULL; } done: MYDB_BEGIN_ALLOW_THREADS; _DBC_close(cursor); MYDB_END_ALLOW_THREADS; return list; } static PyObject* DB_keys(DBObject* self, PyObject* args) { PyObject* txnobj = NULL; DB_TXN *txn = NULL; if (!PyArg_UnpackTuple(args, "keys", 0, 1, &txnobj)) return NULL; if (!checkTxnObj(txnobj, &txn)) return NULL; return _DB_make_list(self, txn, _KEYS_LIST); } static PyObject* DB_items(DBObject* self, PyObject* args) { PyObject* txnobj = NULL; DB_TXN *txn = NULL; if (!PyArg_UnpackTuple(args, "items", 0, 1, &txnobj)) return NULL; if (!checkTxnObj(txnobj, &txn)) return NULL; return _DB_make_list(self, txn, _ITEMS_LIST); } static PyObject* DB_values(DBObject* self, PyObject* args) { PyObject* txnobj = NULL; DB_TXN *txn = NULL; if (!PyArg_UnpackTuple(args, "values", 0, 1, &txnobj)) return NULL; if (!checkTxnObj(txnobj, &txn)) return NULL; return _DB_make_list(self, txn, _VALUES_LIST); } /* --------------------------------------------------------------------- */ /* DBLogCursor methods */ static PyObject* DBLogCursor_close_internal(DBLogCursorObject* self) { int err = 0; if (self->logc != NULL) { EXTRACT_FROM_DOUBLE_LINKED_LIST(self); MYDB_BEGIN_ALLOW_THREADS; err = self->logc->close(self->logc, 0); MYDB_END_ALLOW_THREADS; self->logc = NULL; } RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBLogCursor_close(DBLogCursorObject* self) { return DBLogCursor_close_internal(self); } static PyObject* _DBLogCursor_get(DBLogCursorObject* self, int flag, DB_LSN *lsn2) { int err; DBT data; DB_LSN lsn = {0, 0}; PyObject *dummy, *retval; CLEAR_DBT(data); data.flags = DB_DBT_MALLOC; /* Berkeley DB must do the malloc */ CHECK_LOGCURSOR_NOT_CLOSED(self); if (lsn2) lsn = *lsn2; MYDB_BEGIN_ALLOW_THREADS; err = self->logc->get(self->logc, &lsn, &data, flag); MYDB_END_ALLOW_THREADS; if (err == DB_NOTFOUND) { Py_INCREF(Py_None); retval = Py_None; } else if (makeDBError(err)) { retval = NULL; } else { retval = dummy = BuildValue_S(data.data, data.size); if (dummy) { retval = Py_BuildValue("(ii)O", lsn.file, lsn.offset, dummy); Py_DECREF(dummy); } } FREE_DBT(data); return retval; } static PyObject* DBLogCursor_current(DBLogCursorObject* self) { return _DBLogCursor_get(self, DB_CURRENT, NULL); } static PyObject* DBLogCursor_first(DBLogCursorObject* self) { return _DBLogCursor_get(self, DB_FIRST, NULL); } static PyObject* DBLogCursor_last(DBLogCursorObject* self) { return _DBLogCursor_get(self, DB_LAST, NULL); } static PyObject* DBLogCursor_next(DBLogCursorObject* self) { return _DBLogCursor_get(self, DB_NEXT, NULL); } static PyObject* DBLogCursor_prev(DBLogCursorObject* self) { return _DBLogCursor_get(self, DB_PREV, NULL); } static PyObject* DBLogCursor_set(DBLogCursorObject* self, PyObject* args) { DB_LSN lsn; if (!PyArg_ParseTuple(args, "(ii):set", &lsn.file, &lsn.offset)) return NULL; return _DBLogCursor_get(self, DB_SET, &lsn); } /* --------------------------------------------------------------------- */ /* DBSite methods */ #if (DBVER >= 53) static PyObject* DBSite_close_internal(DBSiteObject* self) { int err = 0; if (self->site != NULL) { EXTRACT_FROM_DOUBLE_LINKED_LIST(self); MYDB_BEGIN_ALLOW_THREADS; err = self->site->close(self->site); MYDB_END_ALLOW_THREADS; self->site = NULL; } RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBSite_close(DBSiteObject* self) { return DBSite_close_internal(self); } static PyObject* DBSite_remove(DBSiteObject* self) { int err = 0; CHECK_SITE_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->site->remove(self->site); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBSite_get_eid(DBSiteObject* self) { int err = 0; int eid; CHECK_SITE_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->site->get_eid(self->site, &eid); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(eid); } static PyObject* DBSite_get_address(DBSiteObject* self) { int err = 0; const char *host; u_int port; CHECK_SITE_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->site->get_address(self->site, &host, &port); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return Py_BuildValue("(sI)", host, port); } static PyObject* DBSite_get_config(DBSiteObject* self, PyObject* args, PyObject* kwargs) { int err = 0; u_int32_t which, value; static char* kwnames[] = { "which", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i:get_config", kwnames, &which)) return NULL; CHECK_SITE_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->site->get_config(self->site, which, &value); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); if (value) { Py_INCREF(Py_True); return Py_True; } else { Py_INCREF(Py_False); return Py_False; } } static PyObject* DBSite_set_config(DBSiteObject* self, PyObject* args, PyObject* kwargs) { int err = 0; u_int32_t which, value; PyObject *valueO; static char* kwnames[] = { "which", "value", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "iO:set_config", kwnames, &which, &valueO)) return NULL; CHECK_SITE_NOT_CLOSED(self); value = PyObject_IsTrue(valueO); MYDB_BEGIN_ALLOW_THREADS; err = self->site->set_config(self->site, which, value); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } #endif /* --------------------------------------------------------------------- */ /* DBCursor methods */ static PyObject* DBC_close_internal(DBCursorObject* self) { int err = 0; if (self->dbc != NULL) { EXTRACT_FROM_DOUBLE_LINKED_LIST(self); if (self->txn) { EXTRACT_FROM_DOUBLE_LINKED_LIST_TXN(self); self->txn=NULL; } MYDB_BEGIN_ALLOW_THREADS; err = _DBC_close(self->dbc); MYDB_END_ALLOW_THREADS; self->dbc = NULL; } RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBC_close(DBCursorObject* self) { return DBC_close_internal(self); } static PyObject* DBC_count(DBCursorObject* self, PyObject* args) { int err = 0; db_recno_t count; int flags = 0; if (!PyArg_ParseTuple(args, "|i:count", &flags)) return NULL; CHECK_CURSOR_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = _DBC_count(self->dbc, &count, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(count); } static PyObject* DBC_current(DBCursorObject* self, PyObject* args, PyObject *kwargs) { return _DBCursor_get(self,DB_CURRENT,args,kwargs,"|iii:current"); } static PyObject* DBC_delete(DBCursorObject* self, PyObject* args) { int err, flags=0; if (!PyArg_ParseTuple(args, "|i:delete", &flags)) return NULL; CHECK_CURSOR_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = _DBC_del(self->dbc, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBC_dup(DBCursorObject* self, PyObject* args) { int err, flags =0; DBC* dbc = NULL; if (!PyArg_ParseTuple(args, "|i:dup", &flags)) return NULL; CHECK_CURSOR_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = _DBC_dup(self->dbc, &dbc, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return (PyObject*) newDBCursorObject(dbc, self->txn, self->mydb); } static PyObject* DBC_first(DBCursorObject* self, PyObject* args, PyObject* kwargs) { return _DBCursor_get(self,DB_FIRST,args,kwargs,"|iii:first"); } static PyObject* DBC_get(DBCursorObject* self, PyObject* args, PyObject *kwargs) { int err, flags=0; PyObject* keyobj = NULL; PyObject* dataobj = NULL; PyObject* retval = NULL; int dlen = -1; int doff = -1; DBT key, data; static char* kwnames[] = { "key","data", "flags", "dlen", "doff", NULL }; CLEAR_DBT(key); CLEAR_DBT(data); if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i|ii:get", &kwnames[2], &flags, &dlen, &doff)) { PyErr_Clear(); if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Oi|ii:get", &kwnames[1], &keyobj, &flags, &dlen, &doff)) { PyErr_Clear(); if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOi|ii:get", kwnames, &keyobj, &dataobj, &flags, &dlen, &doff)) { return NULL; } } } CHECK_CURSOR_NOT_CLOSED(self); if (keyobj && !make_key_dbt(self->mydb, keyobj, &key, NULL)) return NULL; if ( (dataobj && !make_dbt(dataobj, &data)) || (!add_partial_dbt(&data, dlen, doff)) ) { FREE_DBT(key); /* 'make_key_dbt' could do a 'malloc' */ return NULL; } MYDB_BEGIN_ALLOW_THREADS; err = _DBC_get(self->dbc, &key, &data, flags); MYDB_END_ALLOW_THREADS; if ((err == DB_NOTFOUND || err == DB_KEYEMPTY) && self->mydb->moduleFlags.getReturnsNone) { Py_INCREF(Py_None); retval = Py_None; } else if (makeDBError(err)) { retval = NULL; } else { switch (_DB_get_type(self->mydb)) { case -1: retval = NULL; break; case DB_BTREE: case DB_HASH: default: retval = BuildValue_SS(key.data, key.size, data.data, data.size); break; case DB_RECNO: case DB_QUEUE: retval = BuildValue_IS(*((db_recno_t*)key.data), data.data, data.size); break; } } FREE_DBT(key); /* 'make_key_dbt' could do a 'malloc' */ return retval; } static PyObject* DBC_pget(DBCursorObject* self, PyObject* args, PyObject *kwargs) { int err, flags=0; PyObject* keyobj = NULL; PyObject* dataobj = NULL; PyObject* retval = NULL; int dlen = -1; int doff = -1; DBT key, pkey, data; static char* kwnames_keyOnly[] = { "key", "flags", "dlen", "doff", NULL }; static char* kwnames[] = { "key", "data", "flags", "dlen", "doff", NULL }; CLEAR_DBT(key); CLEAR_DBT(data); if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i|ii:pget", &kwnames[2], &flags, &dlen, &doff)) { PyErr_Clear(); if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Oi|ii:pget", kwnames_keyOnly, &keyobj, &flags, &dlen, &doff)) { PyErr_Clear(); if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOi|ii:pget", kwnames, &keyobj, &dataobj, &flags, &dlen, &doff)) { return NULL; } } } CHECK_CURSOR_NOT_CLOSED(self); if (keyobj && !make_key_dbt(self->mydb, keyobj, &key, NULL)) return NULL; if ( (dataobj && !make_dbt(dataobj, &data)) || (!add_partial_dbt(&data, dlen, doff)) ) { FREE_DBT(key); /* 'make_key_dbt' could do a 'malloc' */ return NULL; } CLEAR_DBT(pkey); pkey.flags = DB_DBT_MALLOC; MYDB_BEGIN_ALLOW_THREADS; err = _DBC_pget(self->dbc, &key, &pkey, &data, flags); MYDB_END_ALLOW_THREADS; if ((err == DB_NOTFOUND || err == DB_KEYEMPTY) && self->mydb->moduleFlags.getReturnsNone) { Py_INCREF(Py_None); retval = Py_None; } else if (makeDBError(err)) { retval = NULL; } else { PyObject *pkeyObj; PyObject *dataObj; dataObj = Build_PyString(data.data, data.size); if (self->mydb->primaryDBType == DB_RECNO || self->mydb->primaryDBType == DB_QUEUE) pkeyObj = NUMBER_FromLong(*(int *)pkey.data); else pkeyObj = Build_PyString(pkey.data, pkey.size); if (key.data && key.size) /* return key, pkey and data */ { PyObject *keyObj; int type = _DB_get_type(self->mydb); if (type == DB_RECNO || type == DB_QUEUE) keyObj = NUMBER_FromLong(*(int *)key.data); else keyObj = Build_PyString(key.data, key.size); retval = PyTuple_Pack(3, keyObj, pkeyObj, dataObj); Py_DECREF(keyObj); FREE_DBT(key); /* 'make_key_dbt' could do a 'malloc' */ } else /* return just the pkey and data */ { retval = PyTuple_Pack(2, pkeyObj, dataObj); } Py_DECREF(dataObj); Py_DECREF(pkeyObj); FREE_DBT(pkey); } /* the only time REALLOC should be set is if we used an integer * key that make_key_dbt malloc'd for us. always free these. */ if (key.flags & DB_DBT_REALLOC) { /* 'make_key_dbt' could do a 'malloc' */ FREE_DBT(key); } return retval; } static PyObject* DBC_get_recno(DBCursorObject* self) { int err; db_recno_t recno; DBT key; DBT data; CHECK_CURSOR_NOT_CLOSED(self); CLEAR_DBT(key); CLEAR_DBT(data); MYDB_BEGIN_ALLOW_THREADS; err = _DBC_get(self->dbc, &key, &data, DB_GET_RECNO); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); recno = *((db_recno_t*)data.data); return NUMBER_FromLong(recno); } static PyObject* DBC_last(DBCursorObject* self, PyObject* args, PyObject *kwargs) { return _DBCursor_get(self,DB_LAST,args,kwargs,"|iii:last"); } static PyObject* DBC_next(DBCursorObject* self, PyObject* args, PyObject *kwargs) { return _DBCursor_get(self,DB_NEXT,args,kwargs,"|iii:next"); } static PyObject* DBC_prev(DBCursorObject* self, PyObject* args, PyObject *kwargs) { return _DBCursor_get(self,DB_PREV,args,kwargs,"|iii:prev"); } static PyObject* DBC_put(DBCursorObject* self, PyObject* args, PyObject* kwargs) { int err, flags = 0; PyObject* keyobj, *dataobj; DBT key, data; static char* kwnames[] = { "key", "data", "flags", "dlen", "doff", NULL }; int dlen = -1; int doff = -1; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|iii:put", kwnames, &keyobj, &dataobj, &flags, &dlen, &doff)) return NULL; CHECK_CURSOR_NOT_CLOSED(self); if (!make_key_dbt(self->mydb, keyobj, &key, NULL)) return NULL; if (!make_dbt(dataobj, &data) || !add_partial_dbt(&data, dlen, doff) ) { FREE_DBT(key); /* 'make_key_dbt' could do a 'malloc' */ return NULL; } MYDB_BEGIN_ALLOW_THREADS; err = _DBC_put(self->dbc, &key, &data, flags); MYDB_END_ALLOW_THREADS; FREE_DBT(key); /* 'make_key_dbt' could do a 'malloc' */ RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBC_set(DBCursorObject* self, PyObject* args, PyObject *kwargs) { int err, flags = 0; DBT key, data; PyObject* retval, *keyobj; static char* kwnames[] = { "key", "flags", "dlen", "doff", NULL }; int dlen = -1; int doff = -1; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|iii:set", kwnames, &keyobj, &flags, &dlen, &doff)) return NULL; CHECK_CURSOR_NOT_CLOSED(self); if (!make_key_dbt(self->mydb, keyobj, &key, NULL)) return NULL; CLEAR_DBT(data); if (!add_partial_dbt(&data, dlen, doff)) { FREE_DBT(key); /* 'make_key_dbt' could do a 'malloc' */ return NULL; } MYDB_BEGIN_ALLOW_THREADS; err = _DBC_get(self->dbc, &key, &data, flags|DB_SET); MYDB_END_ALLOW_THREADS; if ((err == DB_NOTFOUND || err == DB_KEYEMPTY) && self->mydb->moduleFlags.cursorSetReturnsNone) { Py_INCREF(Py_None); retval = Py_None; } else if (makeDBError(err)) { retval = NULL; } else { switch (_DB_get_type(self->mydb)) { case -1: retval = NULL; break; case DB_BTREE: case DB_HASH: default: retval = BuildValue_SS(key.data, key.size, data.data, data.size); break; case DB_RECNO: case DB_QUEUE: retval = BuildValue_IS(*((db_recno_t*)key.data), data.data, data.size); break; } FREE_DBT(key); /* 'make_key_dbt' could do a 'malloc' */ } /* the only time REALLOC should be set is if we used an integer * key that make_key_dbt malloc'd for us. always free these. */ if (key.flags & DB_DBT_REALLOC) { FREE_DBT(key); /* 'make_key_dbt' could do a 'malloc' */ } return retval; } static PyObject* DBC_set_range(DBCursorObject* self, PyObject* args, PyObject* kwargs) { int err, flags = 0; DBT key, data; PyObject* retval, *keyobj; static char* kwnames[] = { "key", "flags", "dlen", "doff", NULL }; int dlen = -1; int doff = -1; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|iii:set_range", kwnames, &keyobj, &flags, &dlen, &doff)) return NULL; CHECK_CURSOR_NOT_CLOSED(self); if (!make_key_dbt(self->mydb, keyobj, &key, NULL)) return NULL; CLEAR_DBT(data); if (!add_partial_dbt(&data, dlen, doff)) { FREE_DBT(key); /* 'make_key_dbt' could do a 'malloc' */ return NULL; } MYDB_BEGIN_ALLOW_THREADS; err = _DBC_get(self->dbc, &key, &data, flags|DB_SET_RANGE); MYDB_END_ALLOW_THREADS; if ((err == DB_NOTFOUND || err == DB_KEYEMPTY) && self->mydb->moduleFlags.cursorSetReturnsNone) { Py_INCREF(Py_None); retval = Py_None; } else if (makeDBError(err)) { retval = NULL; } else { switch (_DB_get_type(self->mydb)) { case -1: retval = NULL; break; case DB_BTREE: case DB_HASH: default: retval = BuildValue_SS(key.data, key.size, data.data, data.size); break; case DB_RECNO: case DB_QUEUE: retval = BuildValue_IS(*((db_recno_t*)key.data), data.data, data.size); break; } FREE_DBT(key); /* 'make_key_dbt' could do a 'malloc' */ } /* the only time REALLOC should be set is if we used an integer * key that make_key_dbt malloc'd for us. always free these. */ if (key.flags & DB_DBT_REALLOC) { FREE_DBT(key); /* 'make_key_dbt' could do a 'malloc' */ } return retval; } static PyObject* _DBC_get_set_both(DBCursorObject* self, PyObject* keyobj, PyObject* dataobj, int flags, unsigned int returnsNone) { int err; DBT key, data; PyObject* retval; /* the caller did this: CHECK_CURSOR_NOT_CLOSED(self); */ if (!make_key_dbt(self->mydb, keyobj, &key, NULL)) return NULL; if (!make_dbt(dataobj, &data)) { FREE_DBT(key); /* 'make_key_dbt' could do a 'malloc' */ return NULL; } MYDB_BEGIN_ALLOW_THREADS; err = _DBC_get(self->dbc, &key, &data, flags|DB_GET_BOTH); MYDB_END_ALLOW_THREADS; if ((err == DB_NOTFOUND || err == DB_KEYEMPTY) && returnsNone) { Py_INCREF(Py_None); retval = Py_None; } else if (makeDBError(err)) { retval = NULL; } else { switch (_DB_get_type(self->mydb)) { case -1: retval = NULL; break; case DB_BTREE: case DB_HASH: default: retval = BuildValue_SS(key.data, key.size, data.data, data.size); break; case DB_RECNO: case DB_QUEUE: retval = BuildValue_IS(*((db_recno_t*)key.data), data.data, data.size); break; } } FREE_DBT(key); /* 'make_key_dbt' could do a 'malloc' */ return retval; } static PyObject* DBC_get_both(DBCursorObject* self, PyObject* args) { int flags=0; PyObject *keyobj, *dataobj; if (!PyArg_ParseTuple(args, "OO|i:get_both", &keyobj, &dataobj, &flags)) return NULL; /* if the cursor is closed, self->mydb may be invalid */ CHECK_CURSOR_NOT_CLOSED(self); return _DBC_get_set_both(self, keyobj, dataobj, flags, self->mydb->moduleFlags.getReturnsNone); } /* Return size of entry */ static PyObject* DBC_get_current_size(DBCursorObject* self) { int err, flags=DB_CURRENT; PyObject* retval = NULL; DBT key, data; CHECK_CURSOR_NOT_CLOSED(self); CLEAR_DBT(key); CLEAR_DBT(data); /* We don't allocate any memory, forcing a DB_BUFFER_SMALL error and thus getting the record size. */ data.flags = DB_DBT_USERMEM; data.ulen = 0; MYDB_BEGIN_ALLOW_THREADS; err = _DBC_get(self->dbc, &key, &data, flags); MYDB_END_ALLOW_THREADS; if (err == DB_BUFFER_SMALL || !err) { /* DB_BUFFER_SMALL means positive size, !err means zero length value */ retval = NUMBER_FromLong((long)data.size); err = 0; } RETURN_IF_ERR(); return retval; } static PyObject* DBC_set_both(DBCursorObject* self, PyObject* args) { int flags=0; PyObject *keyobj, *dataobj; if (!PyArg_ParseTuple(args, "OO|i:set_both", &keyobj, &dataobj, &flags)) return NULL; /* if the cursor is closed, self->mydb may be invalid */ CHECK_CURSOR_NOT_CLOSED(self); return _DBC_get_set_both(self, keyobj, dataobj, flags, self->mydb->moduleFlags.cursorSetReturnsNone); } static PyObject* DBC_set_recno(DBCursorObject* self, PyObject* args, PyObject *kwargs) { int err, irecno, flags=0; db_recno_t recno; DBT key, data; PyObject* retval; int dlen = -1; int doff = -1; static char* kwnames[] = { "recno","flags", "dlen", "doff", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i|iii:set_recno", kwnames, &irecno, &flags, &dlen, &doff)) return NULL; CHECK_CURSOR_NOT_CLOSED(self); CLEAR_DBT(key); recno = (db_recno_t) irecno; /* use allocated space so DB will be able to realloc room for the real * key */ key.data = malloc(sizeof(db_recno_t)); if (key.data == NULL) { PyErr_SetString(PyExc_MemoryError, "Key memory allocation failed"); return NULL; } key.size = sizeof(db_recno_t); key.ulen = key.size; memcpy(key.data, &recno, sizeof(db_recno_t)); key.flags = DB_DBT_REALLOC; CLEAR_DBT(data); if (!add_partial_dbt(&data, dlen, doff)) { FREE_DBT(key); return NULL; } MYDB_BEGIN_ALLOW_THREADS; err = _DBC_get(self->dbc, &key, &data, flags|DB_SET_RECNO); MYDB_END_ALLOW_THREADS; if ((err == DB_NOTFOUND || err == DB_KEYEMPTY) && self->mydb->moduleFlags.cursorSetReturnsNone) { Py_INCREF(Py_None); retval = Py_None; } else if (makeDBError(err)) { retval = NULL; } else { /* Can only be used for BTrees, so no need to return int key */ retval = BuildValue_SS(key.data, key.size, data.data, data.size); } FREE_DBT(key); return retval; } static PyObject* DBC_consume(DBCursorObject* self, PyObject* args, PyObject *kwargs) { return _DBCursor_get(self,DB_CONSUME,args,kwargs,"|iii:consume"); } static PyObject* DBC_next_dup(DBCursorObject* self, PyObject* args, PyObject *kwargs) { return _DBCursor_get(self,DB_NEXT_DUP,args,kwargs,"|iii:next_dup"); } static PyObject* DBC_next_nodup(DBCursorObject* self, PyObject* args, PyObject *kwargs) { return _DBCursor_get(self,DB_NEXT_NODUP,args,kwargs,"|iii:next_nodup"); } static PyObject* DBC_prev_dup(DBCursorObject* self, PyObject* args, PyObject *kwargs) { return _DBCursor_get(self,DB_PREV_DUP,args,kwargs,"|iii:prev_dup"); } static PyObject* DBC_prev_nodup(DBCursorObject* self, PyObject* args, PyObject *kwargs) { return _DBCursor_get(self,DB_PREV_NODUP,args,kwargs,"|iii:prev_nodup"); } static PyObject* DBC_join_item(DBCursorObject* self, PyObject* args) { int err, flags=0; DBT key, data; PyObject* retval; if (!PyArg_ParseTuple(args, "|i:join_item", &flags)) return NULL; CHECK_CURSOR_NOT_CLOSED(self); CLEAR_DBT(key); CLEAR_DBT(data); MYDB_BEGIN_ALLOW_THREADS; err = _DBC_get(self->dbc, &key, &data, flags | DB_JOIN_ITEM); MYDB_END_ALLOW_THREADS; if ((err == DB_NOTFOUND || err == DB_KEYEMPTY) && self->mydb->moduleFlags.getReturnsNone) { Py_INCREF(Py_None); retval = Py_None; } else if (makeDBError(err)) { retval = NULL; } else { retval = BuildValue_S(key.data, key.size); } return retval; } static PyObject* DBC_set_priority(DBCursorObject* self, PyObject* args, PyObject* kwargs) { int err, priority; static char* kwnames[] = { "priority", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i:set_priority", kwnames, &priority)) return NULL; CHECK_CURSOR_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->dbc->set_priority(self->dbc, priority); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBC_get_priority(DBCursorObject* self) { int err; DB_CACHE_PRIORITY priority; CHECK_CURSOR_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->dbc->get_priority(self->dbc, &priority); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(priority); } /* --------------------------------------------------------------------- */ /* DBEnv methods */ static PyObject* DBEnv_close_internal(DBEnvObject* self, int flags) { PyObject *dummy; int err; if (!self->closed) { /* Don't close more than once */ while(self->children_txns) { dummy = DBTxn_abort_discard_internal(self->children_txns, 0); Py_XDECREF(dummy); } while(self->children_dbs) { dummy = DB_close_internal(self->children_dbs, 0, 0); Py_XDECREF(dummy); } while(self->children_logcursors) { dummy = DBLogCursor_close_internal(self->children_logcursors); Py_XDECREF(dummy); } #if (DBVER >= 53) while(self->children_sites) { dummy = DBSite_close_internal(self->children_sites); Py_XDECREF(dummy); } #endif } self->closed = 1; if (self->db_env) { MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->close(self->db_env, flags); MYDB_END_ALLOW_THREADS; /* after calling DBEnv->close, regardless of error, this DBEnv * may not be accessed again (Berkeley DB docs). */ self->db_env = NULL; RETURN_IF_ERR(); } RETURN_NONE(); } static PyObject* DBEnv_close(DBEnvObject* self, PyObject* args) { int flags = 0; if (!PyArg_ParseTuple(args, "|i:close", &flags)) return NULL; return DBEnv_close_internal(self, flags); } static PyObject* DBEnv_open(DBEnvObject* self, PyObject* args) { int err, flags=0, mode=0660; char *db_home; if (!PyArg_ParseTuple(args, "z|ii:open", &db_home, &flags, &mode)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->open(self->db_env, db_home, flags, mode); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); self->closed = 0; self->flags = flags; RETURN_NONE(); } static PyObject* DBEnv_memp_stat(DBEnvObject* self, PyObject* args, PyObject *kwargs) { int err; DB_MPOOL_STAT *gsp; DB_MPOOL_FSTAT **fsp, **fsp2; PyObject* d = NULL, *d2, *d3, *r; u_int32_t flags = 0; static char* kwnames[] = { "flags", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i:memp_stat", kwnames, &flags)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->memp_stat(self->db_env, &gsp, &fsp, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); /* Turn the stat structure into a dictionary */ d = PyDict_New(); if (d == NULL) { if (gsp) free(gsp); return NULL; } #define MAKE_ENTRY(name) _addIntToDict(d, #name, gsp->st_##name) MAKE_ENTRY(gbytes); MAKE_ENTRY(bytes); MAKE_ENTRY(ncache); MAKE_ENTRY(max_ncache); MAKE_ENTRY(regsize); MAKE_ENTRY(mmapsize); MAKE_ENTRY(maxopenfd); MAKE_ENTRY(maxwrite); MAKE_ENTRY(maxwrite_sleep); MAKE_ENTRY(map); MAKE_ENTRY(cache_hit); MAKE_ENTRY(cache_miss); MAKE_ENTRY(page_create); MAKE_ENTRY(page_in); MAKE_ENTRY(page_out); MAKE_ENTRY(ro_evict); MAKE_ENTRY(rw_evict); MAKE_ENTRY(page_trickle); MAKE_ENTRY(pages); MAKE_ENTRY(page_clean); MAKE_ENTRY(page_dirty); MAKE_ENTRY(hash_buckets); MAKE_ENTRY(hash_searches); MAKE_ENTRY(hash_longest); MAKE_ENTRY(hash_examined); MAKE_ENTRY(hash_nowait); MAKE_ENTRY(hash_wait); MAKE_ENTRY(hash_max_nowait); MAKE_ENTRY(hash_max_wait); MAKE_ENTRY(region_wait); MAKE_ENTRY(region_nowait); MAKE_ENTRY(mvcc_frozen); MAKE_ENTRY(mvcc_thawed); MAKE_ENTRY(mvcc_freed); MAKE_ENTRY(alloc); MAKE_ENTRY(alloc_buckets); MAKE_ENTRY(alloc_max_buckets); MAKE_ENTRY(alloc_pages); MAKE_ENTRY(alloc_max_pages); MAKE_ENTRY(io_wait); #if (DBVER >= 48) MAKE_ENTRY(sync_interrupted); #endif #undef MAKE_ENTRY free(gsp); d2 = PyDict_New(); if (d2 == NULL) { Py_DECREF(d); if (fsp) free(fsp); return NULL; } #define MAKE_ENTRY(name) _addIntToDict(d3, #name, (*fsp2)->st_##name) for(fsp2=fsp;*fsp2; fsp2++) { d3 = PyDict_New(); if (d3 == NULL) { Py_DECREF(d); Py_DECREF(d2); if (fsp) free(fsp); return NULL; } MAKE_ENTRY(pagesize); MAKE_ENTRY(cache_hit); MAKE_ENTRY(cache_miss); MAKE_ENTRY(map); MAKE_ENTRY(page_create); MAKE_ENTRY(page_in); MAKE_ENTRY(page_out); if(PyDict_SetItemString(d2, (*fsp2)->file_name, d3)) { Py_DECREF(d); Py_DECREF(d2); Py_DECREF(d3); if (fsp) free(fsp); return NULL; } Py_DECREF(d3); } #undef MAKE_ENTRY free(fsp); r = PyTuple_Pack(2, d, d2); Py_DECREF(d); Py_DECREF(d2); return r; } static PyObject* DBEnv_memp_stat_print(DBEnvObject* self, PyObject* args, PyObject *kwargs) { int err; int flags=0; static char* kwnames[] = { "flags", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i:memp_stat_print", kwnames, &flags)) { return NULL; } CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->memp_stat_print(self->db_env, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_memp_trickle(DBEnvObject* self, PyObject* args) { int err, percent, nwrotep; if (!PyArg_ParseTuple(args, "i:memp_trickle", &percent)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->memp_trickle(self->db_env, percent, &nwrotep); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(nwrotep); } static PyObject* DBEnv_memp_sync(DBEnvObject* self, PyObject* args) { int err; DB_LSN lsn = {0, 0}; DB_LSN *lsn_p = NULL; if (!PyArg_ParseTuple(args, "|(ii):memp_sync", &lsn.file, &lsn.offset)) return NULL; if ((lsn.file!=0) || (lsn.offset!=0)) { lsn_p = &lsn; } CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->memp_sync(self->db_env, lsn_p); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_remove(DBEnvObject* self, PyObject* args) { int err, flags=0; char *db_home; if (!PyArg_ParseTuple(args, "s|i:remove", &db_home, &flags)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->remove(self->db_env, db_home, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_dbremove(DBEnvObject* self, PyObject* args, PyObject* kwargs) { int err; u_int32_t flags=0; char *file = NULL; char *database = NULL; PyObject *txnobj = NULL; DB_TXN *txn = NULL; static char* kwnames[] = { "file", "database", "txn", "flags", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|zOi:dbremove", kwnames, &file, &database, &txnobj, &flags)) { return NULL; } if (!checkTxnObj(txnobj, &txn)) { return NULL; } CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->dbremove(self->db_env, txn, file, database, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_dbrename(DBEnvObject* self, PyObject* args, PyObject* kwargs) { int err; u_int32_t flags=0; char *file = NULL; char *database = NULL; char *newname = NULL; PyObject *txnobj = NULL; DB_TXN *txn = NULL; static char* kwnames[] = { "file", "database", "newname", "txn", "flags", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "szs|Oi:dbrename", kwnames, &file, &database, &newname, &txnobj, &flags)) { return NULL; } if (!checkTxnObj(txnobj, &txn)) { return NULL; } CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->dbrename(self->db_env, txn, file, database, newname, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_set_encrypt(DBEnvObject* self, PyObject* args, PyObject* kwargs) { int err; u_int32_t flags=0; char *passwd = NULL; static char* kwnames[] = { "passwd", "flags", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|i:set_encrypt", kwnames, &passwd, &flags)) { return NULL; } MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->set_encrypt(self->db_env, passwd, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_get_encrypt_flags(DBEnvObject* self) { int err; u_int32_t flags; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->get_encrypt_flags(self->db_env, &flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(flags); } static PyObject* DBEnv_get_timeout(DBEnvObject* self, PyObject* args, PyObject* kwargs) { int err; int flag; u_int32_t timeout; static char* kwnames[] = {"flag", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i:get_timeout", kwnames, &flag)) { return NULL; } CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->get_timeout(self->db_env, &timeout, flag); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(timeout); } static PyObject* DBEnv_set_timeout(DBEnvObject* self, PyObject* args, PyObject* kwargs) { int err; u_int32_t flags=0; u_int32_t timeout = 0; static char* kwnames[] = { "timeout", "flags", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii:set_timeout", kwnames, &timeout, &flags)) { return NULL; } MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->set_timeout(self->db_env, (db_timeout_t)timeout, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_set_shm_key(DBEnvObject* self, PyObject* args) { int err; long shm_key = 0; if (!PyArg_ParseTuple(args, "l:set_shm_key", &shm_key)) return NULL; CHECK_ENV_NOT_CLOSED(self); err = self->db_env->set_shm_key(self->db_env, shm_key); RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_get_shm_key(DBEnvObject* self) { int err; long shm_key; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->get_shm_key(self->db_env, &shm_key); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(shm_key); } static PyObject* DBEnv_set_cache_max(DBEnvObject* self, PyObject* args) { int err, gbytes, bytes; if (!PyArg_ParseTuple(args, "ii:set_cache_max", &gbytes, &bytes)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->set_cache_max(self->db_env, gbytes, bytes); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_get_cache_max(DBEnvObject* self) { int err; u_int32_t gbytes, bytes; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->get_cache_max(self->db_env, &gbytes, &bytes); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return Py_BuildValue("(ii)", gbytes, bytes); } static PyObject* DBEnv_set_thread_count(DBEnvObject* self, PyObject* args) { int err; u_int32_t count; if (!PyArg_ParseTuple(args, "i:set_thread_count", &count)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->set_thread_count(self->db_env, count); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_get_thread_count(DBEnvObject* self) { int err; u_int32_t count; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->get_thread_count(self->db_env, &count); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(count); } static PyObject* DBEnv_set_cachesize(DBEnvObject* self, PyObject* args) { int err, gbytes=0, bytes=0, ncache=0; if (!PyArg_ParseTuple(args, "ii|i:set_cachesize", &gbytes, &bytes, &ncache)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->set_cachesize(self->db_env, gbytes, bytes, ncache); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_get_cachesize(DBEnvObject* self) { int err; u_int32_t gbytes, bytes; int ncache; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->get_cachesize(self->db_env, &gbytes, &bytes, &ncache); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return Py_BuildValue("(iii)", gbytes, bytes, ncache); } static PyObject* DBEnv_set_flags(DBEnvObject* self, PyObject* args) { int err, flags=0, onoff=0; if (!PyArg_ParseTuple(args, "ii:set_flags", &flags, &onoff)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->set_flags(self->db_env, flags, onoff); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_get_flags(DBEnvObject* self) { int err; u_int32_t flags; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->get_flags(self->db_env, &flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(flags); } static PyObject* DBEnv_log_set_config(DBEnvObject* self, PyObject* args) { int err, flags, onoff; if (!PyArg_ParseTuple(args, "ii:log_set_config", &flags, &onoff)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->log_set_config(self->db_env, flags, onoff); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_log_get_config(DBEnvObject* self, PyObject* args) { int err, flag, onoff; if (!PyArg_ParseTuple(args, "i:log_get_config", &flag)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->log_get_config(self->db_env, flag, &onoff); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return PyBool_FromLong(onoff); } static PyObject* DBEnv_mutex_set_max(DBEnvObject* self, PyObject* args) { int err; int value; if (!PyArg_ParseTuple(args, "i:mutex_set_max", &value)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->mutex_set_max(self->db_env, value); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_mutex_get_max(DBEnvObject* self) { int err; u_int32_t value; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->mutex_get_max(self->db_env, &value); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(value); } static PyObject* DBEnv_mutex_set_align(DBEnvObject* self, PyObject* args) { int err; int align; if (!PyArg_ParseTuple(args, "i:mutex_set_align", &align)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->mutex_set_align(self->db_env, align); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_mutex_get_align(DBEnvObject* self) { int err; u_int32_t align; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->mutex_get_align(self->db_env, &align); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(align); } static PyObject* DBEnv_mutex_set_increment(DBEnvObject* self, PyObject* args) { int err; int increment; if (!PyArg_ParseTuple(args, "i:mutex_set_increment", &increment)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->mutex_set_increment(self->db_env, increment); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_mutex_get_increment(DBEnvObject* self) { int err; u_int32_t increment; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->mutex_get_increment(self->db_env, &increment); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(increment); } static PyObject* DBEnv_mutex_set_tas_spins(DBEnvObject* self, PyObject* args) { int err; int tas_spins; if (!PyArg_ParseTuple(args, "i:mutex_set_tas_spins", &tas_spins)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->mutex_set_tas_spins(self->db_env, tas_spins); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_mutex_get_tas_spins(DBEnvObject* self) { int err; u_int32_t tas_spins; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->mutex_get_tas_spins(self->db_env, &tas_spins); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(tas_spins); } static PyObject* DBEnv_set_data_dir(DBEnvObject* self, PyObject* args) { int err; char *dir; if (!PyArg_ParseTuple(args, "s:set_data_dir", &dir)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->set_data_dir(self->db_env, dir); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_get_data_dirs(DBEnvObject* self) { int err; PyObject *tuple; PyObject *item; const char **dirpp; int size, i; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->get_data_dirs(self->db_env, &dirpp); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); /* ** Calculate size. Python C API ** actually allows for tuple resizing, ** but this is simple enough. */ for (size=0; *(dirpp+size) ; size++); tuple = PyTuple_New(size); if (!tuple) return NULL; for (i=0; idb_env->set_lg_filemode(self->db_env, filemode); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_get_lg_filemode(DBEnvObject* self) { int err, filemode; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->get_lg_filemode(self->db_env, &filemode); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(filemode); } static PyObject* DBEnv_set_lg_bsize(DBEnvObject* self, PyObject* args) { int err, lg_bsize; if (!PyArg_ParseTuple(args, "i:set_lg_bsize", &lg_bsize)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->set_lg_bsize(self->db_env, lg_bsize); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_get_lg_bsize(DBEnvObject* self) { int err; u_int32_t lg_bsize; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->get_lg_bsize(self->db_env, &lg_bsize); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(lg_bsize); } static PyObject* DBEnv_set_lg_dir(DBEnvObject* self, PyObject* args) { int err; char *dir; if (!PyArg_ParseTuple(args, "s:set_lg_dir", &dir)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->set_lg_dir(self->db_env, dir); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_get_lg_dir(DBEnvObject* self) { int err; const char *dirp; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->get_lg_dir(self->db_env, &dirp); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return PyBytes_FromString(dirp); } static PyObject* DBEnv_set_lg_max(DBEnvObject* self, PyObject* args) { int err, lg_max; if (!PyArg_ParseTuple(args, "i:set_lg_max", &lg_max)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->set_lg_max(self->db_env, lg_max); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_get_lg_max(DBEnvObject* self) { int err; u_int32_t lg_max; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->get_lg_max(self->db_env, &lg_max); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(lg_max); } static PyObject* DBEnv_set_lg_regionmax(DBEnvObject* self, PyObject* args) { int err, lg_max; if (!PyArg_ParseTuple(args, "i:set_lg_regionmax", &lg_max)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->set_lg_regionmax(self->db_env, lg_max); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_get_lg_regionmax(DBEnvObject* self) { int err; u_int32_t lg_regionmax; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->get_lg_regionmax(self->db_env, &lg_regionmax); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(lg_regionmax); } static PyObject* DBEnv_set_lk_partitions(DBEnvObject* self, PyObject* args) { int err, lk_partitions; if (!PyArg_ParseTuple(args, "i:set_lk_partitions", &lk_partitions)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->set_lk_partitions(self->db_env, lk_partitions); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_get_lk_partitions(DBEnvObject* self) { int err; u_int32_t lk_partitions; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->get_lk_partitions(self->db_env, &lk_partitions); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(lk_partitions); } static PyObject* DBEnv_set_lk_detect(DBEnvObject* self, PyObject* args) { int err, lk_detect; if (!PyArg_ParseTuple(args, "i:set_lk_detect", &lk_detect)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->set_lk_detect(self->db_env, lk_detect); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_get_lk_detect(DBEnvObject* self) { int err; u_int32_t lk_detect; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->get_lk_detect(self->db_env, &lk_detect); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(lk_detect); } static PyObject* DBEnv_set_lk_max_locks(DBEnvObject* self, PyObject* args) { int err, max; if (!PyArg_ParseTuple(args, "i:set_lk_max_locks", &max)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->set_lk_max_locks(self->db_env, max); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_get_lk_max_locks(DBEnvObject* self) { int err; u_int32_t lk_max; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->get_lk_max_locks(self->db_env, &lk_max); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(lk_max); } static PyObject* DBEnv_set_lk_max_lockers(DBEnvObject* self, PyObject* args) { int err, max; if (!PyArg_ParseTuple(args, "i:set_lk_max_lockers", &max)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->set_lk_max_lockers(self->db_env, max); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_get_lk_max_lockers(DBEnvObject* self) { int err; u_int32_t lk_max; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->get_lk_max_lockers(self->db_env, &lk_max); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(lk_max); } static PyObject* DBEnv_set_lk_max_objects(DBEnvObject* self, PyObject* args) { int err, max; if (!PyArg_ParseTuple(args, "i:set_lk_max_objects", &max)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->set_lk_max_objects(self->db_env, max); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_get_lk_max_objects(DBEnvObject* self) { int err; u_int32_t lk_max; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->get_lk_max_objects(self->db_env, &lk_max); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(lk_max); } static PyObject* DBEnv_get_mp_mmapsize(DBEnvObject* self) { int err; size_t mmapsize; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->get_mp_mmapsize(self->db_env, &mmapsize); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(mmapsize); } static PyObject* DBEnv_set_mp_mmapsize(DBEnvObject* self, PyObject* args) { int err, mp_mmapsize; if (!PyArg_ParseTuple(args, "i:set_mp_mmapsize", &mp_mmapsize)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->set_mp_mmapsize(self->db_env, mp_mmapsize); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_set_tmp_dir(DBEnvObject* self, PyObject* args) { int err; char *dir; if (!PyArg_ParseTuple(args, "s:set_tmp_dir", &dir)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->set_tmp_dir(self->db_env, dir); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_get_tmp_dir(DBEnvObject* self) { int err; const char *dirpp; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->get_tmp_dir(self->db_env, &dirpp); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return PyBytes_FromString(dirpp); } static PyObject* DBEnv_txn_recover(DBEnvObject* self) { int flags = DB_FIRST; int err; PyObject *list, *tuple, *gid; DBTxnObject *txn; #define PREPLIST_LEN 16 DB_PREPLIST preplist[PREPLIST_LEN]; #if (DBVER < 48) || (DBVER >= 53) long retp, i; #else u_int32_t retp, i; #endif CHECK_ENV_NOT_CLOSED(self); list=PyList_New(0); if (!list) return NULL; while (!0) { MYDB_BEGIN_ALLOW_THREADS err=self->db_env->txn_recover(self->db_env, preplist, PREPLIST_LEN, &retp, flags); #undef PREPLIST_LEN MYDB_END_ALLOW_THREADS if (err) { Py_DECREF(list); RETURN_IF_ERR(); } if (!retp) break; flags=DB_NEXT; /* Prepare for next loop pass */ for (i=0; iflag_prepare=1; /* Recover state */ tuple=PyTuple_New(2); if (!tuple) { Py_DECREF(list); Py_DECREF(gid); Py_DECREF(txn); return NULL; } if (PyTuple_SetItem(tuple, 0, gid)) { Py_DECREF(list); Py_DECREF(gid); Py_DECREF(txn); Py_DECREF(tuple); return NULL; } if (PyTuple_SetItem(tuple, 1, (PyObject *)txn)) { Py_DECREF(list); Py_DECREF(txn); Py_DECREF(tuple); /* This delete the "gid" also */ return NULL; } if (PyList_Append(list, tuple)) { Py_DECREF(list); Py_DECREF(tuple);/* This delete the "gid" and the "txn" also */ return NULL; } Py_DECREF(tuple); } } return list; } static PyObject* DBEnv_txn_begin(DBEnvObject* self, PyObject* args, PyObject* kwargs) { int flags = 0; PyObject* txnobj = NULL; DB_TXN *txn = NULL; static char* kwnames[] = { "parent", "flags", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|Oi:txn_begin", kwnames, &txnobj, &flags)) return NULL; if (!checkTxnObj(txnobj, &txn)) return NULL; CHECK_ENV_NOT_CLOSED(self); return (PyObject*)newDBTxnObject(self, (DBTxnObject *)txnobj, NULL, flags); } static PyObject* DBEnv_txn_checkpoint(DBEnvObject* self, PyObject* args) { int err, kbyte=0, min=0, flags=0; if (!PyArg_ParseTuple(args, "|iii:txn_checkpoint", &kbyte, &min, &flags)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->txn_checkpoint(self->db_env, kbyte, min, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_get_tx_max(DBEnvObject* self) { int err; u_int32_t max; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->get_tx_max(self->db_env, &max); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return PyLong_FromUnsignedLong(max); } static PyObject* DBEnv_set_tx_max(DBEnvObject* self, PyObject* args) { int err, max; if (!PyArg_ParseTuple(args, "i:set_tx_max", &max)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->set_tx_max(self->db_env, max); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_get_tx_timestamp(DBEnvObject* self) { int err; time_t timestamp; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->get_tx_timestamp(self->db_env, ×tamp); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(timestamp); } static PyObject* DBEnv_set_tx_timestamp(DBEnvObject* self, PyObject* args) { int err; long stamp; time_t timestamp; if (!PyArg_ParseTuple(args, "l:set_tx_timestamp", &stamp)) return NULL; CHECK_ENV_NOT_CLOSED(self); timestamp = (time_t)stamp; MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->set_tx_timestamp(self->db_env, ×tamp); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_lock_detect(DBEnvObject* self, PyObject* args) { int err, atype, flags=0; int aborted = 0; if (!PyArg_ParseTuple(args, "i|i:lock_detect", &atype, &flags)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->lock_detect(self->db_env, flags, atype, &aborted); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(aborted); } static PyObject* DBEnv_lock_get(DBEnvObject* self, PyObject* args) { int flags=0; int locker, lock_mode; DBT obj; PyObject* objobj; if (!PyArg_ParseTuple(args, "iOi|i:lock_get", &locker, &objobj, &lock_mode, &flags)) return NULL; if (!make_dbt(objobj, &obj)) return NULL; return (PyObject*)newDBLockObject(self, locker, &obj, lock_mode, flags); } static PyObject* DBEnv_lock_id(DBEnvObject* self) { int err; u_int32_t theID; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->lock_id(self->db_env, &theID); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong((long)theID); } static PyObject* DBEnv_lock_id_free(DBEnvObject* self, PyObject* args) { int err; u_int32_t theID; if (!PyArg_ParseTuple(args, "I:lock_id_free", &theID)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->lock_id_free(self->db_env, theID); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_lock_put(DBEnvObject* self, PyObject* args) { int err; DBLockObject* dblockobj; if (!PyArg_ParseTuple(args, "O!:lock_put", &DBLock_Type, &dblockobj)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->lock_put(self->db_env, &dblockobj->lock); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_fileid_reset(DBEnvObject* self, PyObject* args, PyObject* kwargs) { int err; char *file; u_int32_t flags = 0; static char* kwnames[] = { "file", "flags", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "z|i:fileid_reset", kwnames, &file, &flags)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->fileid_reset(self->db_env, file, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_lsn_reset(DBEnvObject* self, PyObject* args, PyObject* kwargs) { int err; char *file; u_int32_t flags = 0; static char* kwnames[] = { "file", "flags", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "z|i:lsn_reset", kwnames, &file, &flags)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->lsn_reset(self->db_env, file, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_stat_print(DBEnvObject* self, PyObject* args, PyObject *kwargs) { int err; int flags=0; static char* kwnames[] = { "flags", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i:stat_print", kwnames, &flags)) { return NULL; } CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->stat_print(self->db_env, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_log_stat(DBEnvObject* self, PyObject* args) { int err; DB_LOG_STAT* statp = NULL; PyObject* d = NULL; u_int32_t flags = 0; if (!PyArg_ParseTuple(args, "|i:log_stat", &flags)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->log_stat(self->db_env, &statp, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); /* Turn the stat structure into a dictionary */ d = PyDict_New(); if (d == NULL) { if (statp) free(statp); return NULL; } #define MAKE_ENTRY(name) _addIntToDict(d, #name, statp->st_##name) MAKE_ENTRY(magic); MAKE_ENTRY(version); MAKE_ENTRY(mode); MAKE_ENTRY(lg_bsize); MAKE_ENTRY(lg_size); MAKE_ENTRY(record); MAKE_ENTRY(w_mbytes); MAKE_ENTRY(w_bytes); MAKE_ENTRY(wc_mbytes); MAKE_ENTRY(wc_bytes); MAKE_ENTRY(wcount); MAKE_ENTRY(wcount_fill); MAKE_ENTRY(rcount); MAKE_ENTRY(scount); MAKE_ENTRY(cur_file); MAKE_ENTRY(cur_offset); MAKE_ENTRY(disk_file); MAKE_ENTRY(disk_offset); MAKE_ENTRY(maxcommitperflush); MAKE_ENTRY(mincommitperflush); MAKE_ENTRY(regsize); MAKE_ENTRY(region_wait); MAKE_ENTRY(region_nowait); #undef MAKE_ENTRY free(statp); return d; } /* DBEnv_log_stat */ static PyObject* DBEnv_log_stat_print(DBEnvObject* self, PyObject* args, PyObject *kwargs) { int err; int flags=0; static char* kwnames[] = { "flags", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i:log_stat_print", kwnames, &flags)) { return NULL; } CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->log_stat_print(self->db_env, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_lock_stat(DBEnvObject* self, PyObject* args) { int err; DB_LOCK_STAT* sp; PyObject* d = NULL; u_int32_t flags = 0; if (!PyArg_ParseTuple(args, "|i:lock_stat", &flags)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->lock_stat(self->db_env, &sp, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); /* Turn the stat structure into a dictionary */ d = PyDict_New(); if (d == NULL) { free(sp); return NULL; } #define MAKE_ENTRY(name) _addIntToDict(d, #name, sp->st_##name) MAKE_ENTRY(id); MAKE_ENTRY(cur_maxid); MAKE_ENTRY(nmodes); MAKE_ENTRY(maxlocks); MAKE_ENTRY(maxlockers); MAKE_ENTRY(maxobjects); MAKE_ENTRY(nlocks); MAKE_ENTRY(maxnlocks); MAKE_ENTRY(nlockers); MAKE_ENTRY(maxnlockers); MAKE_ENTRY(nobjects); MAKE_ENTRY(maxnobjects); MAKE_ENTRY(nrequests); MAKE_ENTRY(nreleases); MAKE_ENTRY(nupgrade); MAKE_ENTRY(ndowngrade); MAKE_ENTRY(lock_nowait); MAKE_ENTRY(lock_wait); MAKE_ENTRY(ndeadlocks); MAKE_ENTRY(locktimeout); MAKE_ENTRY(txntimeout); MAKE_ENTRY(nlocktimeouts); MAKE_ENTRY(ntxntimeouts); MAKE_ENTRY(objs_wait); MAKE_ENTRY(objs_nowait); MAKE_ENTRY(lockers_wait); MAKE_ENTRY(lockers_nowait); MAKE_ENTRY(lock_wait); MAKE_ENTRY(lock_nowait); MAKE_ENTRY(hash_len); MAKE_ENTRY(regsize); MAKE_ENTRY(region_wait); MAKE_ENTRY(region_nowait); #undef MAKE_ENTRY free(sp); return d; } static PyObject* DBEnv_lock_stat_print(DBEnvObject* self, PyObject* args, PyObject *kwargs) { int err; int flags=0; static char* kwnames[] = { "flags", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i:lock_stat_print", kwnames, &flags)) { return NULL; } CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->lock_stat_print(self->db_env, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_log_cursor(DBEnvObject* self) { int err; DB_LOGC* dblogc; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->log_cursor(self->db_env, &dblogc, 0); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return (PyObject*) newDBLogCursorObject(dblogc, self); } static PyObject* DBEnv_log_flush(DBEnvObject* self) { int err; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS err = self->db_env->log_flush(self->db_env, NULL); MYDB_END_ALLOW_THREADS RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_log_file(DBEnvObject* self, PyObject* args) { int err; DB_LSN lsn = {0, 0}; int size = 20; char *name = NULL; PyObject *retval; if (!PyArg_ParseTuple(args, "(ii):log_file", &lsn.file, &lsn.offset)) return NULL; CHECK_ENV_NOT_CLOSED(self); do { name = malloc(size); if (!name) { PyErr_NoMemory(); return NULL; } MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->log_file(self->db_env, &lsn, name, size); MYDB_END_ALLOW_THREADS; if (err == EINVAL) { free(name); size *= 2; } else if (err) { free(name); RETURN_IF_ERR(); assert(0); /* Unreachable... supposely */ return NULL; } /* ** If the final buffer we try is too small, we will ** get this exception: ** DBInvalidArgError: ** (22, 'Invalid argument -- DB_ENV->log_file: name buffer is too short') */ } while ((err == EINVAL) && (size<(1<<17))); RETURN_IF_ERR(); /* Maybe the size is not the problem */ retval = Py_BuildValue("s", name); free(name); return retval; } static PyObject* DBEnv_log_printf(DBEnvObject* self, PyObject* args, PyObject *kwargs) { int err; char *string; PyObject *txnobj = NULL; DB_TXN *txn = NULL; static char* kwnames[] = {"string", "txn", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|O:log_printf", kwnames, &string, &txnobj)) return NULL; CHECK_ENV_NOT_CLOSED(self); if (!checkTxnObj(txnobj, &txn)) return NULL; /* ** Do not use the format string directly, to avoid attacks. */ MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->log_printf(self->db_env, txn, "%s", string); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_log_archive(DBEnvObject* self, PyObject* args) { int flags=0; int err; char **log_list = NULL; PyObject* list; PyObject* item = NULL; if (!PyArg_ParseTuple(args, "|i:log_archive", &flags)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->log_archive(self->db_env, &log_list, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); list = PyList_New(0); if (list == NULL) { if (log_list) free(log_list); return NULL; } if (log_list) { char **log_list_start; for (log_list_start = log_list; *log_list != NULL; ++log_list) { item = PyBytes_FromString (*log_list); if (item == NULL) { Py_DECREF(list); list = NULL; break; } if (PyList_Append(list, item)) { Py_DECREF(list); list = NULL; Py_DECREF(item); break; } Py_DECREF(item); } free(log_list_start); } return list; } #if (DBVER >= 53) static PyObject* DBEnv_repmgr_site(DBEnvObject* self, PyObject* args, PyObject *kwargs) { int err; DB_SITE* site; char *host; u_int port; static char* kwnames[] = {"host", "port", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "si:repmgr_site", kwnames, &host, &port)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->repmgr_site(self->db_env, host, port, &site, 0); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return (PyObject*) newDBSiteObject(site, self); } static PyObject* DBEnv_repmgr_site_by_eid(DBEnvObject* self, PyObject* args, PyObject *kwargs) { int err; DB_SITE* site; int eid; static char* kwnames[] = {"eid", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i:repmgr_site_by_eid", kwnames, &eid)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->repmgr_site_by_eid(self->db_env, eid, &site); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return (PyObject*) newDBSiteObject(site, self); } #endif static PyObject* DBEnv_mutex_stat(DBEnvObject* self, PyObject* args) { int err; DB_MUTEX_STAT* statp = NULL; PyObject* d = NULL; u_int32_t flags = 0; if (!PyArg_ParseTuple(args, "|i:mutex_stat", &flags)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->mutex_stat(self->db_env, &statp, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); /* Turn the stat structure into a dictionary */ d = PyDict_New(); if (d == NULL) { if (statp) free(statp); return NULL; } #define MAKE_ENTRY(name) _addIntToDict(d, #name, statp->st_##name) MAKE_ENTRY(mutex_align); MAKE_ENTRY(mutex_tas_spins); MAKE_ENTRY(mutex_cnt); MAKE_ENTRY(mutex_free); MAKE_ENTRY(mutex_inuse); MAKE_ENTRY(mutex_inuse_max); MAKE_ENTRY(regsize); MAKE_ENTRY(region_wait); MAKE_ENTRY(region_nowait); #undef MAKE_ENTRY free(statp); return d; } static PyObject* DBEnv_mutex_stat_print(DBEnvObject* self, PyObject* args, PyObject *kwargs) { int err; int flags=0; static char* kwnames[] = { "flags", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i:mutex_stat_print", kwnames, &flags)) { return NULL; } CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->mutex_stat_print(self->db_env, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_txn_stat_print(DBEnvObject* self, PyObject* args, PyObject *kwargs) { int err; int flags=0; static char* kwnames[] = { "flags", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i:stat_print", kwnames, &flags)) { return NULL; } CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->txn_stat_print(self->db_env, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_txn_stat(DBEnvObject* self, PyObject* args) { int err; DB_TXN_STAT* sp; PyObject* d = NULL; u_int32_t flags=0; if (!PyArg_ParseTuple(args, "|i:txn_stat", &flags)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->txn_stat(self->db_env, &sp, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); /* Turn the stat structure into a dictionary */ d = PyDict_New(); if (d == NULL) { free(sp); return NULL; } #define MAKE_ENTRY(name) _addIntToDict(d, #name, sp->st_##name) #define MAKE_TIME_T_ENTRY(name) _addTimeTToDict(d, #name, sp->st_##name) #define MAKE_DB_LSN_ENTRY(name) _addDB_lsnToDict(d, #name, sp->st_##name) MAKE_DB_LSN_ENTRY(last_ckp); MAKE_TIME_T_ENTRY(time_ckp); MAKE_ENTRY(last_txnid); MAKE_ENTRY(maxtxns); MAKE_ENTRY(nactive); MAKE_ENTRY(maxnactive); MAKE_ENTRY(nsnapshot); MAKE_ENTRY(maxnsnapshot); MAKE_ENTRY(nbegins); MAKE_ENTRY(naborts); MAKE_ENTRY(ncommits); MAKE_ENTRY(nrestores); MAKE_ENTRY(regsize); MAKE_ENTRY(region_wait); MAKE_ENTRY(region_nowait); #undef MAKE_DB_LSN_ENTRY #undef MAKE_ENTRY #undef MAKE_TIME_T_ENTRY free(sp); return d; } static PyObject* DBEnv_set_get_returns_none(DBEnvObject* self, PyObject* args) { int flags=0; int oldValue=0; if (!PyArg_ParseTuple(args,"i:set_get_returns_none", &flags)) return NULL; CHECK_ENV_NOT_CLOSED(self); if (self->moduleFlags.getReturnsNone) ++oldValue; if (self->moduleFlags.cursorSetReturnsNone) ++oldValue; self->moduleFlags.getReturnsNone = (flags >= 1); self->moduleFlags.cursorSetReturnsNone = (flags >= 2); return NUMBER_FromLong(oldValue); } static PyObject* DBEnv_get_private(DBEnvObject* self) { /* We can give out the private field even if dbenv is closed */ Py_INCREF(self->private_obj); return self->private_obj; } static PyObject* DBEnv_set_private(DBEnvObject* self, PyObject* private_obj) { /* We can set the private field even if dbenv is closed */ Py_DECREF(self->private_obj); Py_INCREF(private_obj); self->private_obj = private_obj; RETURN_NONE(); } static PyObject* DBEnv_set_intermediate_dir_mode(DBEnvObject* self, PyObject* args) { int err; const char *mode; if (!PyArg_ParseTuple(args,"s:set_intermediate_dir_mode", &mode)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->set_intermediate_dir_mode(self->db_env, mode); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_get_intermediate_dir_mode(DBEnvObject* self) { int err; const char *mode; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->get_intermediate_dir_mode(self->db_env, &mode); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return Py_BuildValue("s", mode); } static PyObject* DBEnv_get_open_flags(DBEnvObject* self) { int err; unsigned int flags; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->get_open_flags(self->db_env, &flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(flags); } #if (DBVER < 48) static PyObject* DBEnv_set_rpc_server(DBEnvObject* self, PyObject* args, PyObject* kwargs) { int err; char *host; long cl_timeout=0, sv_timeout=0; static char* kwnames[] = { "host", "cl_timeout", "sv_timeout", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|ll:set_rpc_server", kwnames, &host, &cl_timeout, &sv_timeout)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->set_rpc_server(self->db_env, NULL, host, cl_timeout, sv_timeout, 0); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } #endif static PyObject* DBEnv_set_mp_max_openfd(DBEnvObject* self, PyObject* args) { int err; int maxopenfd; if (!PyArg_ParseTuple(args, "i:set_mp_max_openfd", &maxopenfd)) { return NULL; } CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->set_mp_max_openfd(self->db_env, maxopenfd); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_get_mp_max_openfd(DBEnvObject* self) { int err; int maxopenfd; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->get_mp_max_openfd(self->db_env, &maxopenfd); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(maxopenfd); } static PyObject* DBEnv_set_mp_max_write(DBEnvObject* self, PyObject* args) { int err; int maxwrite, maxwrite_sleep; if (!PyArg_ParseTuple(args, "ii:set_mp_max_write", &maxwrite, &maxwrite_sleep)) { return NULL; } CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->set_mp_max_write(self->db_env, maxwrite, maxwrite_sleep); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_get_mp_max_write(DBEnvObject* self) { int err; int maxwrite; db_timeout_t maxwrite_sleep; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->get_mp_max_write(self->db_env, &maxwrite, &maxwrite_sleep); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return Py_BuildValue("(ii)", maxwrite, (int)maxwrite_sleep); } static PyObject* DBEnv_set_verbose(DBEnvObject* self, PyObject* args) { int err; int which, onoff; if (!PyArg_ParseTuple(args, "ii:set_verbose", &which, &onoff)) { return NULL; } CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->set_verbose(self->db_env, which, onoff); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_get_verbose(DBEnvObject* self, PyObject* args) { int err; int which; int verbose; if (!PyArg_ParseTuple(args, "i:get_verbose", &which)) { return NULL; } CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->get_verbose(self->db_env, which, &verbose); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return PyBool_FromLong(verbose); } static void _dbenv_event_notifyCallback(DB_ENV* db_env, u_int32_t event, void *event_info) { DBEnvObject *dbenv; PyObject* callback; PyObject* args; PyObject* result = NULL; MYDB_BEGIN_BLOCK_THREADS; dbenv = (DBEnvObject *)db_env->app_private; callback = dbenv->event_notifyCallback; if (callback) { if (event == DB_EVENT_REP_NEWMASTER) { args = Py_BuildValue("(Oii)", dbenv, event, *((int *)event_info)); } else { args = Py_BuildValue("(OiO)", dbenv, event, Py_None); } if (args) { result = PyObject_CallObject(callback, args); } if ((!args) || (!result)) { PyErr_Print(); } Py_XDECREF(args); Py_XDECREF(result); } MYDB_END_BLOCK_THREADS; } static PyObject* DBEnv_set_event_notify(DBEnvObject* self, PyObject* notifyFunc) { int err; CHECK_ENV_NOT_CLOSED(self); if (!PyCallable_Check(notifyFunc)) { makeTypeError("Callable", notifyFunc); return NULL; } Py_XDECREF(self->event_notifyCallback); Py_INCREF(notifyFunc); self->event_notifyCallback = notifyFunc; /* This is to workaround a problem with un-initialized threads (see comment in DB_associate) */ #ifdef WITH_THREAD PyEval_InitThreads(); #endif MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->set_event_notify(self->db_env, _dbenv_event_notifyCallback); MYDB_END_ALLOW_THREADS; if (err) { Py_DECREF(notifyFunc); self->event_notifyCallback = NULL; } RETURN_IF_ERR(); RETURN_NONE(); } /* --------------------------------------------------------------------- */ /* REPLICATION METHODS: Base Replication */ static PyObject* DBEnv_rep_process_message(DBEnvObject* self, PyObject* args) { int err; PyObject *control_py, *rec_py; DBT control, rec; int envid; DB_LSN lsn; if (!PyArg_ParseTuple(args, "OOi:rep_process_message", &control_py, &rec_py, &envid)) return NULL; CHECK_ENV_NOT_CLOSED(self); if (!make_dbt(control_py, &control)) return NULL; if (!make_dbt(rec_py, &rec)) return NULL; MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->rep_process_message(self->db_env, &control, &rec, envid, &lsn); MYDB_END_ALLOW_THREADS; switch (err) { case DB_REP_NEWMASTER : return Py_BuildValue("(iO)", envid, Py_None); break; case DB_REP_DUPMASTER : case DB_REP_HOLDELECTION : case DB_REP_IGNORE : case DB_REP_JOIN_FAILURE : return Py_BuildValue("(iO)", err, Py_None); break; case DB_REP_NEWSITE : { PyObject *tmp, *r; if (!(tmp = PyBytes_FromStringAndSize(rec.data, rec.size))) { return NULL; } r = Py_BuildValue("(iO)", err, tmp); Py_DECREF(tmp); return r; break; } case DB_REP_NOTPERM : case DB_REP_ISPERM : return Py_BuildValue("(i(ll))", err, lsn.file, lsn.offset); break; } RETURN_IF_ERR(); return PyTuple_Pack(2, Py_None, Py_None); } static int _DBEnv_rep_transportCallback(DB_ENV* db_env, const DBT* control, const DBT* rec, const DB_LSN *lsn, int envid, u_int32_t flags) { DBEnvObject *dbenv; PyObject* rep_transport; PyObject* args; PyObject *a, *b; PyObject* result = NULL; int ret=0; MYDB_BEGIN_BLOCK_THREADS; dbenv = (DBEnvObject *)db_env->app_private; rep_transport = dbenv->rep_transport; /* ** The errors in 'a' or 'b' are detected in "Py_BuildValue". */ a = PyBytes_FromStringAndSize(control->data, control->size); b = PyBytes_FromStringAndSize(rec->data, rec->size); args = Py_BuildValue( "(OOO(ll)iI)", dbenv, a, b, lsn->file, lsn->offset, envid, flags); if (args) { result = PyObject_CallObject(rep_transport, args); } if ((!args) || (!result)) { PyErr_Print(); ret = -1; } Py_XDECREF(a); Py_XDECREF(b); Py_XDECREF(args); Py_XDECREF(result); MYDB_END_BLOCK_THREADS; return ret; } static PyObject* DBEnv_rep_set_transport(DBEnvObject* self, PyObject* args) { int err; int envid; PyObject *rep_transport; if (!PyArg_ParseTuple(args, "iO:rep_set_transport", &envid, &rep_transport)) return NULL; CHECK_ENV_NOT_CLOSED(self); if (!PyCallable_Check(rep_transport)) { makeTypeError("Callable", rep_transport); return NULL; } MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->rep_set_transport(self->db_env, envid, &_DBEnv_rep_transportCallback); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); Py_DECREF(self->rep_transport); Py_INCREF(rep_transport); self->rep_transport = rep_transport; RETURN_NONE(); } static PyObject* DBEnv_rep_set_request(DBEnvObject* self, PyObject* args) { int err; unsigned int minimum, maximum; if (!PyArg_ParseTuple(args,"II:rep_set_request", &minimum, &maximum)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->rep_set_request(self->db_env, minimum, maximum); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_rep_get_request(DBEnvObject* self) { int err; u_int32_t minimum, maximum; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->rep_get_request(self->db_env, &minimum, &maximum); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return Py_BuildValue("II", minimum, maximum); } static PyObject* DBEnv_rep_set_limit(DBEnvObject* self, PyObject* args) { int err; int limit; if (!PyArg_ParseTuple(args,"i:rep_set_limit", &limit)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->rep_set_limit(self->db_env, 0, limit); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_rep_get_limit(DBEnvObject* self) { int err; u_int32_t gbytes, bytes; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->rep_get_limit(self->db_env, &gbytes, &bytes); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(bytes); } static PyObject* DBEnv_rep_set_config(DBEnvObject* self, PyObject* args) { int err; int which; int onoff; if (!PyArg_ParseTuple(args,"ii:rep_set_config", &which, &onoff)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->rep_set_config(self->db_env, which, onoff); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_rep_get_config(DBEnvObject* self, PyObject* args) { int err; int which; int onoff; if (!PyArg_ParseTuple(args, "i:rep_get_config", &which)) { return NULL; } CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->rep_get_config(self->db_env, which, &onoff); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return PyBool_FromLong(onoff); } static PyObject* DBEnv_rep_elect(DBEnvObject* self, PyObject* args) { int err; u_int32_t nsites, nvotes; if (!PyArg_ParseTuple(args, "II:rep_elect", &nsites, &nvotes)) { return NULL; } CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->rep_elect(self->db_env, nsites, nvotes, 0); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_rep_start(DBEnvObject* self, PyObject* args, PyObject* kwargs) { int err; PyObject *cdata_py = Py_None; DBT cdata; int flags; static char* kwnames[] = {"flags","cdata", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i|O:rep_start", kwnames, &flags, &cdata_py)) { return NULL; } CHECK_ENV_NOT_CLOSED(self); if (!make_dbt(cdata_py, &cdata)) return NULL; MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->rep_start(self->db_env, cdata.size ? &cdata : NULL, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_rep_sync(DBEnvObject* self) { int err; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->rep_sync(self->db_env, 0); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_rep_set_nsites(DBEnvObject* self, PyObject* args) { int err; int nsites; if (!PyArg_ParseTuple(args, "i:rep_set_nsites", &nsites)) { return NULL; } CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->rep_set_nsites(self->db_env, nsites); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_rep_get_nsites(DBEnvObject* self) { int err; u_int32_t nsites; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->rep_get_nsites(self->db_env, &nsites); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(nsites); } static PyObject* DBEnv_rep_set_priority(DBEnvObject* self, PyObject* args) { int err; int priority; if (!PyArg_ParseTuple(args, "i:rep_set_priority", &priority)) { return NULL; } CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->rep_set_priority(self->db_env, priority); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_rep_get_priority(DBEnvObject* self) { int err; u_int32_t priority; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->rep_get_priority(self->db_env, &priority); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(priority); } static PyObject* DBEnv_rep_set_timeout(DBEnvObject* self, PyObject* args) { int err; int which, timeout; if (!PyArg_ParseTuple(args, "ii:rep_set_timeout", &which, &timeout)) { return NULL; } CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->rep_set_timeout(self->db_env, which, timeout); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_rep_get_timeout(DBEnvObject* self, PyObject* args) { int err; int which; u_int32_t timeout; if (!PyArg_ParseTuple(args, "i:rep_get_timeout", &which)) { return NULL; } CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->rep_get_timeout(self->db_env, which, &timeout); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(timeout); } static PyObject* DBEnv_rep_set_clockskew(DBEnvObject* self, PyObject* args) { int err; unsigned int fast, slow; if (!PyArg_ParseTuple(args,"II:rep_set_clockskew", &fast, &slow)) return NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->rep_set_clockskew(self->db_env, fast, slow); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_rep_get_clockskew(DBEnvObject* self) { int err; unsigned int fast, slow; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->rep_get_clockskew(self->db_env, &fast, &slow); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return Py_BuildValue("(II)", fast, slow); } static PyObject* DBEnv_rep_stat_print(DBEnvObject* self, PyObject* args, PyObject *kwargs) { int err; int flags=0; static char* kwnames[] = { "flags", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i:rep_stat_print", kwnames, &flags)) { return NULL; } CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->rep_stat_print(self->db_env, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_rep_stat(DBEnvObject* self, PyObject* args, PyObject *kwargs) { int err; int flags=0; DB_REP_STAT *statp; PyObject *stats; static char* kwnames[] = { "flags", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i:rep_stat", kwnames, &flags)) { return NULL; } CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->rep_stat(self->db_env, &statp, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); stats=PyDict_New(); if (stats == NULL) { free(statp); return NULL; } #define MAKE_ENTRY(name) _addIntToDict(stats, #name, statp->st_##name) #define MAKE_DB_LSN_ENTRY(name) _addDB_lsnToDict(stats , #name, statp->st_##name) MAKE_ENTRY(bulk_fills); MAKE_ENTRY(bulk_overflows); MAKE_ENTRY(bulk_records); MAKE_ENTRY(bulk_transfers); MAKE_ENTRY(client_rerequests); MAKE_ENTRY(client_svc_miss); MAKE_ENTRY(client_svc_req); MAKE_ENTRY(dupmasters); MAKE_ENTRY(egen); MAKE_ENTRY(election_nvotes); MAKE_ENTRY(startup_complete); MAKE_ENTRY(pg_duplicated); MAKE_ENTRY(pg_records); MAKE_ENTRY(pg_requested); MAKE_ENTRY(next_pg); MAKE_ENTRY(waiting_pg); MAKE_ENTRY(election_cur_winner); MAKE_ENTRY(election_gen); MAKE_DB_LSN_ENTRY(election_lsn); MAKE_ENTRY(election_nsites); MAKE_ENTRY(election_priority); MAKE_ENTRY(election_sec); MAKE_ENTRY(election_usec); MAKE_ENTRY(election_status); MAKE_ENTRY(election_tiebreaker); MAKE_ENTRY(election_votes); MAKE_ENTRY(elections); MAKE_ENTRY(elections_won); MAKE_ENTRY(env_id); MAKE_ENTRY(env_priority); MAKE_ENTRY(gen); MAKE_ENTRY(log_duplicated); MAKE_ENTRY(log_queued); MAKE_ENTRY(log_queued_max); MAKE_ENTRY(log_queued_total); MAKE_ENTRY(log_records); MAKE_ENTRY(log_requested); MAKE_ENTRY(master); MAKE_ENTRY(master_changes); MAKE_ENTRY(max_lease_sec); MAKE_ENTRY(max_lease_usec); MAKE_DB_LSN_ENTRY(max_perm_lsn); MAKE_ENTRY(msgs_badgen); MAKE_ENTRY(msgs_processed); MAKE_ENTRY(msgs_recover); MAKE_ENTRY(msgs_send_failures); MAKE_ENTRY(msgs_sent); MAKE_ENTRY(newsites); MAKE_DB_LSN_ENTRY(next_lsn); MAKE_ENTRY(nsites); MAKE_ENTRY(nthrottles); MAKE_ENTRY(outdated); MAKE_ENTRY(startsync_delayed); MAKE_ENTRY(status); MAKE_ENTRY(txns_applied); MAKE_DB_LSN_ENTRY(waiting_lsn); #undef MAKE_DB_LSN_ENTRY #undef MAKE_ENTRY free(statp); return stats; } /* --------------------------------------------------------------------- */ /* REPLICATION METHODS: Replication Manager */ static PyObject* DBEnv_repmgr_start(DBEnvObject* self, PyObject* args, PyObject* kwargs) { int err; int nthreads, flags; static char* kwnames[] = {"nthreads","flags", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii:repmgr_start", kwnames, &nthreads, &flags)) { return NULL; } CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->repmgr_start(self->db_env, nthreads, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } #if (DBVER < 53) static PyObject* DBEnv_repmgr_set_local_site(DBEnvObject* self, PyObject* args, PyObject* kwargs) { int err; char *host; int port; int flags = 0; static char* kwnames[] = {"host", "port", "flags", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "si|i:repmgr_set_local_site", kwnames, &host, &port, &flags)) { return NULL; } CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->repmgr_set_local_site(self->db_env, host, port, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_repmgr_add_remote_site(DBEnvObject* self, PyObject* args, PyObject* kwargs) { int err; char *host; int port; int flags = 0; int eidp; static char* kwnames[] = {"host", "port", "flags", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "si|i:repmgr_add_remote_site", kwnames, &host, &port, &flags)) { return NULL; } CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->repmgr_add_remote_site(self->db_env, host, port, &eidp, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(eidp); } #endif static PyObject* DBEnv_repmgr_set_ack_policy(DBEnvObject* self, PyObject* args) { int err; int ack_policy; if (!PyArg_ParseTuple(args, "i:repmgr_set_ack_policy", &ack_policy)) { return NULL; } CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->repmgr_set_ack_policy(self->db_env, ack_policy); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_repmgr_get_ack_policy(DBEnvObject* self) { int err; int ack_policy; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->repmgr_get_ack_policy(self->db_env, &ack_policy); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); return NUMBER_FromLong(ack_policy); } static PyObject* DBEnv_repmgr_site_list(DBEnvObject* self) { int err; unsigned int countp; DB_REPMGR_SITE *listp; PyObject *stats, *key, *tuple; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->repmgr_site_list(self->db_env, &countp, &listp); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); stats=PyDict_New(); if (stats == NULL) { free(listp); return NULL; } for(;countp--;) { key=NUMBER_FromLong(listp[countp].eid); if(!key) { Py_DECREF(stats); free(listp); return NULL; } tuple=Py_BuildValue("(sII)", listp[countp].host, listp[countp].port, listp[countp].status); if(!tuple) { Py_DECREF(key); Py_DECREF(stats); free(listp); return NULL; } if(PyDict_SetItem(stats, key, tuple)) { Py_DECREF(key); Py_DECREF(tuple); Py_DECREF(stats); free(listp); return NULL; } Py_DECREF(key); Py_DECREF(tuple); } free(listp); return stats; } static PyObject* DBEnv_repmgr_stat_print(DBEnvObject* self, PyObject* args, PyObject *kwargs) { int err; int flags=0; static char* kwnames[] = { "flags", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i:repmgr_stat_print", kwnames, &flags)) { return NULL; } CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->repmgr_stat_print(self->db_env, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBEnv_repmgr_stat(DBEnvObject* self, PyObject* args, PyObject *kwargs) { int err; int flags=0; DB_REPMGR_STAT *statp; PyObject *stats; static char* kwnames[] = { "flags", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i:repmgr_stat", kwnames, &flags)) { return NULL; } CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->db_env->repmgr_stat(self->db_env, &statp, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); stats=PyDict_New(); if (stats == NULL) { free(statp); return NULL; } #define MAKE_ENTRY(name) _addIntToDict(stats, #name, statp->st_##name) MAKE_ENTRY(perm_failed); MAKE_ENTRY(msgs_queued); MAKE_ENTRY(msgs_dropped); MAKE_ENTRY(connection_drop); MAKE_ENTRY(connect_fail); #undef MAKE_ENTRY free(statp); return stats; } /* --------------------------------------------------------------------- */ /* DBTxn methods */ static void _close_transaction_cursors(DBTxnObject* txn) { PyObject *dummy; while(txn->children_cursors) { PyErr_Warn(PyExc_RuntimeWarning, "Must close cursors before resolving a transaction."); dummy=DBC_close_internal(txn->children_cursors); Py_XDECREF(dummy); } } static void _promote_transaction_dbs_and_sequences(DBTxnObject *txn) { DBObject *db; DBSequenceObject *dbs; while (txn->children_dbs) { db=txn->children_dbs; EXTRACT_FROM_DOUBLE_LINKED_LIST_TXN(db); if (txn->parent_txn) { INSERT_IN_DOUBLE_LINKED_LIST_TXN(txn->parent_txn->children_dbs,db); db->txn=txn->parent_txn; } else { /* The db is already linked to its environment, ** so nothing to do. */ db->txn=NULL; } } while (txn->children_sequences) { dbs=txn->children_sequences; EXTRACT_FROM_DOUBLE_LINKED_LIST_TXN(dbs); if (txn->parent_txn) { INSERT_IN_DOUBLE_LINKED_LIST_TXN(txn->parent_txn->children_sequences,dbs); dbs->txn=txn->parent_txn; } else { /* The sequence is already linked to its ** parent db. Nothing to do. */ dbs->txn=NULL; } } } static PyObject* DBTxn_commit(DBTxnObject* self, PyObject* args) { int flags=0, err; DB_TXN *txn; if (!PyArg_ParseTuple(args, "|i:commit", &flags)) return NULL; _close_transaction_cursors(self); if (!self->txn) { PyObject *t = Py_BuildValue("(is)", 0, "DBTxn must not be used " "after txn_commit, txn_abort " "or txn_discard"); if (t) { PyErr_SetObject(DBError, t); Py_DECREF(t); } return NULL; } self->flag_prepare=0; txn = self->txn; self->txn = NULL; /* this DB_TXN is no longer valid after this call */ EXTRACT_FROM_DOUBLE_LINKED_LIST(self); MYDB_BEGIN_ALLOW_THREADS; err = txn->commit(txn, flags); MYDB_END_ALLOW_THREADS; _promote_transaction_dbs_and_sequences(self); RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBTxn_prepare(DBTxnObject* self, PyObject* args) { int err; char* gid=NULL; Py_ssize_t gid_size=0; if (!PyArg_ParseTuple(args, "s#:prepare", &gid, &gid_size)) return NULL; if (gid_size != DB_GID_SIZE) { PyErr_SetString(PyExc_TypeError, "gid must be DB_GID_SIZE bytes long"); return NULL; } if (!self->txn) { PyObject *t = Py_BuildValue("(is)", 0,"DBTxn must not be used " "after txn_commit, txn_abort " "or txn_discard"); if (t) { PyErr_SetObject(DBError, t); Py_DECREF(t); } return NULL; } self->flag_prepare=1; /* Prepare state */ MYDB_BEGIN_ALLOW_THREADS; err = self->txn->prepare(self->txn, (u_int8_t*)gid); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBTxn_abort_discard_internal(DBTxnObject* self, int discard) { PyObject *dummy; int err=0; DB_TXN *txn; if (!self->txn) { PyObject *t = Py_BuildValue("(is)", 0, "DBTxn must not be used " "after txn_commit, txn_abort " "or txn_discard"); if (t) { PyErr_SetObject(DBError, t); Py_DECREF(t); } return NULL; } txn = self->txn; self->txn = NULL; /* this DB_TXN is no longer valid after this call */ _close_transaction_cursors(self); while (self->children_sequences) { dummy=DBSequence_close_internal(self->children_sequences,0,0); Py_XDECREF(dummy); } while (self->children_dbs) { dummy=DB_close_internal(self->children_dbs, 0, 0); Py_XDECREF(dummy); } EXTRACT_FROM_DOUBLE_LINKED_LIST(self); MYDB_BEGIN_ALLOW_THREADS; if (discard) { assert(!self->flag_prepare); err = txn->discard(txn,0); } else { /* ** If the transaction is in the "prepare" or "recover" state, ** we better do not implicitly abort it. */ if (!self->flag_prepare) { err = txn->abort(txn); } } MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBTxn_abort(DBTxnObject* self) { self->flag_prepare=0; _close_transaction_cursors(self); return DBTxn_abort_discard_internal(self,0); } static PyObject* DBTxn_discard(DBTxnObject* self) { self->flag_prepare=0; _close_transaction_cursors(self); return DBTxn_abort_discard_internal(self,1); } static PyObject* DBTxn_id(DBTxnObject* self) { int id; if (!self->txn) { PyObject *t = Py_BuildValue("(is)", 0, "DBTxn must not be used " "after txn_commit, txn_abort " "or txn_discard"); if (t) { PyErr_SetObject(DBError, t); Py_DECREF(t); } return NULL; } MYDB_BEGIN_ALLOW_THREADS; id = self->txn->id(self->txn); MYDB_END_ALLOW_THREADS; return NUMBER_FromLong(id); } static PyObject* DBTxn_set_timeout(DBTxnObject* self, PyObject* args, PyObject* kwargs) { int err; u_int32_t flags=0; u_int32_t timeout = 0; static char* kwnames[] = { "timeout", "flags", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii:set_timeout", kwnames, &timeout, &flags)) { return NULL; } MYDB_BEGIN_ALLOW_THREADS; err = self->txn->set_timeout(self->txn, (db_timeout_t)timeout, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBTxn_set_name(DBTxnObject* self, PyObject* args) { int err; const char *name; if (!PyArg_ParseTuple(args, "s:set_name", &name)) return NULL; MYDB_BEGIN_ALLOW_THREADS; err = self->txn->set_name(self->txn, name); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBTxn_get_name(DBTxnObject* self) { int err; const char *name; MYDB_BEGIN_ALLOW_THREADS; err = self->txn->get_name(self->txn, &name); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); #if (PY_VERSION_HEX < 0x03000000) if (!name) { return PyString_FromString(""); } return PyString_FromString(name); #else if (!name) { return PyUnicode_FromString(""); } return PyUnicode_FromString(name); #endif } /* --------------------------------------------------------------------- */ /* DBSequence methods */ static PyObject* DBSequence_close_internal(DBSequenceObject* self, int flags, int do_not_close) { int err=0; if (self->sequence!=NULL) { EXTRACT_FROM_DOUBLE_LINKED_LIST(self); if (self->txn) { EXTRACT_FROM_DOUBLE_LINKED_LIST_TXN(self); self->txn=NULL; } /* ** "do_not_close" is used to dispose all related objects in the ** tree, without actually releasing the "root" object. ** This is done, for example, because function calls like ** "DBSequence.remove()" implicitly close the underlying handle. So ** the handle doesn't need to be closed, but related objects ** must be cleaned up. */ if (!do_not_close) { MYDB_BEGIN_ALLOW_THREADS err = self->sequence->close(self->sequence, flags); MYDB_END_ALLOW_THREADS } self->sequence = NULL; RETURN_IF_ERR(); } RETURN_NONE(); } static PyObject* DBSequence_close(DBSequenceObject* self, PyObject* args) { int flags=0; if (!PyArg_ParseTuple(args,"|i:close", &flags)) return NULL; return DBSequence_close_internal(self,flags,0); } static PyObject* DBSequence_get(DBSequenceObject* self, PyObject* args, PyObject* kwargs) { int err, flags = 0; #if (DBVER >= 61) unsigned #endif int delta = 1; db_seq_t value; PyObject *txnobj = NULL; DB_TXN *txn = NULL; static char* kwnames[] = {"delta", "txn", "flags", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, #if (DBVER >= 61) "|IOi:get", #else "|iOi:get", #endif kwnames, &delta, &txnobj, &flags)) return NULL; CHECK_SEQUENCE_NOT_CLOSED(self) if (!checkTxnObj(txnobj, &txn)) return NULL; MYDB_BEGIN_ALLOW_THREADS err = self->sequence->get(self->sequence, txn, delta, &value, flags); MYDB_END_ALLOW_THREADS RETURN_IF_ERR(); return PyLong_FromLongLong(value); } static PyObject* DBSequence_get_dbp(DBSequenceObject* self) { CHECK_SEQUENCE_NOT_CLOSED(self) Py_INCREF(self->mydb); return (PyObject* )self->mydb; } static PyObject* DBSequence_get_key(DBSequenceObject* self) { int err; DBT key; PyObject *retval = NULL; key.flags = DB_DBT_MALLOC; CHECK_SEQUENCE_NOT_CLOSED(self) MYDB_BEGIN_ALLOW_THREADS err = self->sequence->get_key(self->sequence, &key); MYDB_END_ALLOW_THREADS if (!err) retval = Build_PyString(key.data, key.size); FREE_DBT(key); RETURN_IF_ERR(); return retval; } static PyObject* DBSequence_initial_value(DBSequenceObject* self, PyObject* args) { int err; PY_LONG_LONG value; db_seq_t value2; if (!PyArg_ParseTuple(args,"L:initial_value", &value)) return NULL; CHECK_SEQUENCE_NOT_CLOSED(self) value2=value; /* If truncation, compiler should show a warning */ MYDB_BEGIN_ALLOW_THREADS err = self->sequence->initial_value(self->sequence, value2); MYDB_END_ALLOW_THREADS RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBSequence_open(DBSequenceObject* self, PyObject* args, PyObject* kwargs) { int err, flags = 0; PyObject* keyobj; PyObject *txnobj = NULL; DB_TXN *txn = NULL; DBT key; static char* kwnames[] = {"key", "txn", "flags", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|Oi:open", kwnames, &keyobj, &txnobj, &flags)) return NULL; if (!checkTxnObj(txnobj, &txn)) return NULL; if (!make_key_dbt(self->mydb, keyobj, &key, NULL)) return NULL; MYDB_BEGIN_ALLOW_THREADS err = self->sequence->open(self->sequence, txn, &key, flags); MYDB_END_ALLOW_THREADS FREE_DBT(key); RETURN_IF_ERR(); if (txn) { INSERT_IN_DOUBLE_LINKED_LIST_TXN(((DBTxnObject *)txnobj)->children_sequences,self); self->txn=(DBTxnObject *)txnobj; } RETURN_NONE(); } static PyObject* DBSequence_remove(DBSequenceObject* self, PyObject* args, PyObject* kwargs) { PyObject *dummy; int err, flags = 0; PyObject *txnobj = NULL; DB_TXN *txn = NULL; static char* kwnames[] = {"txn", "flags", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|Oi:remove", kwnames, &txnobj, &flags)) return NULL; if (!checkTxnObj(txnobj, &txn)) return NULL; CHECK_SEQUENCE_NOT_CLOSED(self) MYDB_BEGIN_ALLOW_THREADS err = self->sequence->remove(self->sequence, txn, flags); MYDB_END_ALLOW_THREADS dummy=DBSequence_close_internal(self,flags,1); Py_XDECREF(dummy); RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBSequence_set_cachesize(DBSequenceObject* self, PyObject* args) { int err; #if (DBVER >= 61) unsigned #endif int size; if (!PyArg_ParseTuple(args, #if (DBVER >= 61) "I:set_cachesize", #else "i:set_cachesize", #endif &size)) return NULL; CHECK_SEQUENCE_NOT_CLOSED(self) MYDB_BEGIN_ALLOW_THREADS err = self->sequence->set_cachesize(self->sequence, size); MYDB_END_ALLOW_THREADS RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBSequence_get_cachesize(DBSequenceObject* self) { int err; #if (DBVER >= 61) unsigned #endif int size; CHECK_SEQUENCE_NOT_CLOSED(self) MYDB_BEGIN_ALLOW_THREADS err = self->sequence->get_cachesize(self->sequence, &size); MYDB_END_ALLOW_THREADS RETURN_IF_ERR(); return NUMBER_FromLong(size); } static PyObject* DBSequence_set_flags(DBSequenceObject* self, PyObject* args) { int err, flags = 0; if (!PyArg_ParseTuple(args,"i:set_flags", &flags)) return NULL; CHECK_SEQUENCE_NOT_CLOSED(self) MYDB_BEGIN_ALLOW_THREADS err = self->sequence->set_flags(self->sequence, flags); MYDB_END_ALLOW_THREADS RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBSequence_get_flags(DBSequenceObject* self) { unsigned int flags; int err; CHECK_SEQUENCE_NOT_CLOSED(self) MYDB_BEGIN_ALLOW_THREADS err = self->sequence->get_flags(self->sequence, &flags); MYDB_END_ALLOW_THREADS RETURN_IF_ERR(); return NUMBER_FromLong((int)flags); } static PyObject* DBSequence_set_range(DBSequenceObject* self, PyObject* args) { int err; PY_LONG_LONG min, max; db_seq_t min2, max2; if (!PyArg_ParseTuple(args,"(LL):set_range", &min, &max)) return NULL; CHECK_SEQUENCE_NOT_CLOSED(self) min2=min; /* If truncation, compiler should show a warning */ max2=max; MYDB_BEGIN_ALLOW_THREADS err = self->sequence->set_range(self->sequence, min2, max2); MYDB_END_ALLOW_THREADS RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBSequence_get_range(DBSequenceObject* self) { int err; PY_LONG_LONG min, max; db_seq_t min2, max2; CHECK_SEQUENCE_NOT_CLOSED(self) MYDB_BEGIN_ALLOW_THREADS err = self->sequence->get_range(self->sequence, &min2, &max2); MYDB_END_ALLOW_THREADS RETURN_IF_ERR(); min=min2; /* If truncation, compiler should show a warning */ max=max2; return Py_BuildValue("(LL)", min, max); } static PyObject* DBSequence_stat_print(DBSequenceObject* self, PyObject* args, PyObject *kwargs) { int err; int flags=0; static char* kwnames[] = { "flags", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i:stat_print", kwnames, &flags)) { return NULL; } CHECK_SEQUENCE_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->sequence->stat_print(self->sequence, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); RETURN_NONE(); } static PyObject* DBSequence_stat(DBSequenceObject* self, PyObject* args, PyObject* kwargs) { int err, flags = 0; DB_SEQUENCE_STAT* sp = NULL; PyObject* dict_stat; static char* kwnames[] = {"flags", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i:stat", kwnames, &flags)) return NULL; CHECK_SEQUENCE_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; err = self->sequence->stat(self->sequence, &sp, flags); MYDB_END_ALLOW_THREADS; RETURN_IF_ERR(); if ((dict_stat = PyDict_New()) == NULL) { free(sp); return NULL; } #define MAKE_INT_ENTRY(name) _addIntToDict(dict_stat, #name, sp->st_##name) #if (DBVER >= 61) #define MAKE_UNSIGNED_INT_ENTRY(name) _addUnsignedIntToDict(dict_stat, #name, sp->st_##name) #endif #define MAKE_LONG_LONG_ENTRY(name) _addDb_seq_tToDict(dict_stat, #name, sp->st_##name) MAKE_INT_ENTRY(wait); MAKE_INT_ENTRY(nowait); MAKE_LONG_LONG_ENTRY(current); MAKE_LONG_LONG_ENTRY(value); MAKE_LONG_LONG_ENTRY(last_value); MAKE_LONG_LONG_ENTRY(min); MAKE_LONG_LONG_ENTRY(max); #if (DBVER >= 61) MAKE_UNSIGNED_INT_ENTRY(cache_size); #else MAKE_INT_ENTRY(cache_size); #endif MAKE_INT_ENTRY(flags); #undef MAKE_INT_ENTRY #undef MAKE_UNSIGNED_INT_ENTRY #undef MAKE_LONG_LONG_ENTRY free(sp); return dict_stat; } /* --------------------------------------------------------------------- */ /* Method definition tables and type objects */ static PyMethodDef DB_methods[] = { {"append", (PyCFunction)DB_append, METH_VARARGS|METH_KEYWORDS}, {"associate", (PyCFunction)DB_associate, METH_VARARGS|METH_KEYWORDS}, {"close", (PyCFunction)DB_close, METH_VARARGS}, {"compact", (PyCFunction)DB_compact, METH_VARARGS|METH_KEYWORDS}, {"consume", (PyCFunction)DB_consume, METH_VARARGS|METH_KEYWORDS}, {"consume_wait", (PyCFunction)DB_consume_wait, METH_VARARGS|METH_KEYWORDS}, {"cursor", (PyCFunction)DB_cursor, METH_VARARGS|METH_KEYWORDS}, {"delete", (PyCFunction)DB_delete, METH_VARARGS|METH_KEYWORDS}, {"fd", (PyCFunction)DB_fd, METH_NOARGS}, {"exists", (PyCFunction)DB_exists, METH_VARARGS|METH_KEYWORDS}, {"get", (PyCFunction)DB_get, METH_VARARGS|METH_KEYWORDS}, {"pget", (PyCFunction)DB_pget, METH_VARARGS|METH_KEYWORDS}, {"get_both", (PyCFunction)DB_get_both, METH_VARARGS|METH_KEYWORDS}, {"get_byteswapped", (PyCFunction)DB_get_byteswapped,METH_NOARGS}, {"get_size", (PyCFunction)DB_get_size, METH_VARARGS|METH_KEYWORDS}, {"get_type", (PyCFunction)DB_get_type, METH_NOARGS}, {"join", (PyCFunction)DB_join, METH_VARARGS}, {"key_range", (PyCFunction)DB_key_range, METH_VARARGS|METH_KEYWORDS}, {"has_key", (PyCFunction)DB_has_key, METH_VARARGS|METH_KEYWORDS}, {"items", (PyCFunction)DB_items, METH_VARARGS}, {"keys", (PyCFunction)DB_keys, METH_VARARGS}, {"open", (PyCFunction)DB_open, METH_VARARGS|METH_KEYWORDS}, {"put", (PyCFunction)DB_put, METH_VARARGS|METH_KEYWORDS}, {"remove", (PyCFunction)DB_remove, METH_VARARGS|METH_KEYWORDS}, {"rename", (PyCFunction)DB_rename, METH_VARARGS}, {"set_bt_minkey", (PyCFunction)DB_set_bt_minkey, METH_VARARGS}, {"get_bt_minkey", (PyCFunction)DB_get_bt_minkey, METH_NOARGS}, {"set_bt_compare", (PyCFunction)DB_set_bt_compare, METH_O}, {"set_cachesize", (PyCFunction)DB_set_cachesize, METH_VARARGS}, {"get_cachesize", (PyCFunction)DB_get_cachesize, METH_NOARGS}, {"set_dup_compare", (PyCFunction)DB_set_dup_compare, METH_O}, {"set_encrypt", (PyCFunction)DB_set_encrypt, METH_VARARGS|METH_KEYWORDS}, {"get_encrypt_flags", (PyCFunction)DB_get_encrypt_flags, METH_NOARGS}, {"set_flags", (PyCFunction)DB_set_flags, METH_VARARGS}, {"get_flags", (PyCFunction)DB_get_flags, METH_NOARGS}, {"get_transactional", (PyCFunction)DB_get_transactional, METH_NOARGS}, {"set_h_ffactor", (PyCFunction)DB_set_h_ffactor, METH_VARARGS}, {"get_h_ffactor", (PyCFunction)DB_get_h_ffactor, METH_NOARGS}, {"set_h_nelem", (PyCFunction)DB_set_h_nelem, METH_VARARGS}, {"get_h_nelem", (PyCFunction)DB_get_h_nelem, METH_NOARGS}, {"set_lorder", (PyCFunction)DB_set_lorder, METH_VARARGS}, {"get_lorder", (PyCFunction)DB_get_lorder, METH_NOARGS}, {"set_pagesize", (PyCFunction)DB_set_pagesize, METH_VARARGS}, {"get_pagesize", (PyCFunction)DB_get_pagesize, METH_NOARGS}, {"set_re_delim", (PyCFunction)DB_set_re_delim, METH_VARARGS}, {"get_re_delim", (PyCFunction)DB_get_re_delim, METH_NOARGS}, {"set_re_len", (PyCFunction)DB_set_re_len, METH_VARARGS}, {"get_re_len", (PyCFunction)DB_get_re_len, METH_NOARGS}, {"set_re_pad", (PyCFunction)DB_set_re_pad, METH_VARARGS}, {"get_re_pad", (PyCFunction)DB_get_re_pad, METH_NOARGS}, {"set_re_source", (PyCFunction)DB_set_re_source, METH_VARARGS}, {"get_re_source", (PyCFunction)DB_get_re_source, METH_NOARGS}, {"set_q_extentsize",(PyCFunction)DB_set_q_extentsize, METH_VARARGS}, {"get_q_extentsize",(PyCFunction)DB_get_q_extentsize, METH_NOARGS}, {"set_private", (PyCFunction)DB_set_private, METH_O}, {"get_private", (PyCFunction)DB_get_private, METH_NOARGS}, {"set_priority", (PyCFunction)DB_set_priority, METH_VARARGS}, {"get_priority", (PyCFunction)DB_get_priority, METH_NOARGS}, {"get_dbname", (PyCFunction)DB_get_dbname, METH_NOARGS}, {"get_open_flags", (PyCFunction)DB_get_open_flags, METH_NOARGS}, {"stat", (PyCFunction)DB_stat, METH_VARARGS|METH_KEYWORDS}, {"stat_print", (PyCFunction)DB_stat_print, METH_VARARGS|METH_KEYWORDS}, {"sync", (PyCFunction)DB_sync, METH_VARARGS}, {"truncate", (PyCFunction)DB_truncate, METH_VARARGS|METH_KEYWORDS}, {"type", (PyCFunction)DB_get_type, METH_NOARGS}, {"upgrade", (PyCFunction)DB_upgrade, METH_VARARGS}, {"values", (PyCFunction)DB_values, METH_VARARGS}, {"verify", (PyCFunction)DB_verify, METH_VARARGS|METH_KEYWORDS}, {"set_get_returns_none",(PyCFunction)DB_set_get_returns_none, METH_VARARGS}, {NULL, NULL} /* sentinel */ }; /* We need this to support __contains__() */ static PySequenceMethods DB_sequence = { 0, /* sq_length, mapping wins here */ 0, /* sq_concat */ 0, /* sq_repeat */ 0, /* sq_item */ 0, /* sq_slice */ 0, /* sq_ass_item */ 0, /* sq_ass_slice */ (objobjproc)DB_contains, /* sq_contains */ 0, /* sq_inplace_concat */ 0, /* sq_inplace_repeat */ }; static PyMappingMethods DB_mapping = { DB_length, /*mp_length*/ (binaryfunc)DB_subscript, /*mp_subscript*/ (objobjargproc)DB_ass_sub, /*mp_ass_subscript*/ }; static PyMethodDef DBCursor_methods[] = { {"close", (PyCFunction)DBC_close, METH_NOARGS}, {"count", (PyCFunction)DBC_count, METH_VARARGS}, {"current", (PyCFunction)DBC_current, METH_VARARGS|METH_KEYWORDS}, {"delete", (PyCFunction)DBC_delete, METH_VARARGS}, {"dup", (PyCFunction)DBC_dup, METH_VARARGS}, {"first", (PyCFunction)DBC_first, METH_VARARGS|METH_KEYWORDS}, {"get", (PyCFunction)DBC_get, METH_VARARGS|METH_KEYWORDS}, {"pget", (PyCFunction)DBC_pget, METH_VARARGS|METH_KEYWORDS}, {"get_recno", (PyCFunction)DBC_get_recno, METH_NOARGS}, {"last", (PyCFunction)DBC_last, METH_VARARGS|METH_KEYWORDS}, {"next", (PyCFunction)DBC_next, METH_VARARGS|METH_KEYWORDS}, {"prev", (PyCFunction)DBC_prev, METH_VARARGS|METH_KEYWORDS}, {"put", (PyCFunction)DBC_put, METH_VARARGS|METH_KEYWORDS}, {"set", (PyCFunction)DBC_set, METH_VARARGS|METH_KEYWORDS}, {"set_range", (PyCFunction)DBC_set_range, METH_VARARGS|METH_KEYWORDS}, {"get_both", (PyCFunction)DBC_get_both, METH_VARARGS}, {"get_current_size",(PyCFunction)DBC_get_current_size, METH_NOARGS}, {"set_both", (PyCFunction)DBC_set_both, METH_VARARGS}, {"set_recno", (PyCFunction)DBC_set_recno, METH_VARARGS|METH_KEYWORDS}, {"consume", (PyCFunction)DBC_consume, METH_VARARGS|METH_KEYWORDS}, {"next_dup", (PyCFunction)DBC_next_dup, METH_VARARGS|METH_KEYWORDS}, {"next_nodup", (PyCFunction)DBC_next_nodup, METH_VARARGS|METH_KEYWORDS}, {"prev_dup", (PyCFunction)DBC_prev_dup, METH_VARARGS|METH_KEYWORDS}, {"prev_nodup", (PyCFunction)DBC_prev_nodup, METH_VARARGS|METH_KEYWORDS}, {"join_item", (PyCFunction)DBC_join_item, METH_VARARGS}, {"set_priority", (PyCFunction)DBC_set_priority, METH_VARARGS|METH_KEYWORDS}, {"get_priority", (PyCFunction)DBC_get_priority, METH_NOARGS}, {NULL, NULL} /* sentinel */ }; static PyMethodDef DBLogCursor_methods[] = { {"close", (PyCFunction)DBLogCursor_close, METH_NOARGS}, {"current", (PyCFunction)DBLogCursor_current, METH_NOARGS}, {"first", (PyCFunction)DBLogCursor_first, METH_NOARGS}, {"last", (PyCFunction)DBLogCursor_last, METH_NOARGS}, {"next", (PyCFunction)DBLogCursor_next, METH_NOARGS}, {"prev", (PyCFunction)DBLogCursor_prev, METH_NOARGS}, {"set", (PyCFunction)DBLogCursor_set, METH_VARARGS}, {NULL, NULL} /* sentinel */ }; #if (DBVER >= 53) static PyMethodDef DBSite_methods[] = { {"get_config", (PyCFunction)DBSite_get_config, METH_VARARGS | METH_KEYWORDS}, {"set_config", (PyCFunction)DBSite_set_config, METH_VARARGS | METH_KEYWORDS}, {"remove", (PyCFunction)DBSite_remove, METH_NOARGS}, {"get_eid", (PyCFunction)DBSite_get_eid, METH_NOARGS}, {"get_address", (PyCFunction)DBSite_get_address, METH_NOARGS}, {"close", (PyCFunction)DBSite_close, METH_NOARGS}, {NULL, NULL} /* sentinel */ }; #endif static PyMethodDef DBEnv_methods[] = { {"close", (PyCFunction)DBEnv_close, METH_VARARGS}, {"open", (PyCFunction)DBEnv_open, METH_VARARGS}, {"remove", (PyCFunction)DBEnv_remove, METH_VARARGS}, {"dbremove", (PyCFunction)DBEnv_dbremove, METH_VARARGS|METH_KEYWORDS}, {"dbrename", (PyCFunction)DBEnv_dbrename, METH_VARARGS|METH_KEYWORDS}, {"set_thread_count", (PyCFunction)DBEnv_set_thread_count, METH_VARARGS}, {"get_thread_count", (PyCFunction)DBEnv_get_thread_count, METH_NOARGS}, {"set_encrypt", (PyCFunction)DBEnv_set_encrypt, METH_VARARGS|METH_KEYWORDS}, {"get_encrypt_flags", (PyCFunction)DBEnv_get_encrypt_flags, METH_NOARGS}, {"get_timeout", (PyCFunction)DBEnv_get_timeout, METH_VARARGS|METH_KEYWORDS}, {"set_timeout", (PyCFunction)DBEnv_set_timeout, METH_VARARGS|METH_KEYWORDS}, {"set_shm_key", (PyCFunction)DBEnv_set_shm_key, METH_VARARGS}, {"get_shm_key", (PyCFunction)DBEnv_get_shm_key, METH_NOARGS}, {"set_cache_max", (PyCFunction)DBEnv_set_cache_max, METH_VARARGS}, {"get_cache_max", (PyCFunction)DBEnv_get_cache_max, METH_NOARGS}, {"set_cachesize", (PyCFunction)DBEnv_set_cachesize, METH_VARARGS}, {"get_cachesize", (PyCFunction)DBEnv_get_cachesize, METH_NOARGS}, {"memp_trickle", (PyCFunction)DBEnv_memp_trickle, METH_VARARGS}, {"memp_sync", (PyCFunction)DBEnv_memp_sync, METH_VARARGS}, {"memp_stat", (PyCFunction)DBEnv_memp_stat, METH_VARARGS|METH_KEYWORDS}, {"memp_stat_print", (PyCFunction)DBEnv_memp_stat_print, METH_VARARGS|METH_KEYWORDS}, {"mutex_set_max", (PyCFunction)DBEnv_mutex_set_max, METH_VARARGS}, {"mutex_get_max", (PyCFunction)DBEnv_mutex_get_max, METH_NOARGS}, {"mutex_set_align", (PyCFunction)DBEnv_mutex_set_align, METH_VARARGS}, {"mutex_get_align", (PyCFunction)DBEnv_mutex_get_align, METH_NOARGS}, {"mutex_set_increment", (PyCFunction)DBEnv_mutex_set_increment, METH_VARARGS}, {"mutex_get_increment", (PyCFunction)DBEnv_mutex_get_increment, METH_NOARGS}, {"mutex_set_tas_spins", (PyCFunction)DBEnv_mutex_set_tas_spins, METH_VARARGS}, {"mutex_get_tas_spins", (PyCFunction)DBEnv_mutex_get_tas_spins, METH_NOARGS}, {"mutex_stat", (PyCFunction)DBEnv_mutex_stat, METH_VARARGS}, {"mutex_stat_print", (PyCFunction)DBEnv_mutex_stat_print, METH_VARARGS|METH_KEYWORDS}, {"set_data_dir", (PyCFunction)DBEnv_set_data_dir, METH_VARARGS}, {"get_data_dirs", (PyCFunction)DBEnv_get_data_dirs, METH_NOARGS}, {"get_flags", (PyCFunction)DBEnv_get_flags, METH_NOARGS}, {"set_flags", (PyCFunction)DBEnv_set_flags, METH_VARARGS}, {"log_set_config", (PyCFunction)DBEnv_log_set_config, METH_VARARGS}, {"log_get_config", (PyCFunction)DBEnv_log_get_config, METH_VARARGS}, {"set_lg_bsize", (PyCFunction)DBEnv_set_lg_bsize, METH_VARARGS}, {"get_lg_bsize", (PyCFunction)DBEnv_get_lg_bsize, METH_NOARGS}, {"set_lg_dir", (PyCFunction)DBEnv_set_lg_dir, METH_VARARGS}, {"get_lg_dir", (PyCFunction)DBEnv_get_lg_dir, METH_NOARGS}, {"set_lg_max", (PyCFunction)DBEnv_set_lg_max, METH_VARARGS}, {"get_lg_max", (PyCFunction)DBEnv_get_lg_max, METH_NOARGS}, {"set_lg_regionmax",(PyCFunction)DBEnv_set_lg_regionmax, METH_VARARGS}, {"get_lg_regionmax",(PyCFunction)DBEnv_get_lg_regionmax, METH_NOARGS}, {"set_lg_filemode", (PyCFunction)DBEnv_set_lg_filemode, METH_VARARGS}, {"get_lg_filemode", (PyCFunction)DBEnv_get_lg_filemode, METH_NOARGS}, {"set_lk_partitions", (PyCFunction)DBEnv_set_lk_partitions, METH_VARARGS}, {"get_lk_partitions", (PyCFunction)DBEnv_get_lk_partitions, METH_NOARGS}, {"set_lk_detect", (PyCFunction)DBEnv_set_lk_detect, METH_VARARGS}, {"get_lk_detect", (PyCFunction)DBEnv_get_lk_detect, METH_NOARGS}, {"set_lk_max_locks", (PyCFunction)DBEnv_set_lk_max_locks, METH_VARARGS}, {"get_lk_max_locks", (PyCFunction)DBEnv_get_lk_max_locks, METH_NOARGS}, {"set_lk_max_lockers", (PyCFunction)DBEnv_set_lk_max_lockers, METH_VARARGS}, {"get_lk_max_lockers", (PyCFunction)DBEnv_get_lk_max_lockers, METH_NOARGS}, {"set_lk_max_objects", (PyCFunction)DBEnv_set_lk_max_objects, METH_VARARGS}, {"get_lk_max_objects", (PyCFunction)DBEnv_get_lk_max_objects, METH_NOARGS}, {"stat_print", (PyCFunction)DBEnv_stat_print, METH_VARARGS|METH_KEYWORDS}, {"set_mp_mmapsize", (PyCFunction)DBEnv_set_mp_mmapsize, METH_VARARGS}, {"get_mp_mmapsize", (PyCFunction)DBEnv_get_mp_mmapsize, METH_NOARGS}, {"set_tmp_dir", (PyCFunction)DBEnv_set_tmp_dir, METH_VARARGS}, {"get_tmp_dir", (PyCFunction)DBEnv_get_tmp_dir, METH_NOARGS}, {"txn_begin", (PyCFunction)DBEnv_txn_begin, METH_VARARGS|METH_KEYWORDS}, {"txn_checkpoint", (PyCFunction)DBEnv_txn_checkpoint, METH_VARARGS}, {"txn_stat", (PyCFunction)DBEnv_txn_stat, METH_VARARGS}, {"txn_stat_print", (PyCFunction)DBEnv_txn_stat_print, METH_VARARGS|METH_KEYWORDS}, {"get_tx_max", (PyCFunction)DBEnv_get_tx_max, METH_NOARGS}, {"get_tx_timestamp", (PyCFunction)DBEnv_get_tx_timestamp, METH_NOARGS}, {"set_tx_max", (PyCFunction)DBEnv_set_tx_max, METH_VARARGS}, {"set_tx_timestamp", (PyCFunction)DBEnv_set_tx_timestamp, METH_VARARGS}, {"lock_detect", (PyCFunction)DBEnv_lock_detect, METH_VARARGS}, {"lock_get", (PyCFunction)DBEnv_lock_get, METH_VARARGS}, {"lock_id", (PyCFunction)DBEnv_lock_id, METH_NOARGS}, {"lock_id_free", (PyCFunction)DBEnv_lock_id_free, METH_VARARGS}, {"lock_put", (PyCFunction)DBEnv_lock_put, METH_VARARGS}, {"lock_stat", (PyCFunction)DBEnv_lock_stat, METH_VARARGS}, {"lock_stat_print", (PyCFunction)DBEnv_lock_stat_print, METH_VARARGS|METH_KEYWORDS}, {"log_cursor", (PyCFunction)DBEnv_log_cursor, METH_NOARGS}, {"log_file", (PyCFunction)DBEnv_log_file, METH_VARARGS}, {"log_printf", (PyCFunction)DBEnv_log_printf, METH_VARARGS|METH_KEYWORDS}, {"log_archive", (PyCFunction)DBEnv_log_archive, METH_VARARGS}, {"log_flush", (PyCFunction)DBEnv_log_flush, METH_NOARGS}, {"log_stat", (PyCFunction)DBEnv_log_stat, METH_VARARGS}, {"log_stat_print", (PyCFunction)DBEnv_log_stat_print, METH_VARARGS|METH_KEYWORDS}, {"fileid_reset", (PyCFunction)DBEnv_fileid_reset, METH_VARARGS|METH_KEYWORDS}, {"lsn_reset", (PyCFunction)DBEnv_lsn_reset, METH_VARARGS|METH_KEYWORDS}, {"set_get_returns_none",(PyCFunction)DBEnv_set_get_returns_none, METH_VARARGS}, {"txn_recover", (PyCFunction)DBEnv_txn_recover, METH_NOARGS}, #if (DBVER < 48) {"set_rpc_server", (PyCFunction)DBEnv_set_rpc_server, METH_VARARGS||METH_KEYWORDS}, #endif {"set_mp_max_openfd", (PyCFunction)DBEnv_set_mp_max_openfd, METH_VARARGS}, {"get_mp_max_openfd", (PyCFunction)DBEnv_get_mp_max_openfd, METH_NOARGS}, {"set_mp_max_write", (PyCFunction)DBEnv_set_mp_max_write, METH_VARARGS}, {"get_mp_max_write", (PyCFunction)DBEnv_get_mp_max_write, METH_NOARGS}, {"set_verbose", (PyCFunction)DBEnv_set_verbose, METH_VARARGS}, {"get_verbose", (PyCFunction)DBEnv_get_verbose, METH_VARARGS}, {"set_private", (PyCFunction)DBEnv_set_private, METH_O}, {"get_private", (PyCFunction)DBEnv_get_private, METH_NOARGS}, {"get_open_flags", (PyCFunction)DBEnv_get_open_flags, METH_NOARGS}, {"set_intermediate_dir_mode", (PyCFunction)DBEnv_set_intermediate_dir_mode, METH_VARARGS}, {"get_intermediate_dir_mode", (PyCFunction)DBEnv_get_intermediate_dir_mode, METH_NOARGS}, {"rep_start", (PyCFunction)DBEnv_rep_start, METH_VARARGS|METH_KEYWORDS}, {"rep_set_transport", (PyCFunction)DBEnv_rep_set_transport, METH_VARARGS}, {"rep_process_message", (PyCFunction)DBEnv_rep_process_message, METH_VARARGS}, {"rep_elect", (PyCFunction)DBEnv_rep_elect, METH_VARARGS}, {"rep_set_config", (PyCFunction)DBEnv_rep_set_config, METH_VARARGS}, {"rep_get_config", (PyCFunction)DBEnv_rep_get_config, METH_VARARGS}, {"rep_sync", (PyCFunction)DBEnv_rep_sync, METH_NOARGS}, {"rep_set_limit", (PyCFunction)DBEnv_rep_set_limit, METH_VARARGS}, {"rep_get_limit", (PyCFunction)DBEnv_rep_get_limit, METH_NOARGS}, {"rep_set_request", (PyCFunction)DBEnv_rep_set_request, METH_VARARGS}, {"rep_get_request", (PyCFunction)DBEnv_rep_get_request, METH_NOARGS}, {"set_event_notify", (PyCFunction)DBEnv_set_event_notify, METH_O}, {"rep_set_nsites", (PyCFunction)DBEnv_rep_set_nsites, METH_VARARGS}, {"rep_get_nsites", (PyCFunction)DBEnv_rep_get_nsites, METH_NOARGS}, {"rep_set_priority", (PyCFunction)DBEnv_rep_set_priority, METH_VARARGS}, {"rep_get_priority", (PyCFunction)DBEnv_rep_get_priority, METH_NOARGS}, {"rep_set_timeout", (PyCFunction)DBEnv_rep_set_timeout, METH_VARARGS}, {"rep_get_timeout", (PyCFunction)DBEnv_rep_get_timeout, METH_VARARGS}, {"rep_set_clockskew", (PyCFunction)DBEnv_rep_set_clockskew, METH_VARARGS}, {"rep_get_clockskew", (PyCFunction)DBEnv_rep_get_clockskew, METH_VARARGS}, {"rep_stat", (PyCFunction)DBEnv_rep_stat, METH_VARARGS|METH_KEYWORDS}, {"rep_stat_print", (PyCFunction)DBEnv_rep_stat_print, METH_VARARGS|METH_KEYWORDS}, {"repmgr_start", (PyCFunction)DBEnv_repmgr_start, METH_VARARGS|METH_KEYWORDS}, #if (DBVER < 53) {"repmgr_set_local_site", (PyCFunction)DBEnv_repmgr_set_local_site, METH_VARARGS|METH_KEYWORDS}, {"repmgr_add_remote_site", (PyCFunction)DBEnv_repmgr_add_remote_site, METH_VARARGS|METH_KEYWORDS}, #endif {"repmgr_set_ack_policy", (PyCFunction)DBEnv_repmgr_set_ack_policy, METH_VARARGS}, {"repmgr_get_ack_policy", (PyCFunction)DBEnv_repmgr_get_ack_policy, METH_NOARGS}, {"repmgr_site_list", (PyCFunction)DBEnv_repmgr_site_list, METH_NOARGS}, {"repmgr_stat", (PyCFunction)DBEnv_repmgr_stat, METH_VARARGS|METH_KEYWORDS}, {"repmgr_stat_print", (PyCFunction)DBEnv_repmgr_stat_print, METH_VARARGS|METH_KEYWORDS}, #if (DBVER >= 53) {"repmgr_site", (PyCFunction)DBEnv_repmgr_site, METH_VARARGS | METH_KEYWORDS}, {"repmgr_site_by_eid", (PyCFunction)DBEnv_repmgr_site_by_eid, METH_VARARGS | METH_KEYWORDS}, #endif {NULL, NULL} /* sentinel */ }; static PyMethodDef DBTxn_methods[] = { {"commit", (PyCFunction)DBTxn_commit, METH_VARARGS}, {"prepare", (PyCFunction)DBTxn_prepare, METH_VARARGS}, {"discard", (PyCFunction)DBTxn_discard, METH_NOARGS}, {"abort", (PyCFunction)DBTxn_abort, METH_NOARGS}, {"id", (PyCFunction)DBTxn_id, METH_NOARGS}, {"set_timeout", (PyCFunction)DBTxn_set_timeout, METH_VARARGS|METH_KEYWORDS}, {"set_name", (PyCFunction)DBTxn_set_name, METH_VARARGS}, {"get_name", (PyCFunction)DBTxn_get_name, METH_NOARGS}, {NULL, NULL} /* sentinel */ }; static PyMethodDef DBSequence_methods[] = { {"close", (PyCFunction)DBSequence_close, METH_VARARGS}, {"get", (PyCFunction)DBSequence_get, METH_VARARGS|METH_KEYWORDS}, {"get_dbp", (PyCFunction)DBSequence_get_dbp, METH_NOARGS}, {"get_key", (PyCFunction)DBSequence_get_key, METH_NOARGS}, {"initial_value", (PyCFunction)DBSequence_initial_value, METH_VARARGS}, {"open", (PyCFunction)DBSequence_open, METH_VARARGS|METH_KEYWORDS}, {"remove", (PyCFunction)DBSequence_remove, METH_VARARGS|METH_KEYWORDS}, {"set_cachesize", (PyCFunction)DBSequence_set_cachesize, METH_VARARGS}, {"get_cachesize", (PyCFunction)DBSequence_get_cachesize, METH_NOARGS}, {"set_flags", (PyCFunction)DBSequence_set_flags, METH_VARARGS}, {"get_flags", (PyCFunction)DBSequence_get_flags, METH_NOARGS}, {"set_range", (PyCFunction)DBSequence_set_range, METH_VARARGS}, {"get_range", (PyCFunction)DBSequence_get_range, METH_NOARGS}, {"stat", (PyCFunction)DBSequence_stat, METH_VARARGS|METH_KEYWORDS}, {"stat_print", (PyCFunction)DBSequence_stat_print, METH_VARARGS|METH_KEYWORDS}, {NULL, NULL} /* sentinel */ }; static PyObject* DBEnv_db_home_get(DBEnvObject* self) { const char *home = NULL; CHECK_ENV_NOT_CLOSED(self); MYDB_BEGIN_ALLOW_THREADS; self->db_env->get_home(self->db_env, &home); MYDB_END_ALLOW_THREADS; if (home == NULL) { RETURN_NONE(); } return PyBytes_FromString(home); } static PyGetSetDef DBEnv_getsets[] = { {"db_home", (getter)DBEnv_db_home_get, NULL,}, {NULL} }; statichere PyTypeObject DB_Type = { #if (PY_VERSION_HEX < 0x03000000) PyObject_HEAD_INIT(NULL) 0, /*ob_size*/ #else PyVarObject_HEAD_INIT(NULL, 0) #endif "DB", /*tp_name*/ sizeof(DBObject), /*tp_basicsize*/ 0, /*tp_itemsize*/ /* methods */ (destructor)DB_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ 0, /*tp_compare*/ 0, /*tp_repr*/ 0, /*tp_as_number*/ &DB_sequence,/*tp_as_sequence*/ &DB_mapping,/*tp_as_mapping*/ 0, /*tp_hash*/ 0, /* tp_call */ 0, /* tp_str */ 0, /* tp_getattro */ 0, /* tp_setattro */ 0, /* tp_as_buffer */ #if (PY_VERSION_HEX < 0x03000000) Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_WEAKREFS, /* tp_flags */ #else Py_TPFLAGS_DEFAULT, /* tp_flags */ #endif 0, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ offsetof(DBObject, in_weakreflist), /* tp_weaklistoffset */ 0, /*tp_iter*/ 0, /*tp_iternext*/ DB_methods, /*tp_methods*/ 0, /*tp_members*/ }; statichere PyTypeObject DBCursor_Type = { #if (PY_VERSION_HEX < 0x03000000) PyObject_HEAD_INIT(NULL) 0, /*ob_size*/ #else PyVarObject_HEAD_INIT(NULL, 0) #endif "DBCursor", /*tp_name*/ sizeof(DBCursorObject), /*tp_basicsize*/ 0, /*tp_itemsize*/ /* methods */ (destructor)DBCursor_dealloc,/*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ 0, /*tp_compare*/ 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ #if (PY_VERSION_HEX < 0x03000000) Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_WEAKREFS, /* tp_flags */ #else Py_TPFLAGS_DEFAULT, /* tp_flags */ #endif 0, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ offsetof(DBCursorObject, in_weakreflist), /* tp_weaklistoffset */ 0, /*tp_iter*/ 0, /*tp_iternext*/ DBCursor_methods, /*tp_methods*/ 0, /*tp_members*/ }; statichere PyTypeObject DBLogCursor_Type = { #if (PY_VERSION_HEX < 0x03000000) PyObject_HEAD_INIT(NULL) 0, /*ob_size*/ #else PyVarObject_HEAD_INIT(NULL, 0) #endif "DBLogCursor", /*tp_name*/ sizeof(DBLogCursorObject), /*tp_basicsize*/ 0, /*tp_itemsize*/ /* methods */ (destructor)DBLogCursor_dealloc,/*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ 0, /*tp_compare*/ 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ #if (PY_VERSION_HEX < 0x03000000) Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_WEAKREFS, /* tp_flags */ #else Py_TPFLAGS_DEFAULT, /* tp_flags */ #endif 0, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ offsetof(DBLogCursorObject, in_weakreflist), /* tp_weaklistoffset */ 0, /*tp_iter*/ 0, /*tp_iternext*/ DBLogCursor_methods, /*tp_methods*/ 0, /*tp_members*/ }; #if (DBVER >= 53) statichere PyTypeObject DBSite_Type = { #if (PY_VERSION_HEX < 0x03000000) PyObject_HEAD_INIT(NULL) 0, /*ob_size*/ #else PyVarObject_HEAD_INIT(NULL, 0) #endif "DBSite", /*tp_name*/ sizeof(DBSiteObject), /*tp_basicsize*/ 0, /*tp_itemsize*/ /* methods */ (destructor)DBSite_dealloc,/*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ 0, /*tp_compare*/ 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ #if (PY_VERSION_HEX < 0x03000000) Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_WEAKREFS, /* tp_flags */ #else Py_TPFLAGS_DEFAULT, /* tp_flags */ #endif 0, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ offsetof(DBSiteObject, in_weakreflist), /* tp_weaklistoffset */ 0, /*tp_iter*/ 0, /*tp_iternext*/ DBSite_methods, /*tp_methods*/ 0, /*tp_members*/ }; #endif statichere PyTypeObject DBEnv_Type = { #if (PY_VERSION_HEX < 0x03000000) PyObject_HEAD_INIT(NULL) 0, /*ob_size*/ #else PyVarObject_HEAD_INIT(NULL, 0) #endif "DBEnv", /*tp_name*/ sizeof(DBEnvObject), /*tp_basicsize*/ 0, /*tp_itemsize*/ /* methods */ (destructor)DBEnv_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ 0, /*tp_compare*/ 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /* tp_call */ 0, /* tp_str */ 0, /* tp_getattro */ 0, /* tp_setattro */ 0, /* tp_as_buffer */ #if (PY_VERSION_HEX < 0x03000000) Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_WEAKREFS, /* tp_flags */ #else Py_TPFLAGS_DEFAULT, /* tp_flags */ #endif 0, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ offsetof(DBEnvObject, in_weakreflist), /* tp_weaklistoffset */ 0, /* tp_iter */ 0, /* tp_iternext */ DBEnv_methods, /* tp_methods */ 0, /* tp_members */ DBEnv_getsets, /* tp_getsets */ }; statichere PyTypeObject DBTxn_Type = { #if (PY_VERSION_HEX < 0x03000000) PyObject_HEAD_INIT(NULL) 0, /*ob_size*/ #else PyVarObject_HEAD_INIT(NULL, 0) #endif "DBTxn", /*tp_name*/ sizeof(DBTxnObject), /*tp_basicsize*/ 0, /*tp_itemsize*/ /* methods */ (destructor)DBTxn_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ 0, /*tp_compare*/ 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /* tp_call */ 0, /* tp_str */ 0, /* tp_getattro */ 0, /* tp_setattro */ 0, /* tp_as_buffer */ #if (PY_VERSION_HEX < 0x03000000) Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_WEAKREFS, /* tp_flags */ #else Py_TPFLAGS_DEFAULT, /* tp_flags */ #endif 0, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ offsetof(DBTxnObject, in_weakreflist), /* tp_weaklistoffset */ 0, /*tp_iter*/ 0, /*tp_iternext*/ DBTxn_methods, /*tp_methods*/ 0, /*tp_members*/ }; statichere PyTypeObject DBLock_Type = { #if (PY_VERSION_HEX < 0x03000000) PyObject_HEAD_INIT(NULL) 0, /*ob_size*/ #else PyVarObject_HEAD_INIT(NULL, 0) #endif "DBLock", /*tp_name*/ sizeof(DBLockObject), /*tp_basicsize*/ 0, /*tp_itemsize*/ /* methods */ (destructor)DBLock_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ 0, /*tp_compare*/ 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /* tp_call */ 0, /* tp_str */ 0, /* tp_getattro */ 0, /* tp_setattro */ 0, /* tp_as_buffer */ #if (PY_VERSION_HEX < 0x03000000) Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_WEAKREFS, /* tp_flags */ #else Py_TPFLAGS_DEFAULT, /* tp_flags */ #endif 0, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ offsetof(DBLockObject, in_weakreflist), /* tp_weaklistoffset */ }; statichere PyTypeObject DBSequence_Type = { #if (PY_VERSION_HEX < 0x03000000) PyObject_HEAD_INIT(NULL) 0, /*ob_size*/ #else PyVarObject_HEAD_INIT(NULL, 0) #endif "DBSequence", /*tp_name*/ sizeof(DBSequenceObject), /*tp_basicsize*/ 0, /*tp_itemsize*/ /* methods */ (destructor)DBSequence_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ 0, /*tp_compare*/ 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /* tp_call */ 0, /* tp_str */ 0, /* tp_getattro */ 0, /* tp_setattro */ 0, /* tp_as_buffer */ #if (PY_VERSION_HEX < 0x03000000) Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_WEAKREFS, /* tp_flags */ #else Py_TPFLAGS_DEFAULT, /* tp_flags */ #endif 0, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ offsetof(DBSequenceObject, in_weakreflist), /* tp_weaklistoffset */ 0, /*tp_iter*/ 0, /*tp_iternext*/ DBSequence_methods, /*tp_methods*/ 0, /*tp_members*/ }; /* --------------------------------------------------------------------- */ /* Module-level functions */ static PyObject* DB_construct(PyObject* self, PyObject* args, PyObject* kwargs) { PyObject* dbenvobj = NULL; int flags = 0; static char* kwnames[] = { "dbEnv", "flags", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|Oi:DB", kwnames, &dbenvobj, &flags)) return NULL; if (dbenvobj == Py_None) dbenvobj = NULL; else if (dbenvobj && !DBEnvObject_Check(dbenvobj)) { makeTypeError("DBEnv", dbenvobj); return NULL; } return (PyObject* )newDBObject((DBEnvObject*)dbenvobj, flags); } static PyObject* DBEnv_construct(PyObject* self, PyObject* args) { int flags = 0; if (!PyArg_ParseTuple(args, "|i:DbEnv", &flags)) return NULL; return (PyObject* )newDBEnvObject(flags); } static PyObject* DBSequence_construct(PyObject* self, PyObject* args, PyObject* kwargs) { PyObject* dbobj; int flags = 0; static char* kwnames[] = { "db", "flags", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|i:DBSequence", kwnames, &dbobj, &flags)) return NULL; if (!DBObject_Check(dbobj)) { makeTypeError("DB", dbobj); return NULL; } return (PyObject* )newDBSequenceObject((DBObject*)dbobj, flags); } static char bsddb_version_doc[] = "Returns a tuple of major, minor, and patch release numbers of the\n\ underlying DB library."; static PyObject* bsddb_version(PyObject* self) { int major, minor, patch; /* This should be instantaneous, no need to release the GIL */ db_version(&major, &minor, &patch); return Py_BuildValue("(iii)", major, minor, patch); } #if (DBVER >= 51) static PyObject* bsddb_version_full(PyObject* self) { char *version_string; int family, release, major, minor, patch; /* This should be instantaneous, no need to release the GIL */ version_string = db_full_version(&family, &release, &major, &minor, &patch); return Py_BuildValue("(siiiii)", version_string, family, release, major, minor, patch); } #endif /* List of functions defined in the module */ static PyMethodDef bsddb_methods[] = { {"DB", (PyCFunction)DB_construct, METH_VARARGS | METH_KEYWORDS }, {"DBEnv", (PyCFunction)DBEnv_construct, METH_VARARGS}, {"DBSequence", (PyCFunction)DBSequence_construct, METH_VARARGS | METH_KEYWORDS }, {"version", (PyCFunction)bsddb_version, METH_NOARGS, bsddb_version_doc}, #if (DBVER >= 51) {"full_version", (PyCFunction)bsddb_version_full, METH_NOARGS}, #endif {NULL, NULL} /* sentinel */ }; /* API structure */ static BSDDB_api bsddb_api; /* --------------------------------------------------------------------- */ /* Module initialization */ /* Convenience routine to export an integer value. * Errors are silently ignored, for better or for worse... */ #define ADD_INT(dict, NAME) _addIntToDict(dict, #NAME, NAME) /* ** We can rename the module at import time, so the string allocated ** must be big enough, and any use of the name must use this particular ** string. */ #define MODULE_NAME_MAX_LEN 11 static char _bsddbModuleName[MODULE_NAME_MAX_LEN+1] = "_bsddb"; #if (PY_VERSION_HEX >= 0x03000000) static struct PyModuleDef bsddbmodule = { PyModuleDef_HEAD_INIT, _bsddbModuleName, /* Name of module */ NULL, /* module documentation, may be NULL */ -1, /* size of per-interpreter state of the module, or -1 if the module keeps state in global variables. */ bsddb_methods, NULL, /* Reload */ NULL, /* Traverse */ NULL, /* Clear */ NULL /* Free */ }; #endif #if (PY_VERSION_HEX < 0x03000000) DL_EXPORT(void) init_bsddb(void) #else PyMODINIT_FUNC PyInit__bsddb(void) /* Note the two underscores */ #endif { PyObject* m; PyObject* d; PyObject* py_api; PyObject* pybsddb_version_s; PyObject* db_version_s; #if (PY_VERSION_HEX < 0x03000000) pybsddb_version_s = PyString_FromString(PY_BSDDB_VERSION); db_version_s = PyString_FromString(DB_VERSION_STRING); #else /* This data should be ascii, so UTF-8 conversion is fine */ pybsddb_version_s = PyUnicode_FromString(PY_BSDDB_VERSION); db_version_s = PyUnicode_FromString(DB_VERSION_STRING); #endif /* Initialize object types */ if ((PyType_Ready(&DB_Type) < 0) || (PyType_Ready(&DBCursor_Type) < 0) || (PyType_Ready(&DBLogCursor_Type) < 0) || (PyType_Ready(&DBEnv_Type) < 0) || (PyType_Ready(&DBTxn_Type) < 0) || (PyType_Ready(&DBLock_Type) < 0) || (PyType_Ready(&DBSequence_Type) < 0) #if (DBVER >= 53) || (PyType_Ready(&DBSite_Type) < 0) #endif ) { #if (PY_VERSION_HEX < 0x03000000) return; #else return NULL; #endif } /* Create the module and add the functions */ #if (PY_VERSION_HEX < 0x03000000) m = Py_InitModule(_bsddbModuleName, bsddb_methods); #else m=PyModule_Create(&bsddbmodule); #endif if (m == NULL) { #if (PY_VERSION_HEX < 0x03000000) return; #else return NULL; #endif } /* Add some symbolic constants to the module */ d = PyModule_GetDict(m); PyDict_SetItemString(d, "__version__", pybsddb_version_s); PyDict_SetItemString(d, "DB_VERSION_STRING", db_version_s); Py_DECREF(pybsddb_version_s); pybsddb_version_s = NULL; Py_DECREF(db_version_s); db_version_s = NULL; ADD_INT(d, DB_VERSION_MAJOR); ADD_INT(d, DB_VERSION_MINOR); ADD_INT(d, DB_VERSION_PATCH); ADD_INT(d, DB_MAX_PAGES); ADD_INT(d, DB_MAX_RECORDS); #if (DBVER < 48) ADD_INT(d, DB_RPCCLIENT); #endif #if (DBVER < 48) ADD_INT(d, DB_XA_CREATE); #endif ADD_INT(d, DB_CREATE); ADD_INT(d, DB_NOMMAP); ADD_INT(d, DB_THREAD); ADD_INT(d, DB_MULTIVERSION); ADD_INT(d, DB_FORCE); ADD_INT(d, DB_INIT_CDB); ADD_INT(d, DB_INIT_LOCK); ADD_INT(d, DB_INIT_LOG); ADD_INT(d, DB_INIT_MPOOL); ADD_INT(d, DB_INIT_TXN); ADD_INT(d, DB_JOINENV); #if (DBVER >= 48) ADD_INT(d, DB_GID_SIZE); #else ADD_INT(d, DB_XIDDATASIZE); /* Allow new code to work in old BDB releases */ _addIntToDict(d, "DB_GID_SIZE", DB_XIDDATASIZE); #endif ADD_INT(d, DB_RECOVER); ADD_INT(d, DB_RECOVER_FATAL); ADD_INT(d, DB_TXN_NOSYNC); ADD_INT(d, DB_USE_ENVIRON); ADD_INT(d, DB_USE_ENVIRON_ROOT); ADD_INT(d, DB_LOCKDOWN); ADD_INT(d, DB_PRIVATE); ADD_INT(d, DB_SYSTEM_MEM); ADD_INT(d, DB_TXN_SYNC); ADD_INT(d, DB_TXN_NOWAIT); #if (DBVER >= 51) ADD_INT(d, DB_TXN_BULK); #endif #if (DBVER >= 48) ADD_INT(d, DB_CURSOR_BULK); #endif ADD_INT(d, DB_TXN_WAIT); ADD_INT(d, DB_EXCL); ADD_INT(d, DB_FCNTL_LOCKING); ADD_INT(d, DB_ODDFILESIZE); ADD_INT(d, DB_RDWRMASTER); ADD_INT(d, DB_RDONLY); ADD_INT(d, DB_TRUNCATE); ADD_INT(d, DB_EXTENT); ADD_INT(d, DB_CDB_ALLDB); ADD_INT(d, DB_VERIFY); ADD_INT(d, DB_UPGRADE); ADD_INT(d, DB_PRINTABLE); ADD_INT(d, DB_AGGRESSIVE); ADD_INT(d, DB_NOORDERCHK); ADD_INT(d, DB_ORDERCHKONLY); ADD_INT(d, DB_PR_PAGE); ADD_INT(d, DB_PR_RECOVERYTEST); ADD_INT(d, DB_SALVAGE); ADD_INT(d, DB_LOCK_NORUN); ADD_INT(d, DB_LOCK_DEFAULT); ADD_INT(d, DB_LOCK_OLDEST); ADD_INT(d, DB_LOCK_RANDOM); ADD_INT(d, DB_LOCK_YOUNGEST); ADD_INT(d, DB_LOCK_MAXLOCKS); ADD_INT(d, DB_LOCK_MINLOCKS); ADD_INT(d, DB_LOCK_MINWRITE); ADD_INT(d, DB_LOCK_EXPIRE); ADD_INT(d, DB_LOCK_MAXWRITE); _addIntToDict(d, "DB_LOCK_CONFLICT", 0); ADD_INT(d, DB_LOCK_DUMP); ADD_INT(d, DB_LOCK_GET); ADD_INT(d, DB_LOCK_INHERIT); ADD_INT(d, DB_LOCK_PUT); ADD_INT(d, DB_LOCK_PUT_ALL); ADD_INT(d, DB_LOCK_PUT_OBJ); ADD_INT(d, DB_LOCK_NG); ADD_INT(d, DB_LOCK_READ); ADD_INT(d, DB_LOCK_WRITE); ADD_INT(d, DB_LOCK_NOWAIT); ADD_INT(d, DB_LOCK_WAIT); ADD_INT(d, DB_LOCK_IWRITE); ADD_INT(d, DB_LOCK_IREAD); ADD_INT(d, DB_LOCK_IWR); ADD_INT(d, DB_LOCK_READ_UNCOMMITTED); ADD_INT(d, DB_LOCK_WWRITE); ADD_INT(d, DB_LOCK_RECORD); ADD_INT(d, DB_LOCK_UPGRADE); ADD_INT(d, DB_LOCK_SWITCH); ADD_INT(d, DB_LOCK_UPGRADE_WRITE); ADD_INT(d, DB_LOCK_NOWAIT); ADD_INT(d, DB_LOCK_RECORD); ADD_INT(d, DB_LOCK_UPGRADE); ADD_INT(d, DB_LSTAT_ABORTED); ADD_INT(d, DB_LSTAT_FREE); ADD_INT(d, DB_LSTAT_HELD); ADD_INT(d, DB_LSTAT_PENDING); ADD_INT(d, DB_LSTAT_WAITING); ADD_INT(d, DB_ARCH_ABS); ADD_INT(d, DB_ARCH_DATA); ADD_INT(d, DB_ARCH_LOG); ADD_INT(d, DB_ARCH_REMOVE); ADD_INT(d, DB_BTREE); ADD_INT(d, DB_HASH); ADD_INT(d, DB_RECNO); ADD_INT(d, DB_QUEUE); ADD_INT(d, DB_UNKNOWN); ADD_INT(d, DB_DUP); ADD_INT(d, DB_DUPSORT); ADD_INT(d, DB_RECNUM); ADD_INT(d, DB_RENUMBER); ADD_INT(d, DB_REVSPLITOFF); ADD_INT(d, DB_SNAPSHOT); ADD_INT(d, DB_INORDER); ADD_INT(d, DB_JOIN_NOSORT); ADD_INT(d, DB_AFTER); ADD_INT(d, DB_APPEND); ADD_INT(d, DB_BEFORE); ADD_INT(d, DB_CONSUME); ADD_INT(d, DB_CONSUME_WAIT); ADD_INT(d, DB_CURRENT); ADD_INT(d, DB_FAST_STAT); ADD_INT(d, DB_FIRST); ADD_INT(d, DB_FLUSH); ADD_INT(d, DB_GET_BOTH); ADD_INT(d, DB_GET_BOTH_RANGE); ADD_INT(d, DB_GET_RECNO); ADD_INT(d, DB_JOIN_ITEM); ADD_INT(d, DB_KEYFIRST); ADD_INT(d, DB_KEYLAST); ADD_INT(d, DB_LAST); ADD_INT(d, DB_NEXT); ADD_INT(d, DB_NEXT_DUP); ADD_INT(d, DB_NEXT_NODUP); ADD_INT(d, DB_NODUPDATA); ADD_INT(d, DB_NOOVERWRITE); ADD_INT(d, DB_NOSYNC); ADD_INT(d, DB_POSITION); ADD_INT(d, DB_PREV); ADD_INT(d, DB_PREV_NODUP); ADD_INT(d, DB_PREV_DUP); ADD_INT(d, DB_SET); ADD_INT(d, DB_SET_RANGE); ADD_INT(d, DB_SET_RECNO); ADD_INT(d, DB_WRITECURSOR); ADD_INT(d, DB_OPFLAGS_MASK); ADD_INT(d, DB_RMW); ADD_INT(d, DB_DIRTY_READ); ADD_INT(d, DB_MULTIPLE); ADD_INT(d, DB_MULTIPLE_KEY); ADD_INT(d, DB_IMMUTABLE_KEY); ADD_INT(d, DB_READ_UNCOMMITTED); ADD_INT(d, DB_READ_COMMITTED); ADD_INT(d, DB_FREELIST_ONLY); ADD_INT(d, DB_FREE_SPACE); ADD_INT(d, DB_DONOTINDEX); ADD_INT(d, DB_KEYEMPTY); ADD_INT(d, DB_KEYEXIST); ADD_INT(d, DB_LOCK_DEADLOCK); ADD_INT(d, DB_LOCK_NOTGRANTED); ADD_INT(d, DB_NOSERVER); #if (DBVER < 53) ADD_INT(d, DB_NOSERVER_HOME); ADD_INT(d, DB_NOSERVER_ID); #endif ADD_INT(d, DB_NOTFOUND); ADD_INT(d, DB_OLD_VERSION); ADD_INT(d, DB_RUNRECOVERY); ADD_INT(d, DB_VERIFY_BAD); ADD_INT(d, DB_PAGE_NOTFOUND); ADD_INT(d, DB_SECONDARY_BAD); ADD_INT(d, DB_STAT_CLEAR); ADD_INT(d, DB_REGION_INIT); ADD_INT(d, DB_NOLOCKING); ADD_INT(d, DB_YIELDCPU); ADD_INT(d, DB_PANIC_ENVIRONMENT); ADD_INT(d, DB_NOPANIC); ADD_INT(d, DB_OVERWRITE); ADD_INT(d, DB_STAT_SUBSYSTEM); ADD_INT(d, DB_STAT_MEMP_HASH); ADD_INT(d, DB_STAT_LOCK_CONF); ADD_INT(d, DB_STAT_LOCK_LOCKERS); ADD_INT(d, DB_STAT_LOCK_OBJECTS); ADD_INT(d, DB_STAT_LOCK_PARAMS); #if (DBVER >= 48) ADD_INT(d, DB_OVERWRITE_DUP); #endif ADD_INT(d, DB_FOREIGN_ABORT); ADD_INT(d, DB_FOREIGN_CASCADE); ADD_INT(d, DB_FOREIGN_NULLIFY); ADD_INT(d, DB_REGISTER); ADD_INT(d, DB_EID_INVALID); ADD_INT(d, DB_EID_BROADCAST); ADD_INT(d, DB_TIME_NOTGRANTED); ADD_INT(d, DB_TXN_NOT_DURABLE); ADD_INT(d, DB_TXN_WRITE_NOSYNC); ADD_INT(d, DB_DIRECT_DB); ADD_INT(d, DB_INIT_REP); ADD_INT(d, DB_ENCRYPT); ADD_INT(d, DB_CHKSUM); ADD_INT(d, DB_LOG_DIRECT); ADD_INT(d, DB_LOG_DSYNC); ADD_INT(d, DB_LOG_IN_MEMORY); ADD_INT(d, DB_LOG_AUTO_REMOVE); ADD_INT(d, DB_LOG_ZERO); #if (DBVER >= 61) ADD_INT(d, DB_LOG_BLOB); #endif ADD_INT(d, DB_DSYNC_DB); ADD_INT(d, DB_TXN_SNAPSHOT); ADD_INT(d, DB_VERB_DEADLOCK); ADD_INT(d, DB_VERB_FILEOPS); ADD_INT(d, DB_VERB_FILEOPS_ALL); ADD_INT(d, DB_VERB_RECOVERY); ADD_INT(d, DB_VERB_REGISTER); ADD_INT(d, DB_VERB_REPLICATION); ADD_INT(d, DB_VERB_WAITSFOR); #if (DBVER >= 51) ADD_INT(d, DB_VERB_REP_SYSTEM); #endif ADD_INT(d, DB_VERB_REP_ELECT); ADD_INT(d, DB_VERB_REP_LEASE); ADD_INT(d, DB_VERB_REP_MISC); ADD_INT(d, DB_VERB_REP_MSGS); ADD_INT(d, DB_VERB_REP_SYNC); ADD_INT(d, DB_VERB_REPMGR_CONNFAIL); ADD_INT(d, DB_VERB_REPMGR_MISC); ADD_INT(d, DB_EVENT_PANIC); ADD_INT(d, DB_EVENT_REP_CLIENT); ADD_INT(d, DB_EVENT_REP_ELECTED); ADD_INT(d, DB_EVENT_REP_MASTER); ADD_INT(d, DB_EVENT_REP_NEWMASTER); ADD_INT(d, DB_EVENT_REP_PERM_FAILED); ADD_INT(d, DB_EVENT_REP_STARTUPDONE); ADD_INT(d, DB_EVENT_WRITE_FAILED); #if (DBVER >= 51) ADD_INT(d, DB_REPMGR_CONF_ELECTIONS); ADD_INT(d, DB_EVENT_REP_MASTER_FAILURE); ADD_INT(d, DB_EVENT_REP_DUPMASTER); ADD_INT(d, DB_EVENT_REP_ELECTION_FAILED); #endif #if (DBVER >= 48) ADD_INT(d, DB_EVENT_REG_ALIVE); ADD_INT(d, DB_EVENT_REG_PANIC); #endif #if (DBVER >= 61) ADD_INT(d, DB_EVENT_REP_AUTOTAKEOVER_FAILED); ADD_INT(d, DB_FORCESYNCENV); ADD_INT(d, DB_LOG_NOSYNC); #endif #if (DBVER >= 53) ADD_INT(d, DB_EVENT_REP_SITE_ADDED); ADD_INT(d, DB_EVENT_REP_SITE_REMOVED); ADD_INT(d, DB_EVENT_REP_LOCAL_SITE_REMOVED); ADD_INT(d, DB_EVENT_REP_CONNECT_BROKEN); ADD_INT(d, DB_EVENT_REP_CONNECT_ESTD); ADD_INT(d, DB_EVENT_REP_CONNECT_TRY_FAILED); ADD_INT(d, DB_EVENT_REP_INIT_DONE); ADD_INT(d, DB_MEM_LOCK); ADD_INT(d, DB_MEM_LOCKOBJECT); ADD_INT(d, DB_MEM_LOCKER); ADD_INT(d, DB_MEM_LOGID); ADD_INT(d, DB_MEM_TRANSACTION); ADD_INT(d, DB_MEM_THREAD); ADD_INT(d, DB_BOOTSTRAP_HELPER); ADD_INT(d, DB_GROUP_CREATOR); ADD_INT(d, DB_LEGACY); ADD_INT(d, DB_LOCAL_SITE); ADD_INT(d, DB_REPMGR_PEER); #endif ADD_INT(d, DB_REP_DUPMASTER); ADD_INT(d, DB_REP_HOLDELECTION); ADD_INT(d, DB_REP_IGNORE); ADD_INT(d, DB_REP_JOIN_FAILURE); ADD_INT(d, DB_REP_ISPERM); ADD_INT(d, DB_REP_NOTPERM); ADD_INT(d, DB_REP_NEWSITE); ADD_INT(d, DB_REP_MASTER); ADD_INT(d, DB_REP_CLIENT); ADD_INT(d, DB_REP_PERMANENT); #if (DBVER >= 51) ADD_INT(d, DB_REP_CONF_AUTOINIT); #else ADD_INT(d, DB_REP_CONF_NOAUTOINIT); #endif ADD_INT(d, DB_REP_CONF_DELAYCLIENT); ADD_INT(d, DB_REP_CONF_BULK); ADD_INT(d, DB_REP_CONF_NOWAIT); ADD_INT(d, DB_REP_ANYWHERE); ADD_INT(d, DB_REP_REREQUEST); ADD_INT(d, DB_REP_NOBUFFER); ADD_INT(d, DB_REP_LEASE_EXPIRED); ADD_INT(d, DB_IGNORE_LEASE); ADD_INT(d, DB_REP_CONF_LEASE); ADD_INT(d, DB_REPMGR_CONF_2SITE_STRICT); ADD_INT(d, DB_REP_ELECTION); ADD_INT(d, DB_REP_ACK_TIMEOUT); ADD_INT(d, DB_REP_CONNECTION_RETRY); ADD_INT(d, DB_REP_ELECTION_TIMEOUT); ADD_INT(d, DB_REP_ELECTION_RETRY); ADD_INT(d, DB_REP_CHECKPOINT_DELAY); ADD_INT(d, DB_REP_FULL_ELECTION_TIMEOUT); ADD_INT(d, DB_REP_LEASE_TIMEOUT); ADD_INT(d, DB_REP_HEARTBEAT_MONITOR); ADD_INT(d, DB_REP_HEARTBEAT_SEND); ADD_INT(d, DB_REPMGR_PEER); ADD_INT(d, DB_REPMGR_ACKS_ALL); ADD_INT(d, DB_REPMGR_ACKS_ALL_PEERS); ADD_INT(d, DB_REPMGR_ACKS_NONE); ADD_INT(d, DB_REPMGR_ACKS_ONE); ADD_INT(d, DB_REPMGR_ACKS_ONE_PEER); ADD_INT(d, DB_REPMGR_ACKS_QUORUM); ADD_INT(d, DB_REPMGR_CONNECTED); ADD_INT(d, DB_REPMGR_DISCONNECTED); ADD_INT(d, DB_STAT_ALL); #if (DBVER >= 51) ADD_INT(d, DB_REPMGR_ACKS_ALL_AVAILABLE); #endif #if (DBVER >= 48) ADD_INT(d, DB_REP_CONF_INMEM); #endif #if (DBVER >= 61) ADD_INT(d, DB_REPMGR_ISVIEW); ADD_INT(d, DB_DBT_BLOB); ADD_INT(d, DB_STREAM_READ); ADD_INT(d, DB_STREAM_WRITE); ADD_INT(d, DB_STREAM_SYNC_WRITE); #endif ADD_INT(d, DB_TIMEOUT); #if (DBVER >= 51) ADD_INT(d, DB_FORCESYNC); #endif #if (DBVER >= 48) ADD_INT(d, DB_FAILCHK); #endif #if (DBVER >= 51) ADD_INT(d, DB_HOTBACKUP_IN_PROGRESS); #endif ADD_INT(d, DB_BUFFER_SMALL); ADD_INT(d, DB_SEQ_DEC); ADD_INT(d, DB_SEQ_INC); ADD_INT(d, DB_SEQ_WRAP); ADD_INT(d, DB_ENCRYPT_AES); ADD_INT(d, DB_AUTO_COMMIT); ADD_INT(d, DB_PRIORITY_VERY_LOW); ADD_INT(d, DB_PRIORITY_LOW); ADD_INT(d, DB_PRIORITY_DEFAULT); ADD_INT(d, DB_PRIORITY_HIGH); ADD_INT(d, DB_PRIORITY_VERY_HIGH); ADD_INT(d, DB_PRIORITY_UNCHANGED); ADD_INT(d, EINVAL); ADD_INT(d, EACCES); ADD_INT(d, ENOSPC); ADD_INT(d, ENOMEM); ADD_INT(d, EAGAIN); ADD_INT(d, EBUSY); ADD_INT(d, EEXIST); ADD_INT(d, ENOENT); ADD_INT(d, EPERM); ADD_INT(d, DB_SET_LOCK_TIMEOUT); ADD_INT(d, DB_SET_TXN_TIMEOUT); #if (DBVER >= 48) ADD_INT(d, DB_SET_REG_TIMEOUT); #endif /* The exception name must be correct for pickled exception * * objects to unpickle properly. */ #define PYBSDDB_EXCEPTION_BASE "bsddb3.db." /* All the rest of the exceptions derive only from DBError */ #define MAKE_EX(name) name = PyErr_NewException(PYBSDDB_EXCEPTION_BASE #name, DBError, NULL); \ PyDict_SetItemString(d, #name, name) /* The base exception class is DBError */ DBError = NULL; /* used in MAKE_EX so that it derives from nothing */ MAKE_EX(DBError); { PyObject* bases; bases = PyTuple_Pack(2, DBError, PyExc_KeyError); #define MAKE_EX2(name) name = PyErr_NewException(PYBSDDB_EXCEPTION_BASE #name, bases, NULL); \ PyDict_SetItemString(d, #name, name) MAKE_EX2(DBNotFoundError); MAKE_EX2(DBKeyEmptyError); #undef MAKE_EX2 Py_XDECREF(bases); } MAKE_EX(DBCursorClosedError); MAKE_EX(DBKeyExistError); MAKE_EX(DBLockDeadlockError); MAKE_EX(DBLockNotGrantedError); MAKE_EX(DBOldVersionError); MAKE_EX(DBRunRecoveryError); MAKE_EX(DBVerifyBadError); MAKE_EX(DBNoServerError); #if (DBVER < 53) MAKE_EX(DBNoServerHomeError); MAKE_EX(DBNoServerIDError); #endif MAKE_EX(DBPageNotFoundError); MAKE_EX(DBSecondaryBadError); MAKE_EX(DBInvalidArgError); MAKE_EX(DBAccessError); MAKE_EX(DBNoSpaceError); MAKE_EX(DBNoMemoryError); MAKE_EX(DBAgainError); MAKE_EX(DBBusyError); MAKE_EX(DBFileExistsError); MAKE_EX(DBNoSuchFileError); MAKE_EX(DBPermissionsError); MAKE_EX(DBRepHandleDeadError); MAKE_EX(DBRepLockoutError); MAKE_EX(DBRepUnavailError); MAKE_EX(DBRepLeaseExpiredError); MAKE_EX(DBForeignConflictError); #undef MAKE_EX /* Initialise the C API structure and add it to the module */ bsddb_api.api_version = PYBSDDB_API_VERSION; bsddb_api.db_type = &DB_Type; bsddb_api.dbcursor_type = &DBCursor_Type; bsddb_api.dblogcursor_type = &DBLogCursor_Type; bsddb_api.dbenv_type = &DBEnv_Type; bsddb_api.dbtxn_type = &DBTxn_Type; bsddb_api.dblock_type = &DBLock_Type; bsddb_api.dbsequence_type = &DBSequence_Type; bsddb_api.makeDBError = makeDBError; #if (PY_VERSION_HEX < 0x02070000) py_api = PyCObject_FromVoidPtr((void*)&bsddb_api, NULL); #else { /* ** The data must outlive the call!!. So, the static definition. ** The buffer must be big enough... */ static char py_api_name[MODULE_NAME_MAX_LEN+10]; strcpy(py_api_name, _bsddbModuleName); strcat(py_api_name, ".api"); py_api = PyCapsule_New((void*)&bsddb_api, py_api_name, NULL); } #endif /* Check error control */ /* ** PyErr_NoMemory(); ** py_api = NULL; */ if (py_api) { PyDict_SetItemString(d, "api", py_api); Py_DECREF(py_api); } else { /* Something bad happened! */ PyErr_WriteUnraisable(m); if(PyErr_Warn(PyExc_RuntimeWarning, "_pybsddb C API will be not available")) { PyErr_WriteUnraisable(m); } PyErr_Clear(); } /* Check for errors */ if (PyErr_Occurred()) { PyErr_Print(); Py_FatalError("can't initialize module _pybsddb"); Py_DECREF(m); m = NULL; } #if (PY_VERSION_HEX < 0x03000000) return; #else return m; #endif } /* allow this module to be named _pybsddb so that it can be installed * and imported on top of python >= 2.3 that includes its own older * copy of the library named _bsddb without importing the old version. */ #if (PY_VERSION_HEX < 0x03000000) DL_EXPORT(void) init_pybsddb(void) #else PyMODINIT_FUNC PyInit__pybsddb(void) /* Note the two underscores */ #endif { strncpy(_bsddbModuleName, "_pybsddb", MODULE_NAME_MAX_LEN); #if (PY_VERSION_HEX < 0x03000000) init_bsddb(); #else return PyInit__bsddb(); /* Note the two underscores */ #endif } bsddb3-6.2.7/licenses.txt0000644000175000017500000000306213316226203015062 0ustar jceajcea00000000000000The history of this project is long and complicated, and so are their copyrights and licenses. I (Jesus Cea) write this document in orden to clarify the situation. This code was integrated once in Python 2.x, so I guess somebody did the paperwork related to contributor agreement. This code is derived from that version, so that could be a license checkpoint/blank sheet. I must verify that. New files will be covered by the 3-clause BSD license. License of Python files: * Except the following files, license is 3-clause BSD license. Jesus Cea Avion. * test2.py, test3.py: Zope Public License, version 2.0. Zope Corporation and contributors. * Lib*/bsddb/dbrecio.py: Itamar Shtull-Trauring . * Lib*/bsddb/__init__.py: 3-clause BSD license. Digital Creations and Andrew Kuchling. * Lib*/bsddb/db.py: 3-clause BSD license. Digital Creations and Andrew Kuchling. * Lib*/bsddb/dbobj.py, dbutils.py: Free software. Autonomous Zone Industries, Gregory P. Smith. * Lib*/bsddb/dbtables.py: Free software. Autonomous Zone Industries, Gregory P. Smith. * Lib*/bsddb/test/test_dbtables.py: Free software. Autonomous Zone Industries, Gregory P. Smith. * Lib*/bsddb/dbshelve.py: Free software. Total Control Software. License of C files: * Modules/bsddb.h, _bsddb.c: 3-clause BSD license. Digital Creations, Andrew Kuchling, Robin Dunn, Gregory P. Smith, Duncan Grisby, Jesus Cea Avion. NOTE: If this file is changed, "docs/license.rst" must be updated too. bsddb3-6.2.7/test.py0000775000175000017500000000324113617051124014053 0ustar jceajcea00000000000000#!/usr/bin/env python """ Copyright (c) 2008-2020, Jesus Cea Avion All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Jesus Cea Avion nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ import sys if sys.version_info[0] == 2 : import test2 as test else : # >= Python 3.0 import test3 as test if __name__ == "__main__": test.process_args() bsddb3-6.2.7/bsddb3.egg-info/0000775000175000017500000000000013617133045015355 5ustar jceajcea00000000000000bsddb3-6.2.7/bsddb3.egg-info/PKG-INFO0000644000175000017500000000544013617133041016447 0ustar jceajcea00000000000000Metadata-Version: 2.1 Name: bsddb3 Version: 6.2.7 Summary: Python bindings for Oracle Berkeley DB Home-page: https://www.jcea.es/programacion/pybsddb.htm Author: Jesus Cea, Robin Dunn, Gregory P. Smith, Andrew Kuchling, Barry Warsaw Author-email: pybsddb@jcea.es License: 3-clause BSD License Description: This module provides a nearly complete wrapping of the Oracle/Sleepycat C API for the Database Environment, Database, Cursor, Log Cursor, Sequence and Transaction objects, and each of these is exposed as a Python type in the bsddb3.db module. The database objects can use various access methods: btree, hash, recno, and queue. Complete support of Berkeley DB distributed transactions. Complete support for Berkeley DB Replication Manager. Complete support for Berkeley DB Base Replication. Support for RPC. Please see the documents in the docs directory of the source distribution or at the website for more details on the types and methods provided. The goal is to mirror most of the real Berkeley DB API so fall back to the Oracle Berkeley DB documentation as appropriate. If you need to support ancient versiones of Python and/or Berkeley DB , you can use old releases of this bindings. `Homepage `__ -- `Releases (changelog) `__ -- `Documentation `__ -- `Mailing List `__ -- `Donation `__ Platform: UNKNOWN Classifier: License :: OSI Approved :: BSD License Classifier: Development Status :: 5 - Production/Stable Classifier: Intended Audience :: Developers Classifier: Intended Audience :: Information Technology Classifier: Natural Language :: English Classifier: Natural Language :: Spanish Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python Classifier: Topic :: Database Classifier: Topic :: Software Development Classifier: Topic :: System :: Clustering Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 2.6 Classifier: Programming Language :: Python :: 2.7 Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.3 Classifier: Programming Language :: Python :: 3.4 Classifier: Programming Language :: Python :: 3.5 Classifier: Programming Language :: Python :: 3.6 Classifier: Programming Language :: Python :: 3.7 Classifier: Programming Language :: Python :: 3.8 Classifier: Programming Language :: Python :: 3.9 Description-Content-Type: text/x-rst bsddb3-6.2.7/bsddb3.egg-info/dependency_links.txt0000644000175000017500000000000113617133041021415 0ustar jceajcea00000000000000 bsddb3-6.2.7/bsddb3.egg-info/SOURCES.txt0000644000175000017500000000635613617133043017247 0ustar jceajcea00000000000000ChangeLog LICENSE.txt MANIFEST.in README.txt TODO.txt licenses.txt make3.py setup.cfg setup.py setup2.py setup3.py test-full_prerelease.py test.py test2.py test3.py Lib/bsddb/__init__.py Lib/bsddb/db.py Lib/bsddb/dbobj.py Lib/bsddb/dbrecio.py Lib/bsddb/dbshelve.py Lib/bsddb/dbtables.py Lib/bsddb/dbutils.py Lib/bsddb/test/__init__.py Lib/bsddb/test/test_all.py Lib/bsddb/test/test_associate.py Lib/bsddb/test/test_basics.py Lib/bsddb/test/test_compare.py Lib/bsddb/test/test_compat.py Lib/bsddb/test/test_cursor_pget_bug.py Lib/bsddb/test/test_db.py Lib/bsddb/test/test_dbenv.py Lib/bsddb/test/test_dbobj.py Lib/bsddb/test/test_dbshelve.py Lib/bsddb/test/test_dbtables.py Lib/bsddb/test/test_distributed_transactions.py Lib/bsddb/test/test_early_close.py Lib/bsddb/test/test_fileid.py Lib/bsddb/test/test_get_none.py Lib/bsddb/test/test_join.py Lib/bsddb/test/test_lock.py Lib/bsddb/test/test_misc.py Lib/bsddb/test/test_pickle.py Lib/bsddb/test/test_queue.py Lib/bsddb/test/test_recno.py Lib/bsddb/test/test_replication.py Lib/bsddb/test/test_sequence.py Lib/bsddb/test/test_thread.py Lib3/bsddb/__init__.py Lib3/bsddb/db.py Lib3/bsddb/dbobj.py Lib3/bsddb/dbrecio.py Lib3/bsddb/dbshelve.py Lib3/bsddb/dbtables.py Lib3/bsddb/dbutils.py Lib3/bsddb/test/__init__.py Lib3/bsddb/test/test_all.py Lib3/bsddb/test/test_associate.py Lib3/bsddb/test/test_basics.py Lib3/bsddb/test/test_compare.py Lib3/bsddb/test/test_compat.py Lib3/bsddb/test/test_cursor_pget_bug.py Lib3/bsddb/test/test_db.py Lib3/bsddb/test/test_dbenv.py Lib3/bsddb/test/test_dbobj.py Lib3/bsddb/test/test_dbshelve.py Lib3/bsddb/test/test_dbtables.py Lib3/bsddb/test/test_distributed_transactions.py Lib3/bsddb/test/test_early_close.py Lib3/bsddb/test/test_fileid.py Lib3/bsddb/test/test_get_none.py Lib3/bsddb/test/test_join.py Lib3/bsddb/test/test_lock.py Lib3/bsddb/test/test_misc.py Lib3/bsddb/test/test_pickle.py Lib3/bsddb/test/test_queue.py Lib3/bsddb/test/test_recno.py Lib3/bsddb/test/test_replication.py Lib3/bsddb/test/test_sequence.py Lib3/bsddb/test/test_thread.py Modules/_bsddb.c Modules/bsddb.h bsddb3.egg-info/PKG-INFO bsddb3.egg-info/SOURCES.txt bsddb3.egg-info/dependency_links.txt bsddb3.egg-info/top_level.txt docs/README.txt docs/bitcoin.png docs/contents.rst docs/db.rst docs/dbcursor.rst docs/dbenv.rst docs/dblock.rst docs/dblogcursor.rst docs/dbsequence.rst docs/dbsite.rst docs/dbtxn.rst docs/donate.rst docs/history.rst docs/introduction.rst docs/license.rst docs/html/contents.html docs/html/db.html docs/html/dbcursor.html docs/html/dbenv.html docs/html/dblock.html docs/html/dblogcursor.html docs/html/dbsequence.html docs/html/dbsite.html docs/html/dbtxn.html docs/html/donate.html docs/html/genindex.html docs/html/history.html docs/html/introduction.html docs/html/license.html docs/html/search.html docs/html/searchindex.js docs/html/images/bitcoin.png docs/html/static/alabaster.css docs/html/static/basic.css docs/html/static/custom.css docs/html/static/doctools.js docs/html/static/documentation_options.js docs/html/static/file.png docs/html/static/jquery-3.4.1.js docs/html/static/jquery.js docs/html/static/language_data.js docs/html/static/minus.png docs/html/static/plus.png docs/html/static/pygments.css docs/html/static/searchtools.js docs/html/static/underscore-1.3.1.js docs/html/static/underscore.jsbsddb3-6.2.7/bsddb3.egg-info/top_level.txt0000644000175000017500000000002413617133041020075 0ustar jceajcea00000000000000bsddb3 bsddb3/tests bsddb3-6.2.7/README.txt0000644000175000017500000001414513617050225014221 0ustar jceajcea00000000000000THIS DOCUMENT NEEDS TO BE UPDATED. THE INFO IT CONTAINS IS STILL VALUABLE, SO USE YOUR BRAIN :-) README.txt bsddb3 v6.1.x https://www.jcea.es/programacion/pybsddb.htm 2009-06-30 -------------------------------- This module is intended to be the definitive modern Berkeley DB interface for Python. It should be both backwards compatible with the earlier (circa Python 1.5 to 2.2) "bsddb" module in addition to providing access to the much more powerful interface found in Berkeley DB 4.x. This module provides a nearly complete wrapping of the Oracle C API for the Database Environment, Database, Cursor, Transaction and Lock objects. Each of these is exposed as a Python Type in the bsddb3.db module. The database objects can use different access methods: btree, hash, recno, and queue. For the first time all of these are fully supported in the Python wrappers. Please see the documents in the docs directory for more details on the types and methods provided. There is also a collection of test cases in the test directory that can be used to validate the modules, as well as giving an idea of how to use bsddb3.db. Thanks to The Written Word (http://thewrittenword.com/), bsddb3 was known to pass its unit tests on these platforms: HP-UX 10.20, 11.00 Tru64 UNIX 4.0D, 5.0, 5.1 IRIX 6.2, 6.5 Solaris 2.5.1, 2.6, 7, 8, 9, 10 AIX 4.3.2 In addition we've run it on a several varieties of Linux and of course on Win32. This wrapper should be compatible with Berkeley DB releases going back to 4.7 up to and including DB 6.1. It should also be compatible with Python versions 2.6, 2.7, and Python 3.3 to 3.5. Installation ------------ If you are on a Win32 system then you can just get the binary installer and run it and then you'll be all set. If you want to build it yourself, you can follow the directions below, but see the comments in setup.py first. If you are on a Unix/Linux system then keep reading... The Python Distutils are used to build and install bsddb3, so it is fairly simple to get things ready to go. 0. Check the patches directory for any updates required for the version of the Berkeley DB library that you have. If a patch(s) are indicated in the README then apply it to your Berkeley DB sources and rebuild it. 1. First, make sure that you have a Berkeley DB version >= 4.7 and no later than 6.2 and that it is built and installed. Setup.py will detect a db3 or Berkeley DB directory under either /usr/local or /usr in that order; this will catch installations from RPMs and most hand installations under Unix. If setup.py can't find your libdb then you can give it a hint either in the environment (using the BERKELEYDB_DIR environment variable) or on the command line by specifying the directory containing the include and lib directory. For example: python setup.py --berkeley-db=/stuff/BerkeleyDB.4.8 build If your Berkeley DB was built as a shared library, and if that shared library is not on the runtime load path, then you can specify the additional linker flags needed to find the shared library on the command line as well. For example: --lflags="-Xlinker -rpath -Xlinker /stuff/BerkeleyDB.4.8/lib" or perhaps just --lflags="-R /stuff/BerkeleyDB.4.8/lib" Check your compiler and linker documentation to be sure. It is also possible to specify linking against a different library with the --libs switch: --libs="-ldb3" --libs="-ldb3 -lnsl" On some OSes distutils may not always use the correct compiler or linker flags. One user reported having to add the "-lpthread" option in order to link with Berkeley DB that was compiled with threads on AIX. NOTE: My recommendation is to not rely on pre-built versions of Berkeley DB since on some systems there can be several versions already installed and it's sometimes difficult to tell which you are linking with when building bsddb3. Instead get the sources from http://www.sleepycat.com/ and build/install it yourself as a static library and let setup.py find it in /usr/local. It's not such a big library that you have to worry about wasting space by not dynamically linking and doing it this way will possibly save you some gray hairs. 2. From the main bsddb3 distribution directory run this command, (plus any extra flags needed as discussed above): python setup.py build If your Python was built with the old bsddb module built-in (statically linked) then the setup script will complain and you'll have to type "yes" to build anything. Please see the note below about remedying this. 3. To run the test suite, run the following command: python test.py If you would like to see some verbose output from the tests simply add a -v option. A second -v provides even more verbose output. The test.py driver script provides lots of options for debugging, running individual tests, etc. Do "python test.py -h" for details. 4. To install the extension module and the Python modules in the bsddb3 package, run this command as the root user: python setup.py install That's it! Developer Information --------------------- Both the Python and C source code is now shared with the Python project. If you're checking the code out from Subversion, you'll need to run the getsvn.sh script to get a copy of the code. How you run this depends on whether you have write access to the Python Subversion or not (most people do not -- you would know if you do). To check the code out, do the following: % ./getsvn.sh anon This will do an anonymous checkout of the code. To do an authenticated (via ssh) checkout, do the following: % ./getsvn.sh This will check out an extsrc directory and a bsddb directory. There is one caveat: you'll find that extsrc will become populated with every C file in Python's Modules directory. You should just ignore this. -- Robin robin@alldunn.com -- [later updates by] Gregory P. Smith greg@krypto.org -- [even later updates by] Barry A. Warsaw barry@python.org Got questions? email pybsddb-users@lists.sf.net bsddb3-6.2.7/TODO.txt0000664000175000017500000001606413316226203014032 0ustar jceajcea00000000000000* 20161120: Document how to install with alternative Berkeley DB paths using PIP. * 20160422: The "changelog" should merge with the sphynx documentation. * 20160421: Merge "README.txt" with the sphynx documentation. * 20131204: Rewrite "make3.py". * 20080327: Add a parameter to DBEnv.log_flush(). * 20080402: If a prepared/recovered transaction is garbaged collected, we leak transactions. Can we call "discard" in a safe way?. * 20080403: If an exception is raised in a thread in the TestSuite, we pass the test. Bad!. * 20080403: Write a test for MVCC. * 20080403: We should recreate the test data directory in every execution, and delete it when finished. * 20080403: "txn_stat" provides a list of active transactions. Export it to Python. * 20080426: Verify that "DB_ENV->set_event_notify" follows the API. * 20080521: Write a test for "DB_ENV->set_rpc_server". This test would be called if there is a concrete environment variable defined, for example. * 20080522: Think about changing the library name to "berkeleydb". See http://mailman.jcea.es/pipermail/pybsddb/2008-March/000019.html * 20080522: Update the "README.txt" document. * 20080531: "DB_ENV->rep_set_limit" and "DB_ENV->rep_get_limit", support for long values. * 20080629: The testsuite implements a "test_support" module, used when the underlying python version doesn't have it. Because a bug in the test code, this version is used always, even if this python version has "test_support". This is actually useful, because current test code uses features in "test_support" that are not available in previous python versions. * 20080720: The test for crash documented in http://bugs.python.org/issue3307 is disabled because it prints a error message to screen. Solve this and reenable the test. This would require "set_errfile" implementation. * 20080811: "DB.has_key()" must be retained in python3.0, since it allows a transaction parameter. * 20080812: "DBEnv.db_home", under python3.0, is automatically converted to bytes. What charset is used?. * 20080812: Since Python 3.0 dropped the "cmp" function in "sort()" methods, we need to handcode some "Insertion sort" functions, in the testsuite and in the production code. This is ugly and slow. * 20080812: "test_all.do_proxy_db_py3k()" is a very ugly hack. For example, if a test fails, it can leave the testsuite in an inconsistent state, causing spurious failures. * 20080812: We use "getattr()" to avoid "obj.next()" automatic conversion via "2to3" tool. Improve this. * 20080812: Python 3.0 idioms available in 2.6 and up should be used also in this versions. * 20080813: Create a "__contains__" routine in DB, etc, to use when 2to3 tools translate "has_key" to "in". * 20080813: We use "getattr()" to avoid "obj.has_key()" automatic conversion via "2to3" tool. Improve this, specially in "dbtables.py". * 20080813: We can store "None" values in a database. How can we differenciate between stored "None" and NotFound?. We can use exceptions or the "default" parameter, but... this is ugly. * 20080813: TO INVESTIGATE (posible bug in Berkeley DB): if you duplicate a duplicated cursor, crash. * 20080813: The put_bytes/get_bytes technique in "dbtables" is nice, but the "getattr" method is not. The problem is that DB objects can't grow new attributes. Solve this. * 20080814: If pybsddb classes would be subclassed, we could implement conversion methods for keys and values in a very elegant way. This is specially relevant in Python 3.0. When done, delete "StringValues" and "StringKeys" in Python native "test_bsddb.py". * 20080814: If we could subclass the bsddb objects, we could drop "dbobj.py" (a bit outdated by now). * 20080918: If "DB_close_internal()" fails in "DB_verify()", we should close the DB handle. * 20080929: Support "master leases". Beware bug http://forums.oracle.com/forums/thread.jspa?forumID=272&threadID=708324 * 20081011: Evaluate support of "with" statement for things like transactions. * 20081013: Evaluate convenience of returning named tuples in some places. * 20081013: Evaluate convenience of supporting "sys.getsizeof()". * 20081013: Port "PyModule_AddStringMacro" and "PyModule_AddIntMacro" when compiling for old versions of Python. * 20090121: In the "associate()" callback, there are mallocs to contain the "data" portion of DBT's. Test that they are correctly freed by Berkeley DB. * 20090121: If somethings goes wrong in the "associate()" callback, we are going to leak memory and coredump. Solve it. * 20090121: If the "associate()" callback returns an empty list, crash. * 20090121: "DB->compact()" should return more data to the caller. * 20090204: "txn->stat()" returns also a list of active transactions. Evaluate if we must export that data to python. * 20090204: A lot of binding functions allow optional parameters, but not keyword ones. Normalize this. * 20090204: "rep_set_limit()" and "rep_get_limit()" only manages "bytes", not gigabytes. * 20090423: Evaluate convenience of supporting DTrace. * 20090427: Split base replication and replication manager documentation in documents separated of DBENV docs. * 20090427: "__contains__()" is not transactionally protected. This is a problem. Maybe we should raise an exception to avoid the usage of patterns like "if key in DB", not transactionally protected. Think about this. * 20090428: Support DB_MULTIPLE and DB_MULTIPLE_KEY. * 20090630: "README.txt" needs some love. * 20090723: Add encryption tests. * 20091105: Check if the "from unittest.runner import _TextTestResult" trick in Python 2.7 and 3.2 development versions are still necessary. * 20091112: Update documentation links to Oracle site. * 20091112: DBEnv->set_flags() must support True/False. * 20091206: Review ALL documentation, text and comments in code. * 20100111: If "DB_ENV->set/get_mp_mmapsize()" is 32 bits in 64 bits architecture, it is not going to be enough. * 20100112: Currently we increment refcounts of the parent objects. These can keep parent objects around, so better allow GC of them to close the entire object tree. * 20100112: LogCursors should be iterable. * 20100112: "DBEnv->log_file()" use an iterative method to calculate the space. Improve it. * 20100217: When a "Lock" is garbage collected, we leak it and we do not release it. * 20100318: Iterate keys in dbshelve load all keys in memory first. * 20100318: Implement "__iter__()" in DB, maybe thru a DBCursor. * 20100319: Cursors in dbtables should be iterable. * 20100406: Document in the manual the use of the C API. * 20100406: The "_bsddb"/"_pybsddb" import renaming should go away. * 20100429: "setuptools" should work correctly under Python 3 (PYPI). * 20100908: Use PEP 384: "Defining a Stable ABI", when approved. * 20100917: Review and update all documentation. * 20100917: Some errors are exported as integer values, beside the proper exception. For instance, DB_SECONDARY_BAD. Evaluate if it is convenient or not. * 20120116: After dropping Python 2.3 support, some integers returned should be promoted to "unsigned integers". Same with input values.