rdbModel::Table Class Reference

#include <Table.h>

Public Member Functions
	Table ()
	~Table ()
void	setConnection (Connection *connect)
const std::string &	getName () const
Column *	getColumnByName (const std::string &name) const
Index *	getIndexByName (const std::string &name) const
Assertion *	getAssertionByName (const std::string &name) const
int	insertLatest (Row &row, int *serial=0) const
int	insertRow (Row &row, int *serial=0) const
int	supersedeRow (Row &row, int oldKey, int *newKey=0) const
int	updateRows (Row &row, Assertion *where) const
InsertNew *	getInsertNew () const
Supersede *	getSupersede () const
Visitor::VisitorState	accept (Visitor *v)
void	sortColumns ()

Friends
class	rdbModel::XercesBuilder
class	rdbModel::Rdb

Detailed Description

rdbModel representation of a(n SQL-like) table description

Definition at line 33 of file Table.h.

Constructor & Destructor Documentation

Table()

rdbModel::Table::Table

(

)

Definition at line 20 of file Table.cxx.

               : m_primaryKeyCol(""), m_sorted(false), m_nEndUser(0), 
                   m_validRow(0), m_iNew(0), m_sup(0), m_connect(0)    {
    m_sortedCols.clear(); m_programCols.clear(); 
    m_userCols.clear(); m_mayDefault.clear();
    m_out = &std::cout;    m_err = &std::cerr;
  }

~Table()

rdbModel::Table::~Table

(

)

Definition at line 28 of file Table.cxx.

                {
    while (m_cols.size() ) {
      Column* c = m_cols.back();
      m_cols.pop_back();
      delete c;
    }
 
    while (m_asserts.size() ) {
      Assertion* a = m_asserts.back();
      m_asserts.pop_back();
      delete a;
    }
 
    while (m_indices.size() ) {
      Index* i = m_indices.back();
      m_indices.pop_back();
      delete i;
    }
  }

Member Function Documentation

accept()

Visitor::VisitorState rdbModel::Table::accept

(

Visitor *

v

)

Definition at line 102 of file Table.cxx.

                                              {
    
    Visitor::VisitorState state = v->visitTable(this);
    if (state == Visitor::VBRANCHDONE) return Visitor::VCONTINUE;
    if (state != Visitor::VCONTINUE)       return state;
 
    unsigned n = m_cols.size();
 
    for (unsigned i = 0; i < n; i++) {
      state = m_cols[i]->accept(v);
      if (state != Visitor::VCONTINUE) return state;
    }
 
    n = m_indices.size();
    for (unsigned i = 0; i < n; i++) {
      state = m_indices[i]->accept(v);
      if (state != Visitor::VCONTINUE) return state;
    }
 
    n = m_asserts.size();
    for (unsigned i = 0; i < n; i++) {
      state = m_asserts[i]->accept(v);
      if (state != Visitor::VCONTINUE) return state;
    }
    return state;
  }

getAssertionByName()

Assertion * rdbModel::Table::getAssertionByName

(

const std::string &

name

)

const

Definition at line 91 of file Table.cxx.

                                                                  {
    unsigned nAssert = m_asserts.size();
    for (unsigned i = 0; i < nAssert; i++) {
      Assertion* a = m_asserts[i];
      if (a->getName() == name) return a;
    }
    return 0;
 
  }

getColumnByName()

Column * rdbModel::Table::getColumnByName

(

const std::string &

name

)

const

Definition at line 56 of file Table.cxx.

                                                            {
    unsigned nCol = m_sortedCols.size();
    unsigned minI = 0;
    unsigned maxI = nCol;
 
    unsigned guess = maxI/2;
    unsigned oldGuess = nCol;
 
    int cmp = name.compare(m_sortedCols[guess]->getName());
 
    while (cmp != 0)  {
      if (guess == oldGuess) return 0;        // not found
 
      if (cmp < 0 ) {    // thing we tried is > colName, so decrease maxI
        maxI = guess;
      }  else {   // thing we tried is > colName, so increase minI
        minI =  guess;
      }
      oldGuess = guess;
      guess = (minI + maxI)/2;
      cmp = name.compare(m_sortedCols[guess]->getName());
    }
    return m_sortedCols[guess];
 
  }

Referenced by calibUtil::Metadata::checkNulls(), calibUtil::Metadata::checkValues(), rdbModel::Rdb::getColumn(), supersedeRow(), and rdbModel::Assertion::Operator::validCompareOp().

getIndexByName()

