QCassandraContext.cpp

Go to the documentation of this file.

/*
 * Text:
 *      QCassandraContext.cpp
 *
 * Description:
 *      Handling of the cassandra::KsDef.
 *
 * 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/QCassandraContext.h"
#include "QCassandraPrivate.h"
#include <stdexcept>

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


namespace QtCassandra
{

class QCassandraContextPrivate : public org::apache::cassandra::KsDef {};







QCassandraContext::QCassandraContext(QCassandra *cassandra, const QString& context_name)
    : f_private(new QCassandraContextPrivate),
      f_cassandra(cassandra)
      //f_options() -- auto-init
      //f_tables() -- 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(context_name)) {
        throw std::runtime_error("invalid context name (does not match [A-Za-z][A-Za-z0-9_]*)");
    }

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

QCassandraContext::~QCassandraContext()
{
}

QString QCassandraContext::contextName() const
{
    return f_private->name.c_str();
}

void QCassandraContext::setStrategyClass(const QString& strategy_class)
{
    f_private->__set_strategy_class(strategy_class.toUtf8().data());
}

QString QCassandraContext::strategyClass() const
{
    return f_private->strategy_class.c_str();
}

void QCassandraContext::setDescriptionOptions(const QCassandraContextOptions& options)
{
    f_options = options;
}

const QCassandraContext::QCassandraContextOptions& QCassandraContext::descriptionOptions() const
{
    return f_options;
}

void QCassandraContext::setDescriptionOption(const QString& option, const QString& value)
{
    f_options[option] = value;
}

QString QCassandraContext::descriptionOption(const QString& option) const
{
    return f_options[option];
}

QSharedPointer<QCassandraTable> QCassandraContext::table(const QString& table_name)
{
    // table already exists?
    QCassandraTables::iterator ti(f_tables.find(table_name));
    if(ti != f_tables.end()) {
        return ti.value();
    }

    // this is a new table, allocate it
    QSharedPointer<QCassandraTable> t(new QCassandraTable(this, table_name));
    f_tables.insert(table_name, t);
    return t;
}

const QCassandraTables& QCassandraContext::tables() const
{
    return f_tables;
}

QSharedPointer<QCassandraTable> QCassandraContext::findTable(const QString& table_name) const
{
    QCassandraTables::const_iterator it(f_tables.find(table_name));
    if(it == f_tables.end()) {
        QSharedPointer<QCassandraTable> null;
        return null;
    }
    return *it;
}

QCassandraTable& QCassandraContext::operator [] (const QString& table_name)
{
    QCassandraTable *table = findTable(table_name).data();
    if(table == NULL) {
        throw std::runtime_error("named table was not found, cannot return a reference");
    }

    return *table;
}

const QCassandraTable& QCassandraContext::operator [] (const QString& table_name) const
{
    const QCassandraTable *table = findTable(table_name).data();
    if(table == NULL) {
        throw std::runtime_error("named table was not found, cannot return a reference");
    }

    return *table;
}

void QCassandraContext::setReplicationFactor(int32_t factor)
{
    f_private->__set_replication_factor(factor);
}

void QCassandraContext::unsetReplicationFactor()
{
    f_private->__isset.replication_factor = false;
}

int32_t QCassandraContext::replicationFactor() const
{
    return f_private->replication_factor;
}

void QCassandraContext::setDurableWrites(bool durable_writes)
{
    f_private->__set_durable_writes(durable_writes);
}

void QCassandraContext::unsetDurableWrites()
{
    f_private->__isset.durable_writes = false;
}

bool QCassandraContext::durableWrites() const
{
    return f_private->durable_writes;
}

void QCassandraContext::parseContextDefinition(const void *data)
{
    const org::apache::cassandra::KsDef *ks = reinterpret_cast<const org::apache::cassandra::KsDef *>(data);

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

    // strategy class
    f_private->__set_strategy_class(ks->strategy_class);

    // replication factor
    if(ks->__isset.replication_factor) {
        f_private->__set_replication_factor(ks->replication_factor);
    }
    else {
        f_private->__isset.replication_factor = false;
    }

    // durable writes
    if(ks->__isset.durable_writes) {
        f_private->__set_durable_writes(ks->durable_writes);
    }
    else {
        f_private->__isset.durable_writes = false;
    }

    // the options is an array that we keep on our end
    f_options.clear();
    if(ks->__isset.strategy_options) {
        for(std::map<std::string, std::string>::const_iterator
                    o = ks->strategy_options.begin();
                    o != ks->strategy_options.end();
                    ++o) {
            // TBD: can option strings include binary data?
            f_options.insert(o->first.c_str(), o->second.c_str());
        }
    }

    // table definitions (CfDef, column family definitions)
    f_tables.clear();
    for(std::vector<org::apache::cassandra::CfDef>::const_iterator
                cf = ks->cf_defs.begin(); cf != ks->cf_defs.end(); ++cf) {
        QSharedPointer<QCassandraTable> t(table(cf->name.c_str()));
        const org::apache::cassandra::CfDef& cf_def = *cf;
        t->parseTableDefinition(&cf_def);
    }
}

void QCassandraContext::prepareContextDefinition(void *data) const
{
    org::apache::cassandra::KsDef *ks = reinterpret_cast<org::apache::cassandra::KsDef *>(data);
    *ks = *f_private;

    if(ks->strategy_class == "") {
        ks->strategy_class = "org.apache.cassandra.locator.LocalStrategy";
    }
    ks->__set_replication_factor(1);

    // copy the options
    ks->strategy_options.clear();
    for(QCassandraContextOptions::const_iterator
                o = f_options.begin(); o != f_options.end(); ++o)
    {
        ks->strategy_options.insert(
                std::pair<std::string, std::string>(o.key().toUtf8().data(),
                                                    o.value().toUtf8().data()));
    }
    ks->__isset.strategy_options = !ks->strategy_options.empty();

    // copy the tables -- apparently we cannot do that here!
    // instead we have to loop through the table in the previous
    // level and update each column family separately
    ks->cf_defs.clear();
    for(QtCassandra::QCassandraTables::const_iterator
            t = f_tables.begin();
            t != f_tables.end();
            ++t)
    {
        org::apache::cassandra::CfDef cf;
        (*t)->prepareTableDefinition(&cf);
        ks->cf_defs.push_back(cf);
    }
    //if(ks->cf_defs.empty()) ... problem? it's not optional...
}

void QCassandraContext::makeCurrent()
{
    if(f_cassandra == NULL) {
        throw std::runtime_error("this context was dropped and is not attached to a cassandra cluster anymore");
    }

    // we need a shared pointer to the context and the only way to
    // get that is to retrieve it using our name... (somewhat slow
    // but I don't see a cleaner way to do it without generating a
    // pointer reference loop.)
    QSharedPointer<QCassandraContext> me(f_cassandra->context(f_private->name.c_str()));
    f_cassandra->setCurrentContext(me);
}

void QCassandraContext::create()
{
    if(f_cassandra == NULL) {
        throw std::runtime_error("this context was dropped and is not attached to a cassandra cluster anymore");
    }

    f_cassandra->getPrivate()->createContext(*this);

    // If the user defined tables, we must mark them as loaded from Cassandra
    // which in this case would not otherwise happen!
    for(QtCassandra::QCassandraTables::const_iterator
            t = f_tables.begin();
            t != f_tables.end();
            ++t)
    {
        (*t)->setFromCassandra();
    }

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

void QCassandraContext::update()
{
    if(f_cassandra == NULL) {
        throw std::runtime_error("this context was dropped and is not attached to a cassandra cluster anymore");
    }

    f_cassandra->getPrivate()->updateContext(*this);
}

void QCassandraContext::drop()
{
    if(f_cassandra == NULL) {
        throw std::runtime_error("this context was dropped and is not attached to a cassandra cluster anymore");
    }

    f_cassandra->getPrivate()->dropContext(*this);
}

void QCassandraContext::dropTable(const QString& table_name)
{
    if(f_tables.find(table_name) != f_tables.end()) {
        // keep a shared pointer on the table
        QSharedPointer<QCassandraTable> t(table(table_name));

        // remove from the Cassandra database
        makeCurrent();
        f_cassandra->getPrivate()->dropTable(table_name);

        // disconnect all the cached data from this table
        t->unparent();
        f_tables.remove(table_name);
    }
}

void QCassandraContext::createTable(const QCassandraTable *table)
{
    makeCurrent();
    f_cassandra->getPrivate()->createTable(table);
}

void QCassandraContext::updateTable(const QCassandraTable *table)
{
    makeCurrent();
    f_cassandra->getPrivate()->updateTable(table);
}

void QCassandraContext::truncateTable(const QCassandraTable *table)
{
    makeCurrent();
    f_cassandra->getPrivate()->truncateTable(table);
}

void QCassandraContext::insertValue(const QString& table_name, const QByteArray& row_key, const QByteArray& column_key, const QCassandraValue& value)
{
    makeCurrent();
    f_cassandra->getPrivate()->insertValue(table_name, row_key, column_key, value);
}

void QCassandraContext::getValue(const QString& table_name, const QByteArray& row_key, const QByteArray& column_key, QCassandraValue& value)
{
    makeCurrent();
    f_cassandra->getPrivate()->getValue(table_name, row_key, column_key, value);
}

int32_t QCassandraContext::getCellCount(const QString& table_name, const QByteArray& row_key, const QCassandraColumnPredicate& column_predicate)
{
    makeCurrent();
    return f_cassandra->getPrivate()->getCellCount(table_name, row_key, column_predicate);
}

void QCassandraContext::getColumnSlice(QCassandraTable& table, const QByteArray& row_key, const QCassandraColumnPredicate& column_predicate)
{
    makeCurrent();
    f_cassandra->getPrivate()->getColumnSlice(table, row_key, column_predicate);
}

void QCassandraContext::remove(const QString& table_name, const QByteArray& row_key, const QByteArray& column_key, int64_t timestamp, consistency_level_t consistency_level)
{
    makeCurrent();
    f_cassandra->getPrivate()->remove(table_name, row_key, column_key, timestamp, consistency_level);
}

uint32_t QCassandraContext::getRowSlices(QCassandraTable& table, const QCassandraRowPredicate& row_predicate)
{
    makeCurrent();
    return f_cassandra->getPrivate()->getRowSlices(table, row_predicate);
}

void QCassandraContext::clearCache()
{
    // lose all the tables
    for(QCassandraTables::iterator ti(f_tables.begin()); ti != f_tables.end(); ++ti) {
        (*ti)->unparent();
    }
    f_tables.clear();
}

void QCassandraContext::unparent()
{
    f_cassandra = NULL;
    clearCache();
}

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