chainbase::database Class Reference

#include <chainbase.hpp>

Classes
struct	session

Public Types
enum	open_flags { read_only = 0 , read_write = 1 }
using	database_index_row_count_multiset = std::multiset<std::pair<unsigned, std::string>>

Public Member Functions
	database (const bfs::path &dir, open_flags write=read_only, uint64_t shared_file_size=0, bool allow_dirty=false, pinnable_mapped_file::map_mode=pinnable_mapped_file::map_mode::mapped)
	~database ()
	database (database &&)=default
database &	operator= (database &&)=default
bool	is_read_only () const
void	flush ()
void	set_require_locking (bool enable_require_locking)
session	start_undo_session (bool enabled)
int64_t	revision () const
void	undo ()
void	squash ()
void	commit (int64_t revision)
void	undo_all ()
void	set_revision (uint64_t revision)
template<typename MultiIndexType >
void	add_index ()
pinnable_mapped_file::segment_manager *	get_segment_manager ()
const pinnable_mapped_file::segment_manager *	get_segment_manager () const
size_t	get_free_memory () const
template<typename MultiIndexType >
const generic_index< MultiIndexType > &	get_index () const
template<typename MultiIndexType , typename ByIndex >
auto	get_index () const -> decltype(((generic_index< MultiIndexType > *)(nullptr)) ->indices().template get< ByIndex >())
template<typename MultiIndexType >
generic_index< MultiIndexType > &	get_mutable_index ()
template<typename ObjectType , typename IndexedByType , typename CompatibleKey >
const ObjectType *	find (CompatibleKey &&key) const
template<typename ObjectType >
const ObjectType *	find (oid< ObjectType > key=oid< ObjectType >()) const
template<typename ObjectType , typename IndexedByType , typename CompatibleKey >
const ObjectType &	get (CompatibleKey &&key) const
template<typename ObjectType >
const ObjectType &	get (const oid< ObjectType > &key=oid< ObjectType >()) const
template<typename ObjectType , typename Modifier >
void	modify (const ObjectType &obj, Modifier &&m)
template<typename ObjectType >
void	remove (const ObjectType &obj)
template<typename ObjectType , typename Constructor >
const ObjectType &	create (Constructor &&con)
database_index_row_count_multiset	row_count_per_index () const

Detailed Description

This class

Definition at line 252 of file chainbase.hpp.

Member Typedef Documentation

database_index_row_count_multiset

using chainbase::database::database_index_row_count_multiset = std::multiset<std::pair<unsigned, std::string>>

Definition at line 260 of file chainbase.hpp.

Member Enumeration Documentation

open_flags

enum chainbase::database::open_flags

Enumerator
read_only
read_write

Definition at line 255 of file chainbase.hpp.

                         {
            read_only     = 0,
            read_write    = 1
         };

Constructor & Destructor Documentation

database() [1/2]

database::database	(	const bfs::path &	dir,
		open_flags	write = read_only,
		uint64_t	shared_file_size = 0,
		bool	allow_dirty = false,
		pinnable_mapped_file::map_mode	db_map_mode = pinnable_mapped_file::map_mode::mapped )

Definition at line 12 of file chainbase.cpp.

                                                                :
      _db_file(dir, flags & database::read_write, shared_file_size, allow_dirty, db_map_mode),
      _read_only(flags == database::read_only)
   {
   }

~database()

database::~database

(

)

Definition at line 19 of file chainbase.cpp.

   {
      _index_list.clear();
      _index_map.clear();
   }

database() [2/2]

chainbase::database::database ( database && )

default

Member Function Documentation

add_index()

template<typename MultiIndexType >

void chainbase::database::add_index ( )

inline

