TableCursors.h

Go to the documentation of this file.

#ifndef TABLE_CURSORS_H
#define TABLE_CURSORS_H

#include "Table.h"

class TableScanCursor : public Table::Cursor {
  public:
    static ptr<TableScanCursor> factory(Table *table,
                                        ptr<SQLWhereClause> wc);

    bool avail() const {
        return _avail;
    }

    const char *rowData() const {
        ASSERT(avail());
        return (char *)_row.get_data();
    }

    virtual void deleteRow() const {
        try {
            _table->deleteFromIndexes(_key, _row);
            _dbc->del(0);
        } catch (DbException &e) {
            Throw(AuroraBadEntityException, string() +
                  "DbException while deleting row: "
                  + e.what());
        }
    }

    virtual void setTuple(const char *tuple) {
        _ctxt.setTuple(0, tuple);
    }

    virtual void reset() {
        try {
            int ret = _dbc->get(&_key, &_row, DB_FIRST);
            if (ret == DB_NOTFOUND) {
                // No rows.
                _avail = false;
            } else if (ret == 0) {
                _ctxt.setTuple(1, (const char *)_row.get_data());
                if (!_where_clause ||
                    _where_clause->eval<bool>(_ctxt)) {
                    DEBUG << "Satisfied the where clause";
                    _avail = true;
                } else {
                    // Find the next key.
                    ++(*this);
                }
            } else {
                // Shouldn't happen.
                ASSERT(false);
            }
        } catch (DbException &e) {
            Throw(AuroraBadEntityException, string() +
                  "DbException while resetting cursor: "
                  + e.what());
        }
    }

    virtual TableScanCursor& operator ++ () {
        try {
            int ret;
            while ((ret = _dbc->get(&_key, &_row, DB_NEXT)) == 0) {
                // TODO: Check the length of the returned row.
                _ctxt.reset();
                _ctxt.setTuple(1, (const char *)_row.get_data());
                // NULL _where_clause is true.
                if (!_where_clause ||
                    _where_clause->eval<bool>(_ctxt)) {
                    DEBUG << "Satisfied the where clause";
                    _avail = true;
                    return *this;
                }
            }
            if (ret == DB_NOTFOUND) {
                DEBUG << "No more results available in table";
                _avail = false;
            }
            return *this;
        } catch (DbException &e) {
            Throw(AuroraBadEntityException, string() +
                  "DbException while retrieving next result from table: "
                  + e.what());
        }
    }

    virtual string as_string() const {
        return "TableScanCursor(where=" +
            to_string(_where_clause) + ")" ;
    }

    // Reset will need to be called before this can be used.
    TableScanCursor(Table *table,
                    ptr<Expression> where_clause) :
        _table(table), _dbc(_table->getDbCursor()),
        _where_clause(where_clause), _ctxt(2)
    {
    }
    
    virtual ~TableScanCursor() {
        _dbc->close();
    }

  private:
    Table *_table;
    Dbc *_dbc;
    ptr<Expression> _where_clause;
    EvalContext _ctxt;
    Dbt _key;
    Dbt _row;
    bool _avail;
};

class KeyEqualCursor : public Table::Cursor {
  public:
    static ptr<KeyEqualCursor> factory(Table *table,
                                       ptr<SQLWhereClause> wc);

    bool avail() const {
        return _avail;
    }

    const char *rowData() const {
        ASSERT(avail());
        return (char *)_row.get_data();
    }

    virtual void deleteRow() const {
        try {
            _table->deleteFromIndexes(_key, _row);
            _dbc->del(0);
        } catch (DbException &e) {
            Throw(AuroraBadEntityException, string() +
                  "DbException while deleting row: "
                  + e.what());
        }
    }

    virtual void setTuple(const char *tuple) {
        _ctxt.setTuple(0, tuple);
    }

    virtual void reset() {
        try {
            Expression::evalVectorInto(_values, _key_buf, _ctxt);
            _key.set_data(_key_buf);
            _key.set_size(_key_size);

            int ret = _dbc->get(&_key, &_row, DB_SET);
            if (ret == DB_NOTFOUND) {
                // No rows.
                DEBUG << "No rows on reset for key "
                      << to_hex_string(_key_buf, _key_size);
                _avail = false;
            } else if (ret == 0) {
                // Set the tuple because broken things expect that.
                // TODO: Get rid of broken thigns.
                _ctxt.setTuple(1, (const char *)_row.get_data());
                // TODO: Eval the rest of the where clause, if any.
                DEBUG << "Satisfied the where clause";
                _avail = true;
            } else {
                // Shouldn't happen.
                ASSERT(false);
            }
        } catch (DbException &e) {
            Throw(AuroraBadEntityException, string() +
                  "DbException while resetting cursor: "
                  + e.what());
        }
    }

    virtual KeyEqualCursor& operator ++ () {
        // Only ever one valid row.
        _avail = false;
        return *this;
    }

