clickhouse-sql 0.1.0

data/lib/clickhouse/http_client/query.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ClickHouse
+  module HTTPClient
+    # Immutable query value object: SQL text with ClickHouse `{name:Type}`
+    # placeholders, plus the placeholder values to bind. Also the normal form
+    # every accepted query is converted into at the client boundary.
+    Query = Data.define(:sql, :placeholders) do
+      # Accepts a String of trusted SQL or any object honoring the query
+      # protocol (#to_sql and #placeholders).
+      #
+      # @param query [String, #to_sql & #placeholders]
+      # @return [ClickHouse::HTTPClient::Query]
+      def self.wrap(query)
+        case query
+        when String
+          new(sql: query)
+        else
+          # A builder that can compile itself (e.g. ClickHouse::SQL's
+          # SelectQuery#to_query) does so here, so its compile-time
+          # validations — like the nil-placeholder net — apply even when a
+          # caller passes the builder directly instead of calling #to_query.
+          # The arity check excludes ActiveSupport's unrelated
+          # Object#to_query(namespace), which every object responds to.
+          if query.respond_to?(:to_query) && query.method(:to_query).arity.zero?
+            query = query.to_query
+          end
+
+          unless query.respond_to?(:to_sql) && query.respond_to?(:placeholders)
+            raise QueryError, "Expected a SQL string or an object responding to #to_sql and #placeholders, got #{query.class}"
+          end
+
+          new(sql: query.to_sql, placeholders: query.placeholders)
+        end
+      end
+
+      def initialize(sql:, placeholders: {})
+        raise QueryError, "Empty query string given" if sql.to_s.strip.empty?
+
+        super(
+          sql: -sql.to_s,
+          placeholders: ValueNormalization.immutable_copy(
+            ValueNormalization.symbolize_keys(placeholders || {}),
+          ),
+        )
+      end
+
+      # @return [String] SQL query text.
+      def to_sql
+        sql
+      end
+    end
+  end
+end

data/lib/clickhouse/http_client/response_formatter.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module ClickHouse
+  module HTTPClient
+    # Typecasts values from ClickHouse's JSON response according to the
+    # declared column metadata.
+    module ResponseFormatter
+      TYPE_CASTERS = [
+        [/\AU?Int\d+\z/, ->(value) { Integer(value) }],
+        [/\AFloat(?:32|64)\z/, ->(value) { Float(value) }],
+        [/\ADate(?:32)?\z/, ->(value) { Date.parse(value) }],
+        # ClickHouse renders zone-less DateTime/DateTime64 values in the
+        # *server's* default timezone, so parsing them as UTC assumes every
+        # ClickHouse server in the fleet runs UTC. Explicit non-UTC zones
+        # deliberately don't match and pass through as strings.
+        [/\ADateTime(?:64)?(?:\(\d+\)|\(\d+,\s*'UTC'\)|\('UTC'\))?\z/, ->(value) { Time.parse("#{value} UTC") }],
+        [/\AIntervalSecond\z/, ->(value) { Integer(value) }],
+        [/\AIntervalMillisecond\z/, ->(value) { Integer(value) / 1000.0 }],
+      ].freeze
+      private_constant :TYPE_CASTERS
+
+      IDENTITY = ->(value) { value }
+      private_constant :IDENTITY
+
+      # Type wrappers that don't change the text encoding of the inner value.
+      WRAPPER_TYPE = /\A(?:Nullable|LowCardinality)\((.*)\)\z/
+      private_constant :WRAPPER_TYPE
+
+      AGGREGATE_WRAPPER_TYPE = /\ASimpleAggregateFunction\(\s*\w+\s*,\s*(.*)\)\z/
+      private_constant :AGGREGATE_WRAPPER_TYPE
+
+      ARRAY_TYPE = /\AArray\((.*)\)\z/
+      private_constant :ARRAY_TYPE
+
+      def self.format_rows(parsed)
+        casters = parsed["meta"].to_h do |column|
+          [column["name"], caster_for(column["type"])]
+        end
+
+        parsed["data"].map do |row|
+          row.to_h { |column, value| [column, casters.fetch(column, IDENTITY).call(value)] }
+        end
+      end
+
+      def self.caster_for(type)
+        unwrapped = unwrap_type(type)
+
+        # Array elements need the same casting as scalars: JSON output quotes
+        # 64-bit integers and datetimes inside arrays too, so Array(UInt64)
+        # arrives as an array of strings.
+        if (array = ARRAY_TYPE.match(unwrapped))
+          element_caster = caster_for(array[1].strip)
+          return IDENTITY if element_caster.equal?(IDENTITY)
+
+          return ->(value) { value.nil? ? nil : value.map { |element| element_caster.call(element) } }
+        end
+
+        _, cast = TYPE_CASTERS.find { |regex, _| regex.match?(unwrapped) }
+        return IDENTITY unless cast
+
+        ->(value) { value.nil? ? nil : cast.call(value) }
+      end
+      private_class_method :caster_for
+
+      def self.unwrap_type(type)
+        type = type.to_s
+
+        while (match = WRAPPER_TYPE.match(type) || AGGREGATE_WRAPPER_TYPE.match(type))
+          type = match[1]
+        end
+
+        type
+      end
+      private_class_method :unwrap_type
+    end
+    private_constant :ResponseFormatter
+  end
+end

