Engine Class Reference

Engine actor. Each Engine corresponds to a data partition. More...

#include <Engine.h>

Collaboration diagram for Engine:

Classes
struct	background_s
	for replication of out-of-order subtransactions More...

Public Member Functions
	Engine (Topology::partitionAddress *myIdentityArg)
	execute Engine actor More...
virtual	~Engine ()
bool	applyItem (int64_t subtransactionid, class Schema &schemaRef, MessageDispatch::record_s &record)
	apply record on replica More...
bool	applyItem (int64_t subtransactionid, class Schema &schemaRef, MessageApply::applyindex_s &indexinfo)
	apply record on replica More...

Public Attributes
class Message *	msgsnd
int64_t	operationid
int64_t	domainid
int64_t	userid
int64_t	status
Topology::addressStruct	taAddr
class Message *	msgrcv
REUSEMESSAGES domainidToSchemaMap	domainidsToSchemata
class Mboxes	mboxes
Topology::partitionAddress	myIdentity
int64_t	partitionid

Private Member Functions
int64_t	getnextsubtransactionid ()
	generate unique, increasing (per actor) subtransactionid More...
void	createschema ()
	create Schema More...
void	createtable ()
	CREATE TABLE. More...
void	addcolumn ()
	ADD COLUMN with optional index. More...
void	deleteindex ()
	DELETE INDEX. More...
void	deletetable ()
	DROP TABLE. More...
void	deleteschema ()
	delete schema More...
void	getMyPartitionid ()
	learn global partitionid based on position in replica More...
void	apply ()
	replicate set of row or index items to data partition More...
void	background (class MessageApply &inmsg, MessageDispatch::record_s &item)
	background item with subtransactionid More...
void	background (class MessageApply &inmsg, MessageApply::applyindex_s &item)
	background item with subtransactionid More...

Private Attributes
class Topology	myTopology
class Mbox *	mymboxPtr
int64_t	argsize
int64_t	nextsubtransactionid
int64_t	instance
boost::unordered_map< int64_t, class SubTransaction * >	SubTransactions
std::map< int64_t, background_s >	backgrounded

Friends
class	SubTransaction

Detailed Description

Engine actor. Each Engine corresponds to a data partition.

Definition at line 40 of file Engine.h.

Constructor & Destructor Documentation

Engine::Engine

(

Topology::partitionAddress *

myIdentityArg)

execute Engine actor

Parameters

myIdentityArg

how to indentify this

enter message receive event loop

Definition at line 32 of file Engine.cc.

