activerecord-clickhouse-adapter 0.1.0

data/lib/active_record/connection_adapters/clickhouse/quoting.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+
+module ActiveRecord
+  module ConnectionAdapters
+    module ClickHouse
+      module Quoting
+        extend ActiveSupport::Concern
+
+        # disallow_raw_sql! vets order/pluck arguments against these; the abstract
+        # matchers reject backtick-quoted names — this adapter's own quoting style —
+        # so they admit `table`.`column` exactly as MySQL's do.
+        COLUMN_NAME_MATCHER = /
+          \A
+          (
+            (?:
+              # `table_name`.`column_name` | function(one or no argument)
+              ((?:\w+\.|`\w+`\.)?(?:\w+|`\w+`) | \w+\((?:|\g<2>)\))
+            )
+            (?:(?:\s+AS)?\s+(?:\w+|`\w+`))?
+          )
+          (?:\s*,\s*\g<1>)*
+          \z
+        /ix
+
+        COLUMN_NAME_WITH_ORDER_MATCHER = /
+          \A
+          (
+            (?:
+              # `table_name`.`column_name` | function(one or no argument)
+              ((?:\w+\.|`\w+`\.)?(?:\w+|`\w+`) | \w+\((?:|\g<2>)\))
+            )
+            (?:\s+ASC|\s+DESC)?
+            (?:\s+NULLS\s+(?:FIRST|LAST))?
+          )
+          (?:\s*,\s*\g<1>)*
+          \z
+        /ix
+
+        class_methods do
+          def quote_column_name(name)
+            "`#{name.to_s.gsub("`", "``")}`"
+          end
+
+          def quote_table_name(name)
+            name.to_s.split(".").map { |part| quote_column_name(part) }.join(".")
+          end
+
+          def column_name_matcher = COLUMN_NAME_MATCHER
+
+          def column_name_with_order_matcher = COLUMN_NAME_WITH_ORDER_MATCHER
+        end
+
+        # Control characters travel as escape sequences, not raw bytes: DDL passes
+        # through String#squish (which would collapse a raw newline inside a quoted
+        # literal) and the server echoes them back escaped anyway.
+        QUOTED_STRING_ESCAPES = {
+          "\\" => "\\\\", "'" => "\\'",
+          "\n" => "\\n", "\r" => "\\r", "\t" => "\\t", "\0" => "\\0"
+        }.freeze
+
+        def quote_string(string)
+          string.gsub(/[\\'\n\r\t\0]/, QUOTED_STRING_ESCAPES)
+        end
+
+        # DateTime64 stores an epoch and the server parses naive strings in its own
+        # timezone (UTC here); params reject offsets outright (code 457, PLAN.md §2).
+        # UTC is therefore the only faithful wire encoding, whatever default_timezone says.
+        def quoted_date(value)
+          value = value.getutc if value.acts_like?(:time) && !value.utc?
+          result = value.to_fs(:db)
+          value.respond_to?(:usec) && value.usec.positive? ? "#{result}.#{format("%06d", value.usec)}" : result
+        end
+
+        def quoted_true = "true"
+        def quoted_false = "false"
+        def unquoted_true = true
+        def unquoted_false = false
+
+        def quote(value)
+          case value
+          when Array then "[#{value.map { |item| quote(item) }.join(", ")}]"
+          when Hash then "{#{value.map { |key, item| "#{quote(key)}: #{quote(item)}" }.join(", ")}}"
+          when IPAddr then "'#{quote_string(value.to_s)}'"
+          else super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/clickhouse/row_binary.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "date"
+require "ipaddr"
+
+require "active_record/connection_adapters/clickhouse/type_parser"
+
+module ActiveRecord
+  module ConnectionAdapters
+    module ClickHouse
+      # Decodes RowBinaryWithNamesAndTypes bodies: a varint column count, the names,
+      # the type strings, then rows of packed values (probed 2026-07-13, PLAN.md §2).
+      # Yields the same Ruby values the JSON casters produce, so the cast layer treats
+      # both wires identically. Types without a binary decoder raise Undecodable and
+      # the connection retries the query on the JSON wire.
+      class RowBinary
+        Undecodable = Class.new(StandardError) # rubocop:disable Style/EmptyClassDefinition
+
+        INTEGER_FORMATS = {
+          "Int8" => ["c", 1], "Int16" => ["s<", 2], "Int32" => ["l<", 4], "Int64" => ["q<", 8],
+          "UInt8" => ["C", 1], "UInt16" => ["S<", 2], "UInt32" => ["L<", 4], "UInt64" => ["Q<", 8]
+        }.freeze
+
+        # Storage width is decided by precision; the server normalizes every Decimal
+        # alias to Decimal(precision, scale) in the type header.
+        DECIMAL_BYTES = [[9, 4], [18, 8], [38, 16], [76, 32]].freeze
+
+        UNIX_EPOCH_JULIAN_DAY = Date.new(1970, 1, 1).jd
+
+        def self.decode(body) = new(body).decode
+
+        def initialize(body)
+          @body = body
+          @position = 0
+        end
+
+        def decode
+          return [[], [], []] if @body.empty?
+
+          names = Array.new(read_varint) { read_string }
+          types = Array.new(names.length) { read_string }
+          decoders = types.map { |type| value_decoder(TypeParser.parse(type)) }
+          rows = []
+          rows << decoders.map(&:call) until end_of_body?
+          [names, types, rows]
+        end
+
+        private
+
+        def end_of_body? = @position >= @body.bytesize
+
+        def value_decoder(node) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
+          case node.name
+          when "Nullable" then nullable_decoder(node)
+          when "LowCardinality" then value_decoder(node.args.fetch(0))
+          when "SimpleAggregateFunction" then value_decoder(node.args.fetch(1))
+          when "Array" then array_decoder(node)
+          when "Map" then map_decoder(node)
+          when "Tuple" then tuple_decoder(node)
+          # output_format_binary_write_json_as_string=1 delivers JSON columns as String.
+          when "String", "JSON" then -> { read_string }
+          when "FixedString" then -> { read_bytes(node.args.fetch(0)) }
+          when "Bool" then -> { read_unsigned(1) != 0 }
+          when "Enum8" then enum_decoder(node, 1)
+          when "Enum16" then enum_decoder(node, 2)
+          when "UUID" then -> { read_uuid }
+          when "IPv4" then -> { IPAddr.new_ntoh([read_unsigned(4)].pack("N")) }
+          when "IPv6" then -> { IPAddr.new_ntoh(@body.byteslice(advance(16), 16)) }
+          when "Date" then -> { Date.jd(UNIX_EPOCH_JULIAN_DAY + read_unsigned(2)) }
+          when "Date32" then -> { Date.jd(UNIX_EPOCH_JULIAN_DAY + read_signed(4)) }
+          when "DateTime" then -> { represent_instant(Time.at(read_unsigned(4))) }
+          when "DateTime64" then datetime64_decoder(node)
+          when "Float32" then -> { @body.unpack1("e", offset: advance(4)) }
+          when "Float64" then -> { @body.unpack1("E", offset: advance(8)) }
+          when "Decimal" then decimal_decoder(node)
+          when "Int128", "Int256" then -> { read_signed(node.name == "Int128" ? 16 : 32) }
+          when "UInt128", "UInt256" then -> { read_unsigned(node.name == "UInt128" ? 16 : 32) }
+          when "Nothing" then -> { advance(1) && nil }
+          else
+            INTEGER_FORMATS.key?(node.name) ? integer_decoder(node) : raise_undecodable(node)
+          end
+        end
+
+        def raise_undecodable(node)
+          raise Undecodable, "no RowBinary decoder for ClickHouse type #{node.name}"
+        end
+
+        def integer_decoder(node)
+          format, size = INTEGER_FORMATS.fetch(node.name)
+          -> { @body.unpack1(format, offset: advance(size)) }
+        end
+
+        def nullable_decoder(node)
+          inner = value_decoder(node.args.fetch(0))
+          -> { read_unsigned(1) == 1 ? nil : inner.call }
+        end
+
+        def array_decoder(node)
+          inner = value_decoder(node.args.fetch(0))
+          -> { Array.new(read_varint) { inner.call } }
+        end
+
+        def map_decoder(node)
+          key = value_decoder(node.args.fetch(0))
+          value = value_decoder(node.args.fetch(1))
+          -> { Array.new(read_varint) { [key.call, value.call] }.to_h }
+        end
+
+        # Named tuples come back as hashes to match the JSON wire's object shape.
+        def tuple_decoder(node)
+          if node.args.first.is_a?(Array)
+            members = node.args.map { |name, type| [name, value_decoder(type)] }
+            -> { members.to_h { |name, decoder| [name, decoder.call] } }
+          else
+            members = node.args.map { |type| value_decoder(type) }
+            -> { members.map(&:call) }
+          end
+        end
+
+        def enum_decoder(node, size)
+          labels = node.args.to_h { |label, number| [number, label] }
+          -> { labels.fetch(read_signed(size)) }
+        end
+
+        def datetime64_decoder(node)
+          divisor = 10**node.args.fetch(0)
+          -> { represent_instant(Time.at(Rational(read_signed(8), divisor))) }
+        end
+
+        # The wire carries an epoch, so the instant is zone-free; representation
+        # follows default_timezone like every built-in adapter (Time.at is local).
+        def represent_instant(time)
+          ActiveRecord.default_timezone == :local ? time : time.utc
+        end
+
+        def decimal_decoder(node)
+          precision, scale = node.args
+          size = DECIMAL_BYTES.find { |max_precision, _| precision <= max_precision }.last
+          -> { BigDecimal("#{read_signed(size)}e-#{scale}") }
+        end
+
+        def read_varint
+          result = 0
+          shift = 0
+          loop do
+            byte = @body.getbyte(advance(1))
+            result |= (byte & 0x7f) << shift
+            return result if byte < 0x80
+
+            shift += 7
+          end
+        end
+
+        def read_string = read_bytes(read_varint)
+
+        def read_bytes(length)
+          @body.byteslice(advance(length), length).force_encoding(Encoding::UTF_8)
+        end
+
+        def read_unsigned(size)
+          return @body.unpack1(INTEGER_FORMATS.fetch("UInt#{size * 8}").first, offset: advance(size)) if size <= 8
+
+          words = @body.unpack("Q<#{size / 8}", offset: advance(size))
+          words.each_with_index.sum { |word, index| word << (64 * index) }
+        end
+
+        def read_signed(size)
+          return @body.unpack1(INTEGER_FORMATS.fetch("Int#{size * 8}").first, offset: advance(size)) if size <= 8
+
+          value = read_unsigned(size)
+          value >= (1 << ((size * 8) - 1)) ? value - (1 << (size * 8)) : value
+        end
+
+        # UUIDs travel as two little-endian UInt64 halves (high, then low).
+        def read_uuid
+          high, low = @body.unpack("Q<2", offset: advance(16))
+          format("%<high>016x%<low>016x", high: high, low: low)
+            .insert(20, "-").insert(16, "-").insert(12, "-").insert(8, "-")
+        end
+
+        def advance(length)
+          position = @position
+          @position += length
+          position
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/clickhouse/schema_definitions.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module ClickHouse
+      class TableDefinition < ConnectionAdapters::TableDefinition
+        attr_reader :engine, :order, :partition, :ttl, :table_settings, :primary_key_clause, :sample
+
+        def initialize(conn, name, engine: "MergeTree", order: nil, partition: nil, ttl: nil,
+                       settings: nil, primary_key_clause: nil, sample: nil, **)
+          @engine = engine
+          @order = order
+          @partition = partition
+          @ttl = ttl
+          @table_settings = settings
+          @primary_key_clause = primary_key_clause
+          @sample = sample
+          super(conn, name, **)
+        end
+      end
+
+      # Carries the ClickHouse-only column metadata the dumper needs: compression codec
+      # and MATERIALIZED/ALIAS server-computed expressions.
+      class Column < ConnectionAdapters::Column
+        attr_reader :codec, :computed_kind, :computed_expression
+
+        def initialize(*, codec: nil, computed_kind: nil, computed_expression: nil, **)
+          @codec = codec
+          @computed_kind = computed_kind
+          @computed_expression = computed_expression
+          super(*, **)
+        end
+      end
+
+      # A ClickHouse data-skipping index: `using` is the full index type expression
+      # ("bloom_filter", "set(100)", ...) and granularity is index blocks per granule.
+      class IndexDefinition < ConnectionAdapters::IndexDefinition
+        attr_reader :granularity
+
+        def initialize(table, name, columns:, using:, granularity:)
+          @granularity = granularity
+          super(table, name, false, columns, using: using)
+        end
+      end
+
+      class SchemaCreation < ConnectionAdapters::SchemaCreation
+        private
+
+        def visit_TableDefinition(o)
+          stamp_on_cluster(super, o.name)
+        end
+
+        def visit_AlterTable(o)
+          stamp_on_cluster(super, o.name)
+        end
+
+        # ON CLUSTER renders directly after the table name; the first mention is the
+        # one following CREATE/ALTER TABLE.
+        def stamp_on_cluster(sql, table_name)
+          clause = @conn.on_cluster_clause
+          return sql if clause.empty?
+
+          quoted = quote_table_name(table_name)
+          sql.sub("TABLE #{quoted} ", "TABLE #{quoted}#{clause} ")
+        end
+
+        # ClickHouse nullability lives in the type (Nullable/LowCardinality wrappers),
+        # not in NOT NULL constraints, and MergeTree requires an ORDER BY clause.
+        def visit_ColumnDefinition(o)
+          o.sql_type = type_to_sql(o.type, **o.options)
+          column_sql = "#{quote_column_name(o.name)} #{wrapped_sql_type(o)}"
+          add_column_options!(column_sql, column_options(o))
+          column_sql
+        end
+
+        def wrapped_sql_type(o)
+          sql_type = o.sql_type
+          sql_type = "Nullable(#{sql_type})" if o.options[:null]
+          sql_type = "LowCardinality(#{sql_type})" if o.options[:low_cardinality]
+          sql_type
+        end
+
+        def visit_AddColumnDefinition(o)
+          "ADD COLUMN #{accept(o.column)}"
+        end
+
+        # Data-skipping indexes are part of CREATE TABLE (supports_indexes_in_create?);
+        # the expression passes through verbatim — it may be a function of columns.
+        def index_in_create(table_name, column_name, options)
+          columns = Array(column_name)
+          expression = columns.length == 1 ? columns.first.to_s : "(#{columns.join(", ")})"
+          name = options.fetch(:name) { @conn.index_name(table_name, column_name) }
+          # Same portability default as add_index: bloom_filter unless told otherwise.
+          "INDEX #{quote_column_name(name)} #{expression} " \
+            "TYPE #{options.fetch(:using, "bloom_filter")} GRANULARITY #{options.fetch(:granularity, 1)}"
+        end
+
+        # DEFAULT / MATERIALIZED / ALIAS are mutually exclusive ways for a column to get
+        # its value; CODEC composes with any of them.
+        def add_column_options!(sql, options)
+          sql << column_value_clause(options).to_s
+          sql << " CODEC(#{options[:codec]})" if options[:codec]
+          sql
+        end
+
+        def column_value_clause(options)
+          clauses = []
+          if options_include_default?(options)
+            default = options[:default]
+            clauses << " DEFAULT #{default.is_a?(Proc) ? default.call : @conn.quote(default)}"
+          end
+          clauses << " MATERIALIZED #{options[:materialized]}" if options[:materialized]
+          clauses << " ALIAS #{options[:alias]}" if options[:alias]
+          raise ArgumentError, "materialized:, alias: and default: are mutually exclusive" if clauses.many?
+
+          clauses.first
+        end
+
+        def add_table_options!(create_sql, o)
+          if o.engine.include?("MergeTree") && o.order.nil?
+            raise ArgumentError, "#{o.engine} tables require order: (the sorting key); use order: \"tuple()\" for none"
+          end
+
+          create_sql << " ENGINE = #{o.engine}"
+          table_clauses(o).each { |keyword, expression| create_sql << " #{keyword} #{expression}" if expression }
+          create_sql
+        end
+
+        def table_clauses(o)
+          {
+            "PARTITION BY" => o.partition,
+            "PRIMARY KEY" => o.primary_key_clause,
+            "ORDER BY" => o.order,
+            "SAMPLE BY" => o.sample,
+            "TTL" => o.ttl,
+            "SETTINGS" => o.table_settings.present? ? format_settings(o.table_settings) : nil
+          }
+        end
+
+        def format_settings(settings)
+          settings.map { |key, value| "#{key} = #{value}" }.join(", ")
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/clickhouse/schema_dumper.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module ClickHouse
+      # Dumps columns so the schema round-trips through this adapter's DSL: AR-native
+      # types only when type_to_sql regenerates the exact server type, everything else
+      # as a verbatim ClickHouse type string; Nullable/LowCardinality become column
+      # options because absence of null: means NOT NULL here, unlike core Rails.
+      class SchemaDumper < ConnectionAdapters::SchemaDumper
+        private
+
+        # Materialized views and dictionaries dump after every table so their sources
+        # exist on load (dictionaries bind lazily, but keep the order intuitive).
+        def tables(stream)
+          super
+          materialized_views(stream)
+          dictionaries(stream)
+        end
+
+        DICTIONARIES_SQL = <<~SQL.squish
+          SELECT name, create_table_query FROM system.tables
+          WHERE database = currentDatabase() AND engine = 'Dictionary'
+          ORDER BY name
+        SQL
+        private_constant :DICTIONARIES_SQL
+
+        def dictionaries(stream)
+          dumpable = @connection.select_all(DICTIONARIES_SQL, "SCHEMA").reject { |row| ignored?(row["name"]) }
+          dumpable.each_with_index do |dictionary, index|
+            stream.puts if index.zero?
+            stream.puts dictionary_statement(dictionary)
+          end
+        end
+
+        # create_dictionary re-infers columns and re-injects credentials at load time,
+        # so only the identity kwargs are parsed back out of the stored DDL.
+        def dictionary_statement(dictionary)
+          kwargs = dictionary_kwargs(dictionary["create_table_query"])
+          rendered = kwargs.map { |keyword, value| "#{keyword}: #{value}" }
+          "  create_dictionary #{dictionary["name"].inspect}, #{rendered.join(", ")}"
+        end
+
+        def dictionary_kwargs(ddl)
+          database = ddl[/\bDB '([^']+)'/, 1]
+          {
+            source: ddl[/\bTABLE '([^']+)'/, 1].inspect,
+            database: (database.inspect if database && database != current_database),
+            primary_key: ddl[/\bPRIMARY KEY ([^\s(]+)/, 1].inspect,
+            layout: ddl[/\bLAYOUT\((\w+)\(/, 1].downcase.to_sym.inspect,
+            lifetime: "#{ddl[/\bLIFETIME\(MIN (\d+)/, 1].to_i}..#{ddl[/\bMAX (\d+)\)/, 1].to_i}"
+          }.compact
+        end
+
+        # Projections dump right after their table as add_projection calls, parsed back
+        # out of the stored query text (SELECT ... [GROUP BY ...] [ORDER BY ...]).
+        def table(table, stream)
+          super
+          projections(table).each do |row|
+            stream.puts("  #{projection_statement(table, row)}")
+            stream.puts
+          end
+        end
+
+        PROJECTIONS_SQL = <<~SQL.squish
+          SELECT name, query FROM system.projections
+          WHERE database = currentDatabase() AND table = %s ORDER BY name
+        SQL
+        private_constant :PROJECTIONS_SQL
+
+        def projections(table)
+          @connection.select_all(format(PROJECTIONS_SQL, @connection.quote(table)), "SCHEMA").to_a
+        end
+
+        def projection_statement(table, row)
+          query = row["query"]
+          parts = {
+            select: query[/\ASELECT\s+(.*?)(?:\s+GROUP BY\s|\s+ORDER BY\s|\z)/m, 1],
+            group: query[/\sGROUP BY\s+(.*?)(?:\s+ORDER BY\s|\z)/m, 1],
+            order: query[/\sORDER BY\s+(.*)\z/m, 1]
+          }.compact
+          arguments = parts.map { |keyword, expression| "#{keyword}: #{expression.inspect}" }
+          "add_projection #{table.inspect}, #{row["name"].inspect}, #{arguments.join(", ")}"
+        end
+
+        MATERIALIZED_VIEW_SQL = <<~SQL.squish
+          SELECT name, as_select, create_table_query FROM system.tables
+          WHERE database = currentDatabase() AND engine = 'MaterializedView'
+          ORDER BY name
+        SQL
+        private_constant :MATERIALIZED_VIEW_SQL
+
+        def materialized_views(stream)
+          dumpable = @connection.select_all(MATERIALIZED_VIEW_SQL, "SCHEMA").reject { |view| ignored?(view["name"]) }
+          dumpable.each_with_index do |view, index|
+            stream.puts if index.zero?
+            stream.puts materialized_view_statement(view)
+          end
+        end
+
+        # The server database-qualifies every identifier it stores; strip the current
+        # database so the dump loads into any target database.
+        def materialized_view_statement(view)
+          target = view["create_table_query"][/\bTO\s+(\S+)/, 1]
+          select = strip_database_qualifier(view["as_select"])
+          "  create_materialized_view #{view["name"].inspect}, " \
+            "to: #{strip_database_qualifier(target).inspect}, as: #{select.inspect}"
+        end
+
+        def strip_database_qualifier(sql)
+          database = Regexp.escape(current_database)
+          sql.gsub(/(?:`#{database}`|#{database})\./, "")
+        end
+
+        def current_database
+          @current_database ||= @connection.select_value("SELECT currentDatabase()", "SCHEMA")
+        end
+
+        def column_spec(column)
+          inner_type, wrappers = unwrap_column_type(column.sql_type)
+          type = schema_type(column)
+
+          if regenerates_exactly?(type, inner_type, column)
+            spec = prepare_column_options(column)
+            spec[:low_cardinality] = "true" if wrappers.include?(:low_cardinality)
+            [type, spec]
+          else
+            [column.sql_type, verbatim_column_options(column)]
+          end
+        end
+
+        def prepare_column_options(column)
+          spec = super
+          spec.delete(:null)
+          spec[:null] = "true" if column.null
+          spec.merge!(clickhouse_column_options(column))
+        end
+
+        def clickhouse_column_options(column)
+          spec = {}
+          spec[column.computed_kind.to_sym] = column.computed_expression.inspect if column.computed_kind
+          spec[:codec] = column.codec.inspect if column.codec
+          spec
+        end
+
+        # Rails omits precision 6 as the datetime default, but this adapter's default is
+        # DateTime64(3) — always dump the real precision.
+        def schema_precision(column)
+          column.precision&.inspect
+        end
+
+        WRAPPER_TYPES = { /\ALowCardinality\((.*)\)\z/m => :low_cardinality, /\ANullable\((.*)\)\z/m => :null }.freeze
+        private_constant :WRAPPER_TYPES
+
+        def unwrap_column_type(sql_type)
+          wrappers = []
+          inner = sql_type
+          while (wrapper = WRAPPER_TYPES.find { |pattern, _| pattern.match?(inner) })
+            wrappers << wrapper.last
+            inner = inner.match(wrapper.first)[1]
+          end
+          [inner, wrappers]
+        end
+
+        def regenerates_exactly?(type, inner_type, column)
+          return false unless type
+
+          regenerated = @connection.type_to_sql(
+            type, limit: column.limit, precision: column.precision, scale: column.scale
+          )
+          regenerated == inner_type
+        rescue ArgumentError
+          false
+        end
+
+        def verbatim_column_options(column)
+          spec = {}
+          spec[:default] = schema_default(column)
+          spec[:comment] = column.comment.inspect if column.comment.present?
+          spec.compact
+        end
+
+        def index_parts(index)
+          super + ["granularity: #{index.granularity}"]
+        end
+
+        # Hash#inspect renders {:key=>value} before Ruby 3.4; emit the modern literal
+        # so the settings: option dumps identically on every supported Ruby.
+        def format_options(options)
+          options.map { |key, value| "#{key}: #{format_option_value(value)}" }.join(", ")
+        end
+
+        def format_option_value(value)
+          return value.inspect unless value.is_a?(Hash)
+
+          "{#{value.map { |key, entry| "#{key}: #{entry.inspect}" }.join(", ")}}"
+        end
+      end
+    end
+  end
+end