DatabaseManagerImpl Class Reference

#include <DatabaseManagerImpl.h>

Inheritance diagram for DatabaseManagerImpl:

[legend]Collaboration diagram for DatabaseManagerImpl:

[legend]

Public Member Functions
Database *	db ()
Database *	sysDb ()
void	setSysDb (Database *db)
void	setDb (Database *db)
void	setProcSlot ()
TransactionManager *	txnMgr ()
LockManager *	lockMgr ()
DbRetVal	createDatabase (const char *name, size_t size)
DbRetVal	deleteDatabase (const char *name)
DbRetVal	openDatabase (const char *name)
DbRetVal	closeDatabase ()
DbRetVal	createTable (const char *name, TableDef &def)
	creates a table in the database
DbRetVal	dropTable (const char *name)
	deletes a table from the database
Table *	openTable (const char *name)
	opens a table for processing
void	closeTable (Table *table)
	closes the table handle passed
DbRetVal	createIndex (const char *indName, IndexInitInfo *info)
	creates an index on the specified table.
DbRetVal	dropIndex (const char *name)
	deletes the index object
List	getAllTableNames ()
	Returns all the tables as list.
DbRetVal	registerThread ()
DbRetVal	deregisterThread ()
bool	isAnyOneRegistered ()
void	printUsageStatistics ()
void	printDebugLockInfo ()
void	printDebugTransInfo ()
void	printDebugChunkInfo ()
void	printDebugProcInfo ()
DbRetVal	printIndexInfo (char *name)
Friends
class	SessionImpl

---

Detailed Description

Definition at line 45 of file DatabaseManagerImpl.h.

---

Member Function Documentation

DbRetVal DatabaseManagerImpl::closeDatabase

(

)

Definition at line 293 of file DatabaseManagerImpl.cxx.

References DM_Database, Mutex::getLock(), Database::getMetaDataPtr(), Database::getName(), logFinest, logger, ProcessManager::mutex, ProcessManager::noThreads, OK, printDebug, Mutex::releaseLock(), os::shm_detach(), and SYSTEMDB.

Referenced by SessionImpl::close().