References addcolumn(), Topology::partitionAddress::address, apply(), argsize, MessageUserSchema::userschema_s::argsize, BUILTINADDCOLUMN, MessageUserSchema::userschema_s::builtincmd, BUILTINCREATESCHEMA, BUILTINCREATETABLE, BUILTINDELETEINDEX, BUILTINDELETESCHEMA, BUILTINDELETETABLE, createschema(), createtable(), deleteindex(), deleteschema(), deletetable(), domainid, MessageUserSchema::userschema_s::domainid, GETMSG, getMyPartitionid(), Topology::partitionAddress::instance, instance, logfile, Topology::partitionAddress::mbox, mboxes, Message::messageStruct, msgrcv, MSGRECEIVEBATCHSIZE, myIdentity, myTopology, Topology::addressStruct::nodeid, Mboxes::nodeid, operationid, MessageUserSchema::userschema_s::operationid, Message::message_s::payloadtype, PAYLOADUSERSCHEMA, SubTransaction::processTransactionMessage(), Mboxes::sendObBatch(), Message::message_s::sourceAddr, MessageTransaction::transaction_s::subtransactionid, SubTransactions, taAddr, Message::message_s::topic, TOPIC_APPLY, TOPIC_ENDSUBTRANSACTION, TOPIC_SCHEMAREQUEST, TOPIC_TOPOLOGY, TOPIC_TRANSACTION, MessageTransaction::transactionStruct, Mboxes::update(), userid, MessageUserSchema::userschema_s::userid, and MessageUserSchema::userschemaStruct.

                                                      :
    myIdentity(*myIdentityArg)
{
    delete myIdentityArg;
    instance = myIdentity.instance;

    mboxes.nodeid = myIdentity.address.nodeid;
    mboxes.update(myTopology, instance);
    getMyPartitionid();

    int64_t builtincmd = 0;
    int waitfor = 100;

    while (1)
    {
        mboxes.sendObBatch();
        for (size_t inmsg=0; inmsg < MSGRECEIVEBATCHSIZE; inmsg++)
        {
            GETMSG(msgrcv, myIdentity.mbox, waitfor)

                if (msgrcv==NULL)
                {
                    waitfor = 100;
                    break;
                }

            waitfor = 0;

            if (msgrcv->messageStruct.payloadtype==PAYLOADUSERSCHEMA)
            {
                class MessageUserSchema &msgrcvRef =
                    *(class MessageUserSchema *)msgrcv;

                argsize = msgrcvRef.userschemaStruct.argsize;
                taAddr = msgrcvRef.messageStruct.sourceAddr;
                operationid = msgrcvRef.userschemaStruct.operationid;
                domainid = msgrcvRef.userschemaStruct.domainid;
                userid = msgrcvRef.userschemaStruct.userid;
                builtincmd = msgrcvRef.userschemaStruct.builtincmd;
            }

            switch (msgrcv->messageStruct.topic)
            {
            case TOPIC_SCHEMAREQUEST:
                switch (builtincmd)
                {
                case BUILTINCREATESCHEMA:
                    createschema();
                    break;

                case BUILTINCREATETABLE:
                    createtable();
                    break;

                case BUILTINADDCOLUMN:
                    addcolumn();
                    break;

                case BUILTINDELETEINDEX:
                    deleteindex();
                    break;

                case BUILTINDELETETABLE:
                    deletetable();
                    break;

                case BUILTINDELETESCHEMA:
                    deleteschema();
                    break;

                default:
                    fprintf(logfile, "Engine bad schema builtin %li %s %i\n",
                            builtincmd, __FILE__, __LINE__);
                }

                break;

            case TOPIC_TRANSACTION:
            {
                class MessageTransaction &msgrcvRef =
                    *(class MessageTransaction *)msgrcv;
                // create SubTransaction if no subtransaction
                if (msgrcvRef.transactionStruct.subtransactionid <= 0)
                {
                    class SubTransaction &subTransactionidRef =
                        *(new class SubTransaction(msgrcvRef.messageStruct.sourceAddr,
                                                   msgrcvRef.transactionStruct.transactionid,
                                                   msgrcvRef.transactionStruct.domainid,
                                                   this));
                    subTransactionidRef.processTransactionMessage(msgrcv);
                }
                else if (SubTransactions.count(msgrcvRef.transactionStruct.subtransactionid))
                {
                    SubTransactions[msgrcvRef.transactionStruct.subtransactionid]->processTransactionMessage(msgrcv);
                }
            }
            break;

            case TOPIC_ENDSUBTRANSACTION:
            {
                class MessageTransaction &msgrcvRef =
                    *(class MessageTransaction *)msgrcv;

                if (SubTransactions.count(msgrcvRef.transactionStruct.subtransactionid))
                {
                    delete SubTransactions[msgrcvRef.transactionStruct.subtransactionid];
                }
            }
            break;

            case TOPIC_TOPOLOGY:
                mboxes.update(myTopology);
                getMyPartitionid();
                break;

            case TOPIC_APPLY:
            {
                apply();
            }
            break;

            default:
                printf("%s %i Engine bad topic %i\n", __FILE__, __LINE__,
                       msgrcv->messageStruct.topic);
            }
        }
    }
}

Here is the call graph for this function:

Engine::~Engine ( )

virtual

Definition at line 162 of file Engine.cc.

{
}

Member Function Documentation

void Engine::addcolumn ( )

private

ADD COLUMN with optional index.

Definition at line 193 of file Engine.cc.

References BUILTIN_STATUS_OK, domainid, domainidsToSchemata, MessageUserSchema::userschema_s::fieldid, MessageUserSchema::userschema_s::fieldlen, MessageUserSchema::userschema_s::fieldtype, MessageUserSchema::userschema_s::indextype, Message::messageStruct, msgrcv, Message::message_s::sourceAddr, status, MessageUserSchema::userschema_s::tableid, MessageUserSchema::userschemaStruct, and TransactionAgent::usmReply().

Referenced by Engine().

