Merge pull request ClickHouse#18 from ClickHouse/merge-upstream

Merge some changes from artpaul/clickhouse-cpp

Author: abyss7

Diff for: .travis.yml

@@ -41,14 +41,14 @@ matrix:
 before_install:
   - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then echo 'deb http://repo.yandex.ru/clickhouse/deb/stable main/' | sudo tee /etc/apt/sources.list.d/clickhouse.list ; fi
   - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then sudo apt-key adv --keyserver keyserver.ubuntu.com --recv E0C56BD4 ; fi
-  - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then sudo apt-get update -q && sudo apt-get install -q -y clickhouse-server-common ; fi
+  - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then sudo apt-get update -q && sudo apt-get install -q -y --allow-unauthenticated clickhouse-server-common ; fi
   - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then sudo service clickhouse-server start ; fi
 
 # Build steps
 script:
   - eval "${MATRIX_EVAL}"
   - mkdir build
   - cd build
-  - cmake .. && make
+  - cmake .. -DBUILD_TESTS=ON && make
   - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then ./ut/clickhouse-cpp-ut ; fi
   - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then ./ut/clickhouse-cpp-ut --gtest_filter='-Client/*' ; fi

Diff for: CMakeLists.txt

@@ -4,11 +4,16 @@ INCLUDE (cmake/cpp17.cmake)
 INCLUDE (cmake/subdirs.cmake)
 
 OPTION(BUILD_BENCHMARK "Build benchmark" OFF)
+OPTION(BUILD_TESTS "Build tests" OFF)
 
 PROJECT (CLICKHOUSE-CLIENT)
 
     USE_CXX17()
 
+	IF ("${CMAKE_BUILD_TYPE}" STREQUAL "")
+		set(CMAKE_BUILD_TYPE "Debug")
+	ENDIF()
+
     IF (UNIX)
         IF (APPLE)
             SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O2 -Wall -Wextra -Werror")
@@ -24,12 +29,17 @@ PROJECT (CLICKHOUSE-CLIENT)
     SUBDIRS (
         clickhouse
         contrib/cityhash
-        contrib/gtest
         contrib/lz4
-        tests/simple
-        ut
     )
 
     IF (BUILD_BENCHMARK)
         SUBDIRS(bench)
     ENDIF (BUILD_BENCHMARK)
+
+    IF (BUILD_TESTS)
+        SUBDIRS(
+            contrib/gtest
+            tests/simple
+            ut
+        )
+	ENDIF (BUILD_TESTS)

Diff for: README.md

@@ -12,18 +12,18 @@ C++ client for [Yandex ClickHouse](https://clickhouse.yandex/)
 * Enum8, Enum16
 * FixedString(N)
 * Float32, Float64
+* IPv4, IPv6
 * Nullable(T)
 * String
 * Tuple
 * UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64
-* IPv4, IPv6
 
 ## Building
 
 ```sh
 $ mkdir build .
 $ cd build
-$ cmake ..
+$ cmake .. [-DBUILD_TESTS=ON]
 $ make
 ```
 

Diff for: clickhouse/CMakeLists.txt

@@ -11,6 +11,8 @@ SET ( clickhouse-cpp-lib-src
     columns/decimal.cpp
     columns/enum.cpp
     columns/factory.cpp
+    columns/ip4.cpp
+    columns/ip6.cpp
     columns/nullable.cpp
     columns/numeric.cpp
     columns/string.cpp
@@ -85,4 +87,3 @@ 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/)
-

Diff for: clickhouse/base/socket.cpp

@@ -11,6 +11,7 @@
 #   include <errno.h>
 #   include <fcntl.h>
 #   include <netdb.h>
+#   include <netinet/tcp.h>
 #   include <signal.h>
 #   include <unistd.h>
 #   include <netinet/tcp.h>
@@ -57,7 +58,18 @@ void SetNonBlock(SOCKET fd, bool value) {
             errno, std::system_category(), "fail to set nonblocking mode");
     }
 #elif defined(_win_)
-    SetNonBlockSocket(fd, 1);
+    unsigned long inbuf = value;
+    unsigned long outbuf = 0;
+    DWORD written = 0;
+
+    if (!inbuf) {
+        WSAEventSelect(fd, nullptr, 0);
+    }
+
+    if (WSAIoctl(fd, FIONBIO, &inbuf, sizeof(inbuf), &outbuf, sizeof(outbuf), &written, 0, 0) == SOCKET_ERROR) {
+        throw std::system_error(
+            errno, std::system_category(), "fail to set nonblocking mode");
+    }
 #endif
 }
 
@@ -112,7 +124,7 @@ SocketHolder::SocketHolder(SOCKET s)
 {
 }
 
