/*
 * 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.
 */

#include "ignite_runner_suite.h"

#include "ignite/client/ignite_client.h"
#include "ignite/client/ignite_client_configuration.h"

#include <gmock/gmock-matchers.h>
#include <gtest/gtest.h>

#include <chrono>

using namespace ignite;

const std::string LONG_QUERY{"SELECT * FROM system_range(0, 10000000000)"};

/**
 * Test suite.
 */
class sql_test : public ignite_runner_suite {
protected:
    static void SetUpTestSuite() {
        ignite_client_configuration cfg{get_node_addrs()};
        cfg.set_logger(get_logger());
        auto client = ignite_client::start(cfg, std::chrono::seconds(30));

        client.get_sql().execute(nullptr, nullptr, {"DROP TABLE IF EXISTS TEST"}, {});
        client.get_sql().execute(nullptr, nullptr, {"DROP TABLE IF EXISTS execute_script_success"}, {});
        client.get_sql().execute(nullptr, nullptr, {"DROP TABLE IF EXISTS execute_script_fail"}, {});

        client.get_sql().execute(nullptr, nullptr, {"CREATE TABLE TEST(ID INT PRIMARY KEY, VAL VARCHAR)"}, {});

        for (std::int32_t i = 0; i < 10; ++i) {
            client.get_sql().execute(nullptr, nullptr, {"INSERT INTO TEST VALUES (?, ?)"}, {i, "s-" + std::to_string(i)});
        }

        client.get_sql().execute(nullptr, nullptr,
            {"INSERT INTO TBL_ALL_COLUMNS_SQL("
             R"(STR, INT8, KEY, INT16, INT32, INT64, FLOAT, DOUBLE, "UUID", "DATE", "TIME", TIME2, "DATETIME", DATETIME2, )"
             R"("TIMESTAMP", TIMESTAMP2, "BLOB", "DECIMAL", "BOOLEAN"))"
             " VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"},
            {std::string("test"), std::int8_t(1), std::int64_t(42), std::int16_t(2), std::int32_t(3), std::int64_t(4),
                .5f, .6, uuid(0x123e4567e89b12d3, 0x7456426614174000), ignite_date(2023, 2, 7),
                ignite_time(17, 4, 12, 3543634), ignite_time(17, 4, 12, 3543634),
                ignite_date_time({2020, 7, 28}, {2, 15, 52, 6349879}),
                ignite_date_time({2020, 7, 28}, {2, 15, 52, 6349879}), ignite_timestamp(3875238472, 248760634),
                ignite_timestamp(3875238472, 248760634),
                std::vector<std::byte>{std::byte(1), std::byte(2), std::byte(42)}, big_decimal(123456789098765), true});
    }

    static void TearDownTestSuite() {
        ignite_client_configuration cfg{get_node_addrs()};
        cfg.set_logger(get_logger());
        auto client = ignite_client::start(cfg, std::chrono::seconds(30));

        client.get_sql().execute(nullptr, nullptr, {"DELETE FROM TBL_ALL_COLUMNS_SQL"}, {});
        client.get_sql().execute(nullptr, nullptr, {"DROP TABLE TEST"}, {});
        client.get_sql().execute(nullptr, nullptr, {"DROP TABLE IF EXISTS execute_script_success"}, {});
    }

    void SetUp() override {
        ignite_client_configuration cfg{get_node_addrs()};
        cfg.set_logger(get_logger());

        m_client = ignite_client::start(cfg, std::chrono::seconds(30));
    }

    void TearDown() override {
        // remove all
    }

    primitive execute_statement_one_result(const sql_statement &statement) {
        auto result_set0 = m_client.get_sql().execute(nullptr, nullptr, statement, {});

        EXPECT_TRUE(result_set0.has_rowset());
        return result_set0.current_page().front().get(0);
    }

    /** Ignite client. */
    ignite_client m_client;
};