data/lib/clickhouse/http_client/value_normalization.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ClickHouse
+  module HTTPClient
+    module ValueNormalization
+      def self.symbolize_keys(hash)
+        hash.transform_keys do |key|
+          key.respond_to?(:to_sym) ? key.to_sym : key
+        end
+      end
+
+      # Recursively copies and freezes Arrays, Hashes, and Strings so a
+      # value can be held without observing callers' later mutations.
+      def self.immutable_copy(value)
+        case value
+        when Array
+          value.map { |item| immutable_copy(item) }.freeze
+        when Hash
+          value.to_h { |key, item| [immutable_copy(key), immutable_copy(item)] }.freeze
+        when String
+          value.dup.freeze
+        else
+          value
+        end
+      end
+    end
+    private_constant :ValueNormalization
+  end
+end

data/lib/clickhouse/http_client.rb

@@ -0,0 +1,288 @@
+# frozen_string_literal: true
+
+require "date"
+require "json"
+require "logger"
+require "net/http"
+require "securerandom"
+require "time"
+require "uri"
+require "zlib"
+
+require_relative "http_client/error"
+require_relative "http_client/value_normalization"
+require_relative "http_client/database"
+require_relative "http_client/query"
+require_relative "http_client/parameter_serializer"
+require_relative "http_client/response_formatter"
+
+module ClickHouse
+  # HTTP transport for ClickHouse queries: owns database configuration,
+  # HTTP POST mechanics, parameter serialization, response typecasting,
+  # logging, and instrumentation.
+  #
+  # Queries are duck-typed: any object responding to #to_sql (SQL text with
+  # ClickHouse `{name:Type}` placeholders intact) and #placeholders (a Hash of
+  # placeholder names to Ruby values) is accepted, as is a plain String of
+  # trusted SQL. ClickHouse::SQL::Query satisfies this protocol; so does the
+  # HTTPClient::Query value object. An object that also responds to
+  # #to_query (e.g. ClickHouse::SQL::SelectQuery) is compiled through it
+  # first, so builder-level validations always apply.
+  #
+  # nil placeholder values are always sent as NULL. Binding nil to a
+  # non-Nullable placeholder type fails loudly in ClickHouse for most types,
+  # but parses as an empty string for a plain String placeholder — callers
+  # (e.g. ClickHouse::SQL) are expected to validate nil against placeholder
+  # types before execution.
+  #
+  # Derived in part from GitLab's MIT-licensed click_house-client gem;
+  # see LICENSE.
+  module HTTPClient
+    # Instrumentation event emitted around every query.
+    NOTIFICATION_NAME = "sql.click_house"
+    QUERY_ID_HEADER = "x-clickhouse-query-id"
+    private_constant :QUERY_ID_HEADER
+
+    # Successful outcome of a command-style query. Failures raise instead of
+    # returning a result. Statistics are parsed from x-clickhouse-summary and
+    # are final because every request sends wait_end_of_query=1.
+    ExecutionResult = Data.define(:query_id, :statistics)
+
+    NOOP_INSTRUMENTER = Object.new
+    def NOOP_INSTRUMENTER.instrument(_name, payload)
+      yield payload
+    end
+    private_constant :NOOP_INSTRUMENTER
+
+    # Applications typically configure the logger, instrumenter, and database
+    # registry once during initialization.
+    class << self
+      # @return [Logger] Structured query logger.
+      attr_writer :logger # rubocop:disable ThreadSafety/ClassAndModuleAttributes
+
+      def logger
+        @logger ||= Logger.new(IO::NULL) # rubocop:disable ThreadSafety/ClassInstanceVariable
+      end
+
+      # @return [#instrument] Query instrumenter.
+      attr_writer :instrumenter # rubocop:disable ThreadSafety/ClassAndModuleAttributes
+
+      def instrumenter
+        @instrumenter || NOOP_INSTRUMENTER # rubocop:disable ThreadSafety/ClassInstanceVariable
+      end
+
+      # Registers a database connection under a name.
+      def register_database(name, **args)
+        raise ConfigurationError, "The database '#{name}' is already registered" if databases.key?(name)
+
+        databases[name] = Database.build(**args)
+      end
+
+      # @param name [Symbol] Registered database name.
+      # @return [ClickHouse::HTTPClient::Database]
+      def database(name)
+        databases.fetch(name) do
+          raise ConfigurationError, "The database '#{name}' is not registered"
+        end
+      end
+
+      # Executes a SELECT query and returns rows as an Array of Hashes, with
+      # values typecast according to the column types in the response. Callers
+      # migrating an existing result contract can supply a formatter block,
+      # which receives the parsed response including its column metadata.
+      def select(query, database, timeout: nil, &formatter)
+        query = Query.wrap(query)
+        body, content_type = encode_multipart(form_data(query))
+
+        run(query, database, timeout: timeout, body: body, extra_headers: { "Content-Type" => content_type }) do |response|
+          parsed = parse_result_body(response)
+
+          statistics = ValueNormalization.symbolize_keys(parsed["statistics"]) if parsed["statistics"]
+          rows = formatter ? formatter.call(parsed) : ResponseFormatter.format_rows(parsed)
+          [rows, statistics]
+        end
+      end
+
+      # Executes any query without returning row data (INSERT, DELETE, DDL).
+      #
+      # @return [ClickHouse::HTTPClient::ExecutionResult]
+      def execute(query, database, timeout: nil)
+        query = Query.wrap(query)
+        body, content_type = encode_multipart(form_data(query))
+
+        run(query, database, timeout: timeout, body: body, extra_headers: { "Content-Type" => content_type }) do |response|
+          statistics = summary_statistics(response)
+          result = ExecutionResult.new(
+            query_id: response[QUERY_ID_HEADER],
+            statistics: statistics,
+          )
+          [result, statistics]
+        end
+      end
+
+      # Inserts a gzip-compressed CSV IO to ClickHouse.
+      #
+      # Usage:
+      #
+      #   io = StringIO.new(gzip_compressed_csv)
+      #   ClickHouse::HTTPClient.insert_csv("INSERT INTO events (id) FORMAT CSV", io, :main)
+      #
+      # @return [ClickHouse::HTTPClient::ExecutionResult]
+      def insert_csv(query, io, database, timeout: nil)
+        query = Query.wrap(query)
+
+        # The request body carries the CSV data, so there's nowhere to send
+        # param_* placeholder values; ClickHouse would receive unresolved
+        # {name:Type} markers in the SQL.
+        unless query.placeholders.empty?
+          raise QueryError, "insert_csv does not support query placeholders"
+        end
+
+        run(query, database, timeout: timeout, body: io, extra_headers: CSV_HEADERS, uri_variables: { query: query.sql }) do |response|
+          statistics = summary_statistics(response)
+          result = ExecutionResult.new(
+            query_id: response[QUERY_ID_HEADER],
+            statistics: statistics,
+          )
+          [result, statistics]
+        end
+      end
+
+      private
+
+      CSV_HEADERS = { "Transfer-Encoding" => "chunked", "Content-Encoding" => "gzip" }.freeze
+
+      def databases
+        @databases ||= {} # rubocop:disable ThreadSafety/ClassInstanceVariable
+      end
+
+      def run(query, database_name, timeout:, body:, extra_headers:, uri_variables: {})
+        db = database(database_name)
+        uri = db.uri(uri_variables)
+
+        logger.debug { { clickhouse_query: query.sql } }
+
+        result = nil
+        instrumenter.instrument(NOTIFICATION_NAME, { query: query, database: database_name }) do |instrument|
+          response = begin
+            perform_request(uri, db.headers.merge(extra_headers), body, timeout || 30)
+          rescue Net::OpenTimeout => e
+            raise ConnectionError, e.message
+          rescue Net::ReadTimeout, Net::WriteTimeout, Timeout::Error, Errno::ETIMEDOUT => e
+            raise TimeoutError, e.message
+          rescue SocketError, EOFError, IOError, SystemCallError, OpenSSL::SSL::SSLError,
+            Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError, Zlib::Error => e
+            raise ConnectionError, e.message
+          end
+          normalize_response_body(response)
+
+          # The query ID correlates with ClickHouse's own system.query_log and
+          # is useful to instrumentation even when ClickHouse rejects a query.
+          instrument[:query_id] = response[QUERY_ID_HEADER]
+
+          raise DatabaseError, response.body unless response.is_a?(Net::HTTPSuccess)
+
+          result, statistics = yield(response)
+
+          instrument[:statistics] = statistics
+
+          result
+        end
+        result
+      end
+
+      def perform_request(uri, headers, body, timeout)
+        request = Net::HTTP::Post.new(uri.request_uri, headers)
+        if body.respond_to?(:read)
+          request.body_stream = body
+        else
+          request.body = body
+        end
+
+        Net::HTTP.start(
+          uri.hostname,
+          uri.port,
+          use_ssl: uri.scheme == "https",
+          open_timeout: 2,
+          read_timeout: timeout,
+          write_timeout: timeout,
+          max_retries: 0,
+        ) { |http| http.request(request) }
+      end
+
+      def form_data(query)
+        query.placeholders.each_with_object({ "query" => query.sql }) do |(name, value), form|
+          form["param_#{name}"] = ParameterSerializer.serialize(value)
+        end
+      end
+
+      # Placeholders are sent as param_-prefixed multipart form fields
+      # alongside the query, dodging URL length limits. Net::HTTP#set_form
+      # writes non-chunked multipart requests through a Tempfile, so encode the
+      # all-String subset used here directly instead.
+      # See: https://github.com/ClickHouse/ClickHouse/issues/8842
+      def encode_multipart(fields)
+        boundary = "----RubyMultipart#{SecureRandom.hex(16)}"
+        body = String.new(encoding: Encoding::BINARY)
+
+        fields.each do |name, value|
+          escaped_name = name.to_s
+            .gsub(/["\\]/) { |character| "\\#{character}" }
+            .gsub("\r", "%0D")
+            .gsub("\n", "%0A")
+          body << "--#{boundary}\r\n"
+          body << "Content-Disposition: form-data; name=\"#{escaped_name}\"\r\n\r\n"
+          body << value.b
+          body << "\r\n"
+        end
+
+        body << "--#{boundary}--\r\n"
+        [body, "multipart/form-data; boundary=#{boundary}"]
+      end
+
+      def normalize_response_body(response)
+        return unless response.body
+
+        /\bcharset=([^;]+)/.match(response["content-type"]) do |match|
+          response.body.force_encoding(Encoding.find(match[1].strip))
+        end
+      rescue ArgumentError
+        # Match Faraday's NetHTTP adapter: an unsupported charset leaves the
+        # response body in its original binary encoding.
+      end
+
+      # A malformed body on a success status is still a server-side failure:
+      # even with wait_end_of_query buffering, an error can slip in after the
+      # response has been committed (e.g. the buffer overflowing to the
+      # client). ClickHouse appends its error text to the body, so surface
+      # the tail in the DatabaseError rather than a bare JSON::ParserError.
+      def parse_result_body(response)
+        JSON.parse(response.body)
+      rescue JSON::ParserError
+        body = response.body.to_s
+        body_tail = body.length > 500 ? body[-500, 500] : body
+        raise DatabaseError, "Malformed ClickHouse response body (HTTP #{response.code}), body tail: #{body_tail}"
+      end
+
+      def summary_statistics(headers)
+        summary = headers["x-clickhouse-summary"]
+        return {}.freeze unless summary
+
+        # The `x-clickhouse-summary` header encodes its numeric values as
+        # strings, unlike the `statistics` block in the JSON body which uses
+        # real numbers. Coerce them so instrumentation receives numeric metrics
+        # consistently across query paths.
+        ValueNormalization
+          .symbolize_keys(JSON.parse(summary))
+          .transform_values { |value| coerce_numeric(value) }
+          .freeze
+      end
+
+      def coerce_numeric(value)
+        return value unless value.is_a?(String)
+
+        Integer(value, exception: false) || Float(value, exception: false) || value
+      end
+    end
+  end
+end

data/lib/clickhouse/sql/bind_index_manager.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ClickHouse
+  module SQL
+    # Emits sequential `$1`-style bind markers when rendering redacted SQL,
+    # so every typed placeholder in a query gets a stable positional marker
+    # suitable for external log aggregation.
+    #
+    # Derived from GitLab's MIT-licensed click_house-client gem; see LICENSE.
+    class BindIndexManager
+      # @param start_index [Integer] Index of the first bind marker.
+      def initialize(start_index = 1)
+        @current_index = start_index
+      end
+
+      # Returns the next positional bind marker.
+      #
+      # @return [String] Bind marker such as `$1`.
+      def next_bind_str
+        bind_str = "$#{@current_index}"
+        @current_index += 1
+        bind_str
+      end
+    end
+  end
+end

data/lib/clickhouse/sql/error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ClickHouse
+  module SQL
+    # Raised when ClickHouse::SQL cannot safely build or validate a query.
+    #
+    # Deliberately not a ClickHouse::HTTPClient error: a query-building error
+    # is a caller bug in this layer, raised before anything reaches the
+    # client. Rescue it alongside ClickHouse::HTTPClient errors where callers
+    # degrade gracefully on query failure.
+    class Error < StandardError; end
+  end
+end

data/lib/clickhouse/sql/fragment.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module ClickHouse
+  module SQL
+    class Fragment
+      include Part
+
+      # Builds a composable SQL fragment with typed placeholders and slots.
+      #
+      # @param sql [String, #to_s] SQL containing `{name:Type}` values, `{name}`
+      #   slots, and/or anonymous `{}` slots.
+      # @param bindings [Hash{Symbol,String=>Object}] Named placeholder and slot bindings.
+      # @param fills [Array<ClickHouse::SQL::Part>] Positional fills for anonymous
+      #   `{}` slots in source order.
+      # @return [ClickHouse::SQL::Fragment] A validated fragment.
+      def initialize(sql, bindings = {}, fills: [])
+        raise Error, "Empty SQL fragment given" if ValueNormalization.blank_string?(sql)
+
+        @sql = sql.to_s
+        @bindings = ValueNormalization.symbolize_keys(bindings || {})
+        @fills = Array(fills)
+        @placeholders = ClickHouse::SQL.parse_placeholders(@sql)
+
+        validate_fills!
+        validate_bindings!
+      end
+
+      # Renders the fragment with ClickHouse typed placeholders intact.
+      #
+      # @return [String] SQL fragment text.
+      def to_sql
+        render(redacted: false)
+      end
+
+      # Renders the fragment with typed placeholders replaced by bind markers.
+      #
+      # @param bind_index_manager [ClickHouse::SQL::BindIndexManager] Redacted bind index state.
+      # @return [String] Redacted SQL fragment text.
+      def to_redacted_sql(bind_index_manager = ClickHouse::SQL::BindIndexManager.new)
+        render(redacted: true, bind_index_manager:)
+      end
+
+      # Returns typed placeholder values from this fragment and nested slots.
+      #
+      # @return [Hash{Symbol=>Object}] Placeholder values keyed by name.
+      def placeholders
+        ClickHouse::SQL.merge_placeholders!(@typed_placeholder_values.dup, nested_placeholders)
+      end
+
+      # Returns ClickHouse placeholder types from this fragment and nested slots.
+      #
+      # @return [Hash{Symbol=>String}] Placeholder types keyed by name.
+      def placeholder_types
+        ClickHouse::SQL.merge_placeholder_types!(@placeholder_types.dup, nested_placeholder_types)
+      end
+
+      private
+
+      attr_reader :bindings
+
+      def validate_fills!
+        anonymous = @placeholders.select(&:anonymous?)
+        unless anonymous.length == @fills.length
+          raise Error, "Fragment has #{anonymous.length} anonymous {} slots but #{@fills.length} positional fills were given"
+        end
+
+        @fills.each do |fill|
+          next if ClickHouse::SQL.part?(fill)
+
+          raise Error, "Anonymous fragment slot {} requires a SQL fragment, got #{fill.class}"
+        end
+
+        @fill_by_position = anonymous.map(&:begin_pos).zip(@fills).to_h
+      end
+
+      def validate_bindings!
+        named = @placeholders.reject(&:anonymous?)
+        used_names = named.map(&:name_sym)
+        unused_names = bindings.keys - used_names
+        raise Error, "Unused ClickHouse placeholder values: #{unused_names.join(', ')}" if unused_names.any?
+
+        typed_names = named.select(&:typed?).map(&:name_sym)
+        slot_names = named.reject(&:typed?).map(&:name_sym)
+        collisions = typed_names & slot_names
+        raise Error, "Placeholder names cannot be both typed values and fragment slots: #{collisions.join(', ')}" if collisions.any?
+
+        missing_names = used_names.uniq - bindings.keys
+        raise Error, "Missing ClickHouse placeholder values: #{missing_names.join(', ')}" if missing_names.any?
+
+        @typed_placeholder_values = {}
+        @placeholder_types = {}
+
+        named.select(&:typed?).each do |placeholder|
+          type = PlaceholderType.new(placeholder.type)
+          value = type.validate_and_normalize(bindings.fetch(placeholder.name_sym))
+
+          register_typed_placeholder!(placeholder.name_sym, type.normalized, value)
+        end
+
+        named.reject(&:typed?).each do |placeholder|
+          value = bindings.fetch(placeholder.name_sym)
+          next if ClickHouse::SQL.part?(value)
+
+          raise Error, "Fragment slot {#{placeholder.name}} requires a SQL fragment, got #{value.class}"
+        end
+      end
+
+      def register_typed_placeholder!(name, type, value)
+        if @placeholder_types.key?(name)
+          unless @placeholder_types.fetch(name) == type
+            raise Error, "mismatching types for the '#{name}' placeholder: #{@placeholder_types.fetch(name)} vs #{type}"
+          end
+
+          unless @typed_placeholder_values.fetch(name) == value
+            raise Error, "mismatching values for the '#{name}' placeholder: " \
+              "#{ClickHouse::SQL.truncated_inspect(@typed_placeholder_values.fetch(name))} vs #{ClickHouse::SQL.truncated_inspect(value)}"
+          end
+        end
+
+        @placeholder_types[name] = type
+        @typed_placeholder_values[name] = value
+      end
+
+      # Returns nested slot parts (anonymous fills and named slot values) in source order.
+      def slot_parts
+        @placeholders.reject(&:typed?).map { |placeholder| slot_part(placeholder) }
+      end
+
+      def slot_part(placeholder)
+        if placeholder.anonymous?
+          @fill_by_position.fetch(placeholder.begin_pos)
+        else
+          bindings.fetch(placeholder.name_sym)
+        end
+      end
+
+      def nested_placeholders
+        slot_parts.each_with_object({}) do |part, values|
+          ClickHouse::SQL.merge_placeholders!(values, part.placeholders)
+        end
+      end
+
+      def nested_placeholder_types
+        slot_parts.each_with_object({}) do |part, types|
+          ClickHouse::SQL.merge_placeholder_types!(types, part.placeholder_types)
+        end
+      end
+
+      def render(redacted:, bind_index_manager: ClickHouse::SQL::BindIndexManager.new)
+        rendered = +""
+        last_pos = 0
+
+        @placeholders.each do |placeholder|
+          rendered << @sql[last_pos...placeholder.begin_pos]
+          rendered << render_placeholder(placeholder, redacted:, bind_index_manager:)
+          last_pos = placeholder.end_pos
+        end
+
+        rendered << @sql[last_pos..].to_s
+      end
+
+      def render_placeholder(placeholder, redacted:, bind_index_manager:)
+        if placeholder.typed?
+          redacted ? bind_index_manager.next_bind_str : placeholder.raw
+        else
+          ClickHouse::SQL.render_part(slot_part(placeholder), redacted:, bind_index_manager:)
+        end
+      end
+    end
+  end
+end