Definition at line 344 of file chainbase.hpp.

                          {
            const uint16_t type_id = generic_index<MultiIndexType>::value_type::type_id;
            typedef generic_index<MultiIndexType>          index_type;
            typedef typename index_type::allocator_type    index_alloc;
 
            std::string type_name = boost::core::demangle( typeid( typename index_type::value_type ).name() );
 
            if( !( _index_map.size() <= type_id || _index_map[ type_id ] == nullptr ) ) {
               BOOST_THROW_EXCEPTION( std::logic_error( type_name + "::type_id is already in use" ) );
            }
 
            index_type* idx_ptr = nullptr;
            if( _read_only )
               idx_ptr = _db_file.get_segment_manager()->find_no_lock< index_type >( type_name.c_str() ).first;
            else
               idx_ptr = _db_file.get_segment_manager()->find< index_type >( type_name.c_str() ).first;
            bool first_time_adding = false;
            if( !idx_ptr ) {
               if( _read_only ) {
                  BOOST_THROW_EXCEPTION( std::runtime_error( "unable to find index for " + type_name + " in read only database" ) );
               }
               first_time_adding = true;
               idx_ptr = _db_file.get_segment_manager()->construct< index_type >( type_name.c_str() )( index_alloc( _db_file.get_segment_manager() ) );
             }
 
            idx_ptr->validate();
 
            // Ensure the undo stack of added index is consistent with the other indices in the database
            if( _index_list.size() > 0 ) {
               auto expected_revision_range = _index_list.front()->undo_stack_revision_range();
               auto added_index_revision_range = idx_ptr->undo_stack_revision_range();
 
               if( added_index_revision_range.first != expected_revision_range.first ||
                   added_index_revision_range.second != expected_revision_range.second ) {
 
                  if( !first_time_adding ) {
                     BOOST_THROW_EXCEPTION( std::logic_error(
                        "existing index for " + type_name + " has an undo stack (revision range [" +
                        std::to_string(added_index_revision_range.first) + ", " + std::to_string(added_index_revision_range.second) +
                        "]) that is inconsistent with other indices in the database (revision range [" +
                        std::to_string(expected_revision_range.first) + ", " + std::to_string(expected_revision_range.second) +
                        "]); corrupted database?"
                     ) );
                  }
 
                  if( _read_only ) {
                     BOOST_THROW_EXCEPTION( std::logic_error(
                        "new index for " + type_name +
                        " requires an undo stack that is consistent with other indices in the database; cannot fix in read-only mode"
                     ) );
                  }
 
                  idx_ptr->set_revision( static_cast<uint64_t>(expected_revision_range.first) );
                  while( idx_ptr->revision() < expected_revision_range.second ) {
                     idx_ptr->start_undo_session(true).push();
                  }
               }
            }
 
            if( type_id >= _index_map.size() )
               _index_map.resize( type_id + 1 );
 
            auto new_index = new index<index_type>( *idx_ptr );
            _index_map[ type_id ].reset( new_index );
            _index_list.push_back( new_index );
         }

Here is the call graph for this function:

Here is the caller graph for this function:

commit()

void database::commit

(

int64_t

revision

)

