Table Class Reference

create new Table object More...

#include <Table.h>

Collaboration diagram for Table:

Public Member Functions
	Table (int64_t idarg)
virtual	~Table ()
void	setname (string namearg)
	set name More...
std::string *	getname ()
	get name More...
int64_t	addfield (fieldtype_e type, int64_t length, std::string name, indextype_e indextype)
	add field/column More...
bool	makerow (vector< fieldValue_s > *fieldVal, std::string *res)
	assemble row string from fields More...
bool	unmakerow (std::string *rowstring, vector< fieldValue_s > *resultFields)
	extract fields from row string More...
void	getrows (vector< int64_t > rowids, locktype_e locktype, int64_t subtransactionid, int64_t pendingcmdid, vector< returnRow_s > *returnRows, vector< int64_t > *lockPendingRowids, int64_t tacmdentrypoint)
	orphan? More...
int64_t	getnextrowid ()
	generate unique, ever-increasing row identifier More...
void	newrow (int64_t newrowid, int64_t subtransactionid, string &row)
	create new row More...
int64_t	updaterow (int64_t rowid, int64_t subtransactionid, string *row)
	modify row More...
int64_t	deleterow (int64_t rowid, int64_t subtransactionid)
	delete row More...
int64_t	deleterow (int64_t rowid, int64_t subtransactionid, int64_t forward_rowid, int64_t forward_engineid)
	delete row part of replacement More...
void	selectrows (vector< int64_t > *rowids, locktype_e locktype, int64_t subtransactionid, int64_t pendingcmdid, vector< returnRow_s > *returnRows, int64_t tacmdentrypoint)
	return rows for select based on index hits More...
locktype_e	assignToLockQueue (int64_t rowid, locktype_e locktype, int64_t subtransactionid, int64_t pendingcmdid, int64_t tacmdentrypoint)
	add subtransactionid to queue waiting to acquire lock on row More...
void	commitRollbackUnlock (int64_t rowid, int64_t subtransactionid, enginecmd_e cmd)

Public Attributes
int64_t	id
std::string	name
int64_t	nextindexid
std::vector< class Field >	fields
boost::unordered_map< int64_t, std::queue< lockQueueRowEntry > >	lockQueue
class Table *	shadowTable
boost::unordered_map < std::string, int64_t >	columnaNameToFieldMap
boost::unordered_map< int64_t, rowdata_s * >	rows
int64_t	rowsize
int64_t	nextrowid
boost::unordered_map< int64_t, forwarderEntry >	forwarderMap

Friends
class	ApiInterface
class	TransactionAgent
class	Engine
class	Transaction
class	SubTransaction
class	UserSchemaMgr

Detailed Description

create new Table object

Parameters

idarg

tableid

Definition at line 75 of file Table.h.

Constructor & Destructor Documentation

Table::Table

(

int64_t

idarg)

Definition at line 31 of file Table.cc.

References name, rowsize, and shadowTable.

                          : id(idarg)
{
    if (id)   // if a real table, create a shadow table with id 0
    {
        shadowTable = new class Table(0);
    }

    name = "";
    rowsize = 0;
}

virtual Table::~Table ( )

inlinevirtual

Definition at line 79 of file Table.h.

References shadowTable.

    {
        if (id)
        {
            delete shadowTable;
        }
    }

Member Function Documentation

int64_t Table::addfield	(	fieldtype_e	type,
		int64_t	length,
		std::string	name,
		indextype_e	indextype
	)

add field/column

Parameters

type	field type
length	length (for CHARX)
name	field name
indextype	index type

Returns

fieldid

Definition at line 52 of file Table.cc.

References BOOL, CHAR, CHARX, columnaNameToFieldMap, fields, FLOAT, INT, Field::length, logfile, name, rowsize, UINT, and VARCHAR.

Referenced by TransactionAgent::TAaddcolumn().

{
    class Field newfield(type, length, indextype, name);

    fields.push_back(newfield);
    columnaNameToFieldMap[name] = fields.size() - 1;

    if (rowsize != -1)
    {
        rowsize += sizeof(bool);

        switch (type)
        {
        case INT:
            rowsize += sizeof(int64_t);
            break;

        case UINT:
            rowsize += sizeof(uint64_t);
            break;

        case BOOL:
            rowsize += sizeof(bool);
            break;

        case FLOAT:
            rowsize += sizeof(long double);

        case CHAR:
            rowsize += sizeof(char);
            break;

        case CHARX:
            rowsize += length;
            break;

        case VARCHAR:
            rowsize = -1;
            break;

        default:
            fprintf(logfile, "anomaly: %i %s %i\n", type, __FILE__, __LINE__);
        }
    }

    return fields.size() - 1;
}

Here is the caller graph for this function:

locktype_e Table::assignToLockQueue	(	int64_t	rowid,
		locktype_e	locktype,
		int64_t	subtransactionid,
		int64_t	pendingcmdid,
		int64_t	tacmdentrypoint
	)

add subtransactionid to queue waiting to acquire lock on row

Parameters

rowid	rowid
locktype	lock type
subtransactionid	subtransactionid
pendingcmdid	pending command by calling Transaction
tacmdentrypoint	entry point back to pending Transaction command

