QCassandraTable.cpp

Go to the documentation of this file.

/*
 * Text:
 *      QCassandraTable.cpp
 *
 * Description:
 *      Handling of the cassandra::CfDef (Column Family Definition).
 *
 * Documentation:
 *      See each function below.
 *
 * License:
 *      Copyright (c) 2011 Made to Order Software Corp.
 * 
 *      http://snapwebsites.org/
 *      contact@m2osw.com
 * 
 *      Permission is hereby granted, free of charge, to any person obtaining a
 *      copy of this software and associated documentation files (the
 *      "Software"), to deal in the Software without restriction, including
 *      without limitation the rights to use, copy, modify, merge, publish,
 *      distribute, sublicense, and/or sell copies of the Software, and to
 *      permit persons to whom the Software is furnished to do so, subject to
 *      the following conditions:
 *
 *      The above copyright notice and this permission notice shall be included
 *      in all copies or substantial portions of the Software.
 *
 *      THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 *      OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 *      MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 *      IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 *      CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 *      TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 *      SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#include "QtCassandra/QCassandraTable.h"
#include "QtCassandra/QCassandraContext.h"
#include "QCassandraPrivate.h"
#include "thrift-gencpp-cassandra/cassandra_types.h"
#include <stdexcept>

#include <QtCore/QDebug>
#include <QtCore/QRegExp>


namespace QtCassandra
{


class QCassandraTablePrivate : public org::apache::cassandra::CfDef {};





QCassandraTable::QCassandraTable(QCassandraContext *context, const QString& table_name)
    : //f_from_cassandra(false) -- auto-init
      f_private(new QCassandraTablePrivate),
      f_context(context)
      //f_column_definitions() -- auto-init
      //f_rows() -- auto-init
{
    // verify the name here (faster than waiting for the server and good documentation)
    QRegExp re("[A-Za-z][A-Za-z0-9_]*");
    if(!re.exactMatch(table_name)) {
        throw std::runtime_error("invalid column name (does not match [A-Za-z][A-Za-z0-9_]*)");
    }

    // we save the context name (keyspace) and since it's forbidden to change it
    // in the context, we know it won't change here either
    QString keyspace = context->contextName();
    f_private->__set_keyspace(keyspace.toUtf8().data());

    // we save the name and at this point we prevent it from being changed.
    f_private->__set_name(table_name.toUtf8().data());
}

QCassandraTable::~QCassandraTable()
{
}

QString QCassandraTable::contextName() const
{
    return f_private->keyspace.c_str();
}

QString QCassandraTable::tableName() const
{
    return f_private->name.c_str();
}

void QCassandraTable::setIdentifier(int32_t identifier)
{
    f_private->__set_id(identifier);
}

void QCassandraTable::unsetIdentifier()
{
    f_private->__isset.id = false;
}

int32_t QCassandraTable::identifier() const
{
    return f_private->id;
}

void QCassandraTable::setComment(QString comment)
{
    f_private->__set_comment(comment.toUtf8().data());
}

void QCassandraTable::unsetComment()
{
    f_private->__isset.comment = false;
}

QString QCassandraTable::comment() const
{
    return f_private->comment.c_str();
}

void QCassandraTable::setColumnType(const QString& column_type)
{
    if(column_type != "Standard" && column_type != "Super") {
        throw std::runtime_error("the type of a column can be either \"Standard\" or \"Super\".");
    }

    f_private->__set_column_type(column_type.toUtf8().data());
}

void QCassandraTable::unsetColumnType()
{
    f_private->__isset.column_type = false;
}

QString QCassandraTable::columnType() const
{
    return f_private->column_type.c_str();
}

void QCassandraTable::setDefaultValidationClass(const QString& validation_class)
{
    f_private->__set_default_validation_class(validation_class.toUtf8().data());
}

void QCassandraTable::unsetDefaultValidationClass()
{
    f_private->__isset.default_validation_class = false;
}

QString QCassandraTable::defaultValidationClass() const
{
    return f_private->default_validation_class.c_str();
}

void QCassandraTable::setKeyValidationClass(const QString& validation_class)
{
    f_private->__set_key_validation_class(validation_class.toUtf8().data());
}

void QCassandraTable::unsetKeyValidationClass()
{
    f_private->__isset.key_validation_class = false;
}

QString QCassandraTable::keyValidationClass() const
{
    return f_private->key_validation_class.c_str();
}

void QCassandraTable::setKeyAlias(const QString& key_alias)
{
    f_private->__set_key_alias(key_alias.toUtf8().data());
}

void QCassandraTable::unsetKeyAlias()
{
    f_private->__isset.key_alias = false;
}

QString QCassandraTable::keyAlias() const
{
    return f_private->key_alias.c_str();
}

void QCassandraTable::setComparatorType(const QString& comparator_type)
{
    f_private->__set_comparator_type(comparator_type.toUtf8().data());
}

void QCassandraTable::unsetComparatorType()
{
    f_private->__isset.comparator_type = false;
}

QString QCassandraTable::comparatorType() const
{
    return f_private->comparator_type.c_str();
}

void QCassandraTable::setSubcomparatorType(const QString& subcomparator_type)
{
    f_private->__set_subcomparator_type(subcomparator_type.toUtf8().data());
}

void QCassandraTable::unsetSubcomparatorType()
{
    f_private->__isset.subcomparator_type = false;
}

QString QCassandraTable::subcomparatorType() const
{
    return f_private->subcomparator_type.c_str();
}

QSharedPointer<QCassandraColumnDefinition> QCassandraTable::columnDefinition(const QString& column_name)
{
    // column already exists?
    QCassandraColumnDefinitions::iterator ci(f_column_definitions.find(column_name));
    if(ci != f_column_definitions.end()) {
        return ci.value();
    }

    // this is a new column, allocate it
    QSharedPointer<QCassandraColumnDefinition> c(new QCassandraColumnDefinition(this, column_name));
    f_column_definitions.insert(column_name, c);
    return c;
}

const QCassandraColumnDefinitions& QCassandraTable::columnDefinitions() const
{
    return f_column_definitions;
}

void QCassandraTable::setRowCacheSize(double size)
{
    f_private->__set_row_cache_size(size);
}

void QCassandraTable::unsetRowCacheSize()
{
    f_private->__isset.row_cache_size = false;
}

double QCassandraTable::rowCacheSize() const
{
    return f_private->row_cache_size;
}

void QCassandraTable::setRowCacheSavePeriodInSeconds(int32_t seconds)
{
    f_private->__set_row_cache_save_period_in_seconds(seconds);
}

void QCassandraTable::unsetRowCacheSavePeriodInSeconds()
{
    f_private->__isset.row_cache_save_period_in_seconds = false;
}

int32_t QCassandraTable::rowCacheSavePeriodInSeconds() const
{
    return f_private->row_cache_save_period_in_seconds;
}

void QCassandraTable::setKeyCacheSize(double size)
{
    f_private->__set_key_cache_size(size);
}

void QCassandraTable::unsetKeyCacheSize()
{
    f_private->__isset.key_cache_size = false;
}

double QCassandraTable::keyCacheSize() const
{
    return f_private->key_cache_size;
}

void QCassandraTable::setKeyCacheSavePeriodInSeconds(int32_t seconds)
{
    f_private->__set_key_cache_save_period_in_seconds(seconds);
}

void QCassandraTable::unsetKeyCacheSavePeriodInSeconds()
{
    f_private->__isset.key_cache_save_period_in_seconds = false;
}

int32_t QCassandraTable::keyCacheSavePeriodInSeconds() const
{
    return f_private->key_cache_save_period_in_seconds;
}

void QCassandraTable::setReadRepairChance(double repair_chance)
{
    f_private->__set_read_repair_chance(repair_chance);
}

void QCassandraTable::unsetReadRepairChance()
{
    f_private->__isset.read_repair_chance = false;
}

double QCassandraTable::readRepairChance() const
{
    return f_private->read_repair_chance;
}

void QCassandraTable::setMinCompactionThreshold(int32_t threshold)
{
    f_private->__set_min_compaction_threshold(threshold);
}

void QCassandraTable::unsetMinCompactionThreshold()
{
    f_private->__isset.min_compaction_threshold = false;
}

double QCassandraTable::minCompactionThreshold() const
{
    return f_private->min_compaction_threshold;
}

void QCassandraTable::setMaxCompactionThreshold(int32_t threshold)
{
    f_private->__set_max_compaction_threshold(threshold);
}

void QCassandraTable::unsetMaxCompactionThreshold()
{
    f_private->__isset.max_compaction_threshold = false;
}

double QCassandraTable::maxCompactionThreshold() const
{
    return f_private->max_compaction_threshold;
}

void QCassandraTable::setReplicateOnWrite(bool replicate_on_write)
{
    f_private->__set_replicate_on_write(replicate_on_write);
}

void QCassandraTable::unsetReplicateOnWrite()
{
    f_private->__isset.replicate_on_write = false;
}

bool QCassandraTable::replicateOnWrite() const
{
    f_private->replicate_on_write;
}

void QCassandraTable::setMergeShardsChance(double merge_shards_chance)
{
    f_private->__set_merge_shards_chance(merge_shards_chance);
}

void QCassandraTable::unsetMergeShardsChance()
{
    f_private->__isset.merge_shards_chance = false;
}

double QCassandraTable::mergeShardsChance() const
{
    return f_private->merge_shards_chance;
}

void QCassandraTable::setRowCacheProvider(const QString& provider)
{
    f_private->__set_row_cache_provider(provider.toUtf8().data());
}

void QCassandraTable::unsetRowCacheProvider()
{
    f_private->__isset.row_cache_provider = false;
}

QString QCassandraTable::rowCacheProvider() const
{
    return f_private->row_cache_provider.c_str();
}

void QCassandraTable::setGcGraceSeconds(int32_t seconds)
{
    f_private->__set_gc_grace_seconds(seconds);
}

void QCassandraTable::unsetGcGraceSeconds()
{
    f_private->__isset.gc_grace_seconds = false;
}

int32_t QCassandraTable::gcGraceSeconds() const
{
    return f_private->gc_grace_seconds;
}

void QCassandraTable::setMemtableFlushAfterMins(int32_t minutes)
{
    f_private->__set_memtable_flush_after_mins(minutes);
}

void QCassandraTable::unsetMemtableFlushAfterMins()
{
    f_private->__isset.memtable_flush_after_mins = false;
}

int32_t QCassandraTable::memtableFlushAfterMins() const
{
    return f_private->memtable_flush_after_mins;
}

void QCassandraTable::setMemtableThroughputInMb(int32_t megabytes)
{
    f_private->__set_memtable_throughput_in_mb(megabytes);
}

void QCassandraTable::unsetMemtableThroughputInMb()
{
    f_private->__isset.memtable_throughput_in_mb = false;
}

int32_t QCassandraTable::memtableThroughputInMb() const
{
    return f_private->memtable_throughput_in_mb;
}

void QCassandraTable::setMemtableOperationsInMillions(int32_t operations)
{
    f_private->__set_memtable_operations_in_millions(operations);
}

void QCassandraTable::unsetMemtableOperationsInMillions()
{
    f_private->__isset.memtable_operations_in_millions = false;
}

int32_t QCassandraTable::memtableOperationsInMillions() const
{
    return f_private->memtable_operations_in_millions;
}

void QCassandraTable::setFromCassandra()
{
    f_from_cassandra = true;
}

void QCassandraTable::parseTableDefinition(const void *data)
{
    const org::apache::cassandra::CfDef *cf = reinterpret_cast<const org::apache::cassandra::CfDef *>(data);

    if(cf->keyspace != f_private->keyspace) {
        // what do we do here?
        throw std::logic_error("CfDef and QCassandraTablePrivate context names don't match");
    }

    // table name
    if(cf->name != f_private->name) {
        // what do we do here?
        throw std::logic_error("CfDef and QCassandraTablePrivate table names don't match");
    }

    // column type
    if(cf->__isset.column_type) {
        f_private->__set_column_type(cf->column_type);
    }
    else {
        f_private->__isset.column_type = false;
    }

    // comparator type
    if(cf->__isset.comparator_type) {
        f_private->__set_comparator_type(cf->comparator_type);
    }
    else {
        f_private->__isset.comparator_type = false;
    }

    // sub-comparator type
    if(cf->__isset.subcomparator_type) {
        f_private->__set_subcomparator_type(cf->subcomparator_type);
    }
    else {
        f_private->__isset.subcomparator_type = false;
    }

    // comment
    if(cf->__isset.comment) {
        f_private->__set_comment(cf->comment);
    }
    else {
        f_private->__isset.comment = false;
    }

    // row cache size
    if(cf->__isset.row_cache_size) {
        f_private->__set_row_cache_size(cf->row_cache_size);
    }
    else {
        f_private->__isset.row_cache_size = false;
    }

    // key cache size
    if(cf->__isset.key_cache_size) {
        f_private->__set_key_cache_size(cf->key_cache_size);
    }
    else {
        f_private->__isset.key_cache_size = false;
    }

    // read repair chance
    if(cf->__isset.read_repair_chance) {
        f_private->__set_read_repair_chance(cf->read_repair_chance);
    }
    else {
        f_private->__isset.read_repair_chance = false;
    }

    // gc grace seconds
    if(cf->__isset.gc_grace_seconds) {
        f_private->__set_gc_grace_seconds(cf->gc_grace_seconds);
    }
    else {
        f_private->__isset.gc_grace_seconds = false;
    }

    // default validation class
    if(cf->__isset.default_validation_class) {
        f_private->__set_default_validation_class(cf->default_validation_class);
    }
    else {
        f_private->__isset.default_validation_class = false;
    }

    // identifier
    if(cf->__isset.id) {
        f_private->__set_id(cf->id);
    }
    else {
        f_private->__isset.id = false;
    }

    // min compaction threshold
    if(cf->__isset.min_compaction_threshold) {
        f_private->__set_min_compaction_threshold(cf->min_compaction_threshold);
    }
    else {
        f_private->__isset.min_compaction_threshold = false;
    }

    // max compaction threshold
    if(cf->__isset.max_compaction_threshold) {
        f_private->__set_max_compaction_threshold(cf->max_compaction_threshold);
    }
    else {
        f_private->__isset.max_compaction_threshold = false;
    }

    // row cache save period in seconds
    if(cf->__isset.row_cache_save_period_in_seconds) {
        f_private->__set_row_cache_save_period_in_seconds(cf->row_cache_save_period_in_seconds);
    }
    else {
        f_private->__isset.row_cache_save_period_in_seconds = false;
    }

    // key cache save period in seconds
    if(cf->__isset.key_cache_save_period_in_seconds) {
        f_private->__set_key_cache_save_period_in_seconds(cf->key_cache_save_period_in_seconds);
    }
    else {
        f_private->__isset.key_cache_save_period_in_seconds = false;
    }

    // memtable flush after mins
    if(cf->__isset.memtable_flush_after_mins) {
        f_private->__set_memtable_flush_after_mins(cf->memtable_flush_after_mins);
    }
    else {
        f_private->__isset.memtable_flush_after_mins = false;
    }

    // memtable_throughput_in_mb
    if(cf->__isset.memtable_throughput_in_mb) {
        f_private->__set_memtable_throughput_in_mb(cf->memtable_throughput_in_mb);
    }
    else {
        f_private->__isset.memtable_throughput_in_mb = false;
    }

    // memtable_operations_in_millions
    if(cf->__isset.memtable_operations_in_millions) {
        f_private->__set_memtable_operations_in_millions(cf->memtable_operations_in_millions);
    }
    else {
        f_private->__isset.memtable_operations_in_millions = false;
    }

    // replicate on write
    if(cf->__isset.replicate_on_write) {
        f_private->__set_replicate_on_write(cf->replicate_on_write);
    }
    else {
        f_private->__isset.replicate_on_write = false;
    }

    // merge shards chance
    if(cf->__isset.merge_shards_chance) {
        f_private->__set_merge_shards_chance(cf->merge_shards_chance);
    }
    else {
        f_private->__isset.merge_shards_chance = false;
    }

    // key validation class
    if(cf->__isset.key_validation_class) {
        f_private->__set_key_validation_class(cf->key_validation_class);
    }
    else {
        f_private->__isset.key_validation_class = false;
    }

    // row_cache_provider
    if(cf->__isset.row_cache_provider) {
        f_private->__set_row_cache_provider(cf->row_cache_provider);
    }
    else {
        f_private->__isset.row_cache_provider = false;
    }

    // key alias
    if(cf->__isset.key_alias) {
        f_private->__set_key_alias(cf->key_alias);
    }
    else {
        f_private->__isset.key_alias = false;
    }

    // table definitions (CfDef, column family definitions)
    f_column_definitions.clear();
    for(std::vector<org::apache::cassandra::ColumnDef>::const_iterator
                col = cf->column_metadata.begin(); col != cf->column_metadata.end(); ++col) {
        QSharedPointer<QCassandraColumnDefinition> column_definition(columnDefinition(col->name.c_str()));
        const org::apache::cassandra::ColumnDef& column_def(*col);
        column_definition->parseColumnDefinition(&column_def);
    }

    f_from_cassandra = true;
}

void QCassandraTable::prepareTableDefinition(void *data) const
{
    org::apache::cassandra::CfDef *cf = reinterpret_cast<org::apache::cassandra::CfDef *>(data);
    *cf = *f_private;

    // copy the columns
    cf->column_metadata.clear();
    for(QtCassandra::QCassandraColumnDefinitions::const_iterator
            c = f_column_definitions.begin();
            c != f_column_definitions.end();
            ++c)
    {
        org::apache::cassandra::ColumnDef col;
        (*c)->prepareColumnDefinition(&col);
        cf->column_metadata.push_back(col);
    }
    cf->__isset.column_metadata = !cf->column_metadata.empty();
}

void QCassandraTable::create()
{
    if(f_context == NULL) {
        throw std::runtime_error("this table was dropped and is not attached to a context anymore");
    }
    f_context->createTable(this);
    f_from_cassandra = true;

    // TBD: Should we then call describe_keyspace() on our Context
    //      to make sure we've got the right data (defaults) in this
    //      object and column definitions?
}

void QCassandraTable::update()
{
    if(f_context == NULL) {
        throw std::runtime_error("table was dropped and is not attached to a context anymore");
    }
    if(!f_from_cassandra) {
        // you cannot update a table that's not from Cassandra
        throw std::runtime_error("table is not defined in Cassandra, it cannot be updated there");
    }

    f_context->updateTable(this);

    // TBD: Should we then call describe_keyspace() on our Context
    //      to make sure we've got the right data (defaults) in this
    //      object and column definitions?
}

void QCassandraTable::clearCache()
{
    for(QCassandraRows::iterator ri(f_rows.begin()); ri != f_rows.end(); ++ri) {
        (*ri)->unparent();
    }
    f_rows.clear();
}

void QCassandraTable::truncate()
{
    if(f_context == NULL) {
        throw std::runtime_error("table was dropped and is not attached to a context anymore");
    }
    if(f_from_cassandra) {
        f_context->truncateTable(this);
    }

    // delete the memory cache too
    clearCache();
}

uint32_t QCassandraTable::readRows(const QCassandraRowPredicate& row_predicate)
{
    if(f_context == NULL) {
        throw std::runtime_error("table was dropped and is not attached to a context anymore");
    }
    if(f_from_cassandra) {
        return f_context->getRowSlices(*this, row_predicate);
    }
    return 0;
}

QSharedPointer<QCassandraRow> QCassandraTable::row(const QString& row_name)
{
    return row(row_name.toUtf8());
}

QSharedPointer<QCassandraRow> QCassandraTable::row(const QByteArray& row_key)
{
    // row already exists?
    QCassandraRows::iterator ri(f_rows.find(row_key));
    if(ri != f_rows.end()) {
        return ri.value();
    }

    // this is a new row, allocate it
    QSharedPointer<QCassandraRow> c(new QCassandraRow(this, row_key));
    f_rows.insert(row_key, c);
    return c;
}

const QCassandraRows& QCassandraTable::rows() const
{
    return f_rows;
}

QSharedPointer<QCassandraRow> QCassandraTable::findRow(const QString& row_name) const
{
    QCassandraRows::iterator ri(f_rows.find(row_name.toUtf8()));
    if(ri == f_rows.end()) {
        QSharedPointer<QCassandraRow> null;
        return null;
    }
    return *ri;
}

QSharedPointer<QCassandraRow> QCassandraTable::findRow(const QByteArray& row_key) const
{
    QCassandraRows::iterator ri(f_rows.find(row_key));
    if(ri == f_rows.end()) {
        QSharedPointer<QCassandraRow> null;
        return null;
    }
    return *ri;
}

bool QCassandraTable::exists(const QString& row_name) const
{
    return exists(row_name.toUtf8());
}

bool QCassandraTable::exists(const QByteArray& row_key) const
{
    QCassandraRows::iterator ri(f_rows.find(row_key));
    if(ri != f_rows.end()) {
        return true;
    }

    // in this case we're not given a column name so we cannot just
    // use the getValue() function to find out whether the row exists
    // instead we need to get a slice using this row key as the
    // slice parameter

    QCassandraRowPredicate row_predicate;
    row_predicate.setStartRowKey(row_key);
    row_predicate.setEndRowKey(row_key);

    // define a key range that is quite unlikely to match any column
    QSharedPointer<QCassandraColumnRangePredicate> column_predicate(new QCassandraColumnRangePredicate);
    QByteArray key;
    setInt32Value(key, 0x00000000);
    column_predicate->setStartColumnKey(key);
    setInt32Value(key, 0x00000001);
    column_predicate->setFinishColumnKey(key);
    column_predicate->setCount(1);
    row_predicate.setColumnPredicate(column_predicate);

    return const_cast<QCassandraTable *>(this)->readRows(row_predicate) != 0;
}

QCassandraRow& QCassandraTable::operator [] (const QString& row_name)
{
    // in this case we may create the row and that's fine!
    return *row(row_name).data();
}

QCassandraRow& QCassandraTable::operator[] (const QByteArray& row_key)
{
    // in this case we may create the row and that's fine!
    return *row(row_key).data();
}

const QCassandraRow& QCassandraTable::operator[] (const QString& row_name) const
{
    const QCassandraRow *row(findRow(row_name).data());
    if(row == NULL) {
        throw std::runtime_error("row does not exist so it cannot be read from");
    }
    return *row;
}

const QCassandraRow& QCassandraTable::operator[] (const QByteArray& row_key) const
{
    const QCassandraRow *row(findRow(row_key).data());
    if(row == NULL) {
        throw std::runtime_error("row does not exist so it cannot be read from");
    }
    return *row;
}

void QCassandraTable::dropRow(const QByteArray& row_key, QCassandraValue::timestamp_mode_t mode, int64_t timestamp, consistency_level_t consistency_level)
{
    if(QCassandraValue::TIMESTAMP_MODE_AUTO != mode && QCassandraValue::TIMESTAMP_MODE_DEFINED != mode) {
        throw std::runtime_error("invalid timestamp mode in dropRow()");
    }

    // default to the timestamp of the value (which is most certainly
    // what people want in 99.9% of the cases.)
    if(QCassandraValue::TIMESTAMP_MODE_AUTO == mode) {
        // at this point I think the best default for the drop is now
        timestamp = QCassandra::timeofday();
    }

    // use an empty key as the column key so the entire row gets removed
    QByteArray empty_key;
    remove(row_key, empty_key, timestamp, consistency_level);

    QSharedPointer<QCassandraRow> r(row(row_key));
    r->unparent();

    f_rows.remove(row_key);
}

void QCassandraTable::dropRow(const QString& row_name, QCassandraValue::timestamp_mode_t mode, int64_t timestamp, consistency_level_t consistency_level)
{
    dropRow(row_name.toUtf8(), mode, timestamp, consistency_level);
}

void QCassandraTable::insertValue(const QByteArray& row_key, const QByteArray& column_key, const QCassandraValue& value)
{
    if(f_context == NULL) {
        throw std::runtime_error("table was dropped and is not attached to a context anymore");
    }
    if(f_from_cassandra) {
        f_context->insertValue(tableName(), row_key, column_key, value);
    }
}

void QCassandraTable::getValue(const QByteArray& row_key, const QByteArray& column_key, QCassandraValue& value)
{
    if(f_context == NULL) {
        throw std::runtime_error("table was dropped and is not attached to a context anymore");
    }
    if(f_from_cassandra) {
        f_context->getValue(tableName(), row_key, column_key, value);
    }
}

void QCassandraTable::assignRow(const QByteArray& row_key, const QByteArray& column_key, const QCassandraValue& value)
{
    QSharedPointer<QCassandraRow> r(row(row_key));
    QSharedPointer<QCassandraCell> c(r->cell(column_key));
    c->assignValue(value); // assign the value to the cell so we avoid re-reading it
}

int32_t QCassandraTable::getCellCount(const QByteArray& row_key, const QCassandraColumnPredicate& column_predicate)
{
    if(f_context == NULL) {
        throw std::runtime_error("table was dropped and is not attached to a context anymore");
    }
    if(f_from_cassandra) {
        return f_context->getCellCount(tableName(), row_key, column_predicate);
    }

    // return the count from the memory cache
    return f_rows[row_key]->cells().size();
}

void QCassandraTable::getColumnSlice(const QByteArray& row_key, const QCassandraColumnPredicate& column_predicate)
{
    if(f_context == NULL) {
        throw std::runtime_error("table was dropped and is not attached to a context anymore");
    }
    if(f_from_cassandra) {
        f_context->getColumnSlice(*this, row_key, column_predicate);
    }
}

void QCassandraTable::remove(const QByteArray& row_key, const QByteArray& column_key, int64_t timestamp, consistency_level_t consistency_level)
{
    if(f_context == NULL) {
        throw std::runtime_error("table was dropped and is not attached to a context anymore");
    }
    if(f_from_cassandra) {
        f_context->remove(tableName(), row_key, column_key, timestamp, consistency_level);
    }
}

void QCassandraTable::unparent()
{
    f_context = NULL;
    clearCache();
}

} // namespace QtCassandra
// vim: ts=4 sw=4 et