sql_service.h

/*
 * Copyright (c) 2008-2025, 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 "hazelcast/util/export.h"
#include "hazelcast/client/sql/sql_result.h"
#include "hazelcast/client/sql/sql_statement.h"
#include "hazelcast/client/sql/hazelcast_sql_exception.h"
#include "hazelcast/client/sql/impl/read_optimized_lru_cache.h"
 
#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
#pragma warning(push)
#pragma warning(disable : 4251) // for dll export
#endif
 
namespace hazelcast {
namespace client {
namespace impl {
class hazelcast_client_instance_impl;
}
class hazelcast_client;
namespace sql {

class HAZELCAST_API sql_service
{
public:
    template<typename... Params>
    boost::future<std::shared_ptr<sql_result>> execute(const std::string& query,
                                      const Params&... params)
    {
        sql_statement s{ client_context_, query };
        int _[] = { 0, (s.add_parameter(params), 0)... };
        (void)_;
        return execute(s);
    }

    boost::future<std::shared_ptr<sql_result>> execute(
      const sql_statement& statement);
 
    std::shared_ptr<impl::read_optimized_lru_cache<std::string, int32_t>>
      partition_argument_index_cache_;
 
private:
    friend client::impl::hazelcast_client_instance_impl;
    friend sql_result;
 
    client::spi::ClientContext& client_context_;
 
    bool is_smart_routing_;
 
    struct sql_execute_response_parameters
    {
        int64_t update_count;
        std::shared_ptr<sql_row_metadata> row_metadata;
        std::shared_ptr<sql_page> first_page;
        boost::optional<impl::sql_error> error;
        bool is_infinite_rows = false;
        bool is_infinite_rows_exist = false;
        int32_t partition_argument_index = -1;
        bool is_partition_argument_index_exists = false;
    };
 
    struct sql_fetch_response_parameters
    {
        boost::optional<std::shared_ptr<sql_page>> page;
        boost::optional<impl::sql_error> error;
    };
 
    explicit sql_service(client::spi::ClientContext& context);
 
    std::shared_ptr<connection::Connection> query_connection();
    std::shared_ptr<connection::Connection> query_connection(
      int32_t partition_id);
 
    boost::optional<int32_t> extract_partition_id(
      const sql_statement& statement,
      const int32_t arg_index) const;
 
    void rethrow(const std::exception& exc_ptr);
    void rethrow(const std::exception& cause_ptr,
                 const std::shared_ptr<connection::Connection>& connection);
 
    boost::uuids::uuid client_id();
 
    std::shared_ptr<sql_result> handle_execute_response(
      const std::string& sql_query,
      const int32_t original_partition_argument_index,
      protocol::ClientMessage& msg,
      std::shared_ptr<connection::Connection> connection,
      impl::query_id id,
      int32_t cursor_buffer_size,
      std::weak_ptr<std::atomic<int32_t>> statement_par_arg_index_ptr);
 
    static sql_execute_response_parameters decode_execute_response(
      protocol::ClientMessage& msg);
 
    impl::query_id create_query_id(
      const std::shared_ptr<connection::Connection>& query_conn);
 
    boost::future<std::shared_ptr<sql_page>> fetch_page(
      const impl::query_id& q_id,
      int32_t cursor_buffer_size,
      const std::shared_ptr<connection::Connection>& connection);
 
    static sql_fetch_response_parameters decode_fetch_response(
      protocol::ClientMessage message);
 
    static void handle_fetch_response_error(
      boost::optional<impl::sql_error> error);

    boost::future<void> close(
      const std::shared_ptr<connection::Connection>& connection,
      impl::query_id id);
};
} // namespace sql
} // namespace client
} // namespace hazelcast
#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
#pragma warning(pop)
#endif