{

    if (NULL == db_) 
    {
        //Database is already closed
        return OK;
    }
    printDebug(DM_Database, "Closing database: %s",(char*)db_->getName());
    //check if this is the last thread to be deregistered
    int ret = ProcessManager::mutex.getLock(-1, false);
    //If you are not getting lock ret !=0, it means somebody else is there.
    //he will close the database.
    if (ret == 0) {
    //printf("PRABA::FOR DEBUG closedb %d %s\n", ProcessManager::noThreads, (char*)db_->getName());
    if (ProcessManager::noThreads == 0 && 0 == strcmp((char*)db_->getName(), SYSTEMDB)
       || ProcessManager::noThreads == 1 && 0 != strcmp((char*)db_->getName(),  SYSTEMDB) )  {
                os::shm_detach((char*)db_->getMetaDataPtr());
            }
    }
    ProcessManager::mutex.releaseLock(-1, false);
    logFinest(logger, "Closed database");
    delete db_;
    db_ = NULL;
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DatabaseManagerImpl::closeTable

(

Table *

table

)

[virtual]

closes the table handle passed

Parameters:

table

handle to the table

Implements DatabaseManager.

Definition at line 724 of file DatabaseManagerImpl.cxx.

References DM_Database, logFinest, logger, and printDebug.

Referenced by main().

{
    printDebug(DM_Database,"Closing table handle: %x", table);
    if (NULL == table) return;
    //table->unlock();
    delete table;
    logFinest(logger, "Closing Table");
}

Here is the caller graph for this function:

DbRetVal DatabaseManagerImpl::createDatabase	(	const char *	name,
		size_t	size
	)

Definition at line 84 of file DatabaseManagerImpl.cxx.

References os::alignLong(), Conf::config, DM_Database, ErrAlready, ErrOS, os::floor(), Config::getMaxSysDbSize(), Config::getSysDbKey(), Config::getUserDbKey(), Database::initAllocDatabaseMutex(), Database::initDatabaseMutex(), Database::initProcessTableMutex(), Database::initTransTableMutex(), logFinest, logger, MAX_CHUNKS, OK, PAGE_SIZE, printDebug, printError, Database::setCurrentPage(), Database::setDatabaseID(), Database::setFirstPage(), Database::setMaxSize(), Database::setMetaDataPtr(), Database::setName(), Database::setNoOfChunks(), os::shm_attach(), os::shm_create(), and SYSTEMDB.

Referenced by SessionImpl::initSystemDatabase().

{
    if (NULL != db_ )
    {
        printError(ErrAlready, "Database is already created");
        return ErrAlready;
    }
    caddr_t rtnAddr = (caddr_t) NULL;
    shared_memory_id shm_id = 0;

    char *startaddr = (char*)Conf::config.getMapAddress();
    shared_memory_key key = 0;
    if (0 == strcmp(name, SYSTEMDB))
    {
        
        key = Conf::config.getSysDbKey();
    }
    else
    {
        startaddr = startaddr + Conf::config.getMaxSysDbSize();
        key = Conf::config.getUserDbKey();
    }
    shm_id = os::shm_create(key, size, 0666);
    if (-1 == shm_id)
    {
                if (errno == EEXIST) {
                        printError(ErrOS, "Shared Memory already exists");
                }
        printError(ErrOS, "Shared memory create failed");
        return ErrOS;
    }

    void *shm_ptr = os::shm_attach(shm_id, startaddr, SHM_RND);
    rtnAddr  = (caddr_t) shm_ptr;
    if (rtnAddr < 0 || shm_ptr == (char*)0xffffffff)
    {
        printError(ErrOS, "Shared memory attach returned -ve value %d", rtnAddr);
        return ErrOS;
    }
    memset(shm_ptr, 0, size );
    db_ = new Database();
    printDebug(DM_Database, "Creating database:%s",name);

    //TODO:for user database do not have transtable and processtable mutex
    db_->setMetaDataPtr((DatabaseMetaData*)rtnAddr);
    db_->setDatabaseID(1);
    db_->setName(name);
    db_->setMaxSize(size);
    db_->setNoOfChunks(0);
    db_->initAllocDatabaseMutex();
    db_->initTransTableMutex();
    db_->initDatabaseMutex();
    db_->initProcessTableMutex();

    //compute the first page after book keeping information
    size_t offset = os::alignLong(sizeof (DatabaseMetaData));
    //Only for system db chunk array, trans array and proc array will be there
    if (0 == strcmp(name, SYSTEMDB))
    {
        offset = offset + os::alignLong( MAX_CHUNKS  * sizeof (Chunk));
        offset = offset + os::alignLong( Conf::config.getMaxProcs()   * sizeof(Transaction));
        offset = offset + os::alignLong( Conf::config.getMaxProcs() * sizeof(ThreadInfo));
    }
    int multiple = os::floor(offset / PAGE_SIZE);
    char *curPage = (((char*)rtnAddr) + ((multiple + 1) * PAGE_SIZE));

    db_->setCurrentPage(curPage);
    db_->setFirstPage(curPage);

    if (0 == strcmp(name, SYSTEMDB)) return OK;

    /*Allocate new chunk to store hash index nodes
    Chunk *chunkInfo = createUserChunk(sizeof(HashIndexNode));
    if (NULL == chunkInfo)
    {
        printError(ErrSysInternal, "Failed to allocate hash index nodes chunk");
        return ErrSysInternal;
    }
    printDebug(DM_Database, "Creating Chunk for storing Hash index nodes %x",
                                                                  chunkInfo);

    db_->setHashIndexChunk(chunkInfo);*/
    logFinest(logger, "Created database %s" , name);

    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

DbRetVal DatabaseManagerImpl::createIndex	(	const char *	indName,
		IndexInitInfo *	info
	)			[virtual]

creates an index on the specified table.

Create appropriate derived class object of IndexInitInfo based on the type of
the index created and pass it to this method.

Parameters:

	indName	index name
	info	IndexInitInfo

Implements DatabaseManager.

Definition at line 733 of file DatabaseManagerImpl.cxx.

References HashIndexInitInfo::bucketSize, ErrBadCall, ErrNotYet, hashIndex, IndexInitInfo::indType, IndexInitInfo::isPrimary, IndexInitInfo::isUnique, IndexInitInfo::list, OK, printError, IndexInitInfo::tableName, and treeIndex.

{
    DbRetVal rv = OK;
    if (!info->isUnique && info->isPrimary) 
    {
        printError(ErrBadCall, "Primary key cannot be non unique\n");
        return ErrBadCall;
    }
    if (info->indType == hashIndex)
    {
        //Assumes info is of type HashIndexInitInfo
        HashIndexInitInfo *hInfo = (HashIndexInitInfo*) info;
        rv = createHashIndex(indName, info->tableName, info->list, hInfo->bucketSize,
                             info->isUnique, info->isPrimary);
    }
    else if (info->indType == treeIndex)
    {
        //TODO::tree index
        printError(ErrNotYet, "Tree Index not supported\n");
        return ErrNotYet;
    }else {
        printError(ErrBadCall, "Index type not supported\n");
        return ErrBadCall;
    }
    return rv;
}

DbRetVal DatabaseManagerImpl::createTable	(	const char *	name,
		TableDef &	def
	)			[virtual]

creates a table in the database

Parameters:

	name	name of the table
	def	table definition

Returns:

DbRetVal

Implements DatabaseManager.

Definition at line 426 of file DatabaseManagerImpl.cxx.

References os::align(), DM_Database, ErrAlready, ErrNoResource, ErrSysInternal, CatalogTableTABLE::getChunkAndTblPtr(), Database::getDatabaseMutex(), TableDef::getFieldCount(), TableDef::getFieldIterator(), TableDef::getTupleSize(), CatalogTableFIELD::insert(), CatalogTableTABLE::insert(), logFinest, logger, OK, printDebug, printError, Database::releaseDatabaseMutex(), and CatalogTableTABLE::remove().

{
    DbRetVal rv = OK;
    int fldCount = def.getFieldCount();
    //If total field count is less than 32, then 1 integer is used to store all null
    //information, if it is more then 1 char is used to store null information 
    //of each field
    //This is to done to reduce cpu cycles for small tables
    int addSize = 0;
    if (fldCount < 31) addSize = 4; else addSize = os::align(fldCount);
    size_t sizeofTuple = os::align(def.getTupleSize())+addSize;

    rv = systemDatabase_->getDatabaseMutex();
    if (OK != rv ) {
        printError(rv, "Unable to get Database mutex");
        return rv;
    }

    void *tptr =NULL;
    void *chunk = NULL;

    //check whether table already exists
    CatalogTableTABLE cTable(systemDatabase_);
    cTable.getChunkAndTblPtr(name, chunk, tptr);
    if (NULL != tptr)
    {
        systemDatabase_->releaseDatabaseMutex();
        printError(ErrAlready, "Table %s already exists", name);
        return ErrAlready;
    }

    //create a chunk to store the tuples
    Chunk *ptr = createUserChunk(sizeofTuple);
    if (NULL  == ptr)
    {
        systemDatabase_->releaseDatabaseMutex();
        printError(ErrNoResource, "Unable to create user chunk");
        return ErrNoResource;
    }
    printDebug(DM_Database,"Created UserChunk:%x", ptr);

    //add row to TABLE
    int tblID = ((Chunk*)ptr)->getChunkID();
    rv = cTable.insert(name, tblID, sizeofTuple,
                                   def.getFieldCount(), ptr, tptr);
    if (OK != rv)
    {
        deleteUserChunk(ptr);
        systemDatabase_->releaseDatabaseMutex();
        printError(ErrSysInternal, "Unable to update catalog table TABLE");
        return ErrSysInternal;
    }
    printDebug(DM_Database,"Inserted into TABLE:%s",name);
    //add rows to FIELD
    FieldIterator iter = def.getFieldIterator();
    CatalogTableFIELD cField(systemDatabase_);
    rv = cField.insert(iter, tblID ,tptr);
    if (OK != rv)
    {
        deleteUserChunk(ptr);
        void *cptr, *ttptr;//Dummy as remove below needs both these OUT params
        cTable.remove(name, cptr, ttptr);
        systemDatabase_->releaseDatabaseMutex();
        printError(ErrSysInternal, "Unable to update catalog table FIELD");
        return ErrSysInternal;
    }
    printDebug(DM_Database,"Inserted into FIELD:%s",name);
    systemDatabase_->releaseDatabaseMutex();
    printDebug(DM_Database,"Table Created:%s",name);
    logFinest(logger, "Table Created %s" , name);
    return OK;
}

Here is the call graph for this function:

Database* DatabaseManagerImpl::db

(

)

[inline]

Definition at line 87 of file DatabaseManagerImpl.h.

Referenced by SessionImpl::initSystemDatabase(), main(), setDb(), and setSysDb().

{ return db_; }

Here is the caller graph for this function:

DbRetVal DatabaseManagerImpl::deleteDatabase

(

const char *

name

)

Definition at line 175 of file DatabaseManagerImpl.cxx.

References Conf::config, logFinest, logger, OK, os::shm_open(), os::shmctl(), and SYSTEMDB.

Referenced by SessionImpl::destroySystemDatabase().

{
    shared_memory_id shm_id = 0;
    if (0 == strcmp(name, SYSTEMDB))
    {
        shm_id = os::shm_open(Conf::config.getSysDbKey(), 100, 0666);
        os::shmctl(shm_id, IPC_RMID);
                delete systemDatabase_;
                systemDatabase_ = NULL;
    } else {
        shm_id = os::shm_open(Conf::config.getUserDbKey(), 100, 0666);
        os::shmctl(shm_id, IPC_RMID);
                delete db_;
                db_ = NULL;
    }
    logFinest(logger, "Deleted database %s" , name);
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

DbRetVal DatabaseManagerImpl::deregisterThread

(

)

Definition at line 1039 of file DatabaseManagerImpl.cxx.

References ProcessManager::deregisterThread(), and OK.

Referenced by SessionImpl::close().

{
    DbRetVal rv = OK;
    if (pMgr_ != NULL) 
    {
        rv = pMgr_->deregisterThread(procSlot);
        delete pMgr_;
        pMgr_ = NULL;
    }
    return rv;
}

Here is the call graph for this function:

Here is the caller graph for this function:

DbRetVal DatabaseManagerImpl::dropIndex

(

const char *

name

)

[virtual]

deletes the index object

Parameters:

name

index name

Implements DatabaseManager.

Definition at line 928 of file DatabaseManagerImpl.cxx.

{
    return dropIndexInt(name, true);
}

DbRetVal DatabaseManagerImpl::dropTable

(

const char *

name

)

[virtual]

deletes a table from the database

Parameters:

name

name of the table

Returns:

DbRetVal

Implements DatabaseManager.

Definition at line 504 of file DatabaseManagerImpl.cxx.

References DM_Database, ErrLockTimeOut, ErrSysInternal, Chunk::free(), CatalogTableTABLE::getChunkAndTblPtr(), Database::getDatabaseMutex(), LockManager::getExclusiveLock(), CatalogTableINDEX::getIndexName(), CatalogTableINDEX::getNumIndexes(), Database::getSystemDatabaseChunk(), logFinest, logger, OK, printDebug, printError, Database::releaseDatabaseMutex(), LockManager::releaseLock(), CatalogTableFIELD::remove(), CatalogTableTABLE::remove(), and UserChunkTableId.

Referenced by main().

{
    void *chunk = NULL;
    void *tptr =NULL;
    DbRetVal rv = systemDatabase_->getDatabaseMutex();
    if (OK != rv) {
        printError(ErrSysInternal, "Unable to get database mutex");
        return ErrSysInternal;
    }

    //remove the entry in TABLE
    CatalogTableTABLE cTable(systemDatabase_);
    rv = cTable.getChunkAndTblPtr(name, chunk, tptr);
    if (OK != rv) {
        systemDatabase_->releaseDatabaseMutex();
        printError(ErrSysInternal, "Table %s does not exist", name);
        return ErrSysInternal;
    }
    rv = lMgr_->getExclusiveLock(chunk, NULL);
    if (rv !=OK)
    {
        systemDatabase_->releaseDatabaseMutex();
        printError(ErrLockTimeOut, "Unable to acquire exclusive lock on the table\n");
        return rv;
    }

    rv = cTable.remove(name, chunk, tptr);
    if (OK != rv) {
        systemDatabase_->releaseDatabaseMutex();
        printError(ErrSysInternal, "Unable to update catalog table TABLE");
        return ErrSysInternal;
    }
    printDebug(DM_Database,"Deleted from TABLE:%s",name);

    //remove the entries in the FIELD table
    CatalogTableFIELD cField(systemDatabase_);
    rv = cField.remove(tptr);
    if (OK != rv) {
        systemDatabase_->releaseDatabaseMutex();
        printError(ErrSysInternal, "Unable to update catalog table FIELD");
        return ErrSysInternal;
    }
    printDebug(DM_Database,"Deleted from FIELD:%s",name);

    rv = deleteUserChunk((Chunk*)chunk);
    if (OK != rv) {
        systemDatabase_->releaseDatabaseMutex();
        printError(rv, "Unable to delete the chunk");
        return rv;
    }
    printDebug(DM_Database,"Deleted UserChunk:%x", chunk);

    //TODO::check whether indexes are available and drop that also.
    CatalogTableINDEX cIndex(systemDatabase_);
    int noIndexes = cIndex.getNumIndexes(tptr);
    for (int i =1 ; i<= noIndexes; i++) {
        char *idxName = cIndex.getIndexName(tptr, 1);
        dropIndexInt(idxName, false);
    }
    Chunk *chunkNode = systemDatabase_->getSystemDatabaseChunk(UserChunkTableId);
    chunkNode->free(systemDatabase_, (Chunk *) chunk);
    systemDatabase_->releaseDatabaseMutex();
    printDebug(DM_Database, "Deleted Table %s" , name);
    logFinest(logger, "Deleted Table %s" , name);
    rv = lMgr_->releaseLock(chunk);
    if (rv !=OK)
    {
        printError(ErrLockTimeOut, "Unable to release exclusive lock on the table\n");
        return rv;
    }
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

List DatabaseManagerImpl::getAllTableNames

(

)

[virtual]

Returns all the tables as list.

Returns:

List of table names

Implements DatabaseManager.

Definition at line 702 of file DatabaseManagerImpl.cxx.

References ErrSysInternal, Database::getDatabaseMutex(), CatalogTableTABLE::getTableList(), OK, printError, and Database::releaseDatabaseMutex().

Referenced by handleEchoAndComment(), and main().

{
    DbRetVal ret = OK;
    //to store the tuple pointer of the table
    void *tptr =NULL;

    DbRetVal rv = systemDatabase_->getDatabaseMutex();
    if (OK != rv) {
        printError(ErrSysInternal, "Unable to get database mutex");
        List tableList;
        return tableList;
    }
    CatalogTableTABLE cTable(systemDatabase_);
    List tableList = cTable.getTableList();
    systemDatabase_->releaseDatabaseMutex();
    return tableList;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool DatabaseManagerImpl::isAnyOneRegistered

(

)

Definition at line 1051 of file DatabaseManagerImpl.cxx.

References ProcessManager::isAnyOneRegistered().

Referenced by main().

{
    if (pMgr_ != NULL) return pMgr_->isAnyOneRegistered();
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

LockManager* DatabaseManagerImpl::lockMgr

(

)

[inline]

Definition at line 94 of file DatabaseManagerImpl.h.

Referenced by SessionImpl::commit(), SessionImpl::rollback(), and SessionImpl::startTransaction().

{ return lMgr_; }

Here is the caller graph for this function:

DbRetVal DatabaseManagerImpl::openDatabase

(

const char *

name

)

Definition at line 198 of file DatabaseManagerImpl.cxx.

References Conf::config, DM_Database, ErrAlready, ErrNotOpen, ErrOS, ErrSysInternal, Mutex::getLock(), Config::getMaxDbSize(), Config::getMaxSysDbSize(), Config::getSysDbKey(), Config::getUserDbKey(), logFinest, logger, ProcessManager::mutex, ProcessManager::noThreads, OK, printDebug, printError, Mutex::releaseLock(), Database::setMetaDataPtr(), os::shm_attach(), os::shm_open(), size, ProcessManager::sysAddr, ProcessManager::systemDatabase, SYSTEMDB, and ProcessManager::usrAddr.

Referenced by SessionImpl::open().

{
    long size = Conf::config.getMaxSysDbSize();
    char *startaddr = (char*)Conf::config.getMapAddress();
    if (0 == strcmp(name , SYSTEMDB))
    {
        if (NULL !=systemDatabase_)
        {
            printError(ErrAlready, "System Database already open");
            return ErrAlready;
        }
    }
    else
    {
        if (NULL ==systemDatabase_)
        {
            printError(ErrNotOpen, "System Database not open");
            return ErrNotOpen;
        }
        size = Conf::config.getMaxDbSize();
        startaddr = startaddr +  Conf::config.getMaxSysDbSize();
    }
    if (NULL != db_)
    {
        printError(ErrAlready, "User Database already open");
        return ErrAlready;
    }
    //system db should be opened before user database files 
    caddr_t rtnAddr = (caddr_t) NULL;

    shared_memory_id shm_id = 0;
    shared_memory_key key = 0;

    if (0 == strcmp(name, SYSTEMDB))
        key = Conf::config.getSysDbKey();
    else
       key = Conf::config.getUserDbKey();


    int ret = ProcessManager::mutex.getLock(-1, false);
    //If you are not getting lock ret !=0, it means somebody else is there.
    //he will close the database.
    if (ret != 0)
    {
        printError(ErrSysInternal, "Another thread calling open:Wait and then Retry\n");
        return ErrSysInternal;
    }
    void *shm_ptr = NULL;
    bool firstThread = false;
    //printf("PRABA::DEBUG:: opendb %d %s\n", ProcessManager::noThreads, name);
    if (ProcessManager::noThreads == 0 && 0 == strcmp(name, SYSTEMDB)
       || ProcessManager::noThreads == 1 && 0 != strcmp(name, SYSTEMDB) ) {
       shm_id = os::shm_open(key, size, 0666);
       if (shm_id == -1 )
       {
           printError(ErrOS, "Shared memory open failed");
           ProcessManager::mutex.releaseLock(-1, false);
           return ErrOS;
       }
       shm_ptr = os::shm_attach(shm_id, startaddr, SHM_RND);
       if (0 == strcmp(name, SYSTEMDB))
       {
             firstThread = true;
             ProcessManager::sysAddr = (char*) shm_ptr;
       }
       else
       {
              ProcessManager::usrAddr = (char*) shm_ptr;
       }
    } else {
        if (0 == strcmp(name, SYSTEMDB))
              shm_ptr = ProcessManager::sysAddr;
        else
              shm_ptr = ProcessManager::usrAddr;
    }
    ProcessManager::mutex.releaseLock(-1, false);


    rtnAddr  = (caddr_t) shm_ptr;

    if (rtnAddr < 0 || shm_ptr == (char*)0xffffffff)
    {
        printError(ErrOS, "Shared memory attach returned -ve value %x %d", shm_ptr, errno);
        return ErrOS;
    } 
    db_ = new Database();
    db_->setMetaDataPtr((DatabaseMetaData*)rtnAddr);

    if (firstThread) ProcessManager::systemDatabase = db_;

    printDebug(DM_Database, "Opening database: %s", name);
    logFinest(logger, "Opened database %s" , name);
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Table * DatabaseManagerImpl::openTable

(

const char *

name

)

[virtual]

opens a table for processing

Parameters:

name

name of the table

Returns:

DbRetVal

Implements DatabaseManager.

Definition at line 578 of file DatabaseManagerImpl.cxx.

References os::align(), TABLE::chunkPtr_, TableImpl::cNotNullInfo, TableImpl::cNullInfo, DM_Database, ErrNotExists, ErrSysInternal, TableImpl::fldList_, CatalogTableTABLE::getChunkAndTblPtr(), Database::getDatabaseMutex(), CatalogTableFIELD::getFieldInfo(), FieldList::getFieldLength(), CatalogTableINDEXFIELD::getFieldNameAndType(), FieldList::getFieldOffset(), CatalogTableINDEX::getIndexPtrs(), CatalogTableINDEX::getIterator(), FieldList::getIterator(), CatalogTableINDEX::getNoOfBuckets(), CatalogTableINDEX::getNumIndexes(), ProcessManager::getThreadTransAddr(), CatalogTableINDEX::getUnique(), FieldIterator::hasElement(), TableImpl::idxInfo, TableImpl::indexPtr_, TableImpl::iNotNullInfo, TableImpl::iNullInfo, TableImpl::isIntUsedForNULL, TABLE::length_, logFinest, logger, ChunkIterator::nextElement(), FieldIterator::nextElement(), TABLE::numFlds_, TableImpl::numIndexes_, TABLE::numIndexes_, OK, printDebug, printError, Database::procSlot, Database::releaseDatabaseMutex(), SETBIT, TableImpl::setDB(), TableImpl::setLockManager(), TableImpl::setSystemDB(), TableImpl::setTableInfo(), TableImpl::setTrans(), TABLE::tblID_, and TABLE::tblName_.

Referenced by main().

{
    DbRetVal ret = OK;
    //TODO::store table handles in list so that if it is
    //not closed by the application. destructor shall close it.
    TableImpl *table = new TableImpl();
    table->setDB(db_);
    table->setSystemDB(systemDatabase_);
    table->setLockManager(lMgr_);
    table->setTrans(ProcessManager::getThreadTransAddr(systemDatabase_->procSlot));

    //to store the chunk pointer of table
    void *chunk = NULL;

    //to store the tuple pointer of the table
    void *tptr =NULL;

    //TODO::need to take shared lock on the table so that
    //all ddl operation will be denied on that table
    //which includes index creation, alter table

    DbRetVal rv = systemDatabase_->getDatabaseMutex();
    if (OK != rv) {
        printError(ErrSysInternal, "Unable to get database mutex");
        delete table;
        return NULL;
    }
    CatalogTableTABLE cTable(systemDatabase_);
    ret = cTable.getChunkAndTblPtr(name, chunk, tptr);
    if ( OK != ret)
    {
        systemDatabase_->releaseDatabaseMutex();
        delete table;
        printError(ErrNotExists, "Table not exists %s", name);
        return NULL;
    }
    TABLE *tTuple = (TABLE*)tptr;
    table->setTableInfo(tTuple->tblName_, tTuple->tblID_, tTuple->length_,
                        tTuple->numFlds_, tTuple->numIndexes_, tTuple->chunkPtr_);
    /*rv = table->lock(true); //take shared lock
    if (rv !=OK)
    {
        printError(ErrLockTimeOut, "Unable to acquire shared lock on the table\n");
        systemDatabase_->releaseDatabaseMutex();
        delete table;
        return NULL;
    }*/


    if (tTuple->numFlds_ < 31) 
    { 
        table->isIntUsedForNULL = true;
        table->iNullInfo = 0;
        table->iNotNullInfo =0;
    }
    else
    {
        table->isIntUsedForNULL = false;
        int noFields = os::align(tTuple->numFlds_);
        table->cNullInfo = (char*) malloc(noFields);
        table->cNotNullInfo = (char*) malloc(noFields);
        for (int i =0 ; i < noFields; i++) table->cNullInfo[i] =0;
        for (int i =0 ; i < noFields; i++) table->cNotNullInfo[i] =0;

    }

    //get field information from FIELD table
    CatalogTableFIELD cField(systemDatabase_);
    cField.getFieldInfo(tptr, table->fldList_);

    //populate the notnull info
    FieldIterator fIter = table->fldList_.getIterator();
    int fldpos=1;
    while (fIter.hasElement())
    {
        FieldDef def = fIter.nextElement();
        if (table->isIntUsedForNULL) {
            if (def.isNull_) SETBIT(table->iNotNullInfo, fldpos);
        }
        else {
            if (def.isNull_) table->cNotNullInfo[fldpos-1] = 1;
        }
        fldpos++;
   } 

    //get the number of indexes on this table
    //and populate the indexPtr array
    CatalogTableINDEX cIndex(systemDatabase_);
    table->numIndexes_ = cIndex.getNumIndexes(tptr);
    if (table->numIndexes_) {
        table->indexPtr_ = new char*[table->numIndexes_];
        table->idxInfo = new IndexInfo*[table->numIndexes_];
    }
    else
    {
        table->indexPtr_ = NULL;
    }
    cIndex.getIndexPtrs(tptr, table->indexPtr_);
    for (int i =0 ; i < table->numIndexes_; i++ )
    {
        SingleFieldHashIndexInfo *hIdxInfo = new SingleFieldHashIndexInfo();
        CatalogTableINDEXFIELD cIndexField(systemDatabase_);
        cIndexField.getFieldNameAndType(table->indexPtr_[i], hIdxInfo->fldName,
                                                      hIdxInfo->type);
        ChunkIterator citer = CatalogTableINDEX::getIterator(table->indexPtr_[i]);
        hIdxInfo->noOfBuckets = CatalogTableINDEX::getNoOfBuckets(table->indexPtr_[i]);
        hIdxInfo->isUnique = CatalogTableINDEX::getUnique(table->indexPtr_[i]);
        hIdxInfo->buckets = (Bucket*)citer.nextElement();
        hIdxInfo->offset = table->fldList_.getFieldOffset(hIdxInfo->fldName);
        hIdxInfo->length = table->fldList_.getFieldLength(hIdxInfo->fldName);
        table->idxInfo[i] = (IndexInfo*) hIdxInfo;
    }
    systemDatabase_->releaseDatabaseMutex();
   // lMgr->  tTuple->chunkPtr_
    printDebug(DM_Database,"Opening table handle name:%s chunk:%x numIndex:%d",
                                         name, chunk, table->numIndexes_);
    logFinest(logger, "Opening Table %s" , name);

        
    return table;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DatabaseManagerImpl::printDebugChunkInfo

(

)

Definition at line 1078 of file DatabaseManagerImpl.cxx.

{
    printf("<NotYetImplemented> </NotYetImplemented>\n");
}

void DatabaseManagerImpl::printDebugLockInfo

(

)

Definition at line 1065 of file DatabaseManagerImpl.cxx.

References LockManager::printDebugInfo().

Referenced by main().

{
    lMgr_->printDebugInfo();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DatabaseManagerImpl::printDebugProcInfo

(

)

Definition at line 1074 of file DatabaseManagerImpl.cxx.

References ProcessManager::printDebugInfo().

Referenced by main().

{
    pMgr_->printDebugInfo();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DatabaseManagerImpl::printDebugTransInfo

(

)

Definition at line 1070 of file DatabaseManagerImpl.cxx.

References TransactionManager::printDebugInfo().

Referenced by main().

{
    tMgr_->printDebugInfo(systemDatabase_);
}

Here is the call graph for this function:

Here is the caller graph for this function:

DbRetVal DatabaseManagerImpl::printIndexInfo

(

char *

name

)

Definition at line 999 of file DatabaseManagerImpl.cxx.

References CatalogTableINDEX::get(), CatalogTableINDEX::getNoOfBuckets(), Chunk::getTotalDataNodes(), CatalogTableINDEX::getUnique(), OK, and Chunk::totalPages().

Referenced by main().

{
    CatalogTableINDEX cIndex(systemDatabase_);
    DbRetVal rv = OK;
    void *chunk = NULL, *hchunk = NULL;
    void *tptr =NULL;
    rv = cIndex.get(name, chunk, hchunk, tptr);
    if (OK != rv) return rv;
    printf("<IndexName> %s </IndexName>\n", name);
    printf("<Unique> %d </Unique>\n", CatalogTableINDEX::getUnique(tptr));
    Chunk *ch = (Chunk*) chunk;
    printf("<HashBucket>\n");
    printf("  <TotalPages> %d </TotalPages>\n", ch->totalPages());
    printf("  <TotalBuckets> %d </TotalBuckets> \n", CatalogTableINDEX::getNoOfBuckets(tptr));
    printf("</HashBucket>\n");

    ch = (Chunk*) hchunk;
    printf("<IndexNodes>\n");
    printf("  <TotalPages> %d </TotalPages>\n", ch->totalPages());
    printf("  <TotalNodes> %d </TotalNodes>\n", ch->getTotalDataNodes());
    printf("<IndexNodes>\n");
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DatabaseManagerImpl::printUsageStatistics

(

)

Definition at line 1058 of file DatabaseManagerImpl.cxx.

References LockManager::printUsageStatistics(), TransactionManager::printUsageStatistics(), and ProcessManager::printUsageStatistics().

Referenced by main().

{
    pMgr_->printUsageStatistics();
    tMgr_->printUsageStatistics();
    lMgr_->printUsageStatistics();
}

Here is the call graph for this function:

Here is the caller graph for this function:

DbRetVal DatabaseManagerImpl::registerThread

(

)

Definition at line 1023 of file DatabaseManagerImpl.cxx.

References DM_Process, ErrAlready, ProcessManager::getProcSlot(), OK, printDebug, printError, and ProcessManager::registerThread().

Referenced by SessionImpl::open().

{
    DbRetVal rv = OK;
    if (pMgr_ != NULL) 
    {
        printError(ErrAlready, "Process already registered\n");
        return ErrAlready;
    }
    pMgr_ = new ProcessManager();
    rv = pMgr_->registerThread();
    if (rv ==OK) { procSlot = pMgr_->getProcSlot();
        printDebug(DM_Process, "Process registed with slot %d\n", procSlot);
    }
    return rv;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DatabaseManagerImpl::setDb

(

Database *

db

)

[inline]

Definition at line 90 of file DatabaseManagerImpl.h.

References db().

Referenced by SessionImpl::initSystemDatabase().

{ db_ = db; }

Here is the call graph for this function:

Here is the caller graph for this function:

void DatabaseManagerImpl::setProcSlot

(

)

Definition at line 51 of file DatabaseManagerImpl.cxx.

References Database::setProcSlot().

{
systemDatabase_->setProcSlot(procSlot);
db_->setProcSlot(procSlot);
}

Here is the call graph for this function:

void DatabaseManagerImpl::setSysDb

(

Database *

db

)

[inline]

Definition at line 89 of file DatabaseManagerImpl.h.

References db().

Referenced by SessionImpl::initSystemDatabase().

{ systemDatabase_ = db; }

Here is the call graph for this function:

Here is the caller graph for this function:

Database* DatabaseManagerImpl::sysDb

(

)

[inline]

Definition at line 88 of file DatabaseManagerImpl.h.

Referenced by SessionImpl::getSystemDatabase(), SessionImpl::getUserManager(), SessionImpl::initSystemDatabase(), and main().

{ return systemDatabase_; }

Here is the caller graph for this function:

TransactionManager* DatabaseManagerImpl::txnMgr

(

)

[inline]

Definition at line 93 of file DatabaseManagerImpl.h.

Referenced by SessionImpl::commit(), SessionImpl::rollback(), and SessionImpl::startTransaction().

{ return tMgr_; }

Here is the caller graph for this function:

---

Friends And Related Function Documentation

friend class SessionImpl [friend]

Definition at line 123 of file DatabaseManagerImpl.h.

---

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

• include/DatabaseManagerImpl.h
• src/server/DatabaseManagerImpl.cxx

---