static void check_columns(
    const result_set_metadata &meta, std::initializer_list<std::tuple<std::string, ignite_type>> columns) {

    ASSERT_EQ(columns.size(), meta.columns().size());
    size_t i = 0;
    for (auto &column : columns) {
        EXPECT_EQ(i, meta.index_of(std::get<0>(column)));
        EXPECT_EQ(meta.columns()[i].name(), std::get<0>(column));
        EXPECT_EQ(meta.columns()[i].type(), std::get<1>(column));
        ++i;
    }
}

TEST_F(sql_test, sql_simple_select) {
    auto result_set = m_client.get_sql().execute(nullptr, nullptr, {"select 42, 'Lorem'"}, {});

    EXPECT_FALSE(result_set.was_applied());
    EXPECT_TRUE(result_set.has_rowset());
    EXPECT_EQ(-1, result_set.affected_rows());

    check_columns(result_set.metadata(), {{"42", ignite_type::INT32}, {"'Lorem'", ignite_type::STRING}});

    auto page = std::move(result_set).current_page();

    EXPECT_EQ(1, page.size());
    EXPECT_EQ(42, page.front().get(0).get<std::int32_t>());
    EXPECT_EQ("Lorem", page.front().get(1).get<std::string>());

    EXPECT_FALSE(result_set.has_more_pages());
    EXPECT_EQ(0, result_set.current_page().size());
}

TEST_F(sql_test, sql_table_select) {
    auto result_set = m_client.get_sql().execute(nullptr, nullptr, {"select id, val from TEST order by id"}, {});

    EXPECT_FALSE(result_set.was_applied());
    EXPECT_TRUE(result_set.has_rowset());
    EXPECT_EQ(-1, result_set.affected_rows());

    check_columns(result_set.metadata(), {{"ID", ignite_type::INT32}, {"VAL", ignite_type::STRING}});

    auto page = result_set.current_page();

    EXPECT_EQ(10, page.size());

    for (std::int32_t i = 0; i < std::int32_t(page.size()); ++i) {
        EXPECT_EQ(i, page[i].get(0).get<std::int32_t>());
        EXPECT_EQ("s-" + std::to_string(i), page[i].get(1).get<std::string>());
    }

    EXPECT_FALSE(result_set.has_more_pages());
    EXPECT_EQ(10, result_set.current_page().size());
}

TEST_F(sql_test, sql_select_multiple_pages) {
    sql_statement statement{"select id, val from TEST order by id"};
    statement.page_size(1);

    auto result_set = m_client.get_sql().execute(nullptr, nullptr, statement, {});

    EXPECT_FALSE(result_set.was_applied());
    EXPECT_TRUE(result_set.has_rowset());
    EXPECT_EQ(-1, result_set.affected_rows());

    check_columns(result_set.metadata(), {{"ID", ignite_type::INT32}, {"VAL", ignite_type::STRING}});

    for (std::int32_t i = 0; i < 10; ++i) {
        auto page = result_set.current_page();

        EXPECT_EQ(1, page.size()) << "i=" << i;
        EXPECT_EQ(i, page.front().get(0).get<std::int32_t>());
        EXPECT_EQ("s-" + std::to_string(i), page.front().get(1).get<std::string>());

        if (i < 9) {
            ASSERT_TRUE(result_set.has_more_pages());
            result_set.fetch_next_page();
        }
    }

    EXPECT_FALSE(result_set.has_more_pages());
}

TEST_F(sql_test, sql_close_non_empty_cursor) {
    sql_statement statement{"select id, val from TEST order by id"};
    statement.page_size(3);

    auto result_set = m_client.get_sql().execute(nullptr, nullptr, statement, {});

    EXPECT_FALSE(result_set.was_applied());
    EXPECT_TRUE(result_set.has_rowset());
    EXPECT_EQ(-1, result_set.affected_rows());

    auto page = result_set.current_page();
    ASSERT_TRUE(result_set.has_more_pages());

    result_set.close();
}