Returns

Definition at line 1047 of file Table.cc.

References getinsertflag(), lockQueue, lockQueueRowEntry::locktype, NOTFOUNDLOCK, lockQueueRowEntry::pendingcmdid, rows, lockQueueRowEntry::subtransactionid, and lockQueueRowEntry::tacmdentrypoint.

Referenced by selectrows().

{
    if (getinsertflag(rows[rowid]->flags)==true)
    {
        return NOTFOUNDLOCK;
    }

    lockQueueRowEntry entry;
    entry.tacmdentrypoint = tacmdentrypoint;
    entry.locktype = locktype;
    entry.pendingcmdid = pendingcmdid;
    entry.subtransactionid = subtransactionid;

    lockQueue[rowid].push(entry);

    return locktype;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Table::commitRollbackUnlock	(	int64_t	rowid,
		int64_t	subtransactionid,
		enginecmd_e	cmd
	)

Definition at line 651 of file Table.cc.

References cleardeleteflag(), clearlockedflag(), clearreplacedeleteflag(), COMMITCMD, rowdata_s::flags, forwarderMap, getdeleteflag(), getinsertflag(), getlocktype(), getreplacedeleteflag(), logfile, rowdata_s::previoussubtransactionid, READLOCK, rowdata_s::readlockHolders, REVERTCMD, ROLLBACKCMD, rows, setreadlock(), shadowTable, UNLOCKCMD, WRITELOCK, and rowdata_s::writelockHolder.

Referenced by SubTransaction::commitRollbackUnlock(), and SubTransaction::processTransactionMessage().

{
    switch (cmd)
    {
    case COMMITCMD:
    {
        rowdata_s &currentRowRef = *rows[rowid];

        if (getlocktype(currentRowRef.flags)==READLOCK) // just unlock
        {
            if (!currentRowRef.readlockHolders->count(subtransactionid))
            {
                printf("%s %i anomaly subtransactionid %li\n", __FILE__,
                       __LINE__, subtransactionid);
                return; // bogus request
            }

            currentRowRef.readlockHolders->erase(subtransactionid);

            if (currentRowRef.readlockHolders->empty()==true)
            {
                clearlockedflag(&currentRowRef.flags);
                delete currentRowRef.readlockHolders;
                currentRowRef.readlockHolders = NULL;
            }

            return;
        }

        if ((getlocktype(currentRowRef.flags) != WRITELOCK) ||
            (currentRowRef.writelockHolder != subtransactionid))
        {
            printf("%s %i anomaly flags %i subtransactionid %li writelockHolder %li rowid %li cmd %i flags %i\n", __FILE__, __LINE__, (int)currentRowRef.flags,
                   subtransactionid, currentRowRef.writelockHolder, rowid, cmd,
                   (int)currentRowRef.flags);
            return; // bogus request
        }

        if (getdeleteflag(currentRowRef.flags)==true)
        {
            if (getreplacedeleteflag(currentRowRef.flags)==true)
            {
                forwarderMap.erase(rowid);
            }

            delete &currentRowRef;
            rows.erase(rowid);

            if (shadowTable->rows.count(rowid))
            {
                delete shadowTable->rows[rowid];
                shadowTable->rows.erase(rowid);
            }

            return;
        }

        if (currentRowRef.readlockHolders != NULL)
        {
            printf("%s %i anomaly: readlockHolders\n", __FILE__, __LINE__);
            boost::unordered_set<int64_t>::const_iterator it;

            for (it = currentRowRef.readlockHolders->begin();
                 it != currentRowRef.readlockHolders->end(); ++it)
            {
                printf("%s %i readlockHolder %li\n", __FILE__, __LINE__, *it);
            }

            delete currentRowRef.readlockHolders;
            currentRowRef.readlockHolders=NULL;
        }

        // only change the row if changes have been made, this covers in case a
        // locked row didn't get modified, but still part of a commit
        if (shadowTable->rows.count(rowid))
        {
            rowdata_s &shadowRowRef = *shadowTable->rows[rowid];
            shadowRowRef.previoussubtransactionid=currentRowRef.writelockHolder;
            shadowRowRef.flags=0;
            shadowRowRef.writelockHolder=0;
            shadowRowRef.readlockHolders=NULL;

            if (rows[rowid]==shadowTable->rows[rowid]) // insert
            {
                shadowTable->rows.erase(rowid);
            }
            else // update
            {
                delete &currentRowRef;
                rows[rowid]=&shadowRowRef;
                shadowTable->rows.erase(rowid);
            }
        }
        else
        {
            printf("%s %i anomaly\n", __FILE__, __LINE__);
            currentRowRef.flags=0;
            currentRowRef.writelockHolder=0;
        }

        /*
          if (shadowTable->rows.count(rowid))
          {
          if (currentRowRef.previoussubtransactionid==0)
          {
          currentRowRef.previoussubtransactionid = currentRowRef.writelockHolder;
          currentRowRef.row = shadowTable->rows[rowid].row;
          }
          else
          { // if update row uses string::copy() then the container's memory will be consumed
          currentRowRef.previoussubtransactionid = currentRowRef.writelockHolder;
          memcpy(&currentRowRef.row[0], &shadowTable->rows[rowid].row[0],
          currentRowRef.row.size());
          }
          shadowTable->rows.erase(rowid);
          }
          currentRowRef.flags = 0;
          currentRowRef.writelockHolder = 0;
        */
    }
    break;

    case ROLLBACKCMD:
    {
        if (!rows.count(rowid))
        {
            return;
        }

        rowdata_s &currentRowRef = *rows[rowid];

        if ((currentRowRef.writelockHolder != subtransactionid) &&
            (getlocktype(currentRowRef.flags) == WRITELOCK))
        {
            fprintf(logfile, "anomaly: %s %i\n", __FILE__, __LINE__);
            return; // bogus request
        }

        if (getinsertflag(currentRowRef.flags)==true)
        {
            delete &currentRowRef;
            rows.erase(rowid);
            shadowTable->rows.erase(rowid);
            // drain Q
            return;
        }

        if (getdeleteflag(currentRowRef.flags)==true)
        {
            if (getreplacedeleteflag(currentRowRef.flags)==true)
            {
                clearreplacedeleteflag(&currentRowRef.flags);
                forwarderMap.erase(rowid);
            }

            cleardeleteflag(&currentRowRef.flags);

            if (shadowTable->rows.count(rowid))
            {
                printf("%s %i anomaly rowid %li\n", __FILE__, __LINE__, rowid);
                delete shadowTable->rows[rowid];
                shadowTable->rows.erase(rowid);
            }
        }

        currentRowRef.writelockHolder = 0;

        if (getlocktype(currentRowRef.flags)==READLOCK)
        {
            currentRowRef.readlockHolders->erase(subtransactionid);

            if (currentRowRef.readlockHolders->empty()==true)
            {
                delete currentRowRef.readlockHolders;
                currentRowRef.readlockHolders = NULL;
            }
        }

        currentRowRef.flags = 0;

        if (currentRowRef.readlockHolders != NULL)
        {
            setreadlock(&currentRowRef.flags);
        }

        if (shadowTable->rows.count(rowid))
        {
            delete shadowTable->rows[rowid];
            shadowTable->rows.erase(rowid);
        }

        // process Q
    }
    break;

    case UNLOCKCMD:
    {
        rowdata_s &currentRowRef = *rows[rowid];

        if (getlocktype(currentRowRef.flags) != READLOCK)
        {
            fprintf(logfile, "anomaly: %s %i\n", __FILE__, __LINE__);
            return; // bogus request
        }

        if (!currentRowRef.readlockHolders->count(subtransactionid))
        {
            fprintf(logfile, "anomaly: %s %i\n", __FILE__, __LINE__);
            return; // bogus request
        }

        currentRowRef.readlockHolders->erase(subtransactionid);

        if (currentRowRef.readlockHolders->empty()==true)
        {
            clearlockedflag(&currentRowRef.flags);
            delete currentRowRef.readlockHolders;
            currentRowRef.readlockHolders = NULL;
        }
    }
    break;

    // REVERTCMD likely broken somehow
    case REVERTCMD:
    {
        // do what rollback does, but don't unlock
        if (!rows.count(rowid))
        {
            return;
        }

        rowdata_s &currentRowRef = *rows[rowid];

        if ((currentRowRef.writelockHolder != subtransactionid) ||
            (getlocktype(currentRowRef.flags) != WRITELOCK))
        {
            fprintf(logfile, "anomaly: %s %i\n", __FILE__, __LINE__);
            return; // bogus request
        }

        if (getinsertflag(currentRowRef.flags)==true)
        {
            rows.erase(rowid);
        }
        else
        {
            currentRowRef.flags = 0;
        }

        forwarderMap.erase(rowid);
        shadowTable->rows.erase(rowid);
    }
    break;

    default:
        fprintf(logfile, "anomaly %i %s %i\n", cmd, __FILE__, __LINE__);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

int64_t Table::deleterow	(	int64_t	rowid,
		int64_t	subtransactionid
	)

delete row

Parameters

rowid	rowid
subtransactionid	subtransactionid

Returns

Definition at line 1026 of file Table.cc.

References rowdata_s::flags, getlocktype(), logfile, rows, setdeleteflag(), STATUS_NOTOK, STATUS_OK, WRITELOCK, and rowdata_s::writelockHolder.

Referenced by SubTransaction::deleterow(), and deleterow().

{
    if (!rows.count(rowid))
    {
        return STATUS_NOTOK;
    }

    rowdata_s &currentRowRef = *rows[rowid];

    if ((getlocktype(currentRowRef.flags) != WRITELOCK) ||
        (currentRowRef.writelockHolder != subtransactionid))
    {
        fprintf(logfile, "anomaly %i %li %s %i\n", currentRowRef.flags,
                currentRowRef.writelockHolder, __FILE__, __LINE__);
        return STATUS_NOTOK;
    }

    setdeleteflag(&currentRowRef.flags);
    return STATUS_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int64_t Table::deleterow	(	int64_t	rowid,
		int64_t	subtransactionid,
		int64_t	forward_rowid,
		int64_t	forward_engineid
	)

delete row part of replacement

Parameters

rowid	rowid
subtransactionid	subtransactionid
forward_rowid	rowid to forward index hits to
forward_engineid	engineid to forward index hits to

Returns

Definition at line 428 of file Table.cc.

References deleterow(), forwarderEntry::engineid, rowdata_s::flags, forwarderMap, forwarderEntry::rowid, rows, setreplacedeleteflag(), and STATUS_OK.

{
    int64_t status = deleterow(rowid, subtransactionid);

    if (status)
    {
        return status;
    }

    rowdata_s &currentRowRef = *rows[rowid];

    setreplacedeleteflag(&currentRowRef.flags);
    forwarderEntry forwarder;
    forwarder.rowid = forward_rowid;
    forwarder.engineid = forward_engineid;
    forwarderMap[rowid] = forwarder;
    return STATUS_OK;
}

Here is the call graph for this function:

string * Table::getname

(

)

get name

Returns

name

Definition at line 47 of file Table.cc.

References name.

{
    return &name;
}

int64_t Table::getnextrowid

(

)

generate unique, ever-increasing row identifier

Returns

next rowid

Definition at line 1006 of file Table.cc.

References nextrowid.

Referenced by SubTransaction::newrow().

{
    return ++nextrowid;
}

Here is the caller graph for this function:

void Table::getrows	(	vector< int64_t >	rowids,
		locktype_e	locktype,
		int64_t	subtransactionid,
		int64_t	pendingcmdid,
		vector< returnRow_s > *	returnRows,
		vector< int64_t > *	lockPendingRowids,
		int64_t	tacmdentrypoint
	)

orphan?

Parameters

rowids
locktype
subtransactionid
pendingcmdid
returnRows
lockPendingRowids
tacmdentrypoint

Definition at line 253 of file Table.cc.

References rowdata_s::flags, getinsertflag(), getlocktype(), lockQueue, lockQueueRowEntry::locktype, logfile, NOLOCK, lockQueueRowEntry::pendingcmdid, READLOCK, rowdata_s::readlockHolders, rowdata_s::row, returnRow_s::row, returnRow_s::rowid, rows, setreadlock(), setwritelock(), lockQueueRowEntry::subtransactionid, lockQueueRowEntry::tacmdentrypoint, WRITELOCK, and rowdata_s::writelockHolder.

{
    if (locktype != NOLOCK)
    {
        lockPendingRowids->clear();
    }

    rowdata_s *currentRowPtr;

    for (size_t n=0; n < rowids.size(); n++)
    {
        int64_t rid = rowids[n];

        if (rows.count(rid))
        {
            currentRowPtr = rows[rid];

            switch (locktype)
            {
            case NOLOCK:
            {
                if (getinsertflag(currentRowPtr->flags)==false)
                {
                    returnRow_s r = {};
                    r.rowid = rid;
                    r.row = currentRowPtr->row;
                    returnRows->push_back(r);
                }
            }
            break;

            case READLOCK:
            {
                switch (getlocktype(currentRowPtr->flags))
                {
                case NOLOCK: // lock it and add create readlockHolders
                {
                    returnRow_s r = {};
                    r.rowid = rid;
                    r.row = currentRowPtr->row;
                    returnRows->push_back(r);
                    setreadlock(&currentRowPtr->flags);
                    currentRowPtr->readlockHolders =
                        new boost::unordered_set<int64_t>;
                    printf("%s %i ROWID %li READLOCKHOLDERS->insert %li\n",
                           __FILE__, __LINE__, rid, subtransactionid);
                    currentRowPtr->readlockHolders->insert(subtransactionid);
                }
                break;

                case READLOCK:
                {
                    printf("%s %i ROWID %li READLOCKHOLDERS->insert %li\n",
                           __FILE__, __LINE__, rid, subtransactionid);
                    currentRowPtr->readlockHolders->insert(subtransactionid);
                    returnRow_s r = {};
                    r.rowid = rid;
                    r.row = currentRowPtr->row;
                    returnRows->push_back(r);
                }
                break;

                case WRITELOCK:
                {
                    // make it pending
                    lockQueueRowEntry qEntry = {};
                    // populate qEntry, d'accord
                    qEntry.pendingcmdid = pendingcmdid;
                    qEntry.tacmdentrypoint = tacmdentrypoint;
                    qEntry.subtransactionid = subtransactionid;
                    qEntry.locktype = READLOCK;
                    lockQueue[rid].push(qEntry);
                    lockPendingRowids->push_back(rid);
                }
                break;

                default:
                    fprintf(logfile, "anomaly: %i %s %i\n",
                            getlocktype(currentRowPtr->flags), __FILE__,
                            __LINE__);
                }
            }
            break;

            case WRITELOCK:
            {
                switch (getlocktype(currentRowPtr->flags))
                {
                case NOLOCK:
                {
                    // lock it & return
                    setwritelock(&currentRowPtr->flags);
                    currentRowPtr->writelockHolder = subtransactionid;
                    returnRow_s r = {};
                    r.rowid = rid;
                    r.row = currentRowPtr->row;
                    returnRows->push_back(r);
                }
                break;

                case READLOCK:
                {
                    // lock pending
                    lockQueueRowEntry qEntry = {};
                    // populate qEntry, d'accord
                    qEntry.pendingcmdid = pendingcmdid;
                    qEntry.tacmdentrypoint = tacmdentrypoint;
                    qEntry.subtransactionid = subtransactionid;
                    qEntry.locktype = WRITELOCK;
                    lockQueue[rid].push(qEntry);
                    lockPendingRowids->push_back(rid);
                }
                break;

                case WRITELOCK:
                {
                    // lock pending
                    lockQueueRowEntry qEntry = {};
                    // populate qEntry, d'accord
                    qEntry.pendingcmdid = pendingcmdid;
                    qEntry.tacmdentrypoint = tacmdentrypoint;
                    qEntry.subtransactionid = subtransactionid;
                    qEntry.locktype = WRITELOCK;
                    lockQueue[rid].push(qEntry);
                    lockPendingRowids->push_back(rid);
                }
                break;

                default:
                    fprintf(logfile, "anomaly: %i %s %i\n",
                            getlocktype(currentRowPtr->flags), __FILE__,
                            __LINE__);
                }
            }
            break;

            default:
                fprintf(logfile, "anomaly: %i %s %i\n", locktype, __FILE__,
                        __LINE__);
            }
        }
    }
}

Here is the call graph for this function:

bool Table::makerow	(	vector< fieldValue_s > *	fieldVal,
		std::string *	res
	)

assemble row string from fields

Parameters

fieldVal	fields
res	resulting string

Returns

success or failure

Definition at line 101 of file Table.cc.

References BOOL, CHAR, CHARX, fields, FLOAT, INT, Field::length, logfile, rowsize, Field::type, UINT, and VARCHAR.

Referenced by Statement::branchtotype(), Statement::continueUpdate(), and Transaction::updateRow().

{
    vector<fieldValue_s> &fieldValRef = *fieldVal;

    if (fieldValRef.size() != fields.size())
    {
        fprintf(logfile, "%s %i anomaly fieldValRef.size() %lu fields.size() %lu\n", __FILE__, __LINE__, (unsigned long)fieldValRef.size(),
                (unsigned long)fields.size());
        return false;
    }

    if (rowsize != -1)
    {
        res->assign(rowsize, 0);
    }
    else
    {
        int64_t rsize = 0;
        bool hasvarchar=false;

        for (size_t n=0; n<fieldValRef.size(); n++)
        {
            rsize += sizeof(bool);
            rowsize += sizeof(bool);

            switch (fields[n].type)
            {
            case INT:
                rsize += sizeof(int64_t);
                break;

            case UINT:
                rsize += sizeof(uint64_t);
                break;

            case BOOL:
                rsize += sizeof(bool);
                break;

            case FLOAT:
                rsize += sizeof(long double);
                break;

            case CHAR:
                rsize += sizeof(char);
                break;

            case CHARX:
                rsize += fields[n].length;
                break;

            case VARCHAR:
                rsize += sizeof(int64_t);
                rsize += fieldValRef[n].str.length();
                hasvarchar=true;
                break;

            default:
                fprintf(logfile, "anomaly: %i %s %i\n", fields[n].type, __FILE__,
                        __LINE__);
            }

        }

        if (hasvarchar==true)
        {
            rowsize=-1;
        }

        res->assign(rsize, 0);
    }

    int64_t pos = 0;

    for (size_t n=0; n<fields.size(); n++)
    {
        if (fieldValRef[n].isnull==false)
        {
            res->operator [](pos++)=0;
        }
        else
        {
            res->operator[](pos++)=1;
            continue;
        }

        switch (fields[n].type)
        {
        case INT:
            memcpy(&res->operator [](pos), &fieldValRef[n].value.integer,
                   sizeof(fieldValRef[n].value.integer));
            pos += sizeof(fieldValRef[n].value.integer);
            break;

        case UINT:
            memcpy(&res->operator [](pos), &fieldValRef[n].value.uinteger,
                   sizeof(fieldValRef[n].value.uinteger));
            pos += sizeof(fieldValRef[n].value.uinteger);
            break;

        case BOOL:
            memcpy(&res->operator [](pos), &fieldValRef[n].value.boolean,
                   sizeof(fieldValRef[n].value.boolean));
            pos += sizeof(fieldValRef[n].value.boolean);
            break;

        case FLOAT:
            memcpy(&res->operator [](pos), &fieldValRef[n].value.floating,
                   sizeof(fieldValRef[n].value.floating));
            pos += sizeof(fieldValRef[n].value.floating);
            break;

        case CHAR:
            memcpy(&res->operator [](pos), &fieldValRef[n].value.character,
                   sizeof(fieldValRef[n].value.character));
            pos += sizeof(fieldValRef[n].value.character);
            break;

        case CHARX:

            // pad if necessary
            if (fieldValRef[n].str.length() < (size_t)fields[n].length)
            {
                fieldValRef[n].str.append(fields[n].length-
                                          fieldValRef[n].str.length(), ' ');
            }

            fieldValRef[n].str.copy(&res->operator [](pos), fields[n].length, 0);
            pos += fields[n].length;
            break;

        case VARCHAR:
        {
            int64_t varcharlength = fieldValRef[n].str.length();
            memcpy(&res->operator [](pos),
                   &varcharlength, sizeof(varcharlength));
            pos += sizeof(varcharlength);
            memcpy(&res->operator [](pos), fieldValRef[n].str.c_str(),
                   varcharlength);
            pos += varcharlength;
        }
        break;

        default:
            fprintf(logfile, "anomaly: %i %s %i\n", fields[n].type, __FILE__,
                    __LINE__);
        }
    }

    return true;
}

Here is the caller graph for this function:

void Table::newrow	(	int64_t	newrowid,
		int64_t	subtransactionid,
		string &	row
	)

create new row

Parameters

newrowid	rowid
subtransactionid	subtransactionid
row	row

Definition at line 1011 of file Table.cc.

References rowdata_s::flags, rowdata_s::row, rows, setinsertflag(), setwritelock(), shadowTable, and rowdata_s::writelockHolder.

Referenced by SubTransaction::newrow().

{
    rowdata_s *nrow = new rowdata_s();
    //  nrow->flags = 0;
    setwritelock(&nrow->flags);
    nrow->writelockHolder = subtransactionid;
    setinsertflag(&nrow->flags);
    //  nrow.previoussubtransactionid = 0;
    nrow->row = row;
    //  nrow.readlockHolders=NULL;

    rows[newrowid] = nrow;
    shadowTable->rows[newrowid] = nrow;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Table::selectrows	(	vector< int64_t > *	rowids,
		locktype_e	locktype,
		int64_t	subtransactionid,
		int64_t	pendingcmdid,
		vector< returnRow_s > *	returnRows,
		int64_t	tacmdentrypoint
	)

return rows for select based on index hits

Parameters

rowids	list of rowids
locktype	lock type
subtransactionid	subtransactionid
pendingcmdid	pending command by calling Transaction
returnRows	return rows
tacmdentrypoint	entry point back to pending Transaction command

Definition at line 448 of file Table.cc.

References assignToLockQueue(), getlocktype(), returnRow_s::locktype, logfile, NOLOCK, NOTFOUNDLOCK, PENDINGLOCK, READLOCK, returnRow_s::row, returnRow_s::rowid, rows, setreadlock(), setwritelock(), and WRITELOCK.

Referenced by SubTransaction::selectrows().

{
    vector<returnRow_s> &returnRowsRef = *returnRows;
    size_t numrowids = rowids->size();
    returnRowsRef.reserve(numrowids);
    returnRow_s workrow;
    int64_t rowid;

    switch (locktype)
    {
    case NOLOCK:
    {
        for (size_t n=0; n<numrowids; n++)
        {
            rowid = rowids->at(n);
            workrow.rowid = rowid;

            if (!rows.count(rowid))
            {
                workrow.row.clear();
                workrow.locktype = NOTFOUNDLOCK;
            }
            else
            {
                switch (getlocktype(rows[rowid]->flags))
                {
                case NOLOCK:
                    break;

                case READLOCK:
                    if (rows[rowid]->readlockHolders->count(subtransactionid))
                    {
                        continue;
                    }

                    break;

                case WRITELOCK:
                    if (rows[rowid]->writelockHolder==subtransactionid)
                    {
                        continue;
                    }

                    break;

                default:
                    printf("%s %i anomaly %i\n", __FILE__, __LINE__,
                           getlocktype(rows[rowid]->flags));
                    continue;
                }

                workrow.row = rows[rowid]->row;
                workrow.locktype = NOLOCK;
            }

            returnRowsRef.push_back(workrow);
        }
    }
    break;

    case READLOCK:
    {
        for (size_t n=0; n<numrowids; n++)
        {
            rowid = rowids->at(n);
            workrow.rowid = rowid;

            if (!rows.count(rowid))
            {
                workrow.row.clear();
                workrow.locktype = NOTFOUNDLOCK;
            }
            else
            {
                switch (getlocktype(rows[rowid]->flags))
                {
                case NOLOCK: // lock it & return row
                    setreadlock(&rows[rowid]->flags);
                    rows[rowid]->readlockHolders =
                        new boost::unordered_set<int64_t>;
                    rows[rowid]->readlockHolders->insert(subtransactionid);
                    workrow.row = rows[rowid]->row;
                    workrow.locktype = READLOCK;
                    break;

                case READLOCK:
                    if (rows[rowid]->readlockHolders->count(subtransactionid))
                    {
                        continue;
                    }
                    else
                    {
                        rows[rowid]->readlockHolders->insert(subtransactionid);
                        workrow.row = rows[rowid]->row;
                        workrow.locktype = READLOCK;
                    }

                    break;

                case WRITELOCK: // pending
                {
                    if (rows[rowid]->writelockHolder==subtransactionid)
                    {
                        continue;
                    }

                    if (assignToLockQueue(rowid, READLOCK, subtransactionid,
                                          pendingcmdid,
                                          tacmdentrypoint)==NOTFOUNDLOCK)
                    {
                        continue;
                    }

                    workrow.row.clear();
                    workrow.locktype = PENDINGLOCK;
                }
                break;

                default:
                    fprintf(logfile, "anomaly: %i %s %i\n",
                            getlocktype(rows[rowid]->flags), __FILE__, __LINE__);
                }
            }

            returnRowsRef.push_back(workrow);
        }
    }
    break;

    case WRITELOCK:
    {
        for (size_t n=0; n<numrowids; n++)
        {
            rowid = rowids->at(n);
            workrow.rowid = rowid;

            if (!rows.count(rowid))
            {
                workrow.row.clear();
                workrow.locktype = NOTFOUNDLOCK;
            }
            else
            {
                switch (getlocktype(rows[rowid]->flags))
                {
                case NOLOCK: // lock it & return row
                    setwritelock(&rows[rowid]->flags);
                    rows[rowid]->writelockHolder = subtransactionid;
                    workrow.row = rows[rowid]->row;
                    workrow.locktype = WRITELOCK;
                    break;

                case READLOCK: // pending
                    if (assignToLockQueue(rowid, WRITELOCK, subtransactionid,
                                          pendingcmdid,
                                          tacmdentrypoint)==NOTFOUNDLOCK)
                    {
                        continue;
                    }

                    workrow.row.clear();
                    workrow.locktype = PENDINGLOCK;
                    break;

                case WRITELOCK: // pending
                    if (subtransactionid == rows[rowid]->writelockHolder)
                    {
                        workrow.row = rows[rowid]->row;
                        workrow.locktype = WRITELOCK;
                    }
                    else
                    {
                        if (assignToLockQueue(rowid, WRITELOCK, subtransactionid,
                                              pendingcmdid,
                                              tacmdentrypoint)==NOTFOUNDLOCK)
                        {
                            continue;
                        }

                        workrow.row.clear();
                        workrow.locktype = PENDINGLOCK;
                    }

                    break;

                default:
                    fprintf(logfile, "anomaly: %i %s %i\n",
                            getlocktype(rows[rowid]->flags), __FILE__, __LINE__);
                }
            }

            returnRowsRef.push_back(workrow);
        }
    }
    break;

    default:
        fprintf(logfile, "anomaly: %i %s %i\n", locktype, __FILE__, __LINE__);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Table::setname

(

string

namearg)

set name

Parameters

namearg

name

Definition at line 42 of file Table.cc.

References name.

{
    name = namearg;
}

bool Table::unmakerow	(	std::string *	rowstring,
		vector< fieldValue_s > *	resultFields
	)

extract fields from row string

Parameters

rowstring	input row
resultFields	resulting fields

Returns

success or failure

Definition at line 911 of file Table.cc.

References BOOL, CHAR, CHARX, fields, FLOAT, INT, Field::length, logfile, rowsize, Field::type, UINT, and VARCHAR.

Referenced by Statement::andPredicate(), Transaction::continueCommitTransaction(), Statement::continueSelect(), Transaction::continueSqlReplace(), Statement::continueUpdate(), TransactionAgent::handledispatch(), ApiInterface::insertRow(), Statement::stagedPredicate(), and Transaction::updateRow().

{
    vector<fieldValue_s> &resultFieldsRef = *resultFields;
    string &rowstringRef = *rowstring;

    size_t pos = 0;
    size_t  numfields = fields.size();
    resultFieldsRef.resize(numfields, fieldValue_s());
    size_t rowsize = rowstringRef.size();

    for (size_t n=0; n < numfields; n++)
    {
        if (pos >= rowsize-1)   // remember the bool for isnull or not
        {
            return false;
        }

        if (rowstringRef[pos++] == 0)
        {
            resultFieldsRef[n].isnull = false;
        }
        else
        {
            resultFieldsRef[n].isnull = true;
            continue;
        }

        switch (fields[n].type)
        {
        case INT:
            memcpy(&resultFieldsRef[n].value.integer, &rowstringRef[pos],
                   sizeof(resultFieldsRef[n].value.integer));
            pos += sizeof(resultFieldsRef[n].value.integer);
            break;

        case UINT:
            memcpy(&resultFieldsRef[n].value.uinteger, &rowstringRef[pos],
                   sizeof(resultFieldsRef[n].value.uinteger));
            pos += sizeof(resultFieldsRef[n].value.uinteger);
            break;

        case BOOL:
            memcpy(&resultFieldsRef[n].value.boolean, &rowstringRef[pos],
                   sizeof(resultFieldsRef[n].value.boolean));
            pos += sizeof(resultFieldsRef[n].value.boolean);
            break;

        case FLOAT:
            memcpy(&resultFieldsRef[n].value.floating, &rowstringRef[pos],
                   sizeof(resultFieldsRef[n].value.floating));
            pos += sizeof(resultFieldsRef[n].value.floating);
            break;

        case CHAR:
            memcpy(&resultFieldsRef[n].value.character, &rowstringRef[pos],
                   sizeof(resultFieldsRef[n].value.character));
            pos += sizeof(resultFieldsRef[n].value.character);
            break;

        case CHARX: // makerow() already padded this field to the length of the
            // char(x)
            resultFieldsRef[n].str.assign(rowstringRef, pos, fields[n].length);

            if (resultFieldsRef[n].str.size() < fields[n].length)
            {
                // this should not be, but pad it anyway
                printf("%s %i rowstring.size() %lu field %lu resultFieldsRef[n].str.size() %lu fields[n].length %lu\n", __FILE__, __LINE__,
                       (unsigned long)rowstring->size(), (unsigned long)n,
                       resultFieldsRef[n].str.size(), fields[n].length);
                resultFieldsRef[n].str.append(fields[n].length -
                                              resultFieldsRef[n].str.size(), 0);
            }

            pos += fields[n].length;
            break;

        case VARCHAR:
        {
            int64_t varcharlength;
            memcpy(&varcharlength, &rowstringRef[pos], sizeof(varcharlength));
            pos += sizeof(varcharlength);
            resultFieldsRef[n].str.assign(rowstringRef, pos, varcharlength);
            pos += varcharlength;
        }
        break;

        default:
            fprintf(logfile, "anomaly: %i %s %i\n", fields[n].type, __FILE__,
                    __LINE__);
        }
    }

    return true;
}

Here is the caller graph for this function:

int64_t Table::updaterow	(	int64_t	rowid,
		int64_t	subtransactionid,
		string *	row
	)

modify row

Parameters

rowid	rowid
subtransactionid	subtransactionid
row	new row

Returns

status

Definition at line 401 of file Table.cc.

References rowdata_s::flags, getlocktype(), logfile, rowdata_s::row, rows, shadowTable, STATUS_NOTOK, STATUS_OK, WRITELOCK, and rowdata_s::writelockHolder.

Referenced by SubTransaction::updaterow().

{
    if (!rows.count(rowid))
    {
        return STATUS_NOTOK;
    }

    rowdata_s &currentRowRef = *rows[rowid];

    if ((getlocktype(currentRowRef.flags) != WRITELOCK) ||
        (currentRowRef.writelockHolder != subtransactionid))
    {
        fprintf(logfile, "anomaly %i %li %s %i\n", currentRowRef.flags,
                currentRowRef.writelockHolder, __FILE__, __LINE__);
        return STATUS_NOTOK;
    }

    // should probably validate the row is not garbage, but o well    
    rowdata_s *nrow=new rowdata_s();
    nrow->row=*row;
    shadowTable->rows[rowid]=nrow;

    return STATUS_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

friend class ApiInterface

friend

Definition at line 87 of file Table.h.

friend class Engine

friend

Definition at line 89 of file Table.h.

friend class SubTransaction

friend

Definition at line 91 of file Table.h.

friend class Transaction

friend

Definition at line 90 of file Table.h.

friend class TransactionAgent

friend

Definition at line 88 of file Table.h.

friend class UserSchemaMgr

friend

Definition at line 92 of file Table.h.

Member Data Documentation

boost::unordered_map<std::string, int64_t> Table::columnaNameToFieldMap

Definition at line 247 of file Table.h.

Referenced by addfield().

std::vector<class Field> Table::fields

Definition at line 244 of file Table.h.

Referenced by addfield(), Statement::andPredicate(), Engine::applyItem(), Statement::branchtotype(), Transaction::checkNullConstraintOK(), SubTransaction::commitRollbackUnlock(), Transaction::continueCommitTransaction(), Transaction::continueInsertRow(), Transaction::continueSqlInsert(), Transaction::continueSqlReplace(), Statement::continueUpdate(), Transaction::continueUpdateRow(), Transaction::getEngineid(), TransactionAgent::handledispatch(), ApiInterface::insertRow(), makerow(), SubTransaction::processTransactionMessage(), Statement::resolveTableFields2(), Statement::stagedPredicate(), Statement::startQuery(), Statement::subqueryUnique(), and unmakerow().

boost::unordered_map<int64_t, forwarderEntry> Table::forwarderMap

Definition at line 254 of file Table.h.

Referenced by commitRollbackUnlock(), and deleterow().

int64_t Table::id

Definition at line 241 of file Table.h.

boost::unordered_map< int64_t, std::queue<lockQueueRowEntry> > Table::lockQueue

Definition at line 245 of file Table.h.

Referenced by assignToLockQueue(), SubTransaction::drainRowLockQueue(), and getrows().

std::string Table::name

Definition at line 242 of file Table.h.

Referenced by UserSchemaMgr::addcolumn(), addfield(), getname(), setname(), and Table().

int64_t Table::nextindexid

Definition at line 243 of file Table.h.

int64_t Table::nextrowid

Definition at line 252 of file Table.h.

Referenced by getnextrowid().

boost::unordered_map<int64_t, rowdata_s *> Table::rows

Definition at line 249 of file Table.h.

Referenced by Engine::applyItem(), assignToLockQueue(), commitRollbackUnlock(), deleterow(), getrows(), newrow(), SubTransaction::processTransactionMessage(), selectrows(), and updaterow().

int64_t Table::rowsize

Definition at line 251 of file Table.h.

Referenced by addfield(), makerow(), Table(), and unmakerow().

class Table* Table::shadowTable

Definition at line 246 of file Table.h.

Referenced by commitRollbackUnlock(), newrow(), Table(), updaterow(), and ~Table().

---

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

• /home/infinisql/build/infinisql/infinisqld/Table.h
• /home/infinisql/build/infinisql/infinisqld/Table.cc