sql_statement.h

/*
 * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved.
 *
 * 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.
 */
#pragma once
 
#include <chrono>
#include <cstddef>
#include <string>
 
#include <boost/optional/optional.hpp>
 
#include "hazelcast/util/export.h"
#include "hazelcast/client/serialization/pimpl/data.h"
#include "hazelcast/client/serialization/serialization.h"
#include "hazelcast/client/sql/sql_expected_result_type.h"
 
namespace hazelcast {
namespace client {
namespace sql {
class sql_service;

class HAZELCAST_API sql_statement
{
public:
    static constexpr std::chrono::milliseconds TIMEOUT_NOT_SET{ -1 };

    static constexpr std::chrono::milliseconds TIMEOUT_DISABLED{ 0 };

    static constexpr std::chrono::milliseconds DEFAULT_TIMEOUT =
      TIMEOUT_NOT_SET;

    static constexpr int32_t DEFAULT_CURSOR_BUFFER_SIZE = 4096;

    sql_statement(hazelcast_client& client, std::string query);

    const std::string& sql() const;

    sql_statement& sql(std::string sql_string);

    template<typename... Param>
    sql_statement& set_parameters(Param... params);

    template<typename Param>
    sql_statement& add_parameter(const Param& value);

    sql_statement& clear_parameters();

    int32_t cursor_buffer_size() const;

    sql_statement& cursor_buffer_size(int32_t size);

    std::chrono::milliseconds timeout() const;

    sql_statement& timeout(std::chrono::milliseconds timeout);

    sql_expected_result_type expected_result_type() const;

    sql_statement& expected_result_type(sql_expected_result_type type);

    std::shared_ptr<std::atomic<int32_t>> partition_argument_index() const;

    const boost::optional<std::string>& schema() const;

    sql_statement& schema(boost::optional<std::string> schema);
 
private:
    using data = serialization::pimpl::data;
    using serialization_service = serialization::pimpl::SerializationService;
 
    sql_statement(spi::ClientContext& client_context, std::string query);

    sql_statement& partition_argument_index(int32_t partition_argument_index);
 
    std::string sql_;
    std::vector<data> serialized_parameters_;
    int32_t cursor_buffer_size_;
    std::chrono::milliseconds timeout_;
    sql::sql_expected_result_type expected_result_type_;
    boost::optional<std::string> schema_;
    std::shared_ptr<std::atomic<int32_t>> partition_argument_index_;
 
    serialization_service& serialization_service_;
 
    friend hazelcast::client::sql::sql_service;
};
 
template<typename Param>
sql_statement&
sql_statement::add_parameter(const Param& param)
{
    serialized_parameters_.emplace_back(serialization_service_.to_data(param));
 
    return *this;
}
 
template<typename... Param>
sql_statement&
sql_statement::set_parameters(Param... params)
{
    int _[] = { 0, ((void)add_parameter(params), 0)... };
    (void)_;
    return *this;
}
 
} // namespace sql
} // namespace client
} // namespace hazelcast