Berkeley DB is an embedded database system that supports keyed access -to data.
-Developers may choose to store data in any of several different -storage structures to satisfy the requirements of a particular -application. In database terminology, these storage structures and the -code that operates on them are called access methods.
-With bdb >= 0.5.5 nil is stored as an empty string (when marshal is not -used).
-Open the database with
-"store_nil_as_null" => true-
if you want the old behavior (nil stored as `\000')
-The library includes support for the following access methods:
-Berkeley DB environment is an encapsulation of one or more databases, -log files and shared information about the database environment such -as shared memory buffer cache pages.
-Acces Methods
-A sequence is created with BDB::Common::create_sequence or -BDB::Common::open_sequence (only with db >= 4.3)
- -The transaction subsystem makes operations atomic, consistent, -isolated, and durable in the face of system and application -failures. The subsystem requires that the data be properly logged and -locked in order to attain these properties. Berkeley DB contains all -the components necessary to transaction-protect the Berkeley DB access -methods and other forms of data may be protected if they are logged -and locked appropriately.
- -A database cursor is a sequential pointer to the database entries. It -allows traversal of the database and access to duplicate keyed -entries. Cursors are used for operating on collections of records, -for iterating over a database, and for saving handles to individual -records, so that they can be modified after they have been read.
-See also iterators in Acces Methods
- -The lock subsystem provides interprocess and intraprocess concurrency -control mechanisms. While the locking system is used extensively by -the Berkeley DB access methods and transaction system, it may also be -used as a stand-alone subsystem to provide concurrency control to any -set of designated resources.
- -The logging subsystem is the logging facility used by Berkeley DB. It -is largely Berkeley DB specific, although it is potentially useful -outside of the Berkeley DB package for applications wanting -write-ahead logging support. Applications wanting to use the log for -purposes other than logging file modifications based on a set of open -file descriptors will almost certainly need to make source code -modifications to the Berkeley DB code base.
- - - diff -Nru ruby-bdb-0.6.5/bdbxml1/bdbxml.html ruby-bdb-0.6.6/bdbxml1/bdbxml.html --- ruby-bdb-0.6.5/bdbxml1/bdbxml.html 2011-05-25 08:07:14.000000000 +0000 +++ ruby-bdb-0.6.6/bdbxml1/bdbxml.html 1970-01-01 00:00:00.000000000 +0000 @@ -1,59 +0,0 @@ - - - - -Berkeley DB XML is an embedded native XML datastore that provides for -the efficient storage and retrieval of XML encoded information.
-Retrieval is supported by an XPath query engine that derives its efficiency -from indices generated from the stored XML data.
- -The container name provides the base for the filenames of the database -files used to store the container content. The directory within which -the files are opened is taken from the environment passed through the -Container constructor. If no environment was provided, then the -directory used will be the current working directory.
- -Define the indexing strategy for a Container
-Indexing is specified by providing the name of a node and a list of indexing -strategies for that node.
- -A Document is the unit of storage within a Container.
-A Document contains a stream of bytes that may be of type XML. -The Container only indexes the content of Documents -that contain XML.
-Document supports annotation attributes.
- -The context within which a query is performed against a Container.
-The context within which a query is performed against a Container -is complex enough to warrent an encapsulating class. This context -includes a namespace mapping, variable bindings, and flags that -determine how the query result set should be determined and returned -to the caller.
-The XPath syntax permits expressions to refer to namespace prefixes, but -not to define them. The Context class provides a number of namespace -management methods so that the caller may manage the namespace prefix -to URI mapping.
-The XPath syntax also permits expressions to refer to variables, but not -to define them. The Context class provides a number of methods so -that the caller may manage the variable to value bindings.
- -Modify encapsulates the context within which a set of documents specified by -a query can be modified in place.
-The modification is performed using the methods -BDB::XML::Container#modify and BDB::XML::Document#modify
-There are two parts to the object -- the query and the operation. -The query identifies target nodes against which the operation is run. -The operation specifies what modifications to perform.
- -The results of a query are a collection of values. The values could -be either String, Float, true, false, BDB::XML::Documents or BDB::XML::Nodes
-Implement only the method each
- - - diff -Nru ruby-bdb-0.6.5/bdbxml1/docs/container.html ruby-bdb-0.6.6/bdbxml1/docs/container.html --- ruby-bdb-0.6.5/bdbxml1/docs/container.html 2011-05-25 08:07:14.000000000 +0000 +++ ruby-bdb-0.6.6/bdbxml1/docs/container.html 1970-01-01 00:00:00.000000000 +0000 @@ -1,239 +0,0 @@ - - - - -The container name provides the base for the filenames of the database -files used to store the container content. The directory within which -the files are opened is taken from the environment passed through the -Container constructor. If no environment was provided, then the -directory used will be the current working directory.
-allocate(name = nil, options = {})dump(name, filename)load(name, filename)remove(name)rename(name, newname)salvage(name, filename, flags = 0)set_name(name, str)verify(name)close(flags = 0)delete(document, flags = 0)environmentenvenvironment?env?each {|doc| ... }self[id]get(id, flags = 0)self[id] = documentindex=(index)indexRetrieve the BDB::XML::Index
-Return nil if no indexing was specified
initialize(name, flags = 0, mode = 0)modify(mod, context = nil, flags = 0)in-place modification of all documents according to the state of the -BDB::XML::Modify object, which contains an XPath expression to -target document nodes, as well as specification of the modifications -to perform
-context is an optional BDB::XML::Context used for the update -operations on the container.
-flags must be set to zero or BDB::RMW to acquire a write lock
namename=(str)open?parse(query, context = nil)push(document, flags = 0)<<(document)query(xpath, flags = 0)query(string, context, flags = 0)Query the container with an XPath expression, which can be an object -BDB::XML::XPath or a String
-return a BDB::XML::Results object
search(xpath, returntype = BDB::XML::Context::Document) {|doc| ... }Iterate over the result of a query
-returntype can have the values BDB::XML::Context::Document -or BDB::XML::Context::Values
-the query is evaluated lazily
transactionin_transaction?transaction?update(document)update_context {|cxt| ... }context {|cxt| ... }return an BDB::XML::UpdateContext which can be used to perform -[], []=, push, delete, update operation
-This can be used for a performance improvement
The context within which a query is performed against a Container.
-The context within which a query is performed against a Container -is complex enough to warrent an encapsulating class. This context -includes a namespace mapping, variable bindings, and flags that -determine how the query result set should be determined and returned -to the caller.
-The XPath syntax permits expressions to refer to namespace prefixes, but -not to define them. The Context class provides a number of namespace -management methods so that the caller may manage the namespace prefix -to URI mapping.
-The XPath syntax also permits expressions to refer to variables, but not -to define them. The Context class provides a number of methods so -that the caller may manage the variable to value bindings.
-allocateself[variable]self[variable] = valueclear_namespacescleardel_namespace(name)evaltypeevaltype=(type)get_namespace(name)namespace[name]initialize(returntype = nil, evaluation = nil)metadatawith_metadatametadata=(with)with_metadata=(with)returntypereturntype=(type)namespace[name]=(uri)set_namespace(name, uri)Define a namespace prefix, providing the URI that it maps onto
-If uri is nil delete the namespace
A Document is the unit of storage within a Container.
-A Document contains a stream of bytes.
-Document supports annotation attributes.
-allocateself[attr]self[attr] = valcontentcontent=(val)get(uri = "", attr [, class])Return the value of an attribute. uri specify the namespace -where reside the attribute.
-the optional class argument give the type (String, Numeric, ...)
idinitialize(content = "")modify(mod)namename=(val)prefixprefix=(val)query(xpath, context = nil)set(uri = "", prefix = "", attr, value)to_sto_struriuri=(val)The index specification
-allocateadd(uri = "", name, index)delete(uri = "", name, index)each {|uri, name, index| ... }initialize([[uri0, name0, index0] [, [uri1, name1, index1], ... ]])find(uri = "", name)Find the indexing startegy associated with uri, and name
-Return nil is no indexing strategy was defined
replace(uri = "", name, index)to_aModify encapsulates the context within which a set of documents specified by -a query can be modified in place.
-The modification is performed using the methods -BDB::XML::Container#modify and BDB::XML::Document#modify
-There are two parts to the object -- the query and the operation. -The query identifies target nodes against which the operation is run. -The operation specifies what modifications to perform.
-allocatecountinitialize(xpath, operation, type = BDB::XML::Modify::None, name = "", content = "", location = -1, context = nil)xpath is a String, or an BDB::XML::Context object
-operation can have the value BDB::XML::Modify::InsertAfter, -BDB::XML::Modify::InsertBefore, BDB::XML::Modify::Append, -BDB::XML::Modify::Update, BDB::XML::Modify::Remove or -BDB::XML::Modify::Rename.
-type can have the value BDB::XML::Modify::Element, -BDB::XML::Modify::Attribute, BDB::XML::Modify::Text, -BDB::XML::Modify::ProcessingInstruction, BDB::XML::Modify::Comment or -BDB::XML::Modify::None.
-name is the name for the new content.
-content the content for operations that require content.
-location indicate where a new child node will be placed for the -append operation
-context is valid only when a String is given as the first argument. -This must be a BDB::XML::Context which contains the variable -bindings, the namespace prefix to URI mapping, and the query processing -flags.
encoding=(string)The results of a query are a collection of values. The values could -be either String, Float, true, false, BDB::XML::Documents or BDB::XML::Nodes
-each {|val| ... }Berkeley DB XML is an embedded native XML datastore that provides for -the efficient storage and retrieval of XML encoded information.
-Retrieval is supported by an Query query engine that derives its efficiency -from indices generated from the stored XML data.
-The following classes are defined
- -Provides a high-level object used to manage various aspects of Berkeley -DB XML usage. You use XML::Manager to perform activities such as container -management (including creation and open), preparing XQuery queries, -executing one-off queries, creating transaction objects, -creating update and query context objects - -A XML::Manager object can be created with BDB::Envmanager - -BDB::Transaction respond to the same method than BDB::XML::Manager- -
The XML::Container class encapsulates a document container and its -related indices and statistics. XML::Container exposes methods for -managing (putting and deleting) XML::Document objects, managing indices, -and retrieving container statistics.- -
Define the indexing strategy for a Container - -Indexing is specified by providing the name of a node and a list of -indexing strategies for that node.- -
A Document is the unit of storage within a Container. A document consists -of content, a name, and a set of metadata attributes. - -The document content is a byte stream. It must be well formed XML, -but need not be valid.- -
The Context class encapsulates the context within which a query -is performed against an Container. The context includes namespace -mappings, variable bindings, and flags that indicate how the query result -set should be determined and returned to the caller. Multiple queries can -be executed within the same Context; - -Context allows you to define whether queries executed within the -context are to be evaluated lazily or eagerly, and whether the query -is to return live or dead values. - -The Query syntax permits expressions to refer to namespace prefixes, -but not to define them. The Context class provides namespace -management methods so that the caller may manage the namespace prefix to -URI mapping. By default the prefix "dbxml" is defined to be -"http://www.sleepycat.com/2002/dbxml". - -The Query syntax also permits expressions to refer to externally -defined variables. The XmlQueryContext class provides methods that -allow the caller to manage the externally-declared variable to value -bindings.- -
The XML::Modify class encapsulates the context within which a set of one -or more documents specified by an XML::Query query can be modified in -place. The modification is performed using an XML::Modify object, and a -series of methods off that object that identify how the document is to -be modified. Using these methods, the modification steps are -identified. When the object is executed, these steps are performed in -the order that they were specified. - -The modification steps are executed against one or more documents -using XML::Modify::execute. This method can operate on a single document -stored in an XML::Value, or against multiple documents stored in an -XML::Results set that was created as the result of a container or -document query.- -
The results of a query are a collection of values. The values could -be either String, Float, true, false, BDB::XML::Value- -
Class which encapsulates the value of a node in an XML document.- -
Class which enables applications to construct document content without using serialized XML.- -
Class which enables applications to read document content via a pull interface without -materializing XML as text.- - - diff -Nru ruby-bdb-0.6.5/bdbxml2/docs/container.html ruby-bdb-0.6.6/bdbxml2/docs/container.html --- ruby-bdb-0.6.5/bdbxml2/docs/container.html 2011-05-25 08:07:14.000000000 +0000 +++ ruby-bdb-0.6.6/bdbxml2/docs/container.html 1970-01-01 00:00:00.000000000 +0000 @@ -1,159 +0,0 @@ - - - - -
The XML::Container class encapsulates a document container and its -related indices and statistics. XML::Container exposes methods for -managing (putting and deleting) XML::Document objects, managing indices, -and retrieving container statistics.
-Module included : Enumerable
-delete(doc_or_name, context = nil)index?managerpagesizeeach {|doc| ... }self[id]get(id, flags = 0)self[id] = documentindex = indexindexRetrieve the BDB::XML::Index
-Return nil if no indexing was specified
add_index(uri, name, index, context = nil)add_index(uri, name, type, syntax, context = nil)add_default_index(index, context = nil)delete_index(index, context = nil)delete_default_index(index, context = nil)replace_index(index, context = nil)replace_default_index(index, context = nil)nametypeput(document, flags = 0)transactionin_transaction?transaction?update(document, context = nil)syncflagsnode(handle, flags = 0)event_writer(document, update_context, flags = 0)Begins insertion of an XML::Document into the container through use of an -XML::EventWriter object.
-Return the XML::EventWriter which must be closed at end.
The Context class encapsulates the context within which a query -is performed against an Container. The context includes namespace -mappings, variable bindings, and flags that indicate how the query result -set should be determined and returned to the caller. Multiple queries can -be executed within the same Context;
-Context allows you to define whether queries executed within the -context are to be evaluated lazily or eagerly, and whether the query -is to return live or dead values.
-The Query syntax permits expressions to refer to namespace prefixes, -but not to define them. The Context class provides namespace -management methods so that the caller may manage the namespace prefix to -URI mapping. By default the prefix "dbxml" is defined to be -"http://www.sleepycat.com/2002/dbxml".
-The Query syntax also permits expressions to refer to externally -defined variables. The XmlQueryContext class provides methods that -allow the caller to manage the externally-declared variable to value -bindings.
-self[variable]self[variable] = valueclear_namespacescollectioncollection = uriSet theURI specifying the name of the collection.
-The default collection is that which is used by fn:collection() -without any arguments in an XQuery expression.
del_namespace(name)evaltypeevaltype = typeget_namespace(name)get_results(name)returntypereturntype = typeset_namespace(name, uri)Define a namespace prefix, providing the URI that it maps onto
-If uri is nil delete the namespace
uriuri = valA Document is the unit of storage within a Container. A document consists -of content, a name, and a set of metadata attributes.
-The document content is a byte stream. It must be well formed XML, -but need not be valid.
-included module : Enumerable
-self[name]self[name] = valcontentcontent = valeach {|uri, name, value| ... }each_metadata {|uri, name, value| ... }get_metadata(uri, name)get_metadata(name)get(uri, name)get(name)managernamename = valremove_metadata(uri, name)remove_metadata(name)set_metadata(name, value)set_metadata(uri, name, value)set(name, value)set(uri, name, value)to_sto_strevent_readerClass which enables applications to read document content via a pull interface without -materializing XML as text.
-An XML::EventReader can be obtained with the method XML::Document#event_reader -or XML::Value#event_reader
-attribute_countattribute_local_name(index)attribute_namespace_uri(index)attribute_prefix(index)attribute_specified?(index)attribute_value(index)closedocument_standalone?empty_element?empty_element_info?encodingencoding?entity_escape?entity_escape_info?entity_info?entity_info=(boolean)event_typeexpand_entities?expand_entities=(boolean)local_namenamespace_urinext?nextnext_tagprefixstandalone?system_idvalueversionwhitespace?Class which enables applications to construct document content without using serialized XML.
-An XML::EventWriter can be obtained with the method XML::Document#event_writer
-attribute(local_name, prefix = nil, uri = nil, value, speficied)closedtd(text)end_documentend_element(local_name, prefix = nil, uri = nil)end_entity(name)processing_instruction(target, data)start_document(version = nil, encoding = nil, standalone = nil)start_element(local_name, prefix = nil, uri = nil, nattr, empty)start_entity(name, expanded)text(type, txt)Write an text event
-type must be one of XML::EventReader::Characters, XML::EventReader::Whitespace, -XML::EventReader::CDATA, or XML::EventReader::Comment
The XML::Index class encapsulates the indexing specification of a container. -An indexing specification can be retrieved with the XML::Container#index -method, and modified using the XML::Container#index= method.
-Note that adding an index to a container results in re-indexing all of -the documents in that container, which can take a very long time. It is -good practice to design an application to add useful indices before -populating a container.
-Included module : Enumerable
-add(uri, name, index)add(uri, name, type, syntax)call-seq:
-add(uri, name, index) -add(uri, name, type, syntax)-
Add a new index
-add_default(index)defaultdelete(uri, name, index)delete(uri, name, type, syntax)delete_default(index)delete_default(type, syntax)each {|uri, name, index| ... }find(uri = "", name)Find the indexing startegy associated with uri, and name
-Return nil is no indexing strategy was defined
managerreplace(uri, name, index)replace(uri, name, type, syntax)replace_default(index)replace_default(type, syntax)to_aThe XML::IndexLookup class encapsulates the context within which an -index lookup operation can be performed on an XML::Container object. The -lookup is performed using an XML::IndexLookup object, and a series of -methods of that object that specify how the lookup is to be -performed. Using these methods, it is possible to specify inequality -lookups, range lookups, and simple value lookups, as well as the sort -order of the results. By default, results are returned in the sort -order of the index.
-XML::IndexLookup objects are created using XML::Manager::create_index_lookup, -or Txn::create_index_lookup
-The following constant are defined NONE, EQ, GT, -GTE, LT, LTE
-containercontainer=(con)execute(context = nil, flags = 0)high_boundhigh_bound=([value, operation])call-seq:
-self.high_bound = [value, operation]-
Sets the operation and value to be used for the upper bound for a range -index lookup operation. The high bound must be specified to indicate a -range lookup.
indexindex=(string)low_boundlow_bound=([value, operation])call-seq:
-self.low_bound = [value, operation]-
Sets the operation and value to be used for the index lookup operation. -If the operation is a simple inequality lookup, the lower bound is used as -the single value and operation for the lookup. If the operation is a range -lookup, in which an upper bound is specified, the lower bound is used -as the lower boundary value and operation for the lookup.
managernodenode_urinode_namenode=([uri, name])parentparent_uriparent_nameparent=([uri, name])transactiontransaction?Provides a high-level object used to manage various aspects of Berkeley -DB XML usage. You use XML::Manager to perform activities such as container -management (including creation and open), preparing XML::Query queries, -executing one-off queries, creating transaction objects, -creating update and query context objects
-A XML::Manager object can be created with BDB::Env#manager
-BDB::Transaction respond to the same method than BDB::XML::Manager
-new(flags = 0)create_container(name, flags = 0, type = XML::Container::NodeContainer, mode = 0)create_documentcreate_modifycreate_query_context(rt = XML::Context::LiveValues, et = XML::Context::Eager)create_resultsbegin(flags = 0)create_update_contextdump_container(name, path)dump_container(name, io, to_close = false)envhomeload_container(name, path, update = nil)load_container(name, io, to_close = false, update = nil)open_container(name, flags = 0)prepare(query, context = nil)Compile a Query expression and return a new XML::Query object.
-You can then use XML::Query#execute
-query(query, context = nil) [{res| ... }Execute a query. If a block is given it will call Xml::Results#each for -the results, or it will return an Xml::Results object
-This is equivalent to call XML::Manager#prepare and then -XML::Query#execute
-resolver = objectRegister a resolver
-A resolver is an object which can respond to #resolve_collection, -#resolve_document, #resolve_entity, #resolve_schema, #resolve_module -or #resolve_module_location
-These methods (if implemented) must return nil if they can't resolve
-def resolve_collection(txn_or_manager, uri)
-Xml::Results.new-
end
-def resolve_document(txn_or_manager, uri)
-Xml::Value.new-
end
-def resolve_entity(txn_or_manager, system_id, public_id)
-'an object which respond to #read'-
end
-def resolve_schema(txn_or_manager, schema_location, namespace)
-'an object which respond to #read'-
end
-def resolve_module(txn_or_manager, module_location, namespace)
-'an object which respond to #read'-
end
-def resolve_module_location(txn_or_manager, namespace)
-Xml::Results.new-
end
remove_container(name)rename_container(old_name, new_name)container_flagscontainer_flags = flagscontainer_typecontainer_type = typecontainer_version(file)create_index_lookup(container, uri, name, index, value = nil, op = XML::IndexLookup::EQ)pagesizepagesize = sizereindex_container(name, context = nil, flags = 0)Reindex an entire container. The container should be backed up prior to using -this method, as it destroys existing indexes before reindexing. If the operation -fails, and your container is not backed up, you may lose information.
-Use this call to change the type of indexing used for a container between -document-level indexes and node-level indexes. This method can take a very -long time to execute, depending on the size of the container, and should -not be used casually.
-sequence_increment = incrementsequence_incrementupdate_container(name, context = nil)verify_container(name, flags = 0)verify_container(name, path, flags = BDB::SALVAGE)verify_container(name, io, to_close = false, flags = BDB::SALVAGE)flagsimplicit_timezoneimplicit_timezone=(tz)compact_container(name, context = Xml::Context.new)truncate_container(name, context = XML::Context.new)The XML::Modify class encapsulates the context within which a set of one -or more documents specified by an XML::Query query can be modified in -place. The modification is performed using an XML::Modify object, and a -series of methods off that object that identify how the document is to -be modified. Using these methods, the modification steps are -identified. When the object is executed, these steps are performed in -the order that they were specified.
-The modification steps are executed against one or more documents -using XML::Modify::execute. This method can operate on a single document -stored in an XML::Value, or against multiple documents stored in an -XML::Results set that was created as the result of a container or -document query.
-append(query, type, name, content, location = -1)insert_after(query, type, name, content)insert_before(query, type, name, content)remove(query)rename(query, name)update(query, content)execute(obj, context, update = nil)encoding = stringThe results of a query are a collection of values. The values could -be either String, Float, true, false, BDB::XML::Documents or BDB::XML::Nodes
-add(val)each {|val| ... }sizeThe XML::Value class encapsulates the value of a node in an XML document.
-attributesreturn an XML::Results that contains all of the attributes appearing -on this node.
-node type must be XML::Value::Node
boolean?first_childreturns current node's first child node, or nil
-node type must be XML::Value::Node
last_childreturns current node's last child node, or nil
-node type must be XML::Value::Node
local_namereturns the node's local name.
-node type must be XML::Value::Node
namespacereturns the URI used for the node's namespace.
-node type must be XML::Value::Node
next_siblingreturns the sibling node immediately following this node in the -document, or nil.
-node type must be XML::Value::Node
nil?node?node_namereturn the type of the value contained in this value
-node type must be XML::Value::Node
node_valuereturn the node's value
-node type must be XML::Value::Node
number?owner_elementIf the current node is an attribute node, returns the document -element node that contains this attribute node. Otherwise, raise -an exception
-node type must be XML::Value::Node
parent_nodereturns current node's parent, or nil
-node type must be XML::Value::Node
prefixreturns the prefix set for the node's namespace.
-node type must be XML::Value::Node
previous_siblingreturns the sibling node immediately preceding this node -in the document, or nil
-node type must be XML::Value::Node
string?type?(type)typeBerkeley DB environment is an encapsulation of one or more databases,
+ between existing records.
+
+-((
Acces Methods
-A sequence is created with BDB::Common::create_sequence or - BDB::Common::open_sequence (only with db >= 4.3)
-- -+ -The transaction subsystem makes operations atomic, consistent,
+ BDB::Hash, BDB::Recno, BDB::Queue
+
+- * ((
A database cursor is a sequential pointer to the database entries. It
+ and locked appropriately.
+
+-((
See also iterators in Acces Methods
-- -+See also iterators in Acces Methods
-+ -The lock subsystem provides interprocess and intraprocess concurrency
+ records, so that they can be modified after they have been read.
+
+-See also iterators in ((
The logging subsystem is the logging facility used by Berkeley DB. It
+ set of designated resources.
+
+-(( These are the methods for BDB::Recnum Don't mix these methods with methods of BDB::Cursor open the database Removes the database (or subdatabase) represented by the
-name and subname combination. If no subdatabase is specified, the physical file represented by name
-is removed, incidentally removing all subdatabases that it contained. All this methods has the same syntax than for the class Array A database cursor is a sequential pointer to the database entries. It
-allows traversal of the database and access to duplicate keyed
-entries. Cursors are used for operating on collections of records,
-for iterating over a database, and for saving handles to individual
-records, so that they can be modified after they have been read. See also iterators in Acces Methods Creates new cursor that uses the same transaction and locker ID as
-the original cursor. This is useful when an application is using
-locking and requires two or more cursors in the same thread of
-control. flags can have the value BDB::DB_POSITION, in this case the
-newly created cursor is initialized to reference the same position in
-the database as the original cursor and hold the same locks. Retrieve key/data pair from the database See the description of key must be given if the flags parameter is
-BDB::SET | BDB::SET_RANGE | BDB::SET_RECNO key and value must be specified for BDB::GET_BOTH Stores data value into the database. See the description of Stores key/data pairs into the database (only for Btree and Hash
-access methods) flags must have the value BDB::KEYFIRST or
-BDB::KEYLAST Berkeley DB environment is an encapsulation of one or more databases,
-log files and shared information about the database environment such
-as shared memory buffer cache pages. The simplest way to administer a Berkeley DB application environment
-is to create a single home directory that stores the files for the
-applications that will share the environment. The environment home
-directory must be created before any Berkeley DB applications are run.
-Berkeley DB itself never creates the environment home directory. The
-environment can then be identified by the name of that directory. Hash, Possible options are (see the documentation of Berkeley DB
-for more informations) Proc given to set_feedback, set_app_dispatch and
-set_rep_transport can be also specified as a method
-(replace the prefix set_ with bdb_) For bdb_rep_transport the constant ENVID must be defined The constant BDB_ENCRYPT can be used to replace set_encrypt only with BDB::VERSION_MAJOR == 4 && BDB::VERSION_MINOR >= 1 remove the database specified by file and database. If no
-database is nil, the underlying file represented by
-file is removed, incidentally removing all databases
-that it contained. The flags value must be set to 0 or BDB::AUTO_COMMIT only with BDB::VERSION_MAJOR == 4 && BDB::VERSION_MINOR >= 1 rename the database specified by file and database to
-newname. If database is nil, the underlying file
-represented by file is renamed, incidentally renaming all databases
-that it contained. The flags value must be set to 0 or BDB::AUTO_COMMIT The lock_detect function runs one iteration of the deadlock
-detector. The deadlock detector traverses the lock table, and for each
-deadlock it finds, marks one of the participating transactions for
-abort. type can have one the value BDB::LOCK_OLDEST,
-BDB::LOCK_RANDOM or BDB::LOCK_YOUNGUEST flags can have the value BDB::LOCK_CONFLICT, in this case
-the deadlock detector is run only if a lock conflict has occurred
-since the last time that the deadlock detector was run. return the number of transactions aborted by the lock_detect function
-if BDB::VERSION_MAJOR >= 3 or zero The log_archive function return an array of log or database file names. flags value must be set to 0 or the value BDB::ARCH_DATA,
-BDB::ARCH_ABS, BDB::ARCH_LOG same as log_put(string, BDB::FLUSH) Without argument, garantee that all records are written to the disk The log_get return an array [String, BDB::Lsn] according to
-the flag value. flag can has the value BDB::CHECKPOINT, BDB::FIRST,
-BDB::LAST, BDB::NEXT, BDB::PREV, BDB::CURRENT The log_put function appends records to the log. It return
-an object BDB::Lsn flag can have the value BDB::CHECKPOINT, BDB::CURLSN,
-BDB::FLUSH only with BDB::VERSION_MAJOR == 3 && BDB::VERSION_MINOR >= 3 iterate over all prepared transactions. The transaction txn
-must be made a call to #abort, #commit, #discard id is the global transaction ID for the transaction only with BDB::VERSION_MAJOR == 3 && BDB::VERSION_MINOR >= 2 flags can have the value BDB::CDB_ALLDB, BDB::NOMMAP
-BDB::TXN_NOSYNC if onoff is false, the specified flags are cleared The txn_checkpoint function flushes the underlying memory pool,
-writes a checkpoint record to the log and then flushes the log. If either kbyte or min is non-zero, the checkpoint is only done
-if more than min minutes have passed since the last checkpoint, or if
-more than kbyte kilobytes of log data have been written since the last
-checkpoint. Only for DB >= 4.5 Adds a new replication site to the replication manager's list of known sites. Return the environment ID assigned to the remote site Only for DB >= 4.5 Specifies how master and client sites will handle acknowledgment of replication
-messages which are necessary for "permanent" records. policy must be set to one of the following values
-BDB::REPMGR_ACKS_ALL, BDB::REPMGR_ACKS_ALL_PEERS,
-BDB::REPMGR_ACKS_NONE, BDB::REPMGR_ACKS_ONE,
-BDB::REPMGR_ACKS_ONE_PEER, BDB::REPMGR_ACKS_QUORUM Only for DB >= 4.5 Returns the replication manager's client acknowledgment policy. Only for DB >= 4.5 Returns an array with the status of the sites currently known by the
-replication manager. Only for DB >= 4.5 Specifies the host identification string and port number for the local system. Only for DB >= 4.5 Starts the replication manager. Only for DB >= 4.5 Configures the Berkeley DB replication subsystem. which can have the value BDB::REP_CONF_BULK,
-BDB::REP_CONF_DELAYCLIENT, BDB::REP_CONF_NOAUTOINIT,
-BDB::REP_CONF_NOWAIT onoff can have the value true or false Only for DB >= 4.5 Returns true if the specified which parameter is currently set or not. Only for DB >= 4.5 Specifies the total number of sites in a replication group. Only for DB >= 4.5 Returns the total number of sites in a replication group. Only for DB >= 4.5 Specifies the priority in the replication group elections. Only for DB >= 4.5 Returns the database environment priority. Only for DB >= 4.5 Specifies the timeout in the replication group elections. which can have the value BDB::REP_ACK_TIMEOUT,
-BDB::REP_ELECTION_TIMEOUT, BDB::REP_ELECTION_RETRY,
-BDB::REP_CONNECTION_RETRY Only for DB >= 4.5 Returns the database environment timeout for which Only for DB >= 4 Holds an election for the master of a replication group, returning the
-new master's ID Raise BDB::RepUnavail if the timeout expires Only for DB >= 4 Processes an incoming replication message sent by a member of the
-replication group to the local database environment Only for DB >= 4 cdata is an identifier
-flags must be one of BDB::REP_CLIENT, BDB::REP_MASTER
-or BDB::REP_LOGSONLY Only for DB >= 4.4 Reset database file LSN The Env#lsn_reset method allows database files to be moved from one transactional
-database environment to another. fileThe name of the physical file in which the LSNs are to be cleared.
-flags must be set to 0 or BDB::ENCRYPT Only for DB >= 4.4 Reset database file ID The Env#fileid_reset method allows database files to be copied, and then the copy
-used in the same database environment as the original. fileThe name of the physical file in which new file IDs are to be created.
-flags must be set to 0 or BDB::ENCRYPT Only for DB >= 4.4 There are interfaces in the Berkeley DB library which either directly output informational
-messages or statistical information : Env#msgcall is used to set callback which will
-called by BDB The value given must be nil to unconfigure the callback, or and object
-which respond to #call : it will called with a String as argument Only for DB >= 4.4 Declare a proc object which returns a unique identifier pair for the current
-thread of control. The proc must return a pair Only for DB >= 4.4 Declare a proc that formats a process ID and thread ID identifier pair for display. The proc will be called with 2 arguments and must return a String Only for DB >= 4.4 Declare a proc that returns if a thread of control (either a true thread or
-a process) is still running. The proc will be called with 2 arguments (pid, tid) Only for DB >= 4.4 The method checks for threads of control (either a true
-thread or a process) that have exited while manipulating Berkeley DB library
-data structures flag is actually unused and must be set to 0 These are the common methods for BDB::Btree, BDB::Hash,
-BDB::Recno and BDB::Queue The flags must be the string "r", "r+", "w", "w+", "a", "a+" or
-and integer value. The flags value must be set to 0 or by bitwise inclusively
-OR'ing together one or more of the following values Physically truncate the underlying database file,
-discarding all previous subdatabases or databases.
-Underlying filesystem primitives are used to implement
-this flag. For this reason it is only applicable to the
-physical database file and cannot be used to discard
-subdatabases. The DB_TRUNCATE flag cannot be transaction protected,
-and it is an error to specify it in a transaction
-protected environment. Hash, Possible options are (see the documentation of Berkeley DB
-for more informations) set_append_recno will be called with (key, value) and
-it must return nil or the modified value set_encrypt take an Array as arguments with the values
-[password, flags], where flags can be 0 or BDB::ENCRYPT_AES Proc given to set_bt_compare, set_bt_prefix,
-set_dup_compare, set_h_hash, set_store_key
-set_fetch_key, set_store_value, set_fetch_value
-set_feedback and set_append_recno
-can be also specified as a method (replace the prefix set_
-with bdb_) Removes the database (or subdatabase) represented by the
-name and subname combination. If no subdatabase is specified, the physical file represented by name
-is removed, incidentally removing all subdatabases that it contained. associate a secondary index db flag can have the value BDB::RDONLY The block must return the new key, or Qfalse in this case the
-secondary index will not contain any reference to key/value Returns the value correspondind the key flags can have the values BDB::GET_BOTH,
-BDB::SET_RECNO or BDB::RMW In presence of duplicates it will return the first data item, use
-#duplicates if you want all duplicates (see also #each_dup) Returns the primary key and the value corresponding to key
-in the secondary index only with >= 3.3.11 Stores the value associating with key If nil is given as the value, the association from the key will be
-removed. Stores the value associating with key If nil is given as the value, the association from the key
-will be removed. It return the object deleted or nil if the
-specified key don't exist. flags can have the value DBD::NOOVERWRITE, in this case
-it will return nil if the specified key exist, otherwise true Removes the association from the key. It return the object deleted or nil if the specified
-key don't exist. Deletes associations if the evaluation of the block returns true. Return an array of all duplicate associations for key if assoc is false return only the values. Iterates over associations. Iterates over each duplicate associations for key Iterates over each duplicate values for key Iterates over keys. Iterates over values. Iterates over associations in reverse order Iterates over keys in reverse order Iterates over values in reverse order. If the parameter set is given, an initial call will be made
-with the option BDB::SET_RANGE to move the cursor to the specified
-key before iterating. Only with >= 3.3.11 : if the parameter bulk is given,
-an application buffer of size bulk * 1024 will be used
-(see "Retrieving records in bulk" in the documentation of BerkeleyDB) The lock subsystem provides interprocess and intraprocess concurrency
-control mechanisms. While the locking system is used extensively by
-the Berkeley DB access methods and transaction system, it may also be
-used as a stand-alone subsystem to provide concurrency control to any
-set of designated resources. The lock subsystem is created, initialized, and opened by calls to
- The following options can be given when the environnement is created Exception generated by lock call Lock not held by locker Lock not granted Locker killed to resolve a deadlock A lock ID can be obtained with BDB::Env#lock_id See also BDB::Env#lock_stat and
-BDB::Env#lock_detect The lock_get function acquires a lock from the lock table, it return
-an object BDB::Lock string specifies the object to be locked or released. mode is an index into the environment's lock conflict array flags value must be set to 0 or the value BDBD::LOCK_NOWAIT
-in this case if a lock cannot be granted because the requested
-lock conflicts with an existing lock, raise an error BDB::LockGranted This subsystem is used when recovery from application or system
-failure is necessary. The log is stored in one or more files in the environment
-directory. Each file is named using the format log.NNNNNNNNNN, where
-NNNNNNNNNN is the sequence number of the file within the log. If the log region is being created and log files are already present,
-the log files are reviewed and subsequent log writes are appended to
-the end of the log, rather than overwriting current log entries. The lock subsystem is created, initialized, and opened by calls to
- The following options can be given when the environnement is created The log_archive function return an array of log or database file names. flags value must be set to 0 or the value BDB::ARCH_DATA same as log_put(string, BDB::FLUSH) Without argument, garantee that all records are written to the disk The log_get return an array [String, BDB::Lsn] according to
-the flag value. flag can has the value BDB::CHECKPOINT, BDB::FIRST,
-BDB::LAST, BDB::NEXT, BDB::PREV, BDB::CURRENT The log_put function appends records to the log. It return
-an object BDB::Lsn flag can have the value BDB::CHECKPOINT, BDB::CURLSN,
-BDB::FLUSH include Comparable A sequence is created with BDB::Common::create_sequence or
-BDB::Common::open_sequence (only with db >= 4.3) create a new sequence (see also open_sequence) equivalent to
-open_sequence(key, BDB::CREATE|BDB::EXCL, init, options) return (or yield) an object BDB::Sequence create or open a sequence (see BDB::Sequence) key : key for the sequence flags : flags can have BDB::CREATE, BDB::EXCL, BDB::AUTO_COMMIT,
-BDB::THREAD init : initial value for the sequence options : hash with the possible keys "set_cachesize",
-"set_flags" and "set_range" return (or yield) an object BDB::Sequence return the next available element in the sequence and changes
-the sequence value by delta flags can have the value BDB::AUTO_COMMIT, BDB::TXN_NOSYNC remove the sequence flags can have the value BDB::AUTO_COMMIT, BDB::TXN_NOSYNC return statistics about the sequence flags can have the value BDB::STAT_CLEAR The transaction subsystem makes operations atomic, consistent,
-isolated, and durable in the face of system and application
-failures. The subsystem requires that the data be properly logged and
-locked in order to attain these properties. Berkeley DB contains all
-the components necessary to transaction-protect the Berkeley DB access
-methods and other forms of data may be protected if they are logged
-and locked appropriately. The transaction subsystem is created, initialized, and opened by calls
-to BDB::Env#open with the BDB::INIT_TXN
-flag (or BDB::INIT_TRANSACTION) specified.
-Note that enabling transactions automatically enables
-logging, but does not enable locking, as a single thread of control
-that needed atomicity and recoverability would not require it. The following option can be given when the environnement is created and with DB >= 4.0 The transaction is created with BDB::Env#begin
-or with begin See also BDB::Env#txn_stat and
-BDB::Env#txn_checkpoint begin a transaction (the transaction manager must be enabled). flags
-can have the value DBD::TXN_COMMIT, in this case the transaction
-will be commited at end. Return a new transaction object, and the associated database handle
-if specified. If #begin is called as an iterator, #commit and #abort
-will terminate the iterator. An optional hash can be given with the possible keys "flags",
-"set_timeout", "set_txn_timeout", "set_lock_timeout" Commit the transaction. This will finish the transaction.
-The flags can have the value BDB::TXN_SYNC Synchronously flush the log. This means the
-transaction will exhibit all of the ACID (atomicity, consistency
-and isolation and durability) properties. This is the default value. BDB::TXN_NOSYNC Do not synchronously flush the log. This
-means the transaction will exhibit the ACI (atomicity, consistency
-and isolation) properties, but not D (durability), i.e., database
-integrity will be maintained but it is possible that this
-transaction may be undone during recovery instead of being redone. This behavior may be set for an entire Berkeley DB environment as
-part of the open interface. only with BDB::VERSION_MAJOR == 3 && BDB::VERSION_MINOR >= 3 Discard a prepared but not resolved transaction handle, must be called
-only within BDB::Env#recover only with BDB::VERSION_MAJOR == 4 && BDB::VERSION_MINOR >= 1 remove the database specified by file and database. If no
-database is nil, the underlying file represented by
-file is removed, incidentally removing all databases
-that it contained. The flags value must be set to 0 or BDB::AUTO_COMMIT only with BDB::VERSION_MAJOR == 4 && BDB::VERSION_MINOR >= 1 rename the database specified by file and database to
-newname. If database is nil, the underlying file
-represented by file is renamed, incidentally renaming all databases
-that it contained. The flags value must be set to 0 or BDB::AUTO_COMMIT Only with DB >= 4.1 open the database in the current transaction. type must be one of
-the constant BDB::BTREE, BDB::HASH, BDB::RECNO,
-BDB::QUEUE. See open for other
-arguments The txn_prepare function initiates the beginning of a two-phase commit. In a distributed transaction environment, Berkeley DB can be used
-as a local transaction manager. In this case, the distributed
-transaction manager must send prepare messages to each local
-manager. The local manager must then issue a txn_prepare and await its
-successful return before responding to the distributed transaction
-manager. Only after the distributed transaction manager receives
-successful responses from all of its prepare messages should it issue
-any commit messages.Acces Methods
-Class Methods
-
-
-open(name = nil, subname = nil, flags = 0, mode = 0, options = {})create(name = nil, subname = nil, flags = 0, mode = 0, options = {})new(name = nil, subname = nil, flags = 0, mode = 0, options = {})BDB::Recnum.open(name, subname, flags, mode)
-
-is equivalent to
-
-BDB::Recno.open(name, subname, flags, mode,
- "set_flags" => BDB::RENUMBER,
- "set_array_base" => 0)
remove(name, subname = nil)db_remove(name, subname = nil)unlink(name, subname = nil)upgrade(name)db_upgrade(name)Methods
-
-
-
-
-
diff -Nru ruby-bdb-0.6.5/docs/cursor.html ruby-bdb-0.6.6/docs/cursor.html
--- ruby-bdb-0.6.5/docs/cursor.html 2011-05-25 08:07:14.000000000 +0000
+++ ruby-bdb-0.6.6/docs/cursor.html 1970-01-01 00:00:00.000000000 +0000
@@ -1,102 +0,0 @@
-
-
-
-
-self[nth]self[start..end]self[start, length]self[nth] = valself[start..end] = valself[start, length] = valself + otherself * timesself - otherself & otherself | otherself << objself <=> otherclearcollect {|item| ..}collect! {|item| ..}concat(other)delete(val)delete_at(pos)delete_if {|x| ...}reject!{|x|...}each {|x| ...}each_index {|i| ...}empty?fill(val)fill(val, start[, length])fill(val, start..end)include?(val)index(val)indexes(index_1,..., index_n)indices(index_1,..., index_n)join([sep])lengthsizenitemspoppush(obj...)replace(other)reversereverse!reverse_each {|x| ...}rindex(val)shiftto_ato_aryunshift(obj)Cursor operation
-Methods
-
-
-
-
-
diff -Nru ruby-bdb-0.6.5/docs/env.html ruby-bdb-0.6.6/docs/env.html
--- ruby-bdb-0.6.5/docs/env.html 2011-05-25 08:07:14.000000000 +0000
+++ ruby-bdb-0.6.6/docs/env.html 1970-01-01 00:00:00.000000000 +0000
@@ -1,441 +0,0 @@
-
-
-
-
-close()c_close()count()c_count()current()c_current()get(BDB::CURRENT)del()delete()c_del()dup(flags = 0)clone(flags = 0)c_dup(flags = 0)c_clone(flags = 0)first()c_first()get(BDB::FIRST)get(flags, key = nil, value = nil)c_get(flags, key = nil, value = nil)c_get in the Berkeley distribution
-for the different values of the flags parameter.last()c_last()get(BDB::LAST)next()c_next()get(BDB::NEXT)pget(flags, key = nil, value = nil)c_pget(flags, key = nil, value = nil)prev()c_prev()get(BDB::PREV)put(flags, value)c_put(flags, value)c_put in the Berkeley distribution
-for the different values of the flags parameter.put(flags, key, value)c_put(flags, key, value)set(key)c_set(key)set_range(key)c_set_range(key)set_recno(key)c_set_recno(key)get with the flags BDB::SET or BDB::SET_RANGE
-or BDB::SET_RECNOBDB::Env
-
-
-Class Methods
-
-
-open(home, flags = 0, mode = 0, options = {})create(home, flags = 0, mode = 0, options = {})new(home, flags = 0, mode = 0, options = {})
-
-
-
-
-remove()unlink()Methods
-
-
-
-
-
diff -Nru ruby-bdb-0.6.5/docs/hashlike.html ruby-bdb-0.6.6/docs/hashlike.html
--- ruby-bdb-0.6.5/docs/hashlike.html 2011-05-25 08:07:14.000000000 +0000
+++ ruby-bdb-0.6.6/docs/hashlike.html 1970-01-01 00:00:00.000000000 +0000
@@ -1,408 +0,0 @@
-
-
-
-
-close()dbremove(file, database = nil, flags = 0)dbrename(file, database, newname, flags = 0)feedback=(proc)home()lock()lock_id()lock_detect(type, flags = 0)lock_stat()log_archive(flags = 0)log_checkpoint(string)log_curlsn(string)log_each { |string, lsn| ... }log_flush(string = nil)log_get(flag)log_put(string, flag = 0)log_reverse_each { |string, lsn| ... }log_statopen_db(type, name = nil, subname = nil, flags = 0, mode = 0)recover { |txn, id| ... }set_flags(flags, onoff = true)begin(flags = 0)txn_begin(flags = 0)begin(flags = 0, db, ...) { |txn, db, ...| ...}checkpoint(kbyte, min = 0)txn_checkpoint(kbyte, min = 0)stat()txn_stat()repmgr_add_remote(host, port, flag = 0)repmgr_ack_policy=(policy)repmgr_set_ack_policy(policy)repmgr_ack_policyrepmgr_get_ack_policyrepmgr_site_listrepmgr_set_local_site(host, port, flag = 0)repmgr_start(count, flag)rep_config[]=(which, onoff)rep_config?[](which)rep_nsites=(sites)rep_nsitesrep_priority=(priority)rep_priorityrep_timeout[]=(which, timeout)rep_timeout[](which)elect(sites, priority, timeout)rep_elect(sites, priority, timeout)process_message(control, rec, envid)rep_process_message(control, rec, envid)start(cdata, flags)rep_start(cdata, flags)lsn_reset(file, flags = 0)fileid_reset(file, flags = 0)msgcall=(call_proc)thread_id=(call_proc)
-
thread_id_string=(call_proc)is_alive=(call_proc)failcheck(flag = 0)Acces Methods
-Class Methods
-
-
-open(name = nil, subname = nil, flags = 0, mode = 0, options = {})create(name = nil, subname = nil, flags = 0, mode = 0, options = {})new(name = nil, subname = nil, flags = 0, mode = 0, options = {})
-
-
-
-
-For example
-
- module BDB
- class Btreesort < Btree
- def bdb_bt_compare(a, b)
- b.downcase <=> a.downcase
- end
- end
- end
-remove(name, subname = nil)db_remove(name, subname = nil)unlink(name, subname = nil)upgrade(name)db_upgrade(name)Methods
-
-
-self[key]associate(db, flag = 0) { |db, key, value| }cache_prioritycache_priority=valuefeedback=(proc)get(key, flags = 0)db_get(key, flags = 0)fetch(key, flags = 0)pget(key, flags = 0)self[key] = valueput(key, value, flags = 0)db_put(key, value, flags = 0)store(key, value, flags = 0)append(key, value)db_append(key, value)byteswapped?get_byteswappedclear_partialpartial_clearclose(flags = 0)db_close(flags = 0)count(key)dup_count(key)cursor(flags = 0)db_cursor(flags = 0)database()subname()delete(key)db_del(key)delete_if(set = nil) { |key, value| ... }reject!(set = nil) { |key, value| ... }duplicates(key , assoc = true)each(set = nil, bulk = 0, "flags" => 0) { |key, value| ... }each_pair(set = nil, bulk = 0) { |key, value| ... }each_by_prefix(prefix) {|key, value| ... }each_dup(key, bulk = 0) { |key, value| ... }each_dup_value(key, bulk = 0) { |value| ... }each_key(set = nil, bulk = 0) { |key| ... }each_primary(set = nil) { |skey, pkey, pvalue| ... }each_value(set = nil, bulk = 0) { |value| ... }empty?()filename()has_key?(key)key?(key)include?(key)member?(key)has_both?(key, value)both?(key, value)has_value?(value)value?(value)index(value)indexes(value1, value2, )join(cursor , flag = 0) { |key, value| ... }keyslengthsizelog_register(name)log_unregister()reject { |key, value| ... }reverse_each(set = nil) { |key, value| ... }reverse_each_pair(set = nil) { |key, value| ... }reverse_each_by_prefix(prefix) {|key, value| ... }reverse_each_key(set = nil) { |key| ... }reverse_each_primary(set = nil) { |skey, pkey, pvalue| ... }reverse_each_value(set = nil) { |value| ... }set_partial(len, offset)statto_ato_hashtruncateclearvaluesverify(file = nil, flags = 0)compact(start = nil, stop = nil, options = nil)
-
-
Methods specific to BDB::Recno and BDB::Queue
-
-
-poppush valuesshiftRemark
-set
-bulk
-Lock system
-BDB::Env#open with the DBD::INIT_LOCK or
-DBB::INIT_CDB flags specified.
-
-BDB::LockError
-BDB::LockHeld
-BDB::LockGranted
-BDB::LockDead
-BDB::Lockid
-Methods
-
-
-get(string, mode , flags = 0)lock_get(string, mode [, flags])vec(array , flags = 0)lock_vec(array [, flags])
-
-
-BDB::Lock
-Methods
-
-
-
-
-
diff -Nru ruby-bdb-0.6.5/docs/log.html ruby-bdb-0.6.6/docs/log.html
--- ruby-bdb-0.6.5/docs/log.html 2011-05-25 08:07:14.000000000 +0000
+++ ruby-bdb-0.6.6/docs/log.html 1970-01-01 00:00:00.000000000 +0000
@@ -1,110 +0,0 @@
-
-
-
-
-put()lock_put()release()delete()Logging subsystem
-BDB::Env#open with the BDB::INIT_LOG flag specified.
-
-BDB::Env
-Methods
-
-
-log_archive(flags = 0)((|BDB::ARCH_DATA|)), ((|BDB::ARCH_LOG|))
log_checkpoint(string)log_curlsn(string)log_each { |string, lsn| ... }log_flush([string])log_get(flag)log_put(string, flag = 0)log_reverse_each { |string, lsn| ... }log_statBDB::Common
-Methods
-
-
-log_register(name)log_unregister()BDB::Lsn
-
-
-
-
-
diff -Nru ruby-bdb-0.6.5/docs/sequence.html ruby-bdb-0.6.6/docs/sequence.html
--- ruby-bdb-0.6.5/docs/sequence.html 2011-05-25 08:07:14.000000000 +0000
+++ ruby-bdb-0.6.6/docs/sequence.html 1970-01-01 00:00:00.000000000 +0000
@@ -1,68 +0,0 @@
-
-
-
-
-<=>log_file(name)file(name)log_flushflushlog_getgetBDB::Sequence
-class BDB::Common
-
-
-create_sequence(key, init = nil, options = {}) {|sequence| }open_sequence(key, flags = 0, init = nil, options = {}) {|sequence| }Methods
-
-
-
-
-
diff -Nru ruby-bdb-0.6.5/docs/transaction.html ruby-bdb-0.6.6/docs/transaction.html
--- ruby-bdb-0.6.5/docs/transaction.html 2011-05-25 08:07:14.000000000 +0000
+++ ruby-bdb-0.6.6/docs/transaction.html 1970-01-01 00:00:00.000000000 +0000
@@ -1,152 +0,0 @@
-
-
-
-
-cachesizeclosedbflagsget(delta = 1, flags = 0)keyrangeremove(flags = 0)stat(flags = 0)BDB::Txn
-
-
-Methods
-
-
-
-
-
diff -Nru ruby-bdb-0.6.5/.gitignore ruby-bdb-0.6.6/.gitignore
--- ruby-bdb-0.6.5/.gitignore 1970-01-01 00:00:00.000000000 +0000
+++ ruby-bdb-0.6.6/.gitignore 2011-04-06 19:35:39.000000000 +0000
@@ -0,0 +1,11 @@
+*.html
+Makefile
+bdbxml2/bdbxml_features.h
+bdbxml[12]/*.html
+bdbxml[12]/*.so
+bdbxml[12]/docs/*.html
+docs/*.html
+src/Makefile
+src/bdb.so
+src/bdb_features.h
+src/mkmf.log
diff -Nru ruby-bdb-0.6.5/src/bdb_features.h ruby-bdb-0.6.6/src/bdb_features.h
--- ruby-bdb-0.6.5/src/bdb_features.h 2011-05-25 08:07:14.000000000 +0000
+++ ruby-bdb-0.6.6/src/bdb_features.h 1970-01-01 00:00:00.000000000 +0000
@@ -1,527 +0,0 @@
-#define HAVE_RB_FRAME_THIS_FUNC 1
-#define HAVE_RB_BLOCK_PROC 1
-#define HAVE_RB_BLOCK_CALL 1
-#define HAVE_RB_ARY_INSERT 1
-#define HAVE_RB_ARY_VALUES_AT 1
-#define HAVE_TYPE_RB_IO_T 1
-#define HAVE_CONST_DB_AFTER 1
-#define HAVE_CONST_DB_AGGRESSIVE 1
-#define HAVE_CONST_DB_APPEND 1
-#define HAVE_CONST_DB_ARCH_ABS 1
-#define HAVE_CONST_DB_ARCH_DATA 1
-#define HAVE_CONST_DB_ARCH_LOG 1
-#define HAVE_CONST_DB_AUTO_COMMIT 1
-#define HAVE_CONST_DB_BEFORE 1
-#define HAVE_CONST_DB_BTREE 1
-#define HAVE_CONST_DB_CDB_ALLDB 1
-#define HAVE_CONST_DB_CHKSUM 1
-#define HAVE_CONST_DB_CONSUME 1
-#define HAVE_CONST_DB_CONSUME_WAIT 1
-#define HAVE_CONST_DB_CREATE 1
-#define HAVE_CONST_DB_CURRENT 1
-#define HAVE_CONST_DB_DBT_MALLOC 1
-#define HAVE_CONST_DB_DBT_PARTIAL 1
-#define HAVE_CONST_DB_DBT_REALLOC 1
-#define HAVE_CONST_DB_DBT_USERMEM 1
-#define HAVE_CONST_DB_DIRECT_DB 1
-#define HAVE_CONST_DB_DIRECT_LOG 1
-#define HAVE_CONST_DB_DIRTY_READ 1
-#define HAVE_CONST_DB_DONOTINDEX 1
-#define HAVE_CONST_DB_DSYNC_LOG 1
-#define HAVE_CONST_DB_DUP 1
-#define HAVE_CONST_DB_DUPSORT 1
-#define HAVE_CONST_DB_EID_BROADCAST 1
-#define HAVE_CONST_DB_EID_INVALID 1
-#define HAVE_CONST_DB_ENCRYPT 1
-#define HAVE_CONST_DB_ENCRYPT_AES 1
-#define HAVE_CONST_DB_ENV_THREAD 1
-#define HAVE_CONST_DB_EVENT_PANIC 1
-#define HAVE_CONST_DB_EVENT_REP_CLIENT 1
-#define HAVE_CONST_DB_EVENT_REP_ELECTED 1
-#define HAVE_CONST_DB_EVENT_REP_MASTER 1
-#define HAVE_CONST_DB_EVENT_REP_NEWMASTER 1
-#define HAVE_CONST_DB_EVENT_REP_PERM_FAILED 1
-#define HAVE_CONST_DB_EVENT_REP_STARTUPDONE 1
-#define HAVE_CONST_DB_EVENT_WRITE_FAILED 1
-#define HAVE_CONST_DB_EXCL 1
-#define HAVE_CONST_DB_FAST_STAT 1
-#define HAVE_CONST_DB_FIRST 1
-#define HAVE_CONST_DB_FLUSH 1
-#define HAVE_CONST_DB_FORCE 1
-#define HAVE_CONST_DB_GET_BOTH_RANGE 1
-#define HAVE_CONST_DB_GET_RECNO 1
-#define HAVE_CONST_DB_GET_BOTH 1
-#define HAVE_CONST_DB_HASH 1
-#define HAVE_CONST_DB_IGNORE_LEASE 1
-#define HAVE_CONST_DB_INIT_CDB 1
-#define HAVE_CONST_DB_INIT_LOCK 1
-#define HAVE_CONST_DB_INIT_LOG 1
-#define HAVE_CONST_DB_INIT_MPOOL 1
-#define HAVE_CONST_DB_INIT_REP 1
-#define HAVE_CONST_DB_INIT_TXN 1
-#define HAVE_CONST_DB_JOINENV 1
-#define HAVE_CONST_DB_JOIN_ITEM 1
-#define HAVE_CONST_DB_JOIN_NOSORT 1
-#define HAVE_CONST_DB_KEYEMPTY 1
-#define HAVE_CONST_DB_KEYEXIST 1
-#define HAVE_CONST_DB_KEYFIRST 1
-#define HAVE_CONST_DB_KEYLAST 1
-#define HAVE_CONST_DB_LAST 1
-#define HAVE_CONST_DB_LOCKDOWN 1
-#define HAVE_CONST_DB_LOCK_DEADLOCK 1
-#define HAVE_CONST_DB_LOCK_DEFAULT 1
-#define HAVE_CONST_DB_LOCK_EXPIRE 1
-#define HAVE_CONST_DB_LOCK_GET 1
-#define HAVE_CONST_DB_LOCK_GET_TIMEOUT 1
-#define HAVE_CONST_DB_LOCK_IREAD 1
-#define HAVE_CONST_DB_LOCK_IWR 1
-#define HAVE_CONST_DB_LOCK_IWRITE 1
-#define HAVE_CONST_DB_LOCK_MAXLOCKS 1
-#define HAVE_CONST_DB_LOCK_MINLOCKS 1
-#define HAVE_CONST_DB_LOCK_MINWRITE 1
-#define HAVE_CONST_DB_LOCK_NG 1
-#define HAVE_CONST_DB_LOCK_NOTGRANTED 1
-#define HAVE_CONST_DB_LOCK_NOWAIT 1
-#define HAVE_CONST_DB_LOCK_OLDEST 1
-#define HAVE_CONST_DB_LOCK_PUT 1
-#define HAVE_CONST_DB_LOCK_PUT_ALL 1
-#define HAVE_CONST_DB_LOCK_PUT_OBJ 1
-#define HAVE_CONST_DB_LOCK_RANDOM 1
-#define HAVE_CONST_DB_LOCK_READ 1
-#define HAVE_CONST_DB_LOCK_TIMEOUT 1
-#define HAVE_CONST_DB_LOCK_WRITE 1
-#define HAVE_CONST_DB_LOCK_YOUNGEST 1
-#define HAVE_CONST_DB_LOG_AUTOREMOVE 1
-#define HAVE_CONST_DB_LOG_INMEMORY 1
-#define HAVE_CONST_DB_MPOOL_CREATE 1
-#define HAVE_CONST_DB_MPOOL_DIRTY 1
-#define HAVE_CONST_DB_MPOOL_DISCARD 1
-#define HAVE_CONST_DB_MPOOL_LAST 1
-#define HAVE_CONST_DB_MPOOL_NEW 1
-#define HAVE_CONST_DB_MULTIVERSION 1
-#define HAVE_CONST_DB_MUTEX_PROCESS_ONLY 1
-#define HAVE_CONST_DB_NEXT_DUP 1
-#define HAVE_CONST_DB_NEXT_NODUP 1
-#define HAVE_CONST_DB_NODUPDATA 1
-#define HAVE_CONST_DB_NOORDERCHK 1
-#define HAVE_CONST_DB_NOSERVER 1
-#define HAVE_CONST_DB_NOSERVER_HOME 1
-#define HAVE_CONST_DB_NOSERVER_ID 1
-#define HAVE_CONST_DB_NOTFOUND 1
-#define HAVE_CONST_DB_OLD_VERSION 1
-#define HAVE_CONST_DB_ORDERCHKONLY 1
-#define HAVE_CONST_DB_OVERWRITE 1
-#define HAVE_CONST_DB_POSITION 1
-#define HAVE_CONST_DB_PRIVATE 1
-#define HAVE_CONST_DB_SYSTEM_MEM 1
-#define HAVE_CONST_DB_RMW 1
-#define HAVE_CONST_DB_PREV_DUP 1
-#define HAVE_CONST_DB_PREV_NODUP 1
-#define HAVE_CONST_DB_PRINTABLE 1
-#define HAVE_CONST_DB_PRIORITY_DEFAULT 1
-#define HAVE_CONST_DB_PRIORITY_HIGH 1
-#define HAVE_CONST_DB_PRIORITY_LOW 1
-#define HAVE_CONST_DB_PRIORITY_VERY_HIGH 1
-#define HAVE_CONST_DB_QUEUE 1
-#define HAVE_CONST_DB_RDONLY 1
-#define HAVE_CONST_DB_READ_COMMITTED 1
-#define HAVE_CONST_DB_READ_UNCOMMITTED 1
-#define HAVE_CONST_DB_RECNO 1
-#define HAVE_CONST_DB_RECNUM 1
-#define HAVE_CONST_DB_RECOVER 1
-#define HAVE_CONST_DB_RECOVER_FATAL 1
-#define HAVE_CONST_DB_REGION_INIT 1
-#define HAVE_CONST_DB_RENUMBER 1
-#define HAVE_CONST_DB_REPFLAGS_MASK 1
-#define HAVE_CONST_DB_REPMGR_ACKS_ALL 1
-#define HAVE_CONST_DB_REPMGR_ACKS_ALL_PEERS 1
-#define HAVE_CONST_DB_REPMGR_ACKS_NONE 1
-#define HAVE_CONST_DB_REPMGR_ACKS_ONE 1
-#define HAVE_CONST_DB_REPMGR_ACKS_ONE_PEER 1
-#define HAVE_CONST_DB_REPMGR_ACKS_QUORUM 1
-#define HAVE_CONST_DB_REPMGR_CONNECTED 1
-#define HAVE_CONST_DB_REPMGR_DISCONNECTED 1
-#define HAVE_CONST_DB_REPMGR_PEER 1
-#define HAVE_CONST_DB_REP_ACK_TIMEOUT 1
-#define HAVE_CONST_DB_REP_ANYWHERE 1
-#define HAVE_CONST_DB_REP_BULKOVF 1
-#define HAVE_CONST_DB_REP_CHECKPOINT_DELAY 1
-#define HAVE_CONST_DB_REP_CLIENT 1
-#define HAVE_CONST_DB_REP_CONF_BULK 1
-#define HAVE_CONST_DB_REP_CONF_DELAYCLIENT 1
-#define HAVE_CONST_DB_REP_CONF_NOAUTOINIT 1
-#define HAVE_CONST_DB_REP_CONF_NOWAIT 1
-#define HAVE_CONST_DB_REP_CONNECTION_RETRY 1
-#define HAVE_CONST_DB_REP_DEFAULT_PRIORITY 1
-#define HAVE_CONST_DB_REP_DUPMASTER 1
-#define HAVE_CONST_DB_REP_EGENCHG 1
-#define HAVE_CONST_DB_REP_ELECTION 1
-#define HAVE_CONST_DB_REP_ELECTION_RETRY 1
-#define HAVE_CONST_DB_REP_ELECTION_TIMEOUT 1
-#define HAVE_CONST_DB_REP_FULL_ELECTION_TIMEOUT 1
-#define HAVE_CONST_DB_REP_HANDLE_DEAD 1
-#define HAVE_CONST_DB_REP_HOLDELECTION 1
-#define HAVE_CONST_DB_REP_IGNORE 1
-#define HAVE_CONST_DB_REP_ISPERM 1
-#define HAVE_CONST_DB_REP_JOIN_FAILURE 1
-#define HAVE_CONST_DB_REP_LEASE_EXPIRED 1
-#define HAVE_CONST_DB_REP_LEASE_TIMEOUT 1
-#define HAVE_CONST_DB_REP_LOCKOUT 1
-#define HAVE_CONST_DB_REP_LOGREADY 1
-#define HAVE_CONST_DB_REP_MASTER 1
-#define HAVE_CONST_DB_REP_NEWMASTER 1
-#define HAVE_CONST_DB_REP_NEWSITE 1
-#define HAVE_CONST_DB_REP_NOBUFFER 1
-#define HAVE_CONST_DB_REP_NOTPERM 1
-#define HAVE_CONST_DB_REP_PAGEDONE 1
-#define HAVE_CONST_DB_REP_PERMANENT 1
-#define HAVE_CONST_DB_REP_REREQUEST 1
-#define HAVE_CONST_DB_REP_UNAVAIL 1
-#define HAVE_CONST_DB_RPCCLIENT 1
-#define HAVE_CONST_DB_RUNRECOVERY 1
-#define HAVE_CONST_DB_SALVAGE 1
-#define HAVE_CONST_DB_SECONDARY_BAD 1
-#define HAVE_CONST_DB_SET 1
-#define HAVE_CONST_DB_SET_LOCK_TIMEOUT 1
-#define HAVE_CONST_DB_SET_RANGE 1
-#define HAVE_CONST_DB_SET_RECNO 1
-#define HAVE_CONST_DB_SET_TXN_TIMEOUT 1
-#define HAVE_CONST_DB_SNAPSHOT 1
-#define HAVE_CONST_DB_STAT_ALL 1
-#define HAVE_CONST_DB_STAT_CLEAR 1
-#define HAVE_CONST_DB_STAT_SUBSYSTEM 1
-#define HAVE_CONST_DB_THREAD 1
-#define HAVE_CONST_DB_TRUNCATE 1
-#define HAVE_CONST_DB_TXN_ABORT 1
-#define HAVE_CONST_DB_TXN_APPLY 1
-#define HAVE_CONST_DB_TXN_BACKWARD_ROLL 1
-#define HAVE_CONST_DB_TXN_FORWARD_ROLL 1
-#define HAVE_CONST_DB_TXN_NOSYNC 1
-#define HAVE_CONST_DB_TXN_NOWAIT 1
-#define HAVE_CONST_DB_TXN_PRINT 1
-#define HAVE_CONST_DB_TXN_SNAPSHOT 1
-#define HAVE_CONST_DB_TXN_SYNC 1
-#define HAVE_CONST_DB_TXN_WRITE_NOSYNC 1
-#define HAVE_CONST_DB_UNKNOWN 1
-#define HAVE_CONST_DB_UPGRADE 1
-#define HAVE_CONST_DB_USE_ENVIRON 1
-#define HAVE_CONST_DB_USE_ENVIRON_ROOT 1
-#define HAVE_CONST_DB_VERB_DEADLOCK 1
-#define HAVE_CONST_DB_VERB_RECOVERY 1
-#define HAVE_CONST_DB_VERB_REPLICATION 1
-#define HAVE_CONST_DB_VERB_WAITSFOR 1
-#define HAVE_CONST_DB_VERIFY 1
-#define HAVE_CONST_DB_PRIORITY_VERY_LOW 1
-#define HAVE_CONST_DB_WRITECURSOR 1
-#define HAVE_CONST_DB_XA_CREATE 1
-#define HAVE_CONST_DB_XIDDATASIZE 1
-#define HAVE_CONST_DB_MULTIPLE_KEY 1
-#define HAVE_CONST_DB_TXN_NOT_DURABLE 1
-#define HAVE_DB_STRERROR 1
-#define HAVE_TYPE_DB_KEY_RANGE 1
-#define HAVE_TYPE_DB_SEQUENCE 1
-#define HAVE_TYPE_DB_LOGC 1
-#define HAVE_TYPE_DBTYPE 1
-#define HAVE_TYPE_DB_COMPACT 1
-#define HAVE_TYPE_DB_HASH_STAT 1
-#define HAVE_ST_DB_HASH_STAT_HASH_NKEYS 1
-#define HAVE_ST_DB_HASH_STAT_HASH_NDATA 1
-#define HAVE_ST_DB_HASH_STAT_HASH_PAGECNT 1
-#define HAVE_TYPE_DB_QUEUE_STAT 1
-#define HAVE_ST_DB_QUEUE_STAT_QS_NKEYS 1
-#define HAVE_ST_DB_QUEUE_STAT_QS_NDATA 1
-#define HAVE_TYPE_DB_REP_STAT 1
-#define HAVE_ST_DB_REP_STAT_ST_BULK_FILLS 1
-#define HAVE_ST_DB_REP_STAT_ST_BULK_OVERFLOWS 1
-#define HAVE_ST_DB_REP_STAT_ST_BULK_RECORDS 1
-#define HAVE_ST_DB_REP_STAT_ST_BULK_TRANSFERS 1
-#define HAVE_ST_DB_REP_STAT_ST_CLIENT_REREQUESTS 1
-#define HAVE_ST_DB_REP_STAT_ST_CLIENT_SVC_MISS 1
-#define HAVE_ST_DB_REP_STAT_ST_CLIENT_SVC_REQ 1
-#define HAVE_ST_DB_REP_STAT_ST_EGEN 1
-#define HAVE_ST_DB_REP_STAT_ST_ELECTION_NVOTES 1
-#define HAVE_ST_DB_REP_STAT_ST_ELECTION_SEC 1
-#define HAVE_ST_DB_REP_STAT_ST_ELECTION_USEC 1
-#define HAVE_ST_DB_REP_STAT_ST_NEXT_PG 1
-#define HAVE_ST_DB_REP_STAT_ST_PG_DUPLICATED 1
-#define HAVE_ST_DB_REP_STAT_ST_PG_RECORDS 1
-#define HAVE_ST_DB_REP_STAT_ST_PG_REQUESTED 1
-#define HAVE_ST_DB_REP_STAT_ST_STARTUP_COMPLETE 1
-#define HAVE_ST_DB_REP_STAT_ST_WAITING_PG 1
-#define HAVE_ST_DBC_C_CLOSE 1
-#define HAVE_ST_DBC_C_COUNT 1
-#define HAVE_ST_DBC_C_DEL 1
-#define HAVE_ST_DBC_C_DUP 1
-#define HAVE_ST_DBC_C_GET 1
-#define HAVE_ST_DBC_C_PGET 1
-#define HAVE_ST_DBC_C_PUT 1
-#define HAVE_ST_DBC_CLOSE 1
-#define HAVE_ST_DBC_COUNT 1
-#define HAVE_ST_DBC_DEL 1
-#define HAVE_ST_DBC_DUP 1
-#define HAVE_ST_DBC_GET 1
-#define HAVE_ST_DBC_PGET 1
-#define HAVE_ST_DBC_PUT 1
-#define HAVE_ST_DBC_GET_PRIORITY 1
-#define HAVE_ST_DB_APP_PRIVATE 1
-#define HAVE_ST_DB_SET_H_COMPARE 1
-#define HAVE_ST_DB_SET_APPEND_RECNO 1
-#define HAVE_ST_DB_SET_FEEDBACK 1
-#define HAVE_ST_DB_SET_ENCRYPT 1
-#define HAVE_ST_DB_SET_ERRCALL 1
-#define HAVE_ST_DB_GET_TYPE 1
-#define HAVE_ST_DB_PGET 1
-#define HAVE_ST_DB_FD 1
-#define HAVE_ST_DB_SET_PRIORITY 1
-#define HAVE_ST_DB_GET_BT_MINKEY 1
-#define HAVE_ST_DB_GET_CACHESIZE 1
-#define HAVE_ST_DB_GET_DBNAME 1
-#define HAVE_ST_DB_GET_ENV 1
-#define HAVE_ST_DB_GET_H_FFACTOR 1
-#define HAVE_ST_DB_GET_H_NELEM 1
-#define HAVE_ST_DB_GET_LORDER 1
-#define HAVE_ST_DB_GET_PAGESIZE 1
-#define HAVE_ST_DB_GET_Q_EXTENTSIZE 1
-#define HAVE_ST_DB_GET_RE_DELIM 1
-#define HAVE_ST_DB_GET_RE_LEN 1
-#define HAVE_ST_DB_GET_RE_PAD 1
-#define HAVE_ST_DB_GET_RE_SOURCE 1
-#define HAVE_ST_DB_GET_FLAGS 1
-#define HAVE_ST_DB_GET_OPEN_FLAGS 1
-#define HAVE_ST_DB_VERIFY 1
-#define HAVE_ST_DB_TRUNCATE 1
-#define HAVE_ST_DB_UPGRADE 1
-#define HAVE_ST_DB_REMOVE 1
-#define HAVE_ST_DB_RENAME 1
-#define HAVE_ST_DB_JOIN 1
-#define HAVE_ST_DB_GET_BYTESWAPPED 1
-#define HAVE_DB_GET_TYPE_2 1
-#define HAVE_ST_DB_OPEN 1
-#define HAVE_DB_OPEN_7 1
-#define HAVE_DB_OPEN_7_DB_CREATE 1
-#define HAVE_DB_KEY_DBT_MALLOC 1
-#define HAVE_ST_DB_ASSOCIATE 1
-#define HAVE_DB_ASSOCIATE_TXN 1
-#define HAVE_DB_JOIN_FLAG_DBC 1
-#define HAVE_DB_GET_BYTESWAPPED_2 1
-#define HAVE_ST_DB_ENV_GET_CACHESIZE 1
-#define HAVE_ST_DB_ENV_GET_DATA_DIRS 1
-#define HAVE_ST_DB_ENV_GET_FLAGS 1
-#define HAVE_ST_DB_ENV_GET_HOME 1
-#define HAVE_ST_DB_ENV_GET_LG_BSIZE 1
-#define HAVE_ST_DB_ENV_GET_LG_DIR 1
-#define HAVE_ST_DB_ENV_GET_LG_MAX 1
-#define HAVE_ST_DB_ENV_GET_LG_REGIONMAX 1
-#define HAVE_ST_DB_ENV_GET_LK_DETECT 1
-#define HAVE_ST_DB_ENV_GET_LK_MAX_LOCKERS 1
-#define HAVE_ST_DB_ENV_GET_LK_MAX_LOCKS 1
-#define HAVE_ST_DB_ENV_GET_LK_MAX_OBJECTS 1
-#define HAVE_ST_DB_ENV_GET_MP_MMAPSIZE 1
-#define HAVE_ST_DB_ENV_GET_OPEN_FLAGS 1
-#define HAVE_ST_DB_ENV_GET_SHM_KEY 1
-#define HAVE_ST_DB_ENV_GET_TMP_DIR 1
-#define HAVE_ST_DB_ENV_GET_TIMEOUT 1
-#define HAVE_ST_DB_ENV_GET_TX_MAX 1
-#define HAVE_ST_DB_ENV_GET_TX_TIMESTAMP 1
-#define HAVE_ST_DB_ENV_REP_GET_NSITES 1
-#define HAVE_ST_DB_ENV_REP_GET_PRIORITY 1
-#define HAVE_ST_DB_ENV_LOG_PUT 1
-#define HAVE_ST_DB_ENV_LOG_FLUSH 1
-#define HAVE_ST_DB_ENV_LOG_CURSOR 1
-#define HAVE_ST_DB_ENV_LOG_FILE 1
-#define HAVE_ST_DB_ENV_LOG_FLUSH 1
-#define HAVE_ST_DB_ENV_SET_FEEDBACK 1
-#define HAVE_ST_DB_ENV_SET_APP_DISPATCH 1
-#define HAVE_ST_DB_ENV_SET_TIMEOUT 1
-#define HAVE_ST_DB_ENV_SET_ENCRYPT 1
-#define HAVE_ST_DB_ENV_REP_ELECT 1
-#define HAVE_ST_DB_ENV_REP_START 1
-#define HAVE_ST_DB_ENV_REP_PROCESS_MESSAGE 1
-#define HAVE_ST_DB_ENV_REP_SET_LIMIT 1
-#define HAVE_ST_DB_ENV_SET_MSGCALL 1
-#define HAVE_ST_DB_ENV_SET_THREAD_ID 1
-#define HAVE_ST_DB_ENV_SET_THREAD_ID_STRING 1
-#define HAVE_ST_DB_ENV_SET_ISALIVE 1
-#define HAVE_ST_DB_ENV_SET_SHM_KEY 1
-#define HAVE_ST_DB_ENV_REP_SET_NSITES 1
-#define HAVE_ST_DB_ENV_REP_SET_PRIORITY 1
-#define HAVE_ST_DB_ENV_REP_SET_CONFIG 1
-#define HAVE_ST_DB_ENV_REP_SET_TIMEOUT 1
-#define HAVE_ST_DB_ENV_REP_SET_TRANSPORT 1
-#define HAVE_ST_DB_ENV_REPMGR_SET_LOCAL_SITE 1
-#define HAVE_ST_DB_ENV_REPMGR_ADD_REMOTE_SITE 1
-#define HAVE_ST_DB_ENV_REPMGR_SET_ACK_POLICY 1
-#define HAVE_ST_DB_ENV_REPMGR_START 1
-#define HAVE_ST_DB_ENV_SET_EVENT_NOTIFY 1
-#define HAVE_ST_DB_ENV_SET_CACHESIZE 1
-#define HAVE_ST_DB_ENV_SET_TX_TIMESTAMP 1
-#define HAVE_ST_DB_ENV_SET_VERBOSE 1
-#define HAVE_ST_DB_ENV_LK_DETECT 1
-#define HAVE_ST_DB_ENV_SET_LK_DETECT 1
-#define HAVE_ST_DB_ENV_LK_MAX 1
-#define HAVE_ST_DB_ENV_LK_CONFLICTS 1
-#define HAVE_ST_DB_ENV_SET_LK_CONFLICTS 1
-#define HAVE_ST_DB_ENV_SET_TIMEOUT 1
-#define HAVE_ST_DB_ENV_SET_LK_MAX_LOCKS 1
-#define HAVE_ST_DB_ENV_SET_LK_MAX_LOCKERS 1
-#define HAVE_ST_DB_ENV_SET_LK_MAX_OBJECTS 1
-#define HAVE_ST_DB_ENV_SET_LG_BSIZE 1
-#define HAVE_ST_DB_ENV_SET_DATA_DIR 1
-#define HAVE_ST_DB_ENV_SET_LG_DIR 1
-#define HAVE_ST_DB_ENV_SET_TMP_DIR 1
-#define HAVE_ST_DB_ENV_SET_RPC_SERVER 1
-#define HAVE_ST_DB_ENV_SET_FLAGS 1
-#define HAVE_ST_DB_ENV_CLOSE 1
-#define HAVE_ST_DB_ENV_SET_ALLOC 1
-#define HAVE_ST_DB_ENV_SET_ERRCALL 1
-#define HAVE_ST_DB_ENV_LSN_RESET 1
-#define HAVE_ST_DB_ENV_FILEID_RESET 1
-#define HAVE_ST_DB_ENV_FAILCHK 1
-#define HAVE_ST_DB_ENV_REP_SYNC 1
-#define HAVE_ST_DB_ENV_REP_STAT 1
-#define HAVE_DB_ENV_SET_FUNC_YIELD 1
-#define HAVE_DB_ENV_SET_FUNC_SLEEP 1
-#define HAVE_DB_ENV_CREATE 1
-#define HAVE_ST_DB_ENV_OPEN 1
-#define HAVE_DB_ENV_ERRCALL_3 1
-#define HAVE_ST_DB_ENV_LOG_STAT 1
-#define HAVE_ST_DB_ENV_LOG_ARCHIVE 1
-#define HAVE_DB_CURSOR_4 1
-#define HAVE_DB_ENV_REP_ELECT_4 1
-#define HAVE_DB_ENV_REP_PROCESS_MESSAGE_5 1
-#define HAVE_ST_DB_LOG_STAT_ST_LG_BSIZE 1
-#define HAVE_ST_DB_LOG_STAT_ST_LG_SIZE 1
-#define HAVE_ST_DB_LOG_STAT_ST_WCOUNT_FILL 1
-#define HAVE_ST_DB_LOG_STAT_ST_DISK_FILE 1
-#define HAVE_ST_DB_LOG_STAT_ST_DISK_OFFSET 1
-#define HAVE_ST_DB_LOG_STAT_ST_MAXCOMMITPERFLUSH 1
-#define HAVE_ST_DB_LOG_STAT_ST_MINCOMMITPERFLUSH 1
-#define HAVE_ST_DB_BTREE_STAT_BT_NKEYS 1
-#define HAVE_ST_DB_BTREE_STAT_BT_NDATA 1
-#define HAVE_ST_DB_BTREE_STAT_BT_PAGECNT 1
-#define HAVE_DB_STAT_4 1
-#define HAVE_DB_CURSOR_4 1
-#define HAVE_ST_DB_ENV_LOCK_ID_FREE 1
-#define HAVE_ST_DB_ENV_LOCK_ID 1
-#define HAVE_ST_DB_ENV_LOCK_DETECT 1
-#define HAVE_ST_DB_ENV_LOCK_STAT 1
-#define HAVE_ST_DB_ENV_LOCK_GET 1
-#define HAVE_ST_DB_ENV_LOCK_VEC 1
-#define HAVE_ST_DB_ENV_LOCK_PUT 1
-#define HAVE_ST_DB_LOCK_STAT_ST_ID 1
-#define HAVE_ST_DB_LOCK_STAT_ST_LOCK_NOWAIT 1
-#define HAVE_ST_DB_LOCK_STAT_ST_LOCK_WAIT 1
-#define HAVE_ST_DB_LOCK_STAT_ST_OBJS_NOWAIT 1
-#define HAVE_ST_DB_LOCK_STAT_ST_OBJS_WAIT 1
-#define HAVE_ST_DB_LOCK_STAT_ST_LOCKERS_NOWAIT 1
-#define HAVE_ST_DB_LOCK_STAT_ST_LOCKERS_WAIT 1
-#define HAVE_ST_DB_LOCK_STAT_ST_LOCKS_NOWAIT 1
-#define HAVE_ST_DB_LOCK_STAT_ST_LOCKS_WAIT 1
-#define HAVE_ST_DB_LOCKREQ_TIMEOUT 1
-#define HAVE_ST_DB_TXN_ABORT 1
-#define HAVE_ST_DB_TXN_COMMIT 1
-#define HAVE_ST_DB_TXN_ID 1
-#define HAVE_ST_DB_TXN_PREPARE 1
-#define HAVE_ST_DB_TXN_DISCARD 1
-#define HAVE_ST_DB_TXN_SET_TIMEOUT 1
-#define HAVE_ST_DB_TXN_SET_NAME 1
-#define HAVE_ST_DB_ENV_TXN_BEGIN 1
-#define HAVE_ST_DB_ENV_TXN_CHECKPOINT 1
-#define HAVE_ST_DB_ENV_TXN_RECOVER 1
-#define HAVE_ST_DB_ENV_TXN_STAT 1
-#define HAVE_ST_DB_ENV_DBREMOVE 1
-#define HAVE_ST_DB_ENV_DBRENAME 1
-#define HAVE_ST_DB_ENV_SET_TX_MAX 1
-#define HAVE_ST_DB_TXN_STAT_ST_MAXNACTIVE 1
-#define HAVE_ST_DB_TXN_STAT_ST_REGSIZE 1
-#define HAVE_ST_DB_TXN_STAT_ST_REGION_WAIT 1
-#define HAVE_ST_DB_TXN_STAT_ST_REGION_NOWAIT 1
-#define HAVE_ST_DB_TXN_STAT_ST_LAST_CKP 1
-#define HAVE_ST_DB_TXN_STAT_ST_NRESTORES 1
-#define HAVE_ST_DB_TXN_ACTIVE_TID 1
-#define HAVE_ST_DB_TXN_ACTIVE_NAME 1
-#define HAVE_ST_DB_TXN_ACTIVE_PARENTID 1
-#define HAVE_ENV_REP_TRANSPORT_6 1
-#define HAVE_DB_ENV_REP_PROCESS_MESSAGE_ENVID 1
-#define HAVE_DBXML_INTERFACE 0
-#define HAVE_CONST_DB_CACHED_COUNTS 0
-#define HAVE_CONST_DB_CHECKPOINT 0
-#define HAVE_CONST_DB_CHKSUM_SHA1 0
-#define HAVE_CONST_DB_CLIENT 0
-#define HAVE_CONST_DB_CONFIG 0
-#define HAVE_CONST_DB_CURLSN 0
-#define HAVE_CONST_DB_FIXEDLEN 0
-#define HAVE_CONST_DB_HOME 0
-#define HAVE_CONST_DB_INCOMPLETE 0
-#define HAVE_CONST_DB_LOCK_CONFLICT 0
-#define HAVE_CONST_DB_LOCK_NOTHELD 0
-#define HAVE_CONST_DB_LOG_AUTO_REMOVE 0
-#define HAVE_CONST_DB_LOG_DIRECT 0
-#define HAVE_CONST_DB_LOG_DSYNC 0
-#define HAVE_CONST_DB_LOG_IN_MEMORY 0
-#define HAVE_CONST_DB_LOG_ZERO 0
-#define HAVE_CONST_DB_MPOOL_CLEAN 0
-#define HAVE_CONST_DB_MPOOL_PRIVATE 0
-#define HAVE_CONST_DB_PAD 0
-#define HAVE_CONST_DB_RECORDCOUNT 0
-#define HAVE_CONST_DB_REP_FULL_ELECTION 0
-#define HAVE_CONST_DB_REP_LOGSONLY 0
-#define HAVE_CONST_DB_REP_OUTDATED 0
-#define HAVE_CONST_DB_VERB_CHKPOINT 0
-#define HAVE_CONST_DB_REP_CONF_LEASE 0
-#define HAVE_CONST_DB_REP_HEARTBEAT_MONITOR 0
-#define HAVE_CONST_DB_REP_HEARTBEAT_SEND 0
-#define HAVE_TYPE_DB_INFO 0
-#define HAVE_ST_DB_HASH_STAT_HASH_NRECS 0
-#define HAVE_ST_DB_HASH_STAT_HASH_NELEM 0
-#define HAVE_ST_DB_QUEUE_STAT_QS_NRECS 0
-#define HAVE_ST_DB_QUEUE_STAT_QS_START 0
-#define HAVE_ST_DB_SET_Q_EXTENDSIZE 0
-#define HAVE_ST_DB_BYTESWAPPED 0
-#define HAVE_ST_DB_SET_CACHE_PRIORITY 0
-#define HAVE_ST_DB_ENV_GET_REP_LIMIT 0
-#define HAVE_ST_DB_ENV_GET_REP_NSITES 0
-#define HAVE_ST_DB_ENV_GET_TAS_SPINS 0
-#define HAVE_ST_DB_ENV_LG_INFO 0
-#define HAVE_ST_DB_ENV_SET_REP_TRANSPORT 0
-#define HAVE_ST_DB_ENV_SET_TXN_TIMEOUT 0
-#define HAVE_ST_DB_ENV_SET_LOCK_TIMEOUT 0
-#define HAVE_ST_DB_ENV_SET_REP_LIMIT 0
-#define HAVE_ST_DB_ENV_REPMGR_SET_SITE_LIST 0
-#define HAVE_ST_DB_ENV_SET_INTERMEDIATE_DIR_MODE 0
-#define HAVE_ST_DB_ENV_SET_REGION_INIT 0
-#define HAVE_ST_DB_ENV_SET_TAS_SPINS 0
-#define HAVE_ST_DB_ENV_DB_VERBOSE 0
-#define HAVE_ST_DB_ENV_SET_LK_MAX 0
-#define HAVE_ST_DB_ENV_LG_MAX 0
-#define HAVE_ST_DB_ENV_SET_SERVER 0
-#define HAVE_ST_DB_ENV_SET_FUNC_SLEEP 0
-#define HAVE_ST_DB_ENV_SET_FUNC_YIELD 0
-#define HAVE_ST_DB_ENV_LOG_SET_CONFIG 0
-#define HAVE_ST_DB_ENV_FIDP 0
-#define HAVE_ST_DB_ENV_REP_SET_CLOCKSKEW 0
-#define HAVE_ST_DB_ENV_REP_SET_REQUEST 0
-#define HAVE_DB_ENV_SET_REGION_INIT 0
-#define HAVE_DB_APPINIT 0
-#define HAVE_DB_JUMP_SET 0
-#define HAVE_ENV_OPEN_DB_CONFIG 0
-#define HAVE_ENV_REMOVE_4 0
-#define HAVE_ST_DB_ENV_LOG_REGISTER 0
-#define HAVE_DB_LOG_REGISTER_4 0
-#define HAVE_DB_LOG_REGISTER 0
-#define HAVE_ST_DB_ENV_LOG_UNREGISTER 0
-#define HAVE_DB_LOG_UNREGISTER 0
-#define HAVE_DB_ENV_REP_ELECT_7 0
-#define HAVE_DB_ENV_REP_ELECT_5 0
-#define HAVE_DB_ENV_REP_PROCESS_MESSAGE_4 0
-#define HAVE_ST_DB_LOG_STAT_ST_REFCNT 0
-#define HAVE_ST_DB_LOG_STAT_ST_LG_MAX 0
-#define HAVE_ST_DB_LOG_STAT_ST_FLUSHCOMMIT 0
-#define HAVE_ST_DB_BTREE_STAT_BT_NRECS 0
-#define HAVE_ST_DB_ENV_LK_INFO 0
-#define HAVE_ST_DB_LOCK_STAT_ST_LASTID 0
-#define HAVE_ST_DB_LOCK_STAT_ST_NNOWAITS 0
-#define HAVE_ST_DB_LOCK_STAT_ST_NCONFLICTS 0
-#define HAVE_ST_DB_ENV_TX_INFO 0
-#define HAVE_ST_DB_TXN_STAT_ST_PENDING_CKP 0
-#define HAVE_TXN_RECOVER 0
diff -Nru ruby-bdb-0.6.5/src/bdb.h ruby-bdb-0.6.6/src/bdb.h
--- ruby-bdb-0.6.5/src/bdb.h 2011-05-25 08:07:14.000000000 +0000
+++ ruby-bdb-0.6.6/src/bdb.h 2011-04-06 19:35:39.000000000 +0000
@@ -1,9 +1,13 @@
+#include abort()txn_abort()assoc(db, ...)associate(db, ...)txn_assoc(db, ...)begin(flags = 0, db, ...) { |txn, db, ...| ...}begin(flags = 0, db, ...)txn_begin(flags = 0, db, ...)env.begin(db) do |txn, b|
-...
-end
-
-is the same than
-
-env.begin do |txn|
- b = txn.assoc(db)
- ...
-end
-commit(flags = 0)close(flags = 0)txn_commit(flags = 0)txn_close(flags = 0)discardtxn_discarddbremove(file, database = nil, flags = 0)dbrename(file, database, newname, flags = 0)id()txn_id()open_db(type, name = nil, subname = nil, flags = 0, mode = 0)prepare()txn_prepare()prepare(id) # version 3.3.11txn_prepare(id) # version 3.3.11name # version 4.4name=(string) # version 4.4
- default=-4.2,42,-4.1,41,-4.0,-4,40,4,3,2,
+ --with-db-version=
+ default=auto-detected if above values include one, or suffixes
+ of all supported versions)
--with-db-uniquename=