Package com.clickhouse.client

Class AbstractClient<T>

java.lang.Object
com.clickhouse.client.AbstractClient<T>
All Implemented Interfaces:
ClickHouseClient, AutoCloseable
public abstract class AbstractClient<T> extends Object implements ClickHouseClient
Base class for implementing a thread-safe ClickHouse client. It uses ReadWriteLock to manage access to underlying connection.

  • Field Details

  • Constructor Details

    • AbstractClient

      public AbstractClient()

  • Method Details

    • checkHealth

      protected abstract boolean checkHealth(ClickHouseNode server, int timeout)

    • failedResponse

      protected CompletableFuture<ClickHouseResponse> failedResponse(Throwable ex)

    • getExecutor

      protected final ExecutorService getExecutor()
      Gets executor service for this client.
      Returns:
      executor service
      Throws:
      IllegalStateException - when the client is either closed or not initialized

    • getSupportedProtocols

      protected abstract Collection<ClickHouseProtocol> getSupportedProtocols()
      Gets list of supported protocols.
      Returns:
      non-null list of supported protocols

    • getServer

      protected final ClickHouseNode getServer()
      Gets current server.
      Returns:
      current server
      Throws:
      IllegalStateException - when the client is either closed or not initialized

    • checkConnection

      protected boolean checkConnection(T connection, ClickHouseNode requestServer, ClickHouseNode currentServer, ClickHouseRequest<?> request)
      Checks if the underlying connection can be reused. In general, new connection will be created when connection is null or requestServer is different from currentServer - the existing connection will be closed in the later case.
      Parameters:
      connection - existing connection which may or may not be null
      requestServer - non-null requested server, returned from previous call of request.getServer()
      currentServer - current server, same as getServer()
      request - non-null request
      Returns:
      true if the connection should NOT be changed(e.g. requestServer is same as currentServer); false otherwise

    • newConnection

      protected abstract T newConnection(T connection, ClickHouseNode server, ClickHouseRequest<?> request)
      Creates a new connection and optionally close existing connection. This method will be called from getConnection(ClickHouseRequest) as needed.
      Parameters:
      connection - existing connection which may or may not be null
      server - non-null requested server, returned from previous call of request.getServer()
      request - non-null request
      Returns:
      new connection
      Throws:
      CompletionException - when error occured

    • closeConnection

      protected abstract void closeConnection(T connection, boolean force)
      Closes a connection. This method will be called from close().
      Parameters:
      connection - connection to close
      force - whether force to close the connection or not

    • getAsyncExecArguments

      protected Object[] getAsyncExecArguments(ClickHouseRequest<?> sealedRequest)
      Gets arguments required for async execution. This method will be executed in current thread right before sendAsync(ClickHouseRequest, Object...).
      Parameters:
      sealedRequest - non-null sealed request
      Returns:
      arguments required for async execution

    • sendAsync

      protected ClickHouseResponse sendAsync(ClickHouseRequest<?> sealedRequest, Object... args) throws ClickHouseException, IOException
      Sends the request to server in a separate thread.
      Parameters:
      sealedRequest - non-null sealed request
      args - arguments required for sending out the request
      Returns:
      non-null response
      Throws:
      ClickHouseException - when error server failed to process the request
      IOException - when error occurred sending the request

    • send

      protected abstract ClickHouseResponse send(ClickHouseRequest<?> sealedRequest) throws ClickHouseException, IOException
      Sends the request to server in a current thread.
      Parameters:
      sealedRequest - non-null sealed request
      Returns:
      non-null response
      Throws:
      ClickHouseException - when error server failed to process the request
      IOException - when error occurred sending the request

    • getConnection

      protected final T getConnection(ClickHouseRequest<?> request)
      Gets a connection according to the given request.
      Parameters:
      request - non-null request
      Returns:
      non-null connection
      Throws:
      CompletionException - when error occured

    • accept

      public boolean accept(ClickHouseProtocol protocol)
      Description copied from interface: ClickHouseClient
      Tests whether the given protocol is supported or not. An advanced client can support as many protocols as needed.
      Specified by:
      accept in interface ClickHouseClient
      Parameters:
      protocol - protocol to test, null is treated as ClickHouseProtocol.ANY
      Returns:
      true if the given protocol is ClickHouseProtocol.ANY or supported by this client; false otherwise

    • read

      public ClickHouseRequest<?> read(Function<ClickHouseNodeSelector,ClickHouseNode> nodeFunc, Map<ClickHouseOption,Serializable> options)
      Description copied from interface: ClickHouseClient
      Connects to a ClickHouse server to read.
      Specified by:
      read in interface ClickHouseClient
      Parameters:
      nodeFunc - function to get a ClickHouseNode to connect to
      options - optional client options for connecting to the server
      Returns:
      non-null request object holding references to this client and server

    • getConfig

      public final ClickHouseConfig getConfig()
      Description copied from interface: ClickHouseClient
      Gets the immutable configuration associated with this client. In most cases it's the exact same one passed to ClickHouseClient.init(ClickHouseConfig) method for initialization.
      Specified by:
      getConfig in interface ClickHouseClient
      Returns:
      non-null configuration associated with this client

    • init

      public void init(ClickHouseConfig config)
      Description copied from interface: ClickHouseClient
      Initializes the client using immutable configuration extracted from the builder using ClickHouseClientBuilder.getConfig(). In general, it's ClickHouseClientBuilder's responsiblity to call this method to initialize the client at the end of ClickHouseClientBuilder.build(). However, sometimes, you may want to call this method explicitly in order to (re)initialize the client based on certain needs. If that's the case, please consider the environment when calling this method to avoid concurrent modification, and keep in mind that 1) ClickHouseConfig is immutable but ClickHouseClient is NOT; and 2) no guarantee that this method is thread-safe.
      Specified by:
      init in interface ClickHouseClient
      Parameters:
      config - immutable configuration extracted from the builder

    • execute

      public CompletableFuture<ClickHouseResponse> execute(ClickHouseRequest<?> request)
      Description copied from interface: ClickHouseClient
      Creates an immutable copy of the request if it's not sealed, and sends it to a node hold by the request(e.g. ClickHouseNode returned from request.getServer()). Connection will be made for the first-time invocation, and then it will be reused in subsequential calls to the extract same ClickHouseNode until ClickHouseClient.close() is invoked.
      Specified by:
      execute in interface ClickHouseClient
      Parameters:
      request - request object which will be sealed(immutable copy) upon execution, meaning you're free to make any change to this object(e.g. prepare for next call using different SQL statement) without impacting the execution
      Returns:
      non-null future object to get result

    • close

      public final void close()
      Specified by:
      close in interface AutoCloseable
      Specified by:
      close in interface ClickHouseClient

    • ping

      public boolean ping(ClickHouseNode server, int timeout)
      Description copied from interface: ClickHouseClient
      Tests if the given server is alive or not. It always returns false when server is null or timeout is less than one. Pay attention that it's a synchronous call with minimum overhead(e.g. tiny buffer, no compression and no deserialization etc).
      Specified by:
      ping in interface ClickHouseClient
      Parameters:
      server - non-null server to test
      timeout - timeout in millisecond, should be greater than zero
      Returns:
      true if the server is alive; false otherwise