QCassandraRow.cpp

Go to the documentation of this file.

/*
 * Text:
 *      QCassandraRow.cpp
 *
 * Description:
 *      Handling of rows. There is no class representing a row in Cassandra.
 *      A row is just a key. We have this object to allow for our C++ array
 *      syntax to access the Cassandra data.
 *
 * 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/QCassandraRow.h"
#include "QtCassandra/QCassandraTable.h"
#include "QCassandraPrivate.h"
#include "thrift-gencpp-cassandra/cassandra_types.h"
#include <stdexcept>

namespace QtCassandra
{

QCassandraRow::QCassandraRow(QCassandraTable *table, const QByteArray& row_key)
    : f_table(table),
      f_key(row_key)
      //f_cells() -- auto-init
{
    if(f_key.size() > 64535) {
        throw std::runtime_error("row key is more than 64Kb");
    }
}

QCassandraRow::~QCassandraRow()
{
}

QString QCassandraRow::rowName() const
{
    return QString::fromUtf8(f_key.data());
}

const QByteArray& QCassandraRow::rowKey() const
{
    return f_key;
}

int QCassandraRow::cellCount(const QCassandraColumnPredicate& column_predicate)
{
    if(f_table == NULL) {
        throw std::runtime_error("row was dropped and is not attached to a table anymore");
    }
    f_table->getCellCount(f_key, column_predicate);
}

void QCassandraRow::readCells(const QCassandraColumnPredicate& column_predicate)
{
    if(f_table == NULL) {
        throw std::runtime_error("row was dropped and is not attached to a table anymore");
    }
    f_table->getColumnSlice(f_key, column_predicate);
}

QSharedPointer<QCassandraCell> QCassandraRow::cell(const QString& column_name)
{
    return cell(column_name.toUtf8());
}

QSharedPointer<QCassandraCell> QCassandraRow::cell(const QByteArray& column_key)
{
    // column already exists?
    QCassandraCells::iterator ci(f_cells.find(column_key));
    if(ci != f_cells.end()) {
        return ci.value();
    }

    // this is a new column, allocate it
    QSharedPointer<QCassandraCell> c(new QCassandraCell(this, column_key));
    f_cells.insert(column_key, c);
    return c;
}

const QCassandraCells& QCassandraRow::cells() const
{
    return f_cells;
}

QSharedPointer<QCassandraCell> QCassandraRow::findCell(const QString& column_name) const
{
    return findCell(column_name.toUtf8());
}

QSharedPointer<QCassandraCell> QCassandraRow::findCell(const QByteArray& column_key) const
{
    QCassandraCells::const_iterator ci(f_cells.find(column_key));
    if(ci == f_cells.end()) {
        QSharedPointer<QCassandraCell> null;
        return null;
    }
    return *ci;
}

bool QCassandraRow::exists(const QString& column_name) const
{
    return exists(column_name.toUtf8());
}

bool QCassandraRow::exists(const QByteArray& column_key) const
{
    if(f_table == NULL) {
        throw std::runtime_error("row was dropped and is not attached to a table anymore");
    }
    QCassandraCells::const_iterator ci(f_cells.find(column_key));
    if(ci != f_cells.end()) {
        // exists in the cache already
        return true;
    }

    // try reading this cell
    QCassandraValue value;
    try {
        f_table->getValue(f_key, column_key, value);
    }
    catch(const org::apache::cassandra::NotFoundException&) {
        // it doesn't exist in Cassandra either
        return false;
    }

    QSharedPointer<QCassandraCell> c(const_cast<QCassandraRow *>(this)->cell(column_key));
    c->setValue(value);

    return true;
}

QCassandraCell& QCassandraRow::operator [] (const QString& column_name)
{
    return *cell(column_name).data();
}

QCassandraCell& QCassandraRow::operator [] (const QByteArray& column_key)
{
    return *cell(column_key).data();
}

const QCassandraCell& QCassandraRow::operator [] (const QString& column_name) const
{
    return operator [] (column_name.toUtf8());
}

const QCassandraCell& QCassandraRow::operator [] (const QByteArray& column_key) const
{
    const QCassandraCell *cell = findCell(column_key).data();
    if(cell == NULL) {
        throw std::runtime_error("named column while retrieving a cell was not found, cannot return a reference");
    }

    return *cell;
}

void QCassandraRow::clearCache()
{
    for(QCassandraCells::iterator ci(f_cells.begin()); ci != f_cells.end(); ++ci) {
        (*ci)->unparent();
    }
    f_cells.clear();
}

void QCassandraRow::dropCell(const QByteArray& column_key, QCassandraValue::timestamp_mode_t mode, int64_t timestamp)
{
    if(f_table == NULL) {
        throw std::runtime_error("row was dropped and is not attached to a table anymore");
    }
    if(QCassandraValue::TIMESTAMP_MODE_AUTO != mode && QCassandraValue::TIMESTAMP_MODE_DEFINED != mode) {
        throw std::runtime_error("invalid timestamp mode in dropCell()");
    }

    QSharedPointer<QCassandraCell> c(cell(column_key));

    // 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) {
        // the current timestamp mode of f_value is currently ignored
        // because we cannot really know whether the f_value.timestamp()
        // value was assigned or not... (not from the mode that is)
        timestamp = c->value().timestamp();
    }
    f_table->remove(f_key, column_key, timestamp, c->value().consistencyLevel());
    f_cells.remove(column_key);
    c->unparent();
}

void QCassandraRow::dropCell(const QString& column_name, QCassandraValue::timestamp_mode_t mode, int64_t timestamp)
{
    dropCell(column_name.toUtf8(), mode, timestamp);
}

void QCassandraRow::insertValue(const QByteArray& column_key, const QCassandraValue& value)
{
    if(f_table == NULL) {
        throw std::runtime_error("row was dropped and is not attached to a table anymore");
    }
    f_table->insertValue(f_key, column_key, value);
}

void QCassandraRow::getValue(const QByteArray& column_key, QCassandraValue& value)
{
    if(f_table == NULL) {
        throw std::runtime_error("row was dropped and is not attached to a table anymore");
    }
    f_table->getValue(f_key, column_key, value);
}

void QCassandraRow::unparent()
{
    f_table = NULL;
    clearCache();
}

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