cql_connection.h

Go to the documentation of this file.

// Copyright (C) 2018-2019 Internet Systems Consortium, Inc. ("ISC")
// Copyright (C) 2015-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_CONNECTION_H
#define CQL_CONNECTION_H

#include <database/database_connection.h>

#include <cassandra.h>

#include <cstring>
#include <map>
#include <memory>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>

namespace isc {
namespace db {

typedef std::pair<uint32_t, uint32_t> VersionPair;

typedef char const* const StatementTag;

constexpr uint32_t CQL_DRIVER_VERSION_MAJOR = CASS_VERSION_MAJOR;
constexpr uint32_t CQL_DRIVER_VERSION_MINOR = CASS_VERSION_MINOR;

constexpr uint32_t CQL_SCHEMA_VERSION_MAJOR = 5u;
constexpr uint32_t CQL_SCHEMA_VERSION_MINOR = 0u;

struct CqlTaggedStatement {

    StatementTag name_;

    char const* const text_;

    const CassPrepared* prepared_statement_;

    bool is_raw_;

    CqlTaggedStatement(StatementTag name, char const* const text)
        : name_(name), text_(text), prepared_statement_(NULL), is_raw_(false) {
    }

    CqlTaggedStatement(StatementTag name, char const* const text, bool const& is_raw)
        : name_(name), text_(text), prepared_statement_(NULL), is_raw_(is_raw) {
    }
};

struct StatementTagHash {
    size_t operator()(StatementTag const& key) const {
        return std::hash<std::string>{}(std::string(key));
    }
};

struct StatementTagEqual {
    bool operator()(StatementTag const& lhs, StatementTag const& rhs) const {
        return std::strcmp(lhs, rhs) == 0;
    }
};

typedef std::unordered_map<StatementTag, CqlTaggedStatement,
                           StatementTagHash, StatementTagEqual> StatementMap;

typedef std::pair<StatementTag, CqlTaggedStatement> StatementMapEntry;

class CqlConnection : public db::DatabaseConnection {
public:
    explicit CqlConnection(const ParameterMap& parameters);

    virtual ~CqlConnection();

    static std::pair<uint32_t, uint32_t>
    getVersion(const ParameterMap& parameters);

    void prepareStatements(StatementMap& statements);

    void openDatabase();

    void setConsistency(bool force,
                        CassConsistency consistency,
                        CassConsistency serial_consistency);

    void startTransaction();

    virtual void commit();

    virtual void rollback();

    static CassConsistency parseConsistency(std::string value);

    static const std::string
    checkFutureError(const std::string& what,
                     CassFuture* future,
                     StatementTag statement_tag = NULL);

    StatementMap statements_;

    CassCluster* cluster_;

    CassSession* session_;

    CassConsistency consistency_;

    CassConsistency serial_consistency_;

    // @brief Schema meta information, used for UDTs
    const CassSchemaMeta* schema_meta_;

    const CassKeyspaceMeta* keyspace_meta_;

    bool force_consistency_;
};

typedef std::shared_ptr<CqlConnection> CqlConnectionPtr;

}  // namespace db
}  // namespace isc

#endif  // CQL_CONNECTION_H