sql_statement.h

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements. See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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 "ignite/common/primitive.h"
 
#include <chrono>
#include <cstdint>
#include <string>
#include <unordered_map>
 
namespace ignite {

class sql_statement {
public:
    static constexpr std::string_view DEFAULT_SCHEMA{"PUBLIC"};

    static constexpr std::int32_t DEFAULT_PAGE_SIZE{1024};

    static constexpr std::chrono::milliseconds DEFAULT_TIMEOUT{0};
 
    // Default
    sql_statement() = default;

    sql_statement( // NOLINT(google-explicit-constructor)
        std::string query, std::chrono::milliseconds timeout = DEFAULT_TIMEOUT, std::string schema = DEFAULT_SCHEMA.data(),
        std::int32_t page_size = DEFAULT_PAGE_SIZE,
        std::initializer_list<std::pair<const std::string, primitive>> properties = {}, std::string timezone_id = {})
        : m_query(std::move(query))
        , m_timeout(timeout)
        , m_schema(std::move(schema))
        , m_page_size(page_size)
        , m_properties(properties)
        , m_timezone_id(std::move(timezone_id)) {}

    [[nodiscard]] const std::string &query() const { return m_query; }

    void query(std::string val) { m_query = std::move(val); }

    [[nodiscard]] std::chrono::milliseconds timeout() const { return m_timeout; }

    void timeout(std::chrono::milliseconds val) { m_timeout = val; }

    [[nodiscard]] const std::string &schema() const { return m_schema; }

    void schema(std::string val) { m_schema = std::move(val); }

    [[nodiscard]] std::int32_t page_size() const { return m_page_size; }

    void page_size(std::int32_t val) { m_page_size = val; }

    [[nodiscard]] const std::unordered_map<std::string, primitive> &properties() const { return m_properties; }

    void properties(std::initializer_list<std::pair<const std::string, primitive>> val) { m_properties = val; }

    [[nodiscard]] const std::string &timezone_id() const { return m_timezone_id; }

    void timezone_id(std::string val) { m_timezone_id = std::move(val); }
 
private:
    std::string m_query;

    std::chrono::milliseconds m_timeout{DEFAULT_TIMEOUT};

    std::string m_schema{DEFAULT_SCHEMA};

    std::int32_t m_page_size{DEFAULT_PAGE_SIZE};

    std::unordered_map<std::string, primitive> m_properties;

    std::string m_timezone_id;
};
 
} // namespace ignite