cql_exchange.h

Go to the documentation of this file.

// Copyright (C) 2018,2021 Internet Systems Consortium, Inc. ("ISC")
// Copyright (C) 2016-2017 Deutsche Telekom AG.
//
// Authors: Razvan Becheriu <razvan.becheriu@qualitance.com>
//          Andrei Pavel <andrei.pavel@qualitance.com>
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//           http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef CQL_EXCHANGE_H
#define CQL_EXCHANGE_H

#include <cql/cql_connection.h>
#include <cql/sql_common.h>

#include <boost/any.hpp>  // for boost::any

#include <string>
#include <typeinfo>       // for std::type_info
#include <unordered_map>  // for std::unordered_map
#include <utility>
#include <vector>

namespace isc {
namespace db {

typedef std::vector<cass_byte_t> CassBlob;

class CqlExchange;

class AnyArray : public std::vector<boost::any> {
public:
    void add(const boost::any& value);

    void remove(const size_t& index);
};

// @brief Representation of a Cassandra User Defined Type
class Udt : public AnyArray {
public:
    Udt(const CqlConnection& connection, const std::string& name);

    ~Udt();

    void freeUserType();

    void newUserType();

    const CqlConnection& connection_;

    const std::string name_;

    const CassDataType* cass_data_type_;

    CassUserType* cass_user_type_;
};

typedef AnyArray AnyCollection;

typedef CassError (*CqlBindFunction)(const boost::any& value,
                                     const size_t& index,
                                     CassStatement* statement);

typedef CassError (*CqlUdtSetFunction)(const boost::any& value,
                                       const size_t& index,
                                       CassUserType* cass_user_type);

typedef CassError (*CqlCollectionAppendFunction)(const boost::any& value,
                                                 CassCollection* collection);

typedef CassError (*CqlGetFunction)(const boost::any& data,
                                    const CassValue* value);

struct CqlFunction {
    CqlBindFunction cqlBindFunction_;
    CqlUdtSetFunction cqlUdtSetFunction_;
    CqlCollectionAppendFunction cqlCollectionAppendFunction_;
    CqlGetFunction cqlGetFunction_;
};

class CqlExchange : public virtual SqlExchange {
public:
    CqlExchange();

    virtual ~CqlExchange();

    static void convertToDatabaseTime(const time_t& cltt,
                                      const uint32_t& valid_lifetime,
                                      cass_int64_t& expire);

    static void convertFromDatabaseTime(const cass_int64_t& expire,
                                        const cass_int64_t& valid_lifetime,
                                        time_t& cltt);

    virtual void createBindForSelect(AnyArray& data,
                                     StatementTag statement_tag = NULL) = 0;

    AnyArray executeSelect(const CqlConnection& connection,
                           const AnyArray& where_values,
                           StatementTag statement_tag,
                           const bool& single = false);

    void executeMutation(const CqlConnection& connection,
                         const AnyArray& assigned_values,
                         StatementTag statement_tag);

    bool statementApplied(CassFuture* future, size_t* row_count = NULL,
                          size_t* column_count = NULL);

    virtual boost::any retrieve() = 0;
};

class CqlVersionExchange : public virtual CqlExchange {
public:
    CqlVersionExchange();

    virtual ~CqlVersionExchange();

    virtual void
    createBindForSelect(AnyArray& data,
                        StatementTag statement_tag = NULL) override;

    virtual VersionPair retrieveVersion(const CqlConnection& connection);

    virtual boost::any retrieve() override;

    static constexpr StatementTag GET_VERSION = "GET_VERSION";

    static StatementMap tagged_statements_;

private:
    cass_int32_t version_;
    cass_int32_t minor_;
    VersionPair pair_;
};

class CqlCommon {
public:
    static void bindData(const AnyArray& data, CassStatement* statement);

    static void getData(const CassRow* row, AnyArray& data);
};

ExchangeDataType
exchangeType(const boost::any& object);

ExchangeDataType
exchangeType(const CassValueType& type);

}  // namespace db
}  // namespace isc

#endif  // CQL_EXCHANGE_H