Index * rdbModel::Table::getIndexByName

(

const std::string &

name

)

const

Definition at line 82 of file Table.cxx.

                                                          {
    unsigned nIx = m_indices.size();
    for (unsigned iIx = 0; iIx < nIx; iIx++) {
      Index* index = m_indices[iIx];
      if (index->getName() == name) return index;
    }
    return 0;
  }

Referenced by rdbModel::Rdb::getIndex().

getInsertNew()

InsertNew * rdbModel::Table::getInsertNew ( ) const

inline

Definition at line 87 of file Table.h.

{return m_iNew;}

getName()

const std::string & rdbModel::Table::getName ( ) const

inline

Definition at line 40 of file Table.h.

{ return m_name;}

Referenced by getColumnByName(), rdbModel::Rdb::getTable(), rdbModel::Column::getTableName(), insertLatest(), insertRow(), and rdbModel::MysqlConnection::visitTable().

getSupersede()

Supersede * rdbModel::Table::getSupersede ( ) const

inline

Definition at line 88 of file Table.h.

{return m_sup;}

insertLatest()

int rdbModel::Table::insertLatest	(	Row &	row,
		int *	serial = 0 ) const

insertLatest is smart in the following respects: o Makes some checks to see if row is self-consistent o Fills in all fields which are to be supplied by "service" o If row satisfies conditions for being "official"

• queries table to see if any pre-existing rows need adjustment; if so, they are adjusted o Finally inserts the row

If test is true, just output description of what would be done without actually doing it. Note row may be modified by the function. If a non-zero pointer is supplied for serial it will contain the primary key value (if there is one) of the new row on exit.

Definition at line 162 of file Table.cxx.

                                                     {
 
    if (!m_connect) {
      throw RdbException("Table::insertLatest Need matching connection");
    }
    row.rowSort();
 
    // Fill in columns in m_programCols list
    fillProgramCols(row, true);
 
    // Check that all required columns are there and not null
    for (unsigned i = 0; i < m_userCols.size(); i++) {
      FieldVal* f = row.find(m_userCols[i]->getName());
      if ((!f) || (f->m_null)) {
        std::string 
          msg("Table::insertLatest Row to be inserted missing req'd field ");
        msg = msg + m_userCols[i]->getName();
        throw RdbException(msg);
      }
    }
    // Fill in defaults
    fillDefaults(row);
 
    // Check against consistency conditions specified by <insertNew>
    const Assertion* cond = m_iNew->getInternal();
    bool satisfied;
 
    try {
      satisfied = cond->verify(row, row);
    }
    catch (RdbException ex) {
      (*m_out) << ex.getMsg() << std::endl;
      return -1;
    }
 
    if (!satisfied) return -1;   // or maybe throw exception here?
 
    // Check against official conditions specified by <insertNew>
    const Assertion* condO = m_iNew->getOfficial();
    Row empty;
    std::vector<std::string> colNames;
    std::vector<std::string> colValues;
    std::vector<std::string> nullCols;
 
    row.regroup(colNames, colValues, nullCols);
 
    satisfied = condO->verify(empty, row);
 
    // If not official, do insert and exit
    if (!satisfied) {
      bool ok = m_connect->insertRow(m_name, colNames, colValues,
                                     serial, &nullCols);
      return (ok) ?  0 : -1;
    }
 
    const std::vector<InterRow* >& inter = m_iNew->getInterRow();
 
    unsigned nInter = inter.size();
    Assertion* subsAssert;
    for (unsigned iInter = 0; iInter < nInter; iInter++) {
      const Query* q = inter[iInter]->getQuery();
      const std::vector<std::string>& toSelect = q->getToSelect();
 
      // Need to make a new Assertion which substitues our proposed row
      // values for all "toBe" entries
      subsAssert = new Assertion(q->getAssertion(), &row);
 
      std::vector<std::string> orderCols;
      orderCols.clear();
      ResultHandle* r = m_connect->select(m_name, toSelect, orderCols, 
                                          subsAssert);
 
      if (r->getNRows() == 0) {    // no conflicts found
        delete subsAssert;
        continue;   // go on to next InterRow, if any.  
      }
 
      // otherwise
      //    if quit  go ahead and quit
      if (inter[iInter]->getQuit()) {
        delete subsAssert;
        (*m_out) << "insert latest not done because of irreconcilable " 
                 << std::endl << "conflict with existing rows" << std::endl;
        return -1;
      }
      //    else modify conflicting rows as specified in <interRow>.
      //    (i.e., do an update with where clause = subsAssert
 
      std::vector<Set> sets = inter[iInter]->getSets();
 
      bool iu = doInterUpdate(sets, subsAssert, row);
      if (!iu) return -1;
    }
    // Insert and exit
    bool ok = m_connect->insertRow(m_name, colNames, colValues,
                                   serial, &nullCols);
    return (ok) ?  0 : -1;
  }