TEST_F(sql_test, sql_ddl_dml) {
    auto result_set = m_client.get_sql().execute(nullptr, nullptr, {"DROP TABLE IF EXISTS SQL_DDL_DML_TEST"}, {});

    EXPECT_FALSE(result_set.has_rowset());
    EXPECT_EQ(-1, result_set.affected_rows());
    EXPECT_TRUE(result_set.metadata().columns().empty());

    result_set =
        m_client.get_sql().execute(nullptr, nullptr, {"CREATE TABLE SQL_DDL_DML_TEST(ID BIGINT PRIMARY KEY, VAL VARCHAR)"}, {});

    EXPECT_TRUE(result_set.was_applied());
    EXPECT_FALSE(result_set.has_rowset());
    EXPECT_EQ(-1, result_set.affected_rows());
    EXPECT_TRUE(result_set.metadata().columns().empty());

    result_set = m_client.get_sql().execute(
        nullptr, nullptr, {"INSERT INTO SQL_DDL_DML_TEST VALUES (?, ?)"}, {std::int64_t(13), std::string("Hello")});

    EXPECT_FALSE(result_set.was_applied());
    EXPECT_FALSE(result_set.has_rowset());
    EXPECT_EQ(1, result_set.affected_rows());
    EXPECT_TRUE(result_set.metadata().columns().empty());

    result_set = m_client.get_sql().execute(
        nullptr, nullptr, {"INSERT INTO SQL_DDL_DML_TEST VALUES (?, ?)"}, {std::int64_t(14), std::string("World")});

    EXPECT_FALSE(result_set.was_applied());
    EXPECT_FALSE(result_set.has_rowset());
    EXPECT_EQ(1, result_set.affected_rows());
    EXPECT_TRUE(result_set.metadata().columns().empty());

    result_set = m_client.get_sql().execute(nullptr, nullptr, {"UPDATE SQL_DDL_DML_TEST SET VAL = ?"}, {std::string("Test")});

    EXPECT_FALSE(result_set.was_applied());
    EXPECT_FALSE(result_set.has_rowset());
    EXPECT_EQ(2, result_set.affected_rows());
    EXPECT_TRUE(result_set.metadata().columns().empty());

    result_set = m_client.get_sql().execute(nullptr, nullptr, {"DROP TABLE SQL_DDL_DML_TEST"}, {});

    EXPECT_TRUE(result_set.was_applied());
    EXPECT_FALSE(result_set.has_rowset());
    EXPECT_EQ(-1, result_set.affected_rows());
    EXPECT_TRUE(result_set.metadata().columns().empty());
}

TEST_F(sql_test, sql_insert_null) {
    auto result_set = m_client.get_sql().execute(nullptr, nullptr, {"DROP TABLE IF EXISTS SQL_INSERT_NULL_TEST"}, {});
    result_set =
        m_client.get_sql().execute(nullptr, nullptr, {"CREATE TABLE SQL_INSERT_NULL_TEST(ID INT PRIMARY KEY, VAL VARCHAR)"}, {});

    ASSERT_TRUE(result_set.was_applied());

    result_set = m_client.get_sql().execute(nullptr, nullptr, {"INSERT INTO SQL_INSERT_NULL_TEST VALUES (13, NULL)"}, {});

    EXPECT_FALSE(result_set.was_applied());
    EXPECT_FALSE(result_set.has_rowset());
    EXPECT_EQ(1, result_set.affected_rows());
    EXPECT_TRUE(result_set.metadata().columns().empty());

    result_set = m_client.get_sql().execute(nullptr, nullptr, {"DROP TABLE SQL_INSERT_NULL_TEST"}, {});
    EXPECT_TRUE(result_set.was_applied());
}

TEST_F(sql_test, sql_invalid_query) {
    EXPECT_THROW(
        {
            try {
                m_client.get_sql().execute(nullptr, nullptr, {"not a query"}, {});
            } catch (const ignite_error &e) {
                EXPECT_THAT(e.what_str(), ::testing::HasSubstr("Failed to parse query: Non-query expression"));
                throw;
            }
        },
        ignite_error);
}

