cql_connection.h

Go to the documentation of this file.

// Copyright (C) 2018 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 = 3u;
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();
 
    void prepareStatements(StatementMap& statements);
 
    void openDatabase();
 
    void setConsistency(bool force, CassConsistency consistency);
 
    void startTransaction();
 
    virtual void commit();
 
    virtual void rollback();
 
    static const std::string
    checkFutureError(const std::string& what,
                     CassFuture* future,
                     StatementTag statement_tag = NULL);
 
    StatementMap statements_;
 
    CassCluster* cluster_;
 
    CassSession* session_;
 
    CassConsistency 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