insertRow()

int rdbModel::Table::insertRow	(	Row &	row,
		int *	serial = 0 ) const

The less smart insertRow function fills in all fields which are to be supplied by "service" and inserts the row, without any further checks. Good return value is 0

Definition at line 261 of file Table.cxx.

                                                  {
 
    if (!m_connect) {
      throw RdbException("Table::insertRow Need matching connection");
    }
    row.rowSort();
 
    // Fill in columns in m_programCols list
    fillProgramCols(row, true);
 
 
    // Check that all required columns are there and not null
    for (unsigned i = 0; i < m_userCols.size(); i++) {
      FieldVal* f = row.find(m_userCols[i]->getName());
      if ((!f) || (f->m_null)) {
        std::string 
          msg("Table::insertRow Row to be inserted missing req'd field ");
        msg = msg + m_userCols[i]->getName();
        throw RdbException(msg);
      }
    }
 
    // Fill in defaults
    fillDefaults(row);
 
    // Check standard valid row condition if there is one
    if (m_validRow) {
      bool satisfied;
      try {
        satisfied = m_validRow->verify(row, row);
      }
      catch (RdbException ex) {
        (*m_out) << ex.getMsg() << std::endl;
        return -1;
      }
      if (!satisfied) {
        // throw RdbException("Table::insertRow Row to be inserted is not valid");
        (*m_out) << "Table::insertRow Row to be inserted is not valid " 
                  << std::endl;
        m_out->flush();
        return -1;
      }
    }
    // Insert and exit
    std::vector<std::string> colNames;
    std::vector<std::string> colValues;
    std::vector<std::string> nullCols;
 
    row.regroup(colNames, colValues, nullCols);
    bool ok = m_connect->insertRow(m_name, colNames, colValues,
                                   serial, &nullCols);
    return (ok) ?  0 : -1;
  }    

Referenced by supersedeRow().

setConnection()

void rdbModel::Table::setConnection

(

Connection *

connect

)

Definition at line 49 of file Table.cxx.

                                               {
    m_connect = connect;
    m_out = connect->getOut();
    m_err = connect->getErrOut();
  }

sortColumns()

void rdbModel::Table::sortColumns

(

)

Definition at line 129 of file Table.cxx.

                           {
    if (m_sorted) return;
    m_sortedCols = m_cols;
 
    ColCompare  cmpObject;
 
    // Keep around original set so that rdbGUI will display them in
    // this order
    std::sort (m_sortedCols.begin(), m_sortedCols.end(), cmpObject); 
    m_sorted = true;
 
  }

supersedeRow()

int rdbModel::Table::supersedeRow	(	Row &	row,
		int	oldKey,
		int *	newKey = 0 ) const

Given some input values and primary key of an existing row, insert a new row which will supersede the old, according to prescription laid down in <supersede> element of the xml description of the dbs.
Good return value is 0