Definition at line 57 of file chainbase.cpp.

   {
      for( auto& item : _index_list )
      {
         item->commit( revision );
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

create()

template<typename ObjectType , typename Constructor >

const ObjectType & chainbase::database::create ( Constructor && con )

inline

Definition at line 519 of file chainbase.hpp.

         {
             CHAINBASE_REQUIRE_WRITE_LOCK("create", ObjectType);
             typedef typename get_index_type<ObjectType>::type index_type;
             return get_mutable_index<index_type>().emplace( std::forward<Constructor>(con) );
         }

Here is the call graph for this function:

Here is the caller graph for this function:

find() [1/2]

template<typename ObjectType , typename IndexedByType , typename CompatibleKey >

const ObjectType * chainbase::database::find ( CompatibleKey && key ) const

inline

Definition at line 458 of file chainbase.hpp.

         {
             CHAINBASE_REQUIRE_READ_LOCK("find", ObjectType);
             typedef typename get_index_type< ObjectType >::type index_type;
             const auto& idx = get_index< index_type >().indices().template get< IndexedByType >();
             auto itr = idx.find( std::forward< CompatibleKey >( key ) );
             if( itr == idx.end() ) return nullptr;
             return &*itr;
         }

Here is the call graph for this function:

Here is the caller graph for this function:

find() [2/2]

template<typename ObjectType >

const ObjectType * chainbase::database::find ( oid< ObjectType > key = oid< ObjectType >() ) const

inline

Definition at line 469 of file chainbase.hpp.

         {
             CHAINBASE_REQUIRE_READ_LOCK("find", ObjectType);
             typedef typename get_index_type< ObjectType >::type index_type;
             return get_index< index_type >().find( key );
         }

Here is the call graph for this function:

flush()

void chainbase::database::flush

(

)

get() [1/2]

template<typename ObjectType , typename IndexedByType , typename CompatibleKey >

const ObjectType & chainbase::database::get ( CompatibleKey && key ) const

inline

Definition at line 477 of file chainbase.hpp.

         {
             CHAINBASE_REQUIRE_READ_LOCK("get", ObjectType);
             auto obj = find< ObjectType, IndexedByType >( std::forward< CompatibleKey >( key ) );
             if( !obj ) {
                std::stringstream ss;
                ss << "unknown key (" << boost::core::demangle( typeid( key ).name() ) << "): " << key;
                BOOST_THROW_EXCEPTION( std::out_of_range( ss.str().c_str() ) );
             }
             return *obj;
         }

Here is the call graph for this function:

get() [2/2]

template<typename ObjectType >

const ObjectType & chainbase::database::get ( const oid< ObjectType > & key = oid< ObjectType >() ) const

inline

Definition at line 490 of file chainbase.hpp.

         {
             CHAINBASE_REQUIRE_READ_LOCK("get", ObjectType);
             auto obj = find< ObjectType >( key );
             if( !obj ) {
                std::stringstream ss;
                ss << "unknown key (" << boost::core::demangle( typeid( key ).name() ) << "): " << key._id;
                BOOST_THROW_EXCEPTION( std::out_of_range( ss.str().c_str() ) );
             }
             return *obj;
         }

Here is the call graph for this function:

get_free_memory()

size_t chainbase::database::get_free_memory ( ) const

inline

Definition at line 419 of file chainbase.hpp.

         {
            return _db_file.get_segment_manager()->get_free_memory();
         }

Here is the call graph for this function:

Here is the caller graph for this function:

get_index() [1/2]

template<typename MultiIndexType >

const generic_index< MultiIndexType > & chainbase::database::get_index ( ) const

inline

Definition at line 425 of file chainbase.hpp.

         {
            CHAINBASE_REQUIRE_READ_LOCK("get_index", typename MultiIndexType::value_type);
            typedef generic_index<MultiIndexType> index_type;
            typedef index_type*                   index_type_ptr;
            assert( _index_map.size() > index_type::value_type::type_id );
            assert( _index_map[index_type::value_type::type_id] );
            return *index_type_ptr( _index_map[index_type::value_type::type_id]->get() );
         }

Here is the call graph for this function:

Here is the caller graph for this function:

get_index() [2/2]

template<typename MultiIndexType , typename ByIndex >

auto chainbase::database::get_index ( ) const -> decltype( ((generic_index<MultiIndexType>*)( nullptr ))->indices().template get<ByIndex>() )

inline

Definition at line 436 of file chainbase.hpp.

         {
            CHAINBASE_REQUIRE_READ_LOCK("get_index", typename MultiIndexType::value_type);
            typedef generic_index<MultiIndexType> index_type;
            typedef index_type*                   index_type_ptr;
            assert( _index_map.size() > index_type::value_type::type_id );
            assert( _index_map[index_type::value_type::type_id] );
            return index_type_ptr( _index_map[index_type::value_type::type_id]->get() )->indices().template get<ByIndex>();
         }

Here is the call graph for this function:

get_mutable_index()

template<typename MultiIndexType >

generic_index< MultiIndexType > & chainbase::database::get_mutable_index ( )

inline

Definition at line 447 of file chainbase.hpp.

         {
            CHAINBASE_REQUIRE_WRITE_LOCK("get_mutable_index", typename MultiIndexType::value_type);
            typedef generic_index<MultiIndexType> index_type;
            typedef index_type*                   index_type_ptr;
            assert( _index_map.size() > index_type::value_type::type_id );
            assert( _index_map[index_type::value_type::type_id] );
            return *index_type_ptr( _index_map[index_type::value_type::type_id]->get() );
         }

Here is the call graph for this function:

Here is the caller graph for this function:

get_segment_manager() [1/2]

pinnable_mapped_file::segment_manager * chainbase::database::get_segment_manager ( )

inline

Definition at line 411 of file chainbase.hpp.

                                                                    {
            return _db_file.get_segment_manager();
         }

Here is the call graph for this function:

Here is the caller graph for this function:

get_segment_manager() [2/2]

const pinnable_mapped_file::segment_manager * chainbase::database::get_segment_manager ( ) const

inline

Definition at line 415 of file chainbase.hpp.

                                                                                {
            return _db_file.get_segment_manager();
         }

Here is the call graph for this function:

is_read_only()

bool chainbase::database::is_read_only ( ) const

inline

Definition at line 267 of file chainbase.hpp.

{ return _read_only; }

modify()

template<typename ObjectType , typename Modifier >

void chainbase::database::modify ( const ObjectType & obj, Modifier && m )

inline

Definition at line 503 of file chainbase.hpp.

         {
             CHAINBASE_REQUIRE_WRITE_LOCK("modify", ObjectType);
             typedef typename get_index_type<ObjectType>::type index_type;
             get_mutable_index<index_type>().modify( obj, m );
         }

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

database & chainbase::database::operator= ( database && )

default

remove()

template<typename ObjectType >

void chainbase::database::remove ( const ObjectType & obj )

inline

Definition at line 511 of file chainbase.hpp.

         {
             CHAINBASE_REQUIRE_WRITE_LOCK("remove", ObjectType);
             typedef typename get_index_type<ObjectType>::type index_type;
             return get_mutable_index<index_type>().remove( obj );
         }

Here is the call graph for this function:

Here is the caller graph for this function:

revision()

int64_t chainbase::database::revision ( ) const

inline

Definition at line 325 of file chainbase.hpp.

                                 {
             if( _index_list.size() == 0 ) return -1;
             return _index_list[0]->revision();
         }

Here is the caller graph for this function:

row_count_per_index()

database_index_row_count_multiset chainbase::database::row_count_per_index ( ) const

inline

Definition at line 526 of file chainbase.hpp.

                                                                      {
            database_index_row_count_multiset ret;
            for(const auto& ai_ptr : _index_map) {
               if(!ai_ptr)
                  continue;
               ret.emplace(make_pair(ai_ptr->row_count(), ai_ptr->type_name()));
            }
            return ret;
         }

Here is the caller graph for this function:

set_require_locking()

void database::set_require_locking

(

bool

enable_require_locking

)

Definition at line 25 of file chainbase.cpp.

   {
#ifdef CHAINBASE_CHECK_LOCKING
      _enable_require_locking = enable_require_locking;
#endif
   }

set_revision()

void chainbase::database::set_revision ( uint64_t revision )

inline

Definition at line 336 of file chainbase.hpp.

         {
             CHAINBASE_REQUIRE_WRITE_LOCK( "set_revision", uint64_t );
             for( auto i : _index_list ) i->set_revision( revision );
         }

Here is the call graph for this function:

Here is the caller graph for this function:

squash()

void database::squash

(

)

Definition at line 49 of file chainbase.cpp.

   {
      for( auto& item : _index_list )
      {
         item->squash();
      }
   }

start_undo_session()

database::session database::start_undo_session

(

bool

enabled

)

Definition at line 73 of file chainbase.cpp.

   {
      if( enabled ) {
         vector< std::unique_ptr<abstract_session> > _sub_sessions;
         _sub_sessions.reserve( _index_list.size() );
         for( auto& item : _index_list ) {
            _sub_sessions.push_back( item->start_undo_session( enabled ) );
         }
         return session( std::move( _sub_sessions ) );
      } else {
         return session();
      }
   }

Here is the caller graph for this function:

undo()

void database::undo

(

)

Definition at line 41 of file chainbase.cpp.

   {
      for( auto& item : _index_list )
      {
         item->undo();
      }
   }

Here is the caller graph for this function:

undo_all()

void database::undo_all

(

)

Definition at line 65 of file chainbase.cpp.

   {
      for( auto& item : _index_list )
      {
         item->undo_all();
      }
   }

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• libraries/chainbase/include/chainbase/chainbase.hpp
• libraries/chainbase/src/chainbase.cpp