{
    class MessageUserSchema &msgrcvRef = *(class MessageUserSchema *)msgrcv;
    class MessageUserSchema *msg = new class MessageUserSchema(TOPIC_SCHEMAREPLY);
    // either succeeds or fails :-)
    class Schema &schemaRef = *domainidsToSchemata[domainid];
    class Table &tableRef = *schemaRef.tables[msgrcvRef.userschemaStruct.tableid];
    msg->userschemaStruct.fieldid =
        tableRef.addfield((fieldtype_e) msgrcvRef.userschemaStruct.fieldtype,
                          msgrcvRef.userschemaStruct.fieldlen, "",
                          (indextype_e) msgrcvRef.userschemaStruct.indextype);
    status = BUILTIN_STATUS_OK;
    TransactionAgent::usmReply(this, msgrcv->messageStruct.sourceAddr, *msg);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Engine::apply ( )

private

replicate set of row or index items to data partition

Definition at line 689 of file Engine.cc.

References Topology::partitionAddress::address, applyItem(), MessageApply::applyStruct, background(), backgrounded, MessageApply::apply_s::domainid, domainidsToSchemata, Engine::background_s::indices, MessageApply::indices, mboxes, Message::messageStruct, msgrcv, myIdentity, Engine::background_s::rows, MessageApply::rows, Message::message_s::sourceAddr, MessageApply::apply_s::subtransactionid, and Mboxes::toActor().

Referenced by Engine().

{
    class MessageApply &inmsg = *(class MessageApply *)msgrcv;
    class Schema &schemaRef = *domainidsToSchemata[inmsg.applyStruct.domainid];

    for (size_t n=0; n < inmsg.rows.size(); n++)
    {
        if (applyItem(inmsg.applyStruct.subtransactionid, schemaRef,
                      inmsg.rows[n])==false)
        {
            background(inmsg, inmsg.rows[n]);
        }
    }
    
    for (size_t n=0; n < inmsg.indices.size(); n++)
    {
        if (applyItem(inmsg.applyStruct.subtransactionid, schemaRef,
                      inmsg.indices[n])==false)
        {
            background(inmsg, inmsg.indices[n]);
        }
    }

    if (!backgrounded.count(inmsg.applyStruct.subtransactionid))
    {
        class MessageAckApply *ackmsg =
            new class MessageAckApply(inmsg.applyStruct.subtransactionid,
                                      inmsg.applyStruct.applierid, -1, STATUS_OK);
        mboxes.toActor(myIdentity.address, inmsg.messageStruct.sourceAddr,
                       *ackmsg);
    }

    // now, walk through backgrounded items
    map<int64_t, background_s>::iterator itb;

    for (itb = backgrounded.begin(); itb != backgrounded.end(); itb++)
    {
        // itb->first: subtransactionid
        background_s &bref = itb->second;
        vector<MessageDispatch::record_s>::iterator itr;

        for (itr = bref.rows.begin(); itr != bref.rows.end(); itr++)
        {
            if (applyItem(itb->first, schemaRef, *itr)==true)
            {
                bref.rows.erase(itr);
            }
        }

        vector<MessageApply::applyindex_s>::iterator iti;

        for (iti = bref.indices.begin(); iti != bref.indices.end(); iti++)
        {
            if (applyItem(itb->first, schemaRef, *iti)==true)
            {
                bref.indices.erase(iti);
            }
        }

        if (!bref.rows.size() && !bref.indices.size())
        {
            class MessageAckApply *ackmsg =
                new class MessageAckApply(itb->first, bref.applierid, -1,
                                          STATUS_OK);
            mboxes.toActor(myIdentity.address, bref.taAddress, *ackmsg);
            backgrounded.erase(itb);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Engine::applyItem	(	int64_t	subtransactionid,
		class Schema &	schemaRef,
		MessageDispatch::record_s &	record
	)

apply record on replica

Parameters

subtransactionid	subtransactionid
schemaRef	Schema
record	row to apply

Returns

success or failure

Definition at line 249 of file Engine.cc.

References DELETE, INSERT, rowdata_s::previoussubtransactionid, MessageDispatch::record_s::primitive, rowdata_s::row, MessageDispatch::record_s::row, MessageDispatch::record_s::rowid, Table::rows, MessageDispatch::record_s::tableid, Schema::tables, and UPDATE.

Referenced by apply().

{
    class Table &tableRef = *schemaRef.tables[record.tableid];

    switch (record.primitive)
    {
    case INSERT:
    {
        if (tableRef.rows.count(record.rowid))
        {
            printf("%s %i anomaly should not be an existing rowid %li\n",
                   __FILE__, __LINE__, record.rowid);
            return false;
        }

        rowdata_s *row = new rowdata_s();
        row->previoussubtransactionid = subtransactionid;
        row->row = record.row;
        tableRef.rows[record.rowid] = row;
    }
    break;

    case UPDATE:
    {
        if (tableRef.rows.count(record.rowid))
        {
            printf("%s %i anomaly should be an existing rowid %li\n", __FILE__,
                   __LINE__, record.rowid);
            return false;
        }

        if (tableRef.rows[record.rowid]->previoussubtransactionid !=
            subtransactionid)
        {
            return false;
        }

        rowdata_s *row = new rowdata_s();
        row->previoussubtransactionid = subtransactionid;
        row->row = record.row;
        tableRef.rows[record.rowid] = row;
    }
    break;

    case DELETE:
    {
        if (!tableRef.rows.count(record.rowid))
        {
            return false;
        }

        if (tableRef.rows[record.rowid]->previoussubtransactionid !=
            subtransactionid)
        {
            return false;
        }

        delete tableRef.rows[record.rowid];
        tableRef.rows.erase(record.rowid);
    }
    break;

    default:
        printf("%s %i anomaly primitive %i\n", __FILE__, __LINE__,
               record.primitive);
        return false;
    }

    return true;
}

Here is the caller graph for this function:

bool Engine::applyItem	(	int64_t	subtransactionid,
		class Schema &	schemaRef,
		MessageApply::applyindex_s &	indexinfo
	)

apply record on replica

Parameters

subtransactionid	subtransactionid
schemaRef	Schema
indexinfo	index entry to apply

Returns

success or failure

Definition at line 322 of file Engine.cc.

References Index::addifnotthere(), fieldInput_u::boolean, fieldInput_u::character, Index::checkifmatch(), Index::checkifthere(), nonLockingIndexEntry_s::engineid, MessageApply::applyindex_s::entry, MessageApply::applyindex_s::fieldid, Table::fields, MessageApply::applyindex_s::fieldVal, MessageApply::applyindex_s::flags, fieldInput_u::floating, MessageApply::getisaddflag(), Index::getprevioussubtransactionid(), Index::indexmaptype, Index::indextype, fieldInput_u::integer, fieldValue_s::isnull, nonuniquebool, Index::nonuniqueBoolIndex, nonuniquechar, Index::nonuniqueCharIndex, nonuniquecharx, nonuniquefloat, Index::nonuniqueFloatIndex, nonuniqueint, Index::nonuniqueIntIndex, Index::nonuniqueStringIndex, nonuniqueuint, Index::nonuniqueUintIndex, nonuniquevarchar, Index::nulls, Index::rm(), nonLockingIndexEntry_s::rowid, fieldValue_s::str, MessageApply::applyindex_s::tableid, Schema::tables, fieldInput_u::uinteger, UNIQUE, UNIQUENOTNULL, UNORDERED, UNORDEREDNOTNULL, and fieldValue_s::value.

{
    class Table &tableRef = *schemaRef.tables[indexinfo.tableid];
    class Index &indexRef = tableRef.fields[indexinfo.fieldid].index;

    if (indexRef.indextype==UNIQUE || indexRef.indextype==UNORDERED ||
        indexRef.indextype==UNIQUENOTNULL || indexRef.indextype==UNORDEREDNOTNULL)
    {
        // is unique
        if (indexinfo.fieldVal.isnull==true)
        {
            // is unique is null
            if (MessageApply::getisaddflag(indexinfo.flags)==true)
            {
                // is unique is null add
                vector<int64_t> v(2);
                v[0] = indexinfo.entry.rowid;
                v[1] = indexinfo.entry.engineid;
                indexRef.nulls.insert(v);
            }
            else
            {
                // is unique is null delete
                vector<int64_t> v(2);
                v[0] = indexinfo.entry.rowid;
                v[1] = indexinfo.entry.engineid;

                if (!indexRef.nulls.count(v))
                {
                    return false;
                }

                indexRef.nulls.erase(v);
            }
        }
        else
        {
            // is unique not null
            if (MessageApply::getisaddflag(indexinfo.flags)==true)
            {
                // is unique not null add
                if (indexRef.addifnotthere(indexinfo.fieldVal,
                                           indexinfo.entry.rowid,
                                           indexinfo.entry.engineid,
                                           subtransactionid)==false)
                {
                    if (indexRef.getprevioussubtransactionid(indexinfo.fieldVal) >
                        subtransactionid)
                    {
                        return false;
                    }
                }
            }
            else
            {
                // is unique not null delete
                if (indexRef.checkifthere(indexinfo.fieldVal)==true)
                {
                    if (indexRef.checkifmatch(indexinfo.fieldVal,
                                              indexinfo.entry.rowid,
                                              indexinfo.entry.engineid)==true)
                    {
                        indexRef.rm(indexinfo.fieldVal);
                    }
                    else
                    {
                        if (indexRef.getprevioussubtransactionid(indexinfo.fieldVal) <
                            subtransactionid)
                        {
                            return false;
                        }
                    }
                }
                else
                {
                    return false;
                }
            }
        }
    }
    else
    {
        // not unique
        if (indexinfo.fieldVal.isnull==true)
        {
            // not unique is null
            if (MessageApply::getisaddflag(indexinfo.flags)==true)
            {
                // not unique is null add
                vector<int64_t> v(2);
                v[0] = indexinfo.entry.rowid;
                v[1] = indexinfo.entry.engineid;
                indexRef.nulls.insert(v);
            }
            else
            {
                // not unique is null delete
                vector<int64_t> v(2);
                v[0] = indexinfo.entry.rowid;
                v[1] = indexinfo.entry.engineid;

                if (!indexRef.nulls.count(v))
                {
                    return false;
                }

                indexRef.nulls.erase(v);
            }
        }
        else
        {
            // not unique not null
            if (MessageApply::getisaddflag(indexinfo.flags)==true)
            {
                // not unique not null add
                switch (indexRef.indexmaptype)
                {
                case nonuniqueint:
                {
                    int64_t v=indexinfo.fieldVal.value.integer;
                    indexRef.nonuniqueIntIndex->insert(pair<int64_t,
                                                       nonLockingIndexEntry_s>(v,
                                                                               indexinfo.entry));
                }
                break;

                case nonuniqueuint:
                {
                    uint64_t v=indexinfo.fieldVal.value.uinteger;
                    indexRef.nonuniqueUintIndex->insert(pair<uint64_t,
                                                        nonLockingIndexEntry_s>(v,
                                                                                indexinfo.entry));
                }
                break;

                case nonuniquebool:
                {
                    bool v=indexinfo.fieldVal.value.boolean;
                    indexRef.nonuniqueBoolIndex->insert(pair<bool,
                                                        nonLockingIndexEntry_s>(v,
                                                                                indexinfo.entry));
                }
                break;

                case nonuniquefloat:
                {
                    long double v=indexinfo.fieldVal.value.floating;
                    indexRef.nonuniqueFloatIndex->insert(pair<long double,
                                                         nonLockingIndexEntry_s>(v,
                                                                                 indexinfo.entry));
                }
                break;

                case nonuniquechar:
                {
                    indexRef.nonuniqueCharIndex->insert(pair<char,
                                                        nonLockingIndexEntry_s>(indexinfo.fieldVal.value.character,
                                                                                indexinfo.entry));
                }
                break;

                case nonuniquecharx:
                {
                    indexRef.nonuniqueStringIndex->insert(pair<string,
                                                          nonLockingIndexEntry_s>(indexinfo.fieldVal.str,
                                                                                  indexinfo.entry));
                }
                break;

                case nonuniquevarchar:
                {
                    indexRef.nonuniqueStringIndex->insert(pair<string,
                                                          nonLockingIndexEntry_s>(indexinfo.fieldVal.str,
                                                                                  indexinfo.entry));
                }
                break;

                default:
                    printf("%s %i anomaly indexmaptype %i\n", __FILE__, __LINE__,
                           indexRef.indexmaptype);
                }
            }
            else
            {
                // not unique not null delete
                switch (indexRef.indexmaptype)
                {
                case nonuniqueint:
                {
                    pair<multimap<int64_t, nonLockingIndexEntry_s>::iterator,
                         multimap<int64_t, nonLockingIndexEntry_s>::iterator>
                        iteratorRange;
                    nonuniqueIntMap::iterator it;

                    iteratorRange =
                        indexRef.nonuniqueIntIndex->equal_range(indexinfo.fieldVal.value.integer);

                    for (it=iteratorRange.first; it != iteratorRange.second; it++)
                    {
                        if (it->second.rowid==indexinfo.entry.rowid  &&
                            it->second.engineid==indexinfo.entry.engineid)
                        {
                            indexRef.nonuniqueIntIndex->erase(it);
                            return true;
                        }
                    }

                    return false; // found no entry, so background it
                }
                break;

                case nonuniqueuint:
                {
                    pair<multimap<uint64_t, nonLockingIndexEntry_s>::iterator,
                         multimap<uint64_t, nonLockingIndexEntry_s>::iterator>
                        iteratorRange;
                    nonuniqueUintMap::iterator it;

                    iteratorRange =
                        indexRef.nonuniqueUintIndex->equal_range(indexinfo.fieldVal.value.uinteger);

                    for (it=iteratorRange.first; it != iteratorRange.second; it++)
                    {
                        if (it->second.rowid==indexinfo.entry.rowid  &&
                            it->second.engineid==indexinfo.entry.engineid)
                        {
                            indexRef.nonuniqueUintIndex->erase(it);
                            return true;
                        }
                    }

                    return false; // found no entry, so background it
                }
                break;

                case nonuniquebool:
                {
                    pair<multimap<bool, nonLockingIndexEntry_s>::iterator,
                         multimap<bool, nonLockingIndexEntry_s>::iterator>
                        iteratorRange;
                    nonuniqueBoolMap::iterator it;

                    iteratorRange =
                        indexRef.nonuniqueBoolIndex->equal_range(indexinfo.fieldVal.value.boolean);

                    for (it=iteratorRange.first; it != iteratorRange.second; it++)
                    {
                        if (it->second.rowid==indexinfo.entry.rowid  &&
                            it->second.engineid==indexinfo.entry.engineid)
                        {
                            indexRef.nonuniqueBoolIndex->erase(it);
                            return true;
                        }
                    }

                    return false; // found no entry, so background it
                }
                break;

                case nonuniquefloat:
                {
                    pair<multimap<long double, nonLockingIndexEntry_s>::iterator,
                         multimap<long double, nonLockingIndexEntry_s>::iterator>
                        iteratorRange;
                    nonuniqueFloatMap::iterator it;

                    iteratorRange =
                        indexRef.nonuniqueFloatIndex->equal_range(indexinfo.fieldVal.value.floating);

                    for (it=iteratorRange.first; it != iteratorRange.second; it++)
                    {
                        if (it->second.rowid==indexinfo.entry.rowid  &&
                            it->second.engineid==indexinfo.entry.engineid)
                        {
                            indexRef.nonuniqueFloatIndex->erase(it);
                            return true;
                        }
                    }

                    return false; // found no entry, so background it
                }
                break;

                case nonuniquechar:
                {
                    pair<multimap<char, nonLockingIndexEntry_s>::iterator,
                         multimap<char, nonLockingIndexEntry_s>::iterator>
                        iteratorRange;
                    nonuniqueCharMap::iterator it;

                    iteratorRange =
                        indexRef.nonuniqueCharIndex->equal_range(indexinfo.fieldVal.value.character);

                    for (it=iteratorRange.first; it != iteratorRange.second; it++)
                    {
                        if (it->second.rowid==indexinfo.entry.rowid  &&
                            it->second.engineid==indexinfo.entry.engineid)
                        {
                            indexRef.nonuniqueCharIndex->erase(it);
                            return true;
                        }
                    }

                    return false; // found no entry, so background it
                }
                break;

                case nonuniquecharx:
                {
                    pair<multimap<string, nonLockingIndexEntry_s>::iterator,
                         multimap<string, nonLockingIndexEntry_s>::iterator>
                        iteratorRange;
                    nonuniqueStringMap::iterator it;

                    iteratorRange =
                        indexRef.nonuniqueStringIndex->equal_range(indexinfo.fieldVal.str);

                    for (it=iteratorRange.first; it != iteratorRange.second; it++)
                    {
                        if (it->second.rowid==indexinfo.entry.rowid  &&
                            it->second.engineid==indexinfo.entry.engineid)
                        {
                            indexRef.nonuniqueStringIndex->erase(it);
                            return true;
                        }
                    }

                    return false; // found no entry, so background it
                }
                break;

                case nonuniquevarchar:
                {
                    pair<multimap<string, nonLockingIndexEntry_s>::iterator,
                         multimap<string, nonLockingIndexEntry_s>::iterator>
                        iteratorRange;
                    nonuniqueStringMap::iterator it;

                    iteratorRange =
                        indexRef.nonuniqueStringIndex->equal_range(indexinfo.fieldVal.str);

                    for (it=iteratorRange.first; it != iteratorRange.second; it++)
                    {
                        if (it->second.rowid==indexinfo.entry.rowid  &&
                            it->second.engineid==indexinfo.entry.engineid)
                        {
                            indexRef.nonuniqueStringIndex->erase(it);
                            return true;
                        }
                    }

                    return false; // found no entry, so background it
                }
                break;

                default:
                    printf("%s %i anomaly indexmaptype %i\n", __FILE__, __LINE__,
                           indexRef.indexmaptype);
                }
            }
        }
    }

    return true;
}

Here is the call graph for this function:

void Engine::background ( class MessageApply &  inmsg, MessageDispatch::record_s &  item  )

private

background item with subtransactionid

items need to be applied in order of subtransactionid. placed in background, need to be applied once previous items have been replicated

Parameters

inmsg	MessageApply received
item	row

Definition at line 759 of file Engine.cc.

References Engine::background_s::applierid, MessageApply::apply_s::applierid, MessageApply::applyStruct, backgrounded, Message::messageStruct, Message::message_s::sourceAddr, MessageApply::apply_s::subtransactionid, and Engine::background_s::taAddress.

Referenced by apply().

{
    if (!backgrounded.count(inmsg.applyStruct.subtransactionid))
    {
        background_s b;
        b.applierid = inmsg.applyStruct.applierid;
        b.taAddress = inmsg.messageStruct.sourceAddr;
        backgrounded[inmsg.applyStruct.subtransactionid]=b;
    }

    backgrounded[inmsg.applyStruct.subtransactionid].rows.push_back(item);
}

Here is the caller graph for this function:

void Engine::background ( class MessageApply &  inmsg, MessageApply::applyindex_s &  item  )

private

background item with subtransactionid

items need to be applied in order of subtransactionid. placed in background, need to be applied once previous items have been replicated

Parameters

inmsg	MessageApply received
item	index entry

Definition at line 773 of file Engine.cc.

References Engine::background_s::applierid, MessageApply::apply_s::applierid, MessageApply::applyStruct, backgrounded, Message::messageStruct, Message::message_s::sourceAddr, MessageApply::apply_s::subtransactionid, and Engine::background_s::taAddress.

{
    if (!backgrounded.count(inmsg.applyStruct.subtransactionid))
    {
        background_s b;
        b.applierid = inmsg.applyStruct.applierid;
        b.taAddress = inmsg.messageStruct.sourceAddr;
        backgrounded[inmsg.applyStruct.subtransactionid]=b;
    }

    backgrounded[inmsg.applyStruct.subtransactionid].indices.push_back(item);
}

void Engine::createschema ( )

private

create Schema

Definition at line 175 of file Engine.cc.

References createSchema(), Message::messageStruct, msgrcv, Message::message_s::sourceAddr, and TransactionAgent::usmReply().

Referenced by Engine().

{
    createSchema(this);
    class MessageUserSchema *msg = new class MessageUserSchema(TOPIC_SCHEMAREPLY);
    TransactionAgent::usmReply(this, msgrcv->messageStruct.sourceAddr, *msg);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Engine::createtable ( )

private

CREATE TABLE.

Definition at line 182 of file Engine.cc.

References MessageUserSchema::userschema_s::domainid, domainidsToSchemata, Message::messageStruct, msgrcv, Message::message_s::sourceAddr, status, MessageUserSchema::userschema_s::tableid, MessageUserSchema::userschemaStruct, and TransactionAgent::usmReply().

Referenced by Engine().

{
    // should check if map is ok
    class MessageUserSchema &msgrcvRef = *(class MessageUserSchema *)msgrcv;
    class MessageUserSchema *msg = new class MessageUserSchema(TOPIC_SCHEMAREPLY);
    status =
        domainidsToSchemata[msgrcvRef.userschemaStruct.domainid]->createTable(msgrcvRef.userschemaStruct.tableid);
    msg->userschemaStruct.tableid = msgrcvRef.userschemaStruct.tableid;
    TransactionAgent::usmReply(this, msgrcv->messageStruct.sourceAddr, *msg);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Engine::deleteindex ( )

private

DELETE INDEX.

Definition at line 208 of file Engine.cc.

References BUILTIN_STATUS_OK, Message::messageStruct, msgrcv, Message::message_s::sourceAddr, status, and TransactionAgent::usmReply().

Referenced by Engine().

{
    // either succeeds or fails :-)
    class MessageUserSchema *msg = new class MessageUserSchema(TOPIC_SCHEMAREPLY);
    status = BUILTIN_STATUS_OK;
    TransactionAgent::usmReply(this, msgrcv->messageStruct.sourceAddr, *msg);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Engine::deleteschema ( )

private

delete schema

Definition at line 224 of file Engine.cc.

References BUILTIN_STATUS_OK, Message::messageStruct, msgrcv, Message::message_s::sourceAddr, status, and TransactionAgent::usmReply().

Referenced by Engine().

{
    // either succeeds or fails :-)
    class MessageUserSchema *msg = new class MessageUserSchema(TOPIC_SCHEMAREPLY);
    status = BUILTIN_STATUS_OK;
    TransactionAgent::usmReply(this, msgrcv->messageStruct.sourceAddr, *msg);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Engine::deletetable ( )

private

DROP TABLE.

Definition at line 216 of file Engine.cc.

References BUILTIN_STATUS_OK, Message::messageStruct, msgrcv, Message::message_s::sourceAddr, status, and TransactionAgent::usmReply().

Referenced by Engine().

{
    // either succeeds or fails :-)
    class MessageUserSchema *msg = new class MessageUserSchema(TOPIC_SCHEMAREPLY);
    status = BUILTIN_STATUS_OK;
    TransactionAgent::usmReply(this, msgrcv->messageStruct.sourceAddr, *msg);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Engine::getMyPartitionid ( )

private

learn global partitionid based on position in replica

Definition at line 237 of file Engine.cc.

References Topology::partitionAddress::mbox, myIdentity, myTopology, partitionid, and Topology::partitionListThisReplica.

Referenced by Engine().

{
    for (size_t n=0; n < myTopology.partitionListThisReplica.size(); n++)
    {
        if (myIdentity.mbox==myTopology.partitionListThisReplica[n].mbox)
        {
            partitionid = n;
        }
    }
}

Here is the caller graph for this function:

int64_t Engine::getnextsubtransactionid ( )

private

generate unique, increasing (per actor) subtransactionid

Returns

next subtransactionid

Definition at line 232 of file Engine.cc.

References nextsubtransactionid.

Referenced by SubTransaction::SubTransaction().

{
    return ++nextsubtransactionid;
}

Here is the caller graph for this function:

Friends And Related Function Documentation

friend class SubTransaction

friend

Definition at line 91 of file Engine.h.

Member Data Documentation

int64_t Engine::argsize

private

Definition at line 182 of file Engine.h.

Referenced by Engine().

std::map<int64_t, background_s> Engine::backgrounded

private

Definition at line 186 of file Engine.h.

Referenced by apply(), and background().

int64_t Engine::domainid

Definition at line 96 of file Engine.h.

Referenced by addcolumn(), and Engine().

REUSEMESSAGES domainidToSchemaMap Engine::domainidsToSchemata

Definition at line 103 of file Engine.h.

Referenced by addcolumn(), apply(), createtable(), and SubTransaction::SubTransaction().

int64_t Engine::instance

private

Definition at line 184 of file Engine.h.

Referenced by Engine().

class Mboxes Engine::mboxes

Definition at line 104 of file Engine.h.

Referenced by apply(), Engine(), and SubTransaction::replyTransaction().

class Message* Engine::msgrcv

Definition at line 101 of file Engine.h.

Referenced by addcolumn(), apply(), createschema(), createtable(), deleteindex(), deleteschema(), deletetable(), and Engine().

class Message* Engine::msgsnd

Definition at line 94 of file Engine.h.

Topology::partitionAddress Engine::myIdentity

Definition at line 105 of file Engine.h.

Referenced by apply(), Engine(), getMyPartitionid(), and SubTransaction::replyTransaction().

class Mbox* Engine::mymboxPtr

private

Definition at line 181 of file Engine.h.

class Topology Engine::myTopology

private

Definition at line 179 of file Engine.h.

Referenced by Engine(), and getMyPartitionid().

int64_t Engine::nextsubtransactionid

private

Definition at line 183 of file Engine.h.

Referenced by getnextsubtransactionid().

int64_t Engine::operationid

Definition at line 95 of file Engine.h.

Referenced by Engine().

int64_t Engine::partitionid

Definition at line 106 of file Engine.h.

Referenced by SubTransaction::drainIndexLockQueue(), SubTransaction::drainRowLockQueue(), getMyPartitionid(), and SubTransaction::replyTransaction().

int64_t Engine::status

Definition at line 98 of file Engine.h.

Referenced by addcolumn(), createtable(), deleteindex(), deleteschema(), and deletetable().

boost::unordered_map<int64_t, class SubTransaction *> Engine::SubTransactions

private

Definition at line 185 of file Engine.h.

Referenced by SubTransaction::drainIndexLockQueue(), SubTransaction::drainRowLockQueue(), Engine(), SubTransaction::SubTransaction(), and SubTransaction::~SubTransaction().

Topology::addressStruct Engine::taAddr

Definition at line 99 of file Engine.h.

Referenced by Engine().

int64_t Engine::userid

Definition at line 97 of file Engine.h.

Referenced by Engine().

---

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

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