Set the DB_RENUMBER flag in the database handle if you want
                db_vector<> to work like
                std::vector or std::deque.  Do not set
                DB_RENUMBER if you want db_vector<> to work like
                std::list. Note that without DB_RENUMBER set,
                db_vector<> can work faster.
            
                For example, to construct a fast std::queue/std::stack object, you only need a
                db_vector<> object whose database handle does not have
                DB_RENUMBER set.  Of course, if the database handle has DB_RENUMBER set, it
                still works for this kind of scenario, just not as fast.
            
                db_vector does not check whether DB_RENUMBER is set.  If
                you do not set it, db_vector<> will not work like
                std::vector<>/std::deque<> with regard to operator[], because the
                indices are not maintained in that case.
            
                You can find example code showing how to use this feature in the
                StlAdvancedFeaturesExample::queue_stack() method.
            
                Just as is the case with std::vector, inserting/deleting in
                the middle of a db_vector is slower than doing the same
                action at the end of the sequence. This is because the underlying DB_RECNO DB (with
                the DB_RENUMBER flag set) is relatively slow when inserting/deleting in the middle
                or the head — it has to update the index numbers of all the records following
                the one that was inserted/deleted. If you do not need to keep the index ordered on
                insert/delete, you can use db_map instead.
            
                db_vector also contains methods inherited from
                std::list and std::deque,
                including std::list<>'s unique methods
                remove(), remove_if(),
                unique(), merge(),
                sort(), reverse(), and
                splice(). These use the identical semantics/behaviors
                of the std::list<> methods, although
                pushing/deleting at the head is slower than the
                std::deque and std::list 
                equivalent when there are quite a lot of elements in the database.
            
                You can use std::queue,
                std::priority_queue and std::stack
                container adapters with db_vector; they work with db_vector
                even without DB_RENUMBER set.
            
        db_map contains the union of method set from
        std::map and hash_map, but there are some
        methods that can only be called on containers backed by DB_BTREE or
        DB_HASH databases.  You can call
        db_map<>::is_hash() to figure out the type of the backing
        database. If you call unsupported methods then an InvalidFunctionCall exception is thrown. 
	
        These are the DB_BTREE specific methods: upper_bound(),
        lower_bound(), key_comp(),
        and value_comp(). The DB_HASH specific methods are
        key_eq(), hash_funct().