    virtual string as_string() const {
        return "KeyEqualCursor(values=" + to_string(_values) + ")";
    }

    // Reset will need to be called before this can be used.
    KeyEqualCursor(Table *table, size_t key_size,
                   ptr<Expression> value) :
        _table(table),
        _dbc(_table->getDbCursor()), _values(1),
        _ctxt(2), _key_size(key_size)
    {
        _values[0] = value;
        _key_buf = new char[_key_size];
    }
    
    // Reset will need to be called before this can be used.
    KeyEqualCursor(Table *table, size_t key_size,
                   vector<ptr<Expression> > values) :
        _table(table), _dbc(_table->getDbCursor()), _values(values),
        _ctxt(2), _key_size(key_size)
    {
        _key_buf = new char[_key_size];
    }
    
    virtual ~KeyEqualCursor() {
        _dbc->close();
        delete[] _key_buf;
    }

  private:
    Table *_table;
    Dbc *_dbc;
    vector<ptr<Expression> > _values;
    EvalContext _ctxt;
    size_t _key_size;
    char *_key_buf;
    Dbt _key;
    Dbt _row;
    bool _avail;
};

class IndexKeyEqualCursor : public Table::Cursor {
  public:
    static ptr<IndexKeyEqualCursor> factory(Table *table,
                                            ptr<SQLWhereClause> wc);

    virtual bool avail() const {
        return _avail;
    }

    const char *rowData() const {
        ASSERT(avail());
        return (char *)_row.get_data();
    }

    virtual void deleteRow() const {
        try {
            _table->deleteFromIndexes(_pkey, _row);
            _pdbc->del(0);
        } catch (DbException &e) {
            Throw(AuroraBadEntityException, string() +
                  "DbException while deleting row: "
                  + e.what());
        }
    }

    virtual void setTuple(const char *tuple) {
        _ctxt.setTuple(0, tuple);
    }

    virtual void reset() {
        try {
            _value->evalInto(_key_buf, _ctxt);
            _skey.set_data(_key_buf);
            _skey.set_size(_key_size);

            int ret = _sdbc->get(&_skey, &_pkey, DB_SET);
            if (ret == DB_NOTFOUND) {
                // No rows.
                DEBUG << "No rows on reset for secondary key "
                      << _skey;
                _avail = false;
            } else if (ret == 0) {
                getPrimaryRow();
                return;
            } else {
                // Shouldn't happen.
                ASSERT(false);
            }
        } catch (DbException &e) {
            Throw(AuroraBadEntityException, string() +
                  "DbException while resetting cursor: "
                  + e.what());
        }
    }

    virtual IndexKeyEqualCursor& operator ++ () {
        // TODO: There may be more rows, duplicate secondary keys should be allowed.
        // Only ever one valid row.
        int ret = _sdbc->get(&_skey, &_pkey, DB_NEXT_DUP);
        if (ret == DB_NOTFOUND) {
            // No more rows.
            _avail = false;
        } else if (ret == 0) {
            getPrimaryRow();
        } else {
            // Shouldn't happen.
            ASSERT(false);
        }
        return *this;
    }

    virtual string as_string() const {
        return "IndexKeyEqualCursor(value=" + to_string(_value) + ")";
    }

    // Reset will need to be called before this can be used.
    IndexKeyEqualCursor(Table *table, TableIndex *table_index,
                        size_t key_size, ptr<Expression> value) :
        _table(table), _table_index(table_index),
        _pdbc(_table->getDbCursor()),
        _sdbc(_table_index->getDbCursor()),
        _value(value), _ctxt(2), _key_size(key_size),
        _key_buf(new char[_key_size]), _avail(false)
    {}

    virtual ~IndexKeyEqualCursor() {
        _pdbc->close();
        _sdbc->close();
        delete[] _key_buf;
    }

  private:
    void getPrimaryRow() {
        int ret = _pdbc->get(&_pkey, &_row, DB_SET);
        if (ret == DB_NOTFOUND) {
            // No rows. This should never happen.
            FATAL << "No rows for primary key " << _pkey;
        } else if (ret == 0) {
            // Set the tuple because broken things expect that.
            // TODO: Get rid of broken thigns.
            _ctxt.setTuple(1, (const char *)_row.get_data());
            // TODO: Eval the rest of the where clause, if any.
            DEBUG << "Satisfied the where clause";
            _avail = true;
        } else {
            // Shouldn't happen.
            ASSERT(false);
        }
    }

    Table *_table;
    TableIndex *_table_index;
    Dbc *_pdbc;
    Dbc *_sdbc;
    ptr<Expression> _value;
    EvalContext _ctxt;
    size_t _key_size;
    char *_key_buf;
    Dbt _pkey;
    Dbt _skey;
    Dbt _row;
    bool _avail;
};

#endif

---