diamond-orm 0.1.0

data/lib/diamond/struct_factory.rb

@@ -0,0 +1,262 @@
+require_relative 'compiler/dql'
+require 'json'
+
+module Diamond
+  # JSON writer mixed into every Diamond struct class. Serializes
+  # straight from positional values — `{"id":1,"name":"x"}` — without
+  # the intermediate Hash that `to_h` allocates. Makes
+  # `JSON.generate(array_of_structs)` correct (stdlib has no Struct
+  # support and renders `"#<struct …>"` garbage) and fast.
+  module StructJSON
+    def to_json(*)
+      out = +'{'
+      first = true
+      each_pair do |member, value|
+        out << ',' unless first
+        first = false
+        out << '"' << member.to_s << '":'
+        out << JSON.generate(value)
+      end
+      out << '}'
+      out
+    end
+  end
+
+  module StructFactory
+    # struct classes pile up per projection shape. cached per-Ractor on
+    # Ractor.current's local storage so each worker warms its own cache
+    # without tripping isolation errors.
+    CACHES_KEY = Diamond::RACTOR_KEYS[:struct_caches]
+
+    def self.caches
+      Ractor.current[CACHES_KEY] ||= Hash.new { |h, k| h[k] = {} }
+    end
+
+    def self.cache
+      caches[:structs]
+    end
+
+    def self.clear_caches!
+      Ractor.current[CACHES_KEY] = Hash.new { |h, k| h[k] = {} }
+    end
+
+    def self.create(table, row_hash, projection_nodes = nil)
+      members = resolve_members(projection_nodes, table)
+
+      member_names = members.map(&:first)
+      klass = struct_class_for(table, member_names, projection_nodes)
+
+      values = members.map { |member, sql_name| row_hash[sql_name] }
+      klass.new(*values).freeze
+    end
+
+    # Build a frozen struct from a RETURNING result row (one of the
+    # columns the caller asked for, in the order asked). Reuses the
+    # existing struct cache keyed by member-name list.
+    def self.create_from_returning(table, row, columns)
+      member_names = columns.map(&:to_sym)
+      cache_key = "#{table.name}\0#{member_names.join("\0")}"
+      klass = cache[cache_key] ||= Struct.new(*member_names) do
+        include Diamond::StructJSON
+        def save; raise Diamond::InertObjectError, "Data is inert! Use the Table proxy to update."; end
+      end
+      values = columns.map { |c| row[c.to_sym] }
+      klass.new(*values).freeze
+    end
+
+    # Build a frozen struct from an Extralite::Transform result row. The
+    # row shape is a Hash keyed by the transform spec's keys; for parent
+    # columns the key is the bare column name (e.g. "id"), for eagerly-
+    # loaded children the key is the table name and the value is an Array
+    # of nested Hashes (each becoming a child struct).
+    #
+    # Post-processes the Extralite output:
+    #   - strips the "table." prefix from nested column names
+    #   - drops null sentinel rows LEFT JOIN leaves for parents without kids
+    #   - deduplicates children by primary key (Extralite only dedupes
+    #     within a single parent row's join group, not across the join)
+    def self.create_eager(parent_table, row)
+      members = []
+      table_sym = parent_table.is_a?(Symbol) ? parent_table : parent_table.name
+
+      row.each do |key, value|
+        if value.is_a?(Array)
+          # collection (to-many eager join)
+          member_name = key.to_sym
+          # extract actual child table name from column aliases (table.col)
+          sample = value.first
+          child_table_sym = if sample.is_a?(Hash) && sample.keys.first.to_s.include?('.')
+                              sample.keys.first.to_s.split('.', 2).first.to_sym
+                            else
+                              member_name
+                            end
+          child_schema = Diamond.engine.schema_cache[child_table_sym]
+          child_pk = child_schema[:primary_key]
+
+          # strip table. prefix from each child row's keys
+          stripped = value.map do |child_row|
+            child_row.each_with_object({}) do |(k, v), h|
+              short = k.to_s.sub(/^#{Regexp.escape(child_table_sym.to_s)}\./, '').to_sym
+              h[short] = v
+            end
+          end
+
+          # drop null sentinels (Extralite leaves these for parents without
+          # children after a LEFT JOIN)
+          stripped.reject! { |child_row| child_row.values.all?(&:nil?) }
+
+          # dedupe by primary key
+          if child_pk
+            seen = {}
+            stripped = stripped.reject do |r|
+              pk_val = r[child_pk]
+              if seen[pk_val]
+                true
+              else
+                seen[pk_val] = true
+                false
+              end
+            end
+          end
+
+          child_structs = stripped.map { |child_row| create_eager(child_table_sym, child_row) }
+          members << [member_name, child_structs]
+        elsif value.is_a?(Hash)
+          # single object (to-one eager join)
+          member_name = key.to_sym
+          # the key in the transform output is the member name (may be aliased).
+          # the actual child table name is encoded in the column aliases (table.col).
+          # extract it from any key to find the schema for stripping prefixes.
+          sample_key = value.keys.first
+          child_table_sym = if sample_key.to_s.include?('.')
+                              sample_key.to_s.split('.', 2).first.to_sym
+                            else
+                              # no dotted key — fall back to member name as table name
+                              member_name
+                            end
+
+          # strip table. prefix from keys
+          stripped = value.each_with_object({}) do |(k, v), h|
+            short = k.to_s.sub(/^#{Regexp.escape(child_table_sym.to_s)}\./, '').to_sym
+            h[short] = v
+          end
+
+          # drop null sentinel (parent without child) -> nil
+          if stripped.values.all?(&:nil?)
+            members << [member_name, nil]
+          else
+            child_struct = create_eager(child_table_sym, stripped)
+            members << [member_name, child_struct]
+          end
+        else
+          members << [key.to_sym, value]
+        end
+      end
+
+      member_names = members.map(&:first)
+      cache_key = "#{table_sym}\0#{member_names.join("\0")}"
+      klass = cache[cache_key] ||= Struct.new(*member_names) do
+        include Diamond::StructJSON
+        def save; raise Diamond::InertObjectError, "Data is inert! Use the Table proxy to update."; end
+      end
+      klass.new(*members.map(&:last)).freeze
+    end
+
+    # array rows land positionally, no hash lookups. select order ==
+    # member order, `*` included. takes the first members.size values:
+    # joined `SELECT *` yields trailing columns of other tables that
+    # the hash path ignores by key — slicing keeps both paths identical.
+    def self.create_from_array(table, row_array, projection_nodes = nil)
+      build(factory_for(table, projection_nodes), row_array)
+    end
+
+    # Bulk path for materialize: resolves members + struct class ONCE
+    # per query instead of per row (the dominant cost in the hot loop
+    # per bench/rails/breakdown.rb: ~59% of collection time).
+    def self.create_many(table, rows, projection_nodes = nil)
+      factory = factory_for(table, projection_nodes)
+      rows.map { |row| build(factory, row) }
+    end
+
+    # Pre-resolved [klass, member_count] for streaming consumers
+    # (Cursor) that cannot collect rows up front.
+    def self.factory_for(table, projection_nodes = nil)
+      members = resolve_members(projection_nodes, table)
+      member_names = members.map(&:first)
+      [struct_class_for(table, member_names, projection_nodes), member_names.size]
+    end
+
+    def self.build(factory, row_array)
+      klass, count = factory
+      klass.new(*(row_array.size == count ? row_array : row_array.first(count))).freeze
+    end
+
+    def self.struct_class_for(table, member_names, projection_nodes)
+      # NUL can't appear in identifiers, so [a_b, c] and [a, b_c] stop colliding.
+      cache_key = projection_nodes ? "#{table.name}\0#{member_names.join("\0")}" : table.name.to_s
+
+      unless cache[cache_key]
+        cache[cache_key] = Struct.new(*member_names) do
+          include Diamond::StructJSON
+          def save; raise Diamond::InertObjectError, "Data is inert! Use the Table proxy to update."; end
+        end
+      end
+
+      cache[cache_key]
+    end
+
+    def self.resolve_members(projection_nodes, table)
+      if projection_nodes.nil? || projection_nodes.empty?
+        return table.schema[:columns].map { |c| [c, c] }
+      end
+
+      projection_nodes.map do |node|
+        sql_name    = compile_node(node)
+        member_name = member_name_for(node)
+        [member_name, sql_name]
+      end
+    end
+
+    def self.compile_node(node)
+      # Extralite returns symbol keys for both columns and function results
+      # (e.g. { :id => 1, :"COUNT(id)" => 4 }). We mirror that here so
+      # `row_hash[sql_name]` hits the right key.
+      case node
+      when Diamond::AST::Column
+        node.name.to_sym
+      when Diamond::AST::Function
+        Diamond::Compiler::DQL.translate_node(node, []).to_sym
+      when Diamond::AST::WindowFunction
+        Diamond::Compiler::DQL.translate_node(node, []).to_sym
+      else
+        Diamond::Compiler::DQL.translate_node(node, []).to_sym
+      end
+    end
+
+    def self.member_name_for(node)
+      case node
+      when Diamond::AST::Column
+        node.name
+      when Diamond::AST::Function
+        first_arg = node.args.first
+        suffix = case first_arg
+                 when Diamond::AST::Column then first_arg.name
+                 when Diamond::AST::Literal
+                   val = first_arg.value
+                   val.is_a?(String) ? val : (val.nil? ? 'nil' : val.to_s)
+                 else
+                   'all'
+                 end
+        :"#{node.name.downcase}_#{suffix}"
+      when Diamond::AST::WindowFunction
+        parts = []
+        parts.concat(node.partition_by) unless node.partition_by.empty?
+        parts.concat(node.order_by) unless node.order_by.empty?
+        suffix = parts.empty? ? 'all' : parts.join('_')
+        :"#{node.func_name.downcase}_#{suffix}"
+      else
+        raise "Unknown projection node: #{node.class}"
+      end
+    end
+  end
+end

data/lib/diamond/table.rb

@@ -0,0 +1,32 @@
+require_relative 'ast'
+require_relative 'query_object'
+
+module Diamond
+  class Table
+    include Enumerable
+
+    attr_reader :name, :schema
+
+    def initialize(name)
+      @name = name
+      @schema = Diamond.engine.schema_cache[name]
+    end
+
+    # column names in DDL order.
+    def columns
+      @schema[:columns]
+    end
+
+    # primary key column, or nil.
+    def primary_key
+      @schema[:primary_key]
+    end
+
+    # Sequel-style sugar: Users[1] → find(1).first. Returns the frozen
+    # struct, or nil when no row matches (Hash-like miss semantics —
+    # use find! when you want RecordNotFound instead).
+    def [](id)
+      find(id).first
+    end
+  end
+end

data/lib/diamond/version.rb

@@ -0,0 +1,3 @@
+module Diamond
+  VERSION = "0.1.0"
+end