-SocketHolder::SocketHolder(SocketHolder&& other)
+SocketHolder::SocketHolder(SocketHolder&& other) noexcept
     : handle_(other.handle_)
 {
     other.handle_ = -1;
@@ -137,6 +149,26 @@ bool SocketHolder::Closed() const noexcept {
     return handle_ == -1;
 }
 
+void SocketHolder::SetTcpKeepAlive(int idle, int intvl, int cnt) noexcept {
+    int val = 1;
+
+#if defined(_unix_)
+    setsockopt(handle_, SOL_SOCKET, SO_KEEPALIVE, &val, sizeof(val));
+#   if defined(_linux_)
+        setsockopt(handle_, IPPROTO_TCP, TCP_KEEPIDLE, &idle, sizeof(idle));
+#   elif defined(_darwin_)
+        setsockopt(handle_, IPPROTO_TCP, TCP_KEEPALIVE, &idle, sizeof(idle));
+#   else
+#       error "platform is not supported"
+#   endif
+    setsockopt(handle_, IPPROTO_TCP, TCP_KEEPINTVL, &intvl, sizeof(intvl));
+    setsockopt(handle_, IPPROTO_TCP, TCP_KEEPCNT, &cnt, sizeof(cnt));
+#else
+    setsockopt(handle_, SOL_SOCKET, SO_KEEPALIVE, (const char*)&val, sizeof(val));
+    std::ignore = idle = intvl = cnt;
+#endif
+}
+
 SocketHolder& SocketHolder::operator = (SocketHolder&& other) noexcept {
     if (this != &other) {
         Close();
@@ -152,23 +184,6 @@ SocketHolder::operator SOCKET () const noexcept {
     return handle_;
 }
 
-void SocketHolder::SetTcpKeepAlive(int idle, int intvl, int cnt) noexcept {
-    int val = 1;
-    setsockopt(handle_, SOL_SOCKET, SO_KEEPALIVE, &val, sizeof val);
-
-#if defined _darwin_
-    setsockopt(handle_, IPPROTO_TCP, TCP_KEEPALIVE, &idle, sizeof idle);
-    setsockopt(handle_, IPPROTO_TCP, TCP_KEEPINTVL, &intvl, sizeof intvl);
-    setsockopt(handle_, IPPROTO_TCP, TCP_KEEPCNT, &cnt, sizeof cnt);
-#elif defined(_linux_)
-    setsockopt(handle_, IPPROTO_TCP, TCP_KEEPIDLE, &idle, sizeof idle);
-    setsockopt(handle_, IPPROTO_TCP, TCP_KEEPINTVL, &intvl, sizeof intvl);
-    setsockopt(handle_, IPPROTO_TCP, TCP_KEEPCNT, &cnt, sizeof cnt);
-#else
-    std::ignore = idle = intvl = cnt;
-#endif
-}
-
 
 SocketInput::SocketInput(SOCKET s)
     : s_(s)
@@ -210,7 +225,7 @@ void SocketOutput::DoWrite(const void* data, size_t len) {
     static const int flags = 0;
 #endif
 
-    if (::send(s_, (const char*)data, len, flags) != (int)len) {
+    if (::send(s_, (const char*)data, (int)len, flags) != (int)len) {
         throw std::system_error(
             errno, std::system_category(), "fail to send data"
         );
@@ -240,6 +255,7 @@ NetrworkInitializer::NetrworkInitializer() {
 
 
 SOCKET SocketConnect(const NetworkAddress& addr) {
+    int last_err = 0;
     for (auto res = addr.Info(); res != nullptr; res = res->ai_next) {
         SOCKET s(socket(res->ai_family, res->ai_socktype, res->ai_protocol));
 
@@ -256,7 +272,7 @@ SOCKET SocketConnect(const NetworkAddress& addr) {
                 fd.fd = s;
                 fd.events = POLLOUT;
                 fd.revents = 0;
-                int rval = Poll(&fd, 1, 5000);
+                ssize_t rval = Poll(&fd, 1, 5000);
 
                 if (rval == -1) {
                     throw std::system_error(errno, std::system_category(), "fail to connect");
@@ -269,14 +285,17 @@ SOCKET SocketConnect(const NetworkAddress& addr) {
                         SetNonBlock(s, false);
                         return s;
                     }
+                   last_err = err;
                 }
             }
         } else {
             SetNonBlock(s, false);
             return s;
         }
     }
-
+    if (last_err > 0) {
+        throw std::system_error(last_err, std::system_category(), "fail to connect");
+    }
     throw std::system_error(
         errno, std::system_category(), "fail to connect"
     );

Diff for: clickhouse/base/socket.h

@@ -13,6 +13,7 @@
 #   include <winsock2.h>
 #   include <ws2tcpip.h>
 #else
+#   include <arpa/inet.h>
 #   include <sys/types.h>
 #   include <sys/socket.h>
 #   include <poll.h>
@@ -46,20 +47,25 @@ class SocketHolder {
 public:
     SocketHolder();
     SocketHolder(SOCKET s);
-    SocketHolder(SocketHolder&& other);
+    SocketHolder(SocketHolder&& other) noexcept;
 
     ~SocketHolder();
 
     void Close() noexcept;
 
     bool Closed() const noexcept;
 
+    /// @params idle the time (in seconds) the connection needs to remain
+    ///         idle before TCP starts sending keepalive probes.
+    /// @params intvl the time (in seconds) between individual keepalive probes.
+    /// @params cnt the maximum number of keepalive probes TCP should send
+    ///         before dropping the connection.
+    void SetTcpKeepAlive(int idle, int intvl, int cnt) noexcept;
+
     SocketHolder& operator = (SocketHolder&& other) noexcept;
 
     operator SOCKET () const noexcept;
 
-    void SetTcpKeepAlive(int idle, int intvl, int cnt) noexcept;
-
 private:
     SocketHolder(const SocketHolder&) = delete;
     SocketHolder& operator = (const SocketHolder&) = delete;

Diff for: clickhouse/client.cpp

@@ -276,9 +276,9 @@ void Client::Impl::ResetConnection() {
         throw std::system_error(errno, std::system_category());
     }
 
-    if(options_.tcp_keepalive){
-        s.SetTcpKeepAlive(options_.tcp_keepalive_idle,
-                          options_.tcp_keepalive_intvl,
+    if (options_.tcp_keepalive) {
+        s.SetTcpKeepAlive(options_.tcp_keepalive_idle.count(),
+                          options_.tcp_keepalive_intvl.count(),
                           options_.tcp_keepalive_cnt);
     }
 

Diff for: clickhouse/client.h

@@ -7,6 +7,8 @@
 #include "columns/date.h"
 #include "columns/decimal.h"
 #include "columns/enum.h"
+#include "columns/ip4.h"
+#include "columns/ip6.h"
 #include "columns/nullable.h"
 #include "columns/numeric.h"
 #include "columns/string.h"
@@ -63,8 +65,8 @@ struct ClientOptions {
 
     /// TCP Keep alive options
     DECLARE_FIELD(tcp_keepalive, bool, TcpKeepAlive, false);
-    DECLARE_FIELD(tcp_keepalive_idle, int, SetTcpKeepAliveIdle, 60);
-    DECLARE_FIELD(tcp_keepalive_intvl, int, SetTcpKeepAliveInterval, 5);
+    DECLARE_FIELD(tcp_keepalive_idle, std::chrono::seconds, SetTcpKeepAliveIdle, std::chrono::seconds(60));
+    DECLARE_FIELD(tcp_keepalive_intvl, std::chrono::seconds, SetTcpKeepAliveInterval, std::chrono::seconds(5));
     DECLARE_FIELD(tcp_keepalive_cnt, int, SetTcpKeepAliveCount, 3);
 
 #undef DECLARE_FIELD

Diff for: clickhouse/columns/array.cpp

@@ -1,5 +1,4 @@
 #include "array.h"
-
 #include <stdexcept>
 
 namespace clickhouse {
@@ -31,6 +30,18 @@ ColumnRef ColumnArray::GetAsColumn(size_t n) const {
     return data_->Slice(GetOffset(n), GetSize(n));
 }
 
+ColumnRef ColumnArray::Slice(size_t begin, size_t size) {
+    auto result = std::make_shared<ColumnArray>(GetAsColumn(begin));
+    result->OffsetsIncrease(1);
+
+    for (size_t i = 1; i < size; i++)
+    {
+        result->Append(std::make_shared<ColumnArray>(GetAsColumn(begin + i)));
+    }
+
+    return result;
+}
+
 void ColumnArray::Append(ColumnRef column) {
     if (auto col = column->As<ColumnArray>()) {
         if (!col->data_->Type()->IsEqual(data_->Type())) {
@@ -67,6 +78,10 @@ size_t ColumnArray::Size() const {
     return offsets_->Size();
 }
 
+void ColumnArray::OffsetsIncrease(size_t n) {
+    offsets_->Append(n);
+}
+
 size_t ColumnArray::GetOffset(size_t n) const {
     return (n == 0) ? 0 : (*offsets_)[n - 1];
 }

Diff for: clickhouse/columns/array.h

@@ -28,15 +28,17 @@ class ColumnArray : public Column {
 
     /// Saves column data to output stream.
     void Save(CodedOutputStream* output) override;
-    
+
     /// Clear column data .
     void Clear() override;
-    
+
     /// Returns count of rows in the column.
     size_t Size() const override;
 
     /// Makes slice of the current column.
-    ColumnRef Slice(size_t, size_t) override { return ColumnRef(); }
+    ColumnRef Slice(size_t, size_t) override;
+
+    void OffsetsIncrease(size_t);
 
 private:
     size_t GetOffset(size_t n) const;

Diff for: clickhouse/columns/date.cpp

@@ -18,8 +18,7 @@ void ColumnDate::Clear() {
 }
 
 std::time_t ColumnDate::At(size_t n) const {
-    /// TODO: This code is fundamentally wrong.
-    return data_->At(n) * std::time_t(86400);
+    return static_cast<std::time_t>(data_->At(n)) * 86400;
 }
 
 void ColumnDate::Append(ColumnRef column) {
@@ -95,5 +94,4 @@ ColumnRef ColumnDateTime::Slice(size_t begin, size_t len) {
     return result;
 }
 
-
 }