TEST_F(sql_test, sql_unknown_table) {
    EXPECT_THROW(
        {
            try {
                m_client.get_sql().execute(nullptr, nullptr, {"select id from unknown_table"}, {});
            } catch (const ignite_error &e) {
                EXPECT_THAT(e.what_str(), ::testing::HasSubstr("Object 'UNKNOWN_TABLE' not found"));
                throw;
            }
        },
        ignite_error);
}

TEST_F(sql_test, sql_unknown_column) {
    EXPECT_THROW(
        {
            try {
                m_client.get_sql().execute(nullptr, nullptr, {"select unknown_column from test"}, {});
            } catch (const ignite_error &e) {
                EXPECT_THAT(e.what_str(), ::testing::HasSubstr("Column 'UNKNOWN_COLUMN' not found in any table"));
                throw;
            }
        },
        ignite_error);
}

TEST_F(sql_test, sql_create_existing_table) {
    EXPECT_THROW(
        {
            try {
                m_client.get_sql().execute(nullptr, nullptr, {"CREATE TABLE TEST(ID INT PRIMARY KEY, VAL VARCHAR)"}, {});
            } catch (const ignite_error &e) {
                EXPECT_THAT(e.what_str(), ::testing::HasSubstr("Table with name 'PUBLIC.TEST' already exists"));
                // TODO: IGNITE-21217 Check STMT_VALIDATION error code usage
                EXPECT_THAT(e.get_status_code(), ignite::error::code::STMT_VALIDATION);
                throw;
            }
        },
        ignite_error);
}

TEST_F(sql_test, sql_add_existing_column) {
    EXPECT_THROW(
        {
            try {
                m_client.get_sql().execute(nullptr, nullptr, {"ALTER TABLE TEST ADD COLUMN ID INT"}, {});
            } catch (const ignite_error &e) {
                EXPECT_THAT(e.what_str(), ::testing::HasSubstr("Column with name 'ID' already exists"));
                // TODO: IGNITE-21217 Check STMT_VALIDATION error code usage
                EXPECT_THAT(e.get_status_code(), ignite::error::code::STMT_VALIDATION);
                throw;
            }
        },
        ignite_error);
}

TEST_F(sql_test, sql_alter_nonexisting_table) {
    EXPECT_THROW(
        {
            try {
                m_client.get_sql().execute(nullptr, nullptr, {"ALTER TABLE UNKNOWN_TABLE ADD COLUMN ID INT"}, {});
            } catch (const ignite_error &e) {
                EXPECT_THAT(e.what_str(), ::testing::HasSubstr("Table with name 'PUBLIC.UNKNOWN_TABLE' not found"));
                // TODO: IGNITE-21217 Check STMT_VALIDATION error code usage
                EXPECT_THAT(e.get_status_code(), ignite::error::code::STMT_VALIDATION);
                throw;
            }
        },
        ignite_error);
}

TEST_F(sql_test, sql_statement_defaults) {
    sql_statement statement;

    EXPECT_EQ(statement.page_size(), sql_statement::DEFAULT_PAGE_SIZE);
    EXPECT_EQ(statement.schema(), sql_statement::DEFAULT_SCHEMA);
    EXPECT_EQ(statement.timeout(), sql_statement::DEFAULT_TIMEOUT);
}

TEST_F(sql_test, decimal_literal) {
    auto result_set = m_client.get_sql().execute(nullptr, nullptr, {"SELECT CAST('12345.6789' AS DECIMAL(9, 4))"}, {});

    EXPECT_TRUE(result_set.has_rowset());

    auto value = result_set.current_page().front().get(0).get<big_decimal>();

    EXPECT_EQ(4, value.get_scale());
    EXPECT_EQ(9, value.get_precision());

    std::stringstream ss;
    ss << value;
    auto value_str = ss.str();

    EXPECT_EQ("12345.6789", value_str);
}