Definition at line 315 of file Table.cxx.

                                                                 {
    std::string oldKeyStr;
    facilities::Util::itoa(oldKey, oldKeyStr);
 
    if (m_primaryKeyCol.size() == 0) {
      throw RdbException("Table::supersedeRow No primary key column!");
    }
 
    // Confirm that row does not contain any of the fixed or oldForced columns
    row.rowSort();
    const std::vector<std::string>& forced = m_sup->getForced();
    for (unsigned i = 0; i < forced.size(); i++) {
      if (row.find(forced[i])) {
        //        throw RdbException
        //          (std::string("Table::supersedeRow bad column in input row ") +
        // forced[i]);
        (*m_out) << "Table::supersedeRow bad column in input row '"
                 << forced[i] << "'" << std::endl;
        m_out->flush();
        return -1;
      }
    }
    const std::vector<FieldVal>& fixed = m_sup->getFixed();
    for (unsigned i = 0; i < fixed.size(); i++) {
      if (row.find(fixed[i].m_colname)) {
        //        throw RdbException
        //          (std::string("Table::supersedeRow bad column in input row ") +
        //           fixed[i].m_colname);
        (*m_out) << "Table::supersedeRow bad column in input row " <<
          fixed[i].m_colname;
        m_out->flush();
        return -1;
      }
    }
 
    // Check that old row is supersedable
    if (!isSupersedable(oldKeyStr)) {
      *m_out << "Row " << oldKey << " is not supersedable" << std::endl;
      m_out->flush();
      return -1;
    }
    
    // Fill in fixed fields
    const std::vector<std::string>& fixedInterp = m_sup->getFixedInterp();
    for (unsigned i = 0; i < fixed.size(); i++) {
 
      FieldVal fv = fixed[i];
      if (fixedInterp[i].size() > 0) {
        Column* c = getColumnByName(fixed[i].m_colname);
        c->interpret(fixedInterp[i], fv.m_val);
      }
      row.addField(fv);
    }
    row.rowSort();
 
    // Fetch needed fields from row to be superseded (oldKey)
    Assertion::Operator* whereOp = 
      new Assertion::Operator(OPTYPEequal, m_primaryKeyCol,
                              oldKeyStr, FIELDTYPEold, FIELDTYPElit);
    Assertion* where = new Assertion(whereOp);
 
    std::vector<std::string> noCols;
    const std::vector<std::string>& fromOld = m_sup->getFromOld();
    noCols.clear();
    ResultHandle* results = m_connect->select(m_name, fromOld, 
                                              noCols, where);
    //    std::vector<std::string> vals;
    //    results->getRow(vals);
    std::vector<std::string*> vals;
    results->getRowPtrs(vals);
    // Merge as needed into our row.  First bunch may already be in the row
    unsigned nDef = m_sup->getOldDefaulted().size();
    for (unsigned i = 0; i < nDef; i++) {
      if (!(row.find(fromOld[i])) ) {
        if (vals[i] == 0) {
          row.addField(FieldVal(fromOld[i], "", true));
        }
        else {
          row.addField(FieldVal(fromOld[i], *vals[i]));
        }
        row.rowSort();
      }
    }
    // Remainder definitely have to be merged in
    for (unsigned i = nDef; i < fromOld.size(); i++) {
      if (vals[i] == 0) {
        row.addField(FieldVal(fromOld[i], "", true));
      }
      else {
        row.addField(FieldVal(fromOld[i], *vals[i]));
      }
    }
    results->cleanFieldPtrs(vals);
    
    // Insert the row and update old row
    int insRet;
    try {
      insRet = insertRow(row, serial);
    }
    catch (RdbException ex) {
      (*m_out) << ex.getMsg() << std::endl;
      insRet = -1;
    }
 
    if (insRet) { // something went wrong
      delete where;
      return insRet;
    }
 
    // Do the update of old row
    const std::vector<Set*>& setOld = m_sup->getSetOld();
    std::vector<FieldVal> oldFields;
    oldFields.reserve(setOld.size());
    for (unsigned i = 0; i < setOld.size(); i++) {
      std::string src = setOld[i]->getSrcValue();
      std::string col = setOld[i]->getDestColName();
      if (setOld[i]->hasInterp() ) {
        Column* c = getColumnByName(col);
        c->interpret(setOld[i]->getInterp(), src);
      }
      oldFields.push_back(FieldVal(col, src));
    }
    Row updateArg(oldFields);
    try {
      int iUpdated = updateRows(updateArg, where);
      if (iUpdated == 1) return 0;
      return -1;
    }
    catch (RdbException uEx) {
      (*m_out) << uEx.getMsg() << std::endl;
      return -1;
    }
  }

updateRows()

int rdbModel::Table::updateRows	(	Row &	row,
		Assertion *	where ) const

Silently fills in "service" fields as well as requested updates Good return value is 0

Definition at line 449 of file Table.cxx.

                                                        {
 
    if (!m_connect) {
      throw RdbException("Table::insertLatest Need matching connection");
    }
    row.rowSort();
 
    // Fill in columns in m_programCols list
    fillProgramCols(row, false);
 
    std::vector<std::string> colNames;
    std::vector<std::string> colValues;
    std::vector<std::string> nullCols;
 
    row.regroup(colNames, colValues, nullCols);
 
    return m_connect->update(m_name, colNames, colValues, where, &nullCols);
  }

Referenced by supersedeRow().

Friends And Related Symbol Documentation

rdbModel::Rdb

friend class rdbModel::Rdb

friend

Definition at line 97 of file Table.h.

rdbModel::XercesBuilder

friend class rdbModel::XercesBuilder

friend

Definition at line 96 of file Table.h.

---

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

• Table.h
• Table.cxx