lockmgr Namespace Reference

Namespaces
	helpers

Classes
class	TableLockMgrImpl
class	TableSchemaLockMgr
	Locks protecting a physical table object returned from the catalog. Table Metadata Locks prevent incompatible concurrent operations on table objects. For example, before dropping or altering a table, a metadata write lock must be acquired. This prevents concurrent read + drop, concurrent drops, etc. More...
class	InsertDataLockMgr
	Prevents simultaneous inserts into the same table. To allow concurrent Insert/Select queries, Insert queries only obtain a write lock on table data when checkpointing (flushing chunks to disk). Inserts/Data load will take an exclusive (write) lock to ensure only one insert proceeds on each table at a time. More...
class	TableDataLockMgr
	Locks protecting table data. Read queries take a read lock, while write queries (update, delete) obtain a write lock. Note that insert queries do not currently take a write lock (to allow concurrent inserts). Instead, insert queries obtain a write lock on the table metadata to allow existing read queries to finish (and block new ones) before flushing the inserted data to disk. More...
class	TableSchemaLockContainer
class	TableSchemaLockContainer< ReadLock >
class	TableSchemaLockContainer< WriteLock >
class	TableDataLockContainer
class	TableDataLockContainer< WriteLock >
class	TableDataLockContainer< ReadLock >
class	TableInsertLockContainer
class	TableInsertLockContainer< WriteLock >
class	TableInsertLockContainer< ReadLock >
class	MutexTracker
class	TrackedRefLock
class	AbstractLockContainer
class	LockContainerImpl

Typedefs
using	LockedTableDescriptors = std::vector< std::unique_ptr< lockmgr::AbstractLockContainer< const TableDescriptor * >>>
using	MutexTypeBase = heavyai::shared_mutex
using	WriteLockBase = heavyai::unique_lock< MutexTracker >
using	ReadLockBase = heavyai::shared_lock< MutexTracker >
using	WriteLock = TrackedRefLock< WriteLockBase >
using	ReadLock = TrackedRefLock< ReadLockBase >

Functions
void	validate_table_descriptor_after_lock (const TableDescriptor *td_prelock, const Catalog_Namespace::Catalog &cat, const std::string &table_name, const bool populate_fragmenter)
template<typename T >
std::ostream &	operator<< (std::ostream &os, const TableLockMgrImpl< T > &lock_mgr)

Typedef Documentation

using lockmgr::LockedTableDescriptors = typedef std::vector<std::unique_ptr<lockmgr::AbstractLockContainer<const TableDescriptor*>>>

Definition at line 271 of file LockMgr.h.

using lockmgr::MutexTypeBase = typedef heavyai::shared_mutex

Definition at line 38 of file LockMgrImpl.h.

using lockmgr::ReadLock = typedef TrackedRefLock<ReadLockBase>

Definition at line 141 of file LockMgrImpl.h.

using lockmgr::ReadLockBase = typedef heavyai::shared_lock<MutexTracker>

Definition at line 112 of file LockMgrImpl.h.

using lockmgr::WriteLock = typedef TrackedRefLock<WriteLockBase>

Definition at line 140 of file LockMgrImpl.h.

using lockmgr::WriteLockBase = typedef heavyai::unique_lock<MutexTracker>

Definition at line 111 of file LockMgrImpl.h.

Function Documentation

template<typename T >

std::ostream& lockmgr::operator<<	(	std::ostream &	os,
		const TableLockMgrImpl< T > &	lock_mgr
	)

Definition at line 385 of file LockMgrImpl.h.

                                                                            {
  for (const auto& table_key : lock_mgr.getLockedTables()) {
    for (const auto& k : table_key) {
      os << k << " ";
    }
    os << "\n";
  }
  return os;
}

void lockmgr::validate_table_descriptor_after_lock ( const TableDescriptor *  td_prelock, const Catalog_Namespace::Catalog &  cat, const std::string &  table_name, const bool  populate_fragmenter  )

inline

Definition at line 98 of file LockMgr.h.

References Catalog_Namespace::DBMetadata::dbName, Catalog_Namespace::Catalog::getCurrentDB(), and Catalog_Namespace::Catalog::getMetadataForTable().

Referenced by lockmgr::TableSchemaLockContainer< ReadLock >::acquireTableDescriptor(), and lockmgr::TableSchemaLockContainer< WriteLock >::acquireTableDescriptor().

                                                                                 {
  auto td_postlock = cat.getMetadataForTable(table_name, populate_fragmenter);
  if (td_prelock != td_postlock) {
    if (td_postlock == nullptr) {
      throw std::runtime_error("Table/View ID " + table_name + " for catalog " +
                               cat.getCurrentDB().dbName + " does not exist");
    } else {
      // This should be very unusual case where a table has moved
      // read DROP, CREATE kind of pattern
      // but kept same name
      // it is not safe to proceed here as the locking was based on the old
      // chunk attributes of the table, which could belong to a different table now
      throw std::runtime_error("Table/View ID " + table_name + " for catalog " +
                               cat.getCurrentDB().dbName +
                               " changed whilst attempting to acquire table lock");
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function: