Column.cxx

Go to the documentation of this file.

// $Header: /bes/bes/BossCvs/Calibration/rdbModel/src/Tables/Column.cxx,v 1.1.1.1 2005/10/17
// 06:10:53 maqm Exp $
 
#include "rdbModel/Tables/Column.h"
#include "facilities/Timestamp.h"
#include "rdbModel/Tables/Datatype.h"
#include "rdbModel/Tables/Table.h"
 
#include <algorithm>
namespace rdbModel {
 
  Column::~Column() { delete m_type; }
 
  Enum* Column::getEnum() const { return m_type->getEnum(); }
 
  const std::string& Column::getTableName() const { return m_myTable->getName(); }
 
  bool Column::okValue( const std::string& val, bool set ) const {
    // auto increment and datetime values are established by rdbms
    if ( set )
    {
 
      if ( ( m_from == FROMautoIncrement ) || ( m_from == FROMnow ) ) return false;
    }
 
    return m_type->okValue( val );
  }
 
  bool Column::isCompatible( const Column* otherCol ) const {
    return m_type->isCompatible( otherCol->m_type );
  }
 
  bool Column::isAutoIncrement() const { return ( m_from == FROMautoIncrement ); }
 
  bool Column::interpret( const std::string& interpType, std::string& val ) {
    // Currently only interpretation is for timestamp-like columns.
    // Value of interpType must be "time" and val must be "NOW".
    // In this case, substitute ascii current time
    if ( interpType.compare( std::string( "time" ) ) != 0 ) return false;
 
    Datatype::TYPES dtype = m_type->getType();
    if ( ( dtype != Datatype::TYPEdatetime ) && ( dtype != Datatype::TYPEtimestamp ) )
    { return false; }
    if ( val.compare( std::string( "NOW" ) ) != 0 ) return false;
 
    val = facilities::Timestamp().getString();
    return true;
  }
 
  Visitor::VisitorState Column::accept( Visitor* v ) {
 
    Visitor::VisitorState state = v->visitColumn( this );
    if ( state == Visitor::VBRANCHDONE ) return Visitor::VCONTINUE;
    return state;
  }
 
  void Row::rowSort() {
    if ( m_sorted ) return;
 
    FieldValCompare cmp;
    std::sort( m_fields.begin(), m_fields.end(), cmp );
    m_sorted = true;
  }
 
  FieldVal* Row::find( std::string colname ) {
    unsigned nField = m_fields.size();
    unsigned minI   = 0;
    unsigned maxI   = nField;
 
    unsigned guess    = maxI / 2;
    unsigned oldGuess = nField;
 
    int cmp = colname.compare( m_fields[guess].m_colname );
 
    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      = colname.compare( m_fields[guess].m_colname );
    }
    return &m_fields[guess];
  }
 
  void Row::regroup( std::vector<std::string>& colNames, std::vector<std::string>& colVals,
                     std::vector<std::string>& nullCols ) const {
    unsigned nFields = m_fields.size();
    colNames.reserve( nFields );
    colVals.reserve( nFields );
 
    for ( unsigned i = 0; i < nFields; i++ )
    {
      if ( m_fields[i].m_null ) { nullCols.push_back( m_fields[i].m_colname ); }
      else
      {
        colNames.push_back( m_fields[i].m_colname );
        colVals.push_back( m_fields[i].m_val );
      }
    }
  }
 
} // namespace rdbModel