TEST_F(sql_test, all_type_arguments) {
    auto result_set = m_client.get_sql().execute(nullptr, nullptr,
        {"select str,int8,int16,int32,int64,\"FLOAT\",\"DOUBLE\",\"UUID\",\"DATE\",\"TIME\",time2,"
         "\"DATETIME\",datetime2,\"TIMESTAMP\",timestamp2,\"BLOB\",\"DECIMAL\",\"BOOLEAN\" from TBL_ALL_COLUMNS_SQL"},
        {});

    EXPECT_TRUE(result_set.has_rowset());

    auto row = result_set.current_page().front();
    EXPECT_EQ(row.get(0).get<std::string>(), "test");
    EXPECT_EQ(row.get(1).get<std::int8_t>(), 1);
    EXPECT_EQ(row.get(2).get<std::int16_t>(), 2);
    EXPECT_EQ(row.get(3).get<std::int32_t>(), 3);
    EXPECT_EQ(row.get(4).get<std::int64_t>(), 4);
    EXPECT_FLOAT_EQ(row.get(5).get<float>(), 0.5f);
    EXPECT_DOUBLE_EQ(row.get(6).get<double>(), 0.6);
    EXPECT_EQ(row.get(7).get<uuid>(), uuid(0x123e4567e89b12d3, 0x7456426614174000));
    EXPECT_EQ(row.get(8).get<ignite_date>(), ignite_date(2023, 2, 7));
    EXPECT_EQ(row.get(9).get<ignite_time>(), ignite_time(17, 4, 12, 3000000));
    EXPECT_EQ(row.get(10).get<ignite_time>(), ignite_time(17, 4, 12, 3000000));
    EXPECT_EQ(row.get(11).get<ignite_date_time>(), ignite_date_time({2020, 7, 28}, {2, 15, 52, 6000000}));
    EXPECT_EQ(row.get(12).get<ignite_date_time>(), ignite_date_time({2020, 7, 28}, {2, 15, 52, 6000000}));
    EXPECT_EQ(row.get(13).get<ignite_timestamp>(), ignite_timestamp(3875238472, 248000000));
    EXPECT_EQ(row.get(14).get<ignite_timestamp>(), ignite_timestamp(3875238472, 248000000));
    EXPECT_EQ(row.get(16).get<big_decimal>(), big_decimal(123456789098765));
    EXPECT_EQ(row.get(17).get<bool>(), true);

    auto blob = row.get(15).get<std::vector<std::byte>>();
    EXPECT_EQ(blob[0], std::byte(1));
    EXPECT_EQ(blob[1], std::byte(2));
    EXPECT_EQ(blob[2], std::byte(42));
}

TEST_F(sql_test, uuid_literal) {
    auto result_set =
        m_client.get_sql().execute(nullptr, nullptr, {"SELECT CAST('df6bbb13-f2d2-42b4-bef9-7ab8524a0704' AS UUID)"}, {});

    EXPECT_TRUE(result_set.has_rowset());

    auto value = result_set.current_page().front().get(0).get<uuid>();

    std::stringstream ss;
    ss << value;
    auto value_str = ss.str();

    EXPECT_EQ("df6bbb13-f2d2-42b4-bef9-7ab8524a0704", value_str);
}

TEST_F(sql_test, uuid_argument) {
    uuid req{0x123e4567e89b12d3, 0x7456426614174000};
    auto result_set =
        m_client.get_sql().execute(nullptr, nullptr, {R"(select MAX("UUID") from TBL_ALL_COLUMNS_SQL WHERE "UUID" = ?)"}, {req});

    EXPECT_TRUE(result_set.has_rowset());

    auto value = result_set.current_page().front().get(0).get<uuid>();
    EXPECT_EQ(req, value);
}

