QCassandraColumnPredicate.cpp

Go to the documentation of this file.

/*
 * Text:
 *      QCassandraColumnPredicate.cpp
 *
 * Description:
 *      Definition of column predicates to get row slices.
 *
 * 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/QCassandraColumnPredicate.h"
//#include "QtCassandra/QCassandraTable.h"
#include "thrift-gencpp-cassandra/cassandra_types.h"
#include <stdexcept>

namespace QtCassandra
{

QCassandraColumnPredicate::QCassandraColumnPredicate()
    //: f_consistency_level(CONSISTENCY_LEVEL_DEFAULT) -- auto-init
{
}

consistency_level_t QCassandraColumnPredicate::consistencyLevel() const
{
    return f_consistency_level;
}

void QCassandraColumnPredicate::setConsistencyLevel(consistency_level_t consistency_level)
{
    f_consistency_level = consistency_level;
}

void QCassandraColumnPredicate::toPredicate(void *data) const
{
    org::apache::cassandra::SlicePredicate *slice_predicate = reinterpret_cast<org::apache::cassandra::SlicePredicate *>(data);

    // using empty strings for the start & end make the slice range
    // return all the columns; although this way we're not offering
    // a limit and the reversed flag...
    slice_predicate->__isset.slice_range = true;
}









QCassandraColumnNamePredicate::QCassandraColumnNamePredicate()
    //: QCassandraColumnPredicate() -- auto-init
    //  f_column_keys() -- auto-init
{
}

void QCassandraColumnNamePredicate::clearColumns()
{
    f_column_keys.clear();
}

void QCassandraColumnNamePredicate::addColumnName(const QString& column_name)
{
    addColumnKey(column_name.toUtf8());
}

void QCassandraColumnNamePredicate::addColumnKey(const QByteArray& column_key)
{
    if(column_key.size() > 65535) {
        throw std::runtime_error("the column key is more than 64Kb");
    }
    f_column_keys.append(column_key);
}

const QCassandraColumnNamePredicate::QCassandraColumnKeys& QCassandraColumnNamePredicate::columnKeys() const
{
    return f_column_keys;
}

void QCassandraColumnNamePredicate::toPredicate(void *data) const
{
    org::apache::cassandra::SlicePredicate *slice_predicate = reinterpret_cast<org::apache::cassandra::SlicePredicate *>(data);

    slice_predicate->column_names.clear();
    for(QCassandraColumnKeys::const_iterator
            it = f_column_keys.begin();
            it != f_column_keys.end();
            ++it)
    {
        std::string key(it->data(), it->size());
        slice_predicate->column_names.push_back(key);
    }
    slice_predicate->__isset.column_names = true;
    slice_predicate->__isset.slice_range = false;
}








QCassandraColumnRangePredicate::QCassandraColumnRangePredicate()
    //: QCassandraColumnPredicate() -- auto-init
    //  f_start_column() -- auto-init
    //  f_end_column() -- auto-init
    //  f_reversed(false) -- auto-init
    //  f_count(100) -- auto-init
{
}

QString QCassandraColumnRangePredicate::startColumnName() const
{
    return QString::fromUtf8(f_start_column.data());
}

void QCassandraColumnRangePredicate::setStartColumnName(const QString& column_name)
{
    setStartColumnKey(column_name.toUtf8());
}

const QByteArray& QCassandraColumnRangePredicate::startColumnKey() const
{
    return f_start_column;
}

void QCassandraColumnRangePredicate::setStartColumnKey(const QByteArray& column_key)
{
    if(column_key.size() > 65535) {
        throw std::runtime_error("the start column key is more than 64Kb");
    }
    f_start_column = column_key;
}

QString QCassandraColumnRangePredicate::endColumnName() const
{
    return QString::fromUtf8(f_end_column.data());
}

void QCassandraColumnRangePredicate::setFinishColumnName(const QString& column_name)
{
    setFinishColumnKey(column_name.toUtf8());
}

const QByteArray& QCassandraColumnRangePredicate::endColumnKey() const
{
    return f_end_column;
}

void QCassandraColumnRangePredicate::setFinishColumnKey(const QByteArray& column_key)
{
    if(column_key.size() > 65535) {
        throw std::runtime_error("the end column key is more than 64Kb");
    }
    f_end_column = column_key;
}

bool QCassandraColumnRangePredicate::reversed() const
{
    return f_reversed;
}

void QCassandraColumnRangePredicate::setReversed(bool reversed)
{
    f_reversed = reversed;
}

int32_t QCassandraColumnRangePredicate::count() const
{
    return f_count;
}

void QCassandraColumnRangePredicate::setCount(int32_t count)
{
    f_count = count;
}

void QCassandraColumnRangePredicate::toPredicate(void *data) const
{
    org::apache::cassandra::SlicePredicate *slice_predicate = reinterpret_cast<org::apache::cassandra::SlicePredicate *>(data);

    slice_predicate->slice_range.__set_start(f_start_column.data());
    slice_predicate->slice_range.__set_finish(f_end_column.data());
    slice_predicate->slice_range.__set_reversed(f_reversed);
    slice_predicate->slice_range.__set_count(f_count);
    slice_predicate->__isset.slice_range = true;
    slice_predicate->__isset.column_names = false;
}


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