Table.h

Go to the documentation of this file.

#ifndef TABLE_H
#define TABLE_H

#include <db_cxx.h>
#include <string>

#include "Expression.h"
#include "SQLSelect.h"
#include "TupleDescription.h"
#include "xercesDomUtil.h"
#include "Params.h"

BOREALIS_NAMESPACE_BEGIN;

class AuroraNode;
class SQLSelect;
class SQLUpdate;
class Table;

class SelectQueryHandle {
  public:
    virtual void doQuery(const char *tuple) = 0;
        
    virtual bool avail() const = 0;

    virtual void evalInto(char *buf) = 0;

    virtual SelectQueryHandle& operator ++ () = 0;

    virtual ~SelectQueryHandle() {}
};

class UpdateQueryHandle {
  public:
    virtual void doUpdate(const char *tuple) = 0;
    virtual bool avail() const = 0;
    virtual void updateRow() = 0;

    // TODO: Check to make sure this specification is acceptable.
    // Only valid before updateRow is called.
    virtual const char *old_row() const = 0;
    // Only valid after updateRow is called.
    virtual const char *new_row() const = 0;

    virtual UpdateQueryHandle& operator ++ () = 0;

    virtual void doWholeUpdate(const char *tuple);
    virtual ~UpdateQueryHandle() {}
};

class ScanQueryHandle {
  public:
    virtual void doScan() = 0;

    virtual bool avail() const = 0;

    virtual const char *data() const = 0;

    virtual ScanQueryHandle& operator ++ () = 0;

    virtual ~ScanQueryHandle() {}
};

class DbHandle {
  public:
    DbHandle(DbEnv *dbe, int flags) : _open(false), _db(new Db(dbe, flags)) {}
    ~DbHandle() 
    { 
        if (_open) {
            try {
                DEBUG << "Closing DbHandle";
                _db->close(0);
            } catch (DbException &e) {
                NOTICE << "Caught DbException: " << e.what();
            }
        }
        delete _db;
    }
    // TODO: This is lame. Get it right.
    void mark_open() { _open = true; }
    Db *operator->() const { return _db; }
    Db *get() const { return _db; }
  private:
    DbHandle(const DbHandle &);
    DbHandle &operator=(const DbHandle &);
    bool _open; 
    Db *_db;
};

class TableEnvironment {
  public:
    TableEnvironment(AuroraNode &node);
    ~TableEnvironment()
    { 
        if (_open) {
            try {
                _db_env->close(0);
            } catch (DbException &e) {
                NOTICE << "Caught DbException: " << e.what();
            }
        }
        delete _db_env;
    }
    DbEnv *getDbEnv() { return _db_env; }
    const DbEnv *getDbEnv() const { return _db_env; }
  private:
    static void db_err_callback(const char *errpfx, char *msg);
    TableEnvironment(const TableEnvironment &);
    TableEnvironment &operator=(const TableEnvironment &);
    AuroraNode &_node;
    bool _open; // If true, table needs to be closed.
    DbEnv *_db_env;
};

class TableIndex {
  public:
    TableIndex(ptr<TableEnvironment> tenv, Table &table,
               string field_name);
    ~TableIndex() {}

    void insertRow(const Dbt &pkey, const Dbt &value);

    void deleteRow(const Dbt &pkey, const Dbt &value);

    string as_string() const
    {
        return "TableIndex(field=" + to_string(*_field) + ")";
    }

    string getFieldName() const
    {
        return _field->getName();
    }

    size_t getKeyLength() const { return _field->getSize(); }

    Dbc *getDbCursor();

  private:
    TableIndex(TableIndex &);
    TableIndex();
    TableIndex &operator=(TableIndex &);

    ptr<TableEnvironment> _tenv;
    Table &_table;
    DbHandle _db;
    const TupleDescription::Field *_field;
};
    

class Table {
  public:
    Table(string name, const TupleDescription schema,
          const DOMElement *element, ptr<TableEnvironment> tenv);

    Table(string name, TupleDescription schema, DBTYPE db_type,
          int db_open_flags, ptr<TableEnvironment> tenv);

    void Table::addIndex(const DOMElement *elt);

    ~Table();

    string getName() const { return _name; }

    const TupleDescription getSchema() const { return _schema; }

    void insert(const void *tuple);
    // TODO: This might want an ExprContext.
    ptr<SelectQueryHandle> compileSelect(ptr<SQLSelect> select);
    ptr<UpdateQueryHandle> compileUpdate(ptr<SQLUpdate> select);
    ptr<ScanQueryHandle> getScanQueryHandle();

    void sync();

    // For queue tables
    unsigned int deleteFromHead(unsigned int head);
    void insertIntoQueue(const void *tuple) throw (AuroraException);

    unsigned int getSize() throw (AuroraException);

    string as_string() const
    {
        return "Table{name=" + _name + "; schema=" + _schema.getName() + "}";
    }

    // The following methods are used by the cursors. They
    // should probably be protected in some way or another.
    Dbc *getDbCursor();
    const vector<string> &getKeyFieldNames() const
       { return _key_field_names; }
    vector<ptr<TableIndex> > &getIndexes() { return _indexes; }
    void insertIntoIndexes(const Dbt &_key, const Dbt &_value);
    void deleteFromIndexes(const Dbt &_key, const Dbt &_value);
    
  protected:
    void evalKey(char *buf, const char *row);

  private:
    string _name;
    Params _params;
    TupleDescription _schema;
    ptr<TableEnvironment> _tenv;
    DbHandle _db;
    DBTYPE _db_type;
    int _db_open_flags;

    vector<string> _key_field_names;
    vector<TupleDescription::Field> _key_fields;
    int _key_length;
    char *_key_buffer;

    vector<ptr<TableIndex> > _indexes;

    // Working buffer for new rows, used by doUpdate.
    // TODO: This might be vestigial.
    char *_row_buffer;

    void init();

  public:
    // Abstract base class for cursors.
    // TODO: Make cursors not share evalcontexts.
    class Cursor {
      public:
        virtual void setTuple(const char *tuple) = 0;

        virtual void reset() = 0;

        virtual bool avail() const = 0;

        virtual const char *rowData() const = 0;

        virtual void deleteRow() const = 0;

        virtual string as_string() const
        {
            return to_string(typeid(*this));
        }

        virtual Cursor& operator ++ () = 0;

        virtual ~Cursor() {}
      private:
        Cursor operator ++ (int);
    };

  private:
    ptr<Cursor> cursorFactory(ptr<SQLWhereClause> wc);
};

BOREALIS_NAMESPACE_END;

static inline string to_string(const Dbt &dbt) {
    return "Dbt(" + to_escaped_string(dbt.get_data(),
                                      dbt.get_size()) + ")";
}

#endif

---