TEST_F(sql_test, null_column) {
    auto result_set = m_client.get_sql().execute(nullptr, nullptr, {"select NULL"}, {});

    EXPECT_TRUE(result_set.has_rowset());

    auto &columns = result_set.metadata().columns();
    EXPECT_EQ(1, columns.size());
    EXPECT_EQ(ignite_type::NIL, columns.at(0).type());

    auto value = result_set.current_page().front().get(0);
    EXPECT_EQ(ignite_type::NIL, value.get_type());
    EXPECT_TRUE(value.is_null());
}

TEST_F(sql_test, execute_script_success) {
    m_client.get_sql().execute_script(nullptr,
        {"CREATE TABLE execute_script_success (id INT PRIMARY KEY, step INTEGER); "
            "INSERT INTO execute_script_success VALUES(1, 0); "
            "UPDATE execute_script_success SET step = 1; "
            "UPDATE execute_script_success SET step = 2; "},
        {});

    auto result_set = m_client.get_sql().execute(nullptr, nullptr, {"SELECT step FROM execute_script_success"}, {});
    EXPECT_TRUE(result_set.has_rowset());
    EXPECT_FALSE(result_set.has_more_pages());

    auto &columns = result_set.metadata().columns();
    EXPECT_EQ(1, columns.size());
    EXPECT_EQ(ignite_type::INT32, columns.at(0).type());

    ASSERT_EQ(1, result_set.current_page().size());
    auto value = result_set.current_page().front().get(0);
    EXPECT_EQ(ignite_type::INT32, value.get_type());
    EXPECT_EQ(2, value.get<std::int32_t>());
}

TEST_F(sql_test, execute_script_fail) {
    EXPECT_THROW(
        {
            try {
                m_client.get_sql().execute_script(nullptr,
                    {"CREATE TABLE execute_script_fail (id INT PRIMARY KEY, step INTEGER); "
                     "INSERT INTO execute_script_fail VALUES(1, 0); "
                     "UPDATE execute_script_fail SET step = 1; "
                     "UPDATE execute_script_fail SET step = 3 WHERE step > 1/0; "
                     "UPDATE execute_script_fail SET step = 2; "},
                    {});
            } catch (const ignite_error &e) {
                EXPECT_THAT(e.what_str(), ::testing::HasSubstr("Division by zero"));
                throw;
            }
        },
        ignite_error);

    auto result_set = m_client.get_sql().execute(nullptr, nullptr, {"SELECT step FROM execute_script_fail"}, {});
    EXPECT_TRUE(result_set.has_rowset());
    EXPECT_FALSE(result_set.has_more_pages());

    auto &columns = result_set.metadata().columns();
    EXPECT_EQ(1, columns.size());
    EXPECT_EQ(ignite_type::INT32, columns.at(0).type());

    ASSERT_EQ(1, result_set.current_page().size());
    auto value = result_set.current_page().front().get(0);
    EXPECT_EQ(ignite_type::INT32, value.get_type());
    EXPECT_EQ(1, value.get<std::int32_t>());
}

TEST_F(sql_test, timezone_passed) {
    sql_statement statement{"SELECT CURRENT_TIMESTAMP"};
    statement.timezone_id("UTC+8");
    auto ts0 = execute_statement_one_result(statement);
    EXPECT_EQ(ignite_type::TIMESTAMP, ts0.get_type());

    statement.timezone_id("UTC-2");
    auto ts1 = execute_statement_one_result(statement);
    EXPECT_EQ(ignite_type::TIMESTAMP, ts1.get_type());

    EXPECT_NE(ts0.get<ignite_timestamp>(), ts1.get<ignite_timestamp>());
}

/**
 * Execute and cancel request.
 * @param sql SQL facade.
 * @pagram tx Transaction.
 * @param query Query.
 * @param token Cancellation token.
 * @return Result set.
 */
std::future<result_set> execute_fut(sql sql, transaction *tx, const std::string &query, cancellation_token *token) {
    auto promise = std::make_shared<std::promise<result_set>>();
    sql.execute_async(tx, token, {query}, {}, result_promise_setter(promise));

    return promise->get_future();
}

