clickhouse-native 0.0.1

data/ext/clickhouse_native/vendor/clickhouse-cpp/README.md

@@ -0,0 +1,260 @@
+ClickHouse C++ client [![Linux](https://github.com/ClickHouse/clickhouse-cpp/actions/workflows/linux.yml/badge.svg)](https://github.com/ClickHouse/clickhouse-cpp/actions/workflows/linux.yml) [![macOS](https://github.com/ClickHouse/clickhouse-cpp/actions/workflows/macos.yml/badge.svg)](https://github.com/ClickHouse/clickhouse-cpp/actions/workflows/macos.yml) [![Windows MSVC](https://github.com/ClickHouse/clickhouse-cpp/actions/workflows/windows_msvc.yml/badge.svg)](https://github.com/ClickHouse/clickhouse-cpp/actions/workflows/windows_msvc.yml) [![Windows mingw](https://github.com/ClickHouse/clickhouse-cpp/actions/workflows/windows_mingw.yml/badge.svg)](https://github.com/ClickHouse/clickhouse-cpp/actions/workflows/windows_mingw.yml)
+=====
+
+C++ client for [ClickHouse](https://clickhouse.com/).
+
+## Supported data types
+
+* Array(T)
+* Date
+* DateTime, DateTime64
+* DateTime([timezone]), DateTime64(N, [timezone])
+* Decimal32, Decimal64, Decimal128
+* Enum8, Enum16
+* FixedString(N)
+* Float32, Float64
+* IPv4, IPv6
+* Nullable(T)
+* String
+* LowCardinality(String) or LowCardinality(FixedString(N))
+* Tuple
+* UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64
+* UInt128, Int128
+* UUID
+* Map
+* Point, Ring, Polygon, MultiPolygon
+
+## Dependencies
+In the most basic case one needs only:
+- a C++-17-complaint compiler,
+- `cmake` (3.12 or newer), and
+- `ninja`
+
+Optional dependencies:
+- openssl
+- liblz4
+- libabsl
+- libzstd
+
+## Building
+
+```sh
+$ mkdir build .
+$ cd build
+$ cmake .. [-DBUILD_TESTS=ON]
+$ make
+```
+
+Please refer to the workflows for the reference on dependencies/build options
+- https://github.com/ClickHouse/clickhouse-cpp/blob/master/.github/workflows/linux.yml
+- https://github.com/ClickHouse/clickhouse-cpp/blob/master/.github/workflows/windows_msvc.yml
+- https://github.com/ClickHouse/clickhouse-cpp/blob/master/.github/workflows/windows_mingw.yml
+- https://github.com/ClickHouse/clickhouse-cpp/blob/master/.github/workflows/macos.yml
+
+
+## Example application build with clickhouse-cpp
+
+There are various ways to integrate clickhouse-cpp with the build system of an application. Below example uses the simple approach based on
+submodules presented in https://www.youtube.com/watch?v=ED-WUk440qc .
+
+- `mkdir clickhouse-app && cd clickhouse-app && git init`
+- `git submodule add https://github.com/ClickHouse/clickhouse-cpp.git contribs/clickhouse-cpp`
+- `touch app.cpp`, then copy the following C++ code into that file
+
+```cpp
+#include <iostream>
+#include <clickhouse/client.h>
+
+using namespace clickhouse;
+
+int main()
+{
+    /// Initialize client connection.
+    Client client(ClientOptions().SetHost("localhost"));
+
+    /// Create a table.
+    client.Execute("CREATE TABLE IF NOT EXISTS default.numbers (id UInt64, name String) ENGINE = Memory");
+
+    /// Insert some values.
+    {
+        Block block;
+
+        auto id = std::make_shared<ColumnUInt64>();
+        id->Append(1);
+        id->Append(7);
+
+        auto name = std::make_shared<ColumnString>();
+        name->Append("one");
+        name->Append("seven");
+
+        block.AppendColumn("id"  , id);
+        block.AppendColumn("name", name);
+
+        client.Insert("default.numbers", block);
+    }
+
+    /// Select values inserted in the previous step.
+    client.Select("SELECT id, name FROM default.numbers", [] (const Block& block)
+        {
+            for (size_t i = 0; i < block.GetRowCount(); ++i) {
+                std::cout << block[0]->As<ColumnUInt64>()->At(i) << " "
+                          << block[1]->As<ColumnString>()->At(i) << "\n";
+            }
+        }
+    );
+
+    /// Select values inserted in the previous step using external data feature
+    /// See https://clickhouse.com/docs/engines/table-engines/special/external-data
+    {
+        Block block1, block2;
+        auto id = std::make_shared<ColumnUInt64>();
+        id->Append(1);
+        block1.AppendColumn("id"  , id);
+
+        auto name = std::make_shared<ColumnString>();
+        name->Append("seven");
+        block2.AppendColumn("name", name);
+
+        const std::string _1 = "_1";
+        const std::string _2 = "_2";
+
+        const ExternalTables external = {{_1, block1}, {_2, block2}};
+        client.SelectWithExternalData("SELECT id, name FROM default.numbers where id in (_1) or name in (_2)",
+                                      external, [] (const Block& block)
+            {
+                for (size_t i = 0; i < block.GetRowCount(); ++i) {
+                    std::cout << block[0]->As<ColumnUInt64>()->At(i) << " "
+                              << block[1]->As<ColumnString>()->At(i) << "\n";
+                }
+            }
+        );
+    }
+
+    /// Delete table.
+    client.Execute("DROP TABLE default.numbers");
+
+    return 0;
+}
+```
+
+- `touch CMakeLists.txt`, then copy the following CMake code into that file
+
+```cmake
+cmake_minimum_required(VERSION 3.12)
+project(application-example)
+
+set(CMAKE_CXX_STANDARD 17)
+
+add_subdirectory(contribs/clickhouse-cpp)
+
+add_executable(${PROJECT_NAME} "app.cpp")
+
+target_include_directories(${PROJECT_NAME} PRIVATE contribs/clickhouse-cpp/ contribs/clickhouse-cpp/contrib/absl)
+
+target_link_libraries(${PROJECT_NAME} PRIVATE clickhouse-cpp-lib)
+```
+
+- run `rm -rf build && cmake -B build -S . && cmake --build build -j32` to remove remainders of the previous builds, run CMake and build the
+  application. The generated binary is located in location `build/application-example`.
+
+## Batch Insertion
+
+In addition to the `Insert` method, which inserts all the data in a block in a
+single call, you can use the `BeginInsert` / `InsertData` / `EndInsert`
+pattern to insert batches of data. This can be useful for managing larger data
+sets without inflating memory with the entire set.
+
+To use it pass `BeginInsert` an `INSERT` statement ending in `VALUES` but with
+no actual values. Use the resulting `Block` to append batches of data, sending
+each to the sever with `InsertData`. Finally, call `EndInsert` (or let the
+client go out of scope) to signal the server that insertion is complete.
+Example:
+
+```cpp
+// Start the insertion.
+auto block = client->BeginInsert("INSERT INTO foo (id, name) VALUES");
+
+// Grab the columns from the block.
+auto col1 = block[0]->As<ColumnUInt64>();
+auto col2 = block[1]->As<ColumnString>();
+
+// Add a couple of records to the block.
+col1.Append(1);
+col1.Append(2);
+col2.Append("holden");
+col2.Append("naomi");
+
+// Send those records.
+block.RefreshRowCount();
+client->InsertData(block);
+block.Clear();
+
+// Add another record.
+col1.Append(3);
+col2.Append("amos");
+
+// Send it and finish.
+block.RefreshRowCount();
+client->EndInsert(block);
+```
+
+## Thread-safety
+⚠ Please note that `Client` instance is NOT thread-safe. I.e. you must create a separate `Client` for each thread or utilize some synchronization techniques. ⚠
+
+## Retries
+If you wish to implement some retry logic atop of `clickhouse::Client` there are few simple rules to make you life easier:
+- If previous attempt threw an exception, then make sure to call `clickhouse::Client::ResetConnection()` before the next try.
+- For `clickhouse::Client::Insert()` you can reuse a block from previous try, no need to rebuild it from scratch.
+
+See https://github.com/ClickHouse/clickhouse-cpp/issues/184 for details.
+
+## Asynchronous inserts
+See https://clickhouse.com/docs/en/cloud/bestpractices/asynchronous-inserts for details.
+
+⚠ The asynchronous setting is different according to the clickhouse-server version. The under example with clickhouse-server version 24.8.4.13. ⚠
+
+> Our strong recommendation is to use async_insert=1,wait_for_async_insert=1 if using asynchronous inserts. Using wait_for_async_insert=0 is very risky because your INSERT client may not be aware if there are errors, and also can cause potential overload if your client continues to write quickly in a situation where the ClickHouse server needs to slow down the writes and create some backpressure in order to ensure reliability of the service.
+
+- Only use the SDK, do not need to change the clickhouse-server config. Asynchronous inserts only work if the data is sent as SQL text format. Here is the example.
+```cpp
+// You can specify the asynchronous insert settings by using the SETTINGS clause of insert queries
+clickhouse::Query query("INSERT INTO default.test SETTINGS async_insert=1,wait_for_async_insert=1,async_insert_busy_timeout_ms=5000,async_insert_use_adaptive_busy_timeout=0,async_insert_max_data_size=104857600 VALUES(10,10)");
+client.Execute(query);
+
+// Or by SetSetting
+clickhouse::Query query("INSERT INTO default.test VALUES(10,10)");
+query.SetSetting("async_insert", clickhouse::QuerySettingsField{ "1", 1 });
+query.SetSetting("wait_for_async_insert", clickhouse::QuerySettingsField{ "1", 1 }); // strong recommendation
+query.SetSetting("async_insert_busy_timeout_ms", clickhouse::QuerySettingsField{ "5000", 1 });
+query.SetSetting("async_insert_max_data_size", clickhouse::QuerySettingsField{ "104857600", 1 });
+query.SetSetting("async_insert_use_adaptive_busy_timeout", clickhouse::QuerySettingsField{ "0", 1 });
+client.Execute(query);
+
+// Not available case. The Insert interface actually use the native data format
+clickhouse::Block block;
+client.Insert("default.test", block);
+```
+- Change the clickhouse-server users.xml, enable asynchronous inserts (available for the native data format). Here is the example.
+```xml
+<profiles>
+        <!-- Default settings. -->
+        <default>
+            <async_insert>1</async_insert>
+            <wait_for_async_insert>1</wait_for_async_insert>
+            <async_insert_use_adaptive_busy_timeout>0</async_insert_use_adaptive_busy_timeout>
+            <async_insert_busy_timeout_ms>5000</async_insert_busy_timeout_ms>
+            <async_insert_max_data_size>104857600</async_insert_max_data_size>
+        </default>
+
+        <!-- Profile that allows only read queries. -->
+        <readonly>
+            <readonly>1</readonly>
+        </readonly>
+    </profiles>
+```
+- Enabling asynchronous inserts at the user level. Ensure your login account has the privileges about ALTER USER. Then you can use insert_account for asynchronous inserts.
+```sql
+ALTER USER insert_account SETTINGS async_insert=1,wait_for_async_insert=1,async_insert_use_adaptive_busy_timeout=0,async_insert_busy_timeout_ms=5000,async_insert_max_data_size=104857600
+```
+
+

data/ext/clickhouse_native/vendor/clickhouse-cpp/clickhouse/CMakeLists.txt

@@ -0,0 +1,246 @@
+SET ( clickhouse-cpp-lib-src
+    base/compressed.cpp
+    base/input.cpp
+    base/output.cpp
+    base/platform.cpp
+    base/socket.cpp
+    base/wire_format.cpp
+    base/endpoints_iterator.cpp
+
+    columns/array.cpp
+    columns/column.cpp
+    columns/date.cpp
+    columns/decimal.cpp
+    columns/enum.cpp
+    columns/factory.cpp
+    columns/geo.cpp
+    columns/ip4.cpp
+    columns/ip6.cpp
+    columns/lowcardinality.cpp
+    columns/nullable.cpp
+    columns/numeric.cpp
+    columns/map.cpp
+    columns/string.cpp
+    columns/tuple.cpp
+    columns/time.cpp
+    columns/uuid.cpp
+
+    columns/itemview.cpp
+
+    types/type_parser.cpp
+    types/types.cpp
+
+    block.cpp
+    client.cpp
+    query.cpp
+
+    # Headers
+    base/buffer.h
+    base/compressed.h
+    base/endpoints_iterator.h
+    base/input.h
+    base/open_telemetry.h
+    base/output.h
+    base/platform.h
+    base/projected_iterator.h
+    base/singleton.h
+    base/socket.h
+    base/sslsocket.h
+    base/string_utils.h
+    base/string_view.h
+    base/uuid.h
+    base/wire_format.h
+
+    columns/array.h
+    columns/column.h
+    columns/date.h
+    columns/decimal.h
+    columns/enum.h
+    columns/factory.h
+    columns/geo.h
+    columns/ip4.h
+    columns/ip6.h
+    columns/itemview.h
+    columns/lowcardinality.h
+    columns/lowcardinalityadaptor.h
+    columns/map.h
+    columns/nothing.h
+    columns/nullable.h
+    columns/numeric.h
+    columns/string.h
+    columns/time.h
+    columns/tuple.h
+    columns/utils.h
+    columns/uuid.h
+
+    types/type_parser.h
+    types/types.h
+
+    block.h
+    client.h
+    error_codes.h
+    exceptions.h
+    protocol.h
+    query.h
+    server_exception.h
+)
+
+if (MSVC)
+    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+    add_compile_options(/W4)
+    # remove in 3.0
+    add_compile_options(/wd4996)
+else()
+    set(cxx_extra_wall "-Wempty-body -Wconversion -Wreturn-type -Wparentheses -Wuninitialized -Wunreachable-code -Wunused-function -Wunused-value -Wunused-variable")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${cxx_extra_wall}")
+
+    if(CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
+        # a little abnormal when clang check conversion
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${cxx_extra_wall} -Wno-conversion")
+    endif()
+endif()
+
+IF (WITH_OPENSSL)
+    LIST(APPEND clickhouse-cpp-lib-src base/sslsocket.cpp)
+ENDIF ()
+
+ADD_LIBRARY (clickhouse-cpp-lib ${clickhouse-cpp-lib-src}
+    version.h)
+SET_TARGET_PROPERTIES (clickhouse-cpp-lib
+    PROPERTIES
+    LINKER_LANGUAGE CXX
+    VERSION ${CLICKHOUSE_CPP_VERSION}
+)
+TARGET_LINK_LIBRARIES (clickhouse-cpp-lib
+    absl::int128
+    cityhash::cityhash
+    lz4::lz4
+    zstd::zstd
+)
+TARGET_INCLUDE_DIRECTORIES (clickhouse-cpp-lib
+    PUBLIC ${PROJECT_SOURCE_DIR}
+)
+
+IF (NOT BUILD_SHARED_LIBS)
+    ADD_LIBRARY (clickhouse-cpp-lib-static ALIAS clickhouse-cpp-lib)
+ELSE ()
+    SET_TARGET_PROPERTIES (clickhouse-cpp-lib
+        PROPERTIES
+        SO_VERSION ${CLICKHOUSE_CPP_VERSION}
+        SO_VERSION ${CLICKHOUSE_CPP_VERSION_MAJOR}
+    )
+ENDIF ()
+
+
+IF (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND NOT DISABLE_CLANG_LIBC_WORKAROUND)
+    INCLUDE (CheckCXXSourceCompiles)
+
+    CHECK_CXX_SOURCE_COMPILES("#include <bits/c++config.h>\nint main() { return __GLIBCXX__ != 0; }"
+                              BUILDING_WITH_LIB_STDCXX)
+
+    IF (BUILDING_WITH_LIB_STDCXX)
+        # there is a problem with __builtin_mul_overflow call at link time
+        # the error looks like: ... undefined reference to `__muloti4' ...
+        # caused by clang bug https://bugs.llvm.org/show_bug.cgi?id=16404
+        # explicit linking to compiler-rt allows to workaround the problem
+        SET (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} --rtlib=compiler-rt")
+
+        # some workaround for linking issues on linux:
+        # /usr/bin/ld: CMakeFiles/simple-test.dir/main.cpp.o: undefined reference to symbol '_Unwind_Resume@@GCC_3.0'
+        # /usr/bin/ld: /lib/x86_64-linux-gnu/libgcc_s.so.1: error adding symbols: DSO missing from command line
+        # FIXME: that workaround breaks clang build on mingw
+        TARGET_LINK_LIBRARIES (clickhouse-cpp-lib gcc_s)
+    ENDIF ()
+ENDIF ()
+
+
+INSTALL (TARGETS clickhouse-cpp-lib
+    ARCHIVE DESTINATION lib
+    LIBRARY DESTINATION lib
+)
+IF (NOT BUILD_SHARED_LIBS)
+    IF (NOT WITH_SYSTEM_CITYHASH)
+        INSTALL (TARGETS cityhash
+            ARCHIVE DESTINATION lib
+            LIBRARY DESTINATION lib
+        )
+    ENDIF()
+    IF (NOT WITH_SYSTEM_LZ4)
+        INSTALL (TARGETS lz4
+            ARCHIVE DESTINATION lib
+            LIBRARY DESTINATION lib
+        )
+    ENDIF()
+    IF (NOT WITH_SYSTEM_ZSTD)
+        INSTALL (TARGETS zstdstatic
+            ARCHIVE DESTINATION lib
+            LIBRARY DESTINATION lib
+        )
+    ENDIF()
+    IF (NOT WITH_SYSTEM_ABSEIL)
+        INSTALL (TARGETS absl_int128
+            ARCHIVE DESTINATION lib
+            LIBRARY DESTINATION lib
+        )
+    ENDIF()
+ENDIF()
+
+# general
+INSTALL(FILES block.h DESTINATION include/clickhouse/)
+INSTALL(FILES client.h DESTINATION include/clickhouse/)
+INSTALL(FILES error_codes.h DESTINATION include/clickhouse/)
+INSTALL(FILES exceptions.h DESTINATION include/clickhouse/)
+INSTALL(FILES server_exception.h DESTINATION include/clickhouse/)
+INSTALL(FILES protocol.h DESTINATION include/clickhouse/)
+INSTALL(FILES query.h DESTINATION include/clickhouse/)
+INSTALL(FILES version.h DESTINATION include/clickhouse/)
+
+# base
+INSTALL(FILES base/buffer.h DESTINATION include/clickhouse/base/)
+INSTALL(FILES base/compressed.h DESTINATION include/clickhouse/base/)
+INSTALL(FILES base/input.h DESTINATION include/clickhouse/base/)
+INSTALL(FILES base/open_telemetry.h DESTINATION include/clickhouse/base/)
+INSTALL(FILES base/output.h DESTINATION include/clickhouse/base/)
+INSTALL(FILES base/platform.h DESTINATION include/clickhouse/base/)
+INSTALL(FILES base/projected_iterator.h DESTINATION include/clickhouse/base/)
+INSTALL(FILES base/singleton.h DESTINATION include/clickhouse/base/)
+INSTALL(FILES base/socket.h DESTINATION include/clickhouse/base/)
+INSTALL(FILES base/string_utils.h DESTINATION include/clickhouse/base/)
+INSTALL(FILES base/string_view.h DESTINATION include/clickhouse/base/)
+INSTALL(FILES base/uuid.h DESTINATION include/clickhouse/base/)
+INSTALL(FILES base/wire_format.h DESTINATION include/clickhouse/base/)
+INSTALL(FILES base/endpoints_iterator.h DESTINATION include/clickhouse/base/)
+
+# columns
+INSTALL(FILES columns/array.h DESTINATION include/clickhouse/columns/)
+INSTALL(FILES columns/column.h DESTINATION include/clickhouse/columns/)
+INSTALL(FILES columns/date.h DESTINATION include/clickhouse/columns/)
+INSTALL(FILES columns/decimal.h DESTINATION include/clickhouse/columns/)
+INSTALL(FILES columns/enum.h DESTINATION include/clickhouse/columns/)
+INSTALL(FILES columns/factory.h DESTINATION include/clickhouse/columns/)
+INSTALL(FILES columns/geo.h DESTINATION include/clickhouse/columns/)
+INSTALL(FILES columns/ip4.h DESTINATION include/clickhouse/columns/)
+INSTALL(FILES columns/ip6.h DESTINATION include/clickhouse/columns/)
+INSTALL(FILES columns/itemview.h DESTINATION include/clickhouse/columns/)
+INSTALL(FILES columns/lowcardinality.h DESTINATION include/clickhouse/columns/)
+INSTALL(FILES columns/nothing.h DESTINATION include/clickhouse/columns/)
+INSTALL(FILES columns/nullable.h DESTINATION include/clickhouse/columns/)
+INSTALL(FILES columns/numeric.h DESTINATION include/clickhouse/columns/)
+INSTALL(FILES columns/map.h DESTINATION include/clickhouse/columns/)
+INSTALL(FILES columns/string.h DESTINATION include/clickhouse/columns/)
+INSTALL(FILES columns/time.h DESTINATION include/clickhouse/columns/)
+INSTALL(FILES columns/tuple.h DESTINATION include/clickhouse/columns/)
+INSTALL(FILES columns/utils.h DESTINATION include/clickhouse/columns/)
+INSTALL(FILES columns/uuid.h DESTINATION include/clickhouse/columns/)
+
+# types
+INSTALL(FILES types/type_parser.h DESTINATION include/clickhouse/types/)
+INSTALL(FILES types/types.h DESTINATION include/clickhouse/types/)
+
+IF (WITH_OPENSSL)
+    TARGET_LINK_LIBRARIES (clickhouse-cpp-lib OpenSSL::SSL)
+ENDIF ()
+
+IF (WIN32 OR MINGW)
+    TARGET_LINK_LIBRARIES (clickhouse-cpp-lib wsock32 ws2_32)
+ENDIF ()

data/ext/clickhouse_native/vendor/clickhouse-cpp/clickhouse/base/buffer.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+namespace clickhouse {
+
+using Buffer = std::vector<uint8_t>;
+
+}