/**
 * Execute and cancel request.
 * @param sql SQL facade.
 * @pagram tx Transaction.
 * @param query Query.
 * @return Result set.
 */
result_set execute_and_cancel(sql sql, transaction *tx, const std::string &query) {
    auto handle = cancel_handle::create();
    auto token = handle->get_token();

    auto fut = execute_fut(sql, tx, query, token.get());

    handle->cancel();
    return fut.get();
}

TEST_F(sql_test, cancel_statement) {
    EXPECT_THROW(
    {
        try {
            execute_and_cancel(m_client.get_sql(), nullptr, LONG_QUERY);
        } catch (const ignite_error &e) {
            EXPECT_EQ(e.get_status_code(), error::code::EXECUTION_CANCELLED);
            EXPECT_THAT(e.what_str(), ::testing::HasSubstr("The query was cancelled while executing"));
            throw;
        }
    },
    ignite_error);
}

TEST_F(sql_test, cancel_statement_tx) {
    auto tx = m_client.get_transactions().begin();
    EXPECT_THROW(
    {
        try {
            execute_and_cancel(m_client.get_sql(), &tx, LONG_QUERY);
        } catch (const ignite_error &e) {
            EXPECT_EQ(e.get_status_code(), error::code::EXECUTION_CANCELLED);
            EXPECT_THAT(e.what_str(), ::testing::HasSubstr("The query was cancelled while executing"));
            throw;
        }
    },
    ignite_error);
}

TEST_F(sql_test, cancel_query_before_execution) {
    auto handle = cancel_handle::create();
    auto token = handle->get_token();
    handle->cancel();

    EXPECT_THROW(
    {
        try {
            m_client.get_sql().execute(nullptr, token.get(), {"SELECT 1"}, {});
        } catch (const ignite_error &e) {
            EXPECT_EQ(e.get_status_code(), error::code::EXECUTION_CANCELLED);
            EXPECT_THAT(e.what_str(), ::testing::HasSubstr("The query was cancelled while executing"));
            throw;
        }
    },
    ignite_error);
}

TEST_F(sql_test, cancel_multiple_queries_using_same_token) {
    auto handle = cancel_handle::create();
    auto token = handle->get_token();

    std::array<result_set, 3> results;
    for (int i = 0; i < 3; i++) {
        results[i] = m_client.get_sql().execute(nullptr,token.get(), {LONG_QUERY}, {});
        results[i].fetch_next_page();
    }

    handle->cancel();

    for (int i = 0; i < 3; i++) {
        EXPECT_THROW(
        {
            try {
                while (results[i].has_more_pages()) {
                    results[i].fetch_next_page();
                }
            } catch (const ignite_error &e) {
                EXPECT_EQ(e.get_status_code(), error::code::EXECUTION_CANCELLED);
                EXPECT_THAT(e.what_str(), ::testing::HasSubstr("The query was cancelled while executing"));
                throw;
            }
        },
        ignite_error);
    }
}

TEST_F(sql_test, cancel_query_multiple_times) {
    auto handle = cancel_handle::create();
    auto token = handle->get_token();

    auto res = m_client.get_sql().execute(nullptr,token.get(), {LONG_QUERY}, {});

    handle->cancel();
    handle->cancel();
    handle->cancel();
    handle->cancel();

    EXPECT_THROW(
    {
        try {
            while (res.has_more_pages()) {
                res.fetch_next_page();
            }
        } catch (const ignite_error &e) {
            EXPECT_EQ(e.get_status_code(), error::code::EXECUTION_CANCELLED);
            EXPECT_THAT(e.what_str(), ::testing::HasSubstr("The query was cancelled while executing"));
            throw;
        }
    },
    ignite_error);

    handle->cancel();
    handle->cancel();
    handle->cancel();
    handle->cancel();
}