pipeloader 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3dfa060eef9aa9ccdeb6bf2408b3289a06daca11cc8b53e3b1ff476964a27577
-  data.tar.gz: 2c419c78fb32aafbf9f76e7a376afae92d82a9f4e67f2ecb2f31f00f97bbbd43
+  metadata.gz: 2efb3ab68daaf2649998d53eab252167254d1e195ff3f46ff676c1bcaeeb8d17
+  data.tar.gz: a45b1c6236205caf6421437bdf4ec6b04b459698d630f63708c6f929e63c1242
 SHA512:
-  metadata.gz: 81b2c029fc1226ab37b620a9699fddc873d979aa82ff693ed5b4b6539326aed038fd0de4a2431b37f8571a390c0b5638da1e41c4b784341f1f9caeb4aadeeed6
-  data.tar.gz: f905883e768f604f436d4e64b29bd84fea16bbe6d3bfadf68ec4b423ec0824015cf166ac73ba3c68d9536f0e0a9303b7bb53b09be58f5e9f0bdfbb880b03a767
+  metadata.gz: c607f4d9a7c5c4c5ee035bc2458ad3e91b0a1d15e83d7a9cedd35a2942de1c470521175eff0d9898211c828575c1615aeb514212e3edb252159686b5aa11864b
+  data.tar.gz: 5d9dbf27e303c91733d6f6b5787015bf993a9658b173f689e4cecbd9a0a55739ac4d691976bc4cfe034f0b5d0d8e541717c1a57a3b6780ed58b57c454d3e7180

data/lib/pipeloader/ar_patch.rb

@@ -26,7 +26,9 @@ module Pipeloader
           sql, bind_objs, = to_sql_and_binds(relation, binds, preparable, allow_retry)
           if sql.lstrip[0, 6].casecmp("select").zero?
             params = bind_objs.map { |b| b.respond_to?(:value_for_database) ? b.value_for_database : b }
-            return dl.with(Pipeloader::Source, raw_connection).load([sql, params])
+            # Hand the Source this connection (self): it pipelines on raw_connection
+            # and types results via the adapter's OID lookup. One Source per checkout.
+            return dl.with(Pipeloader::Source, self).load([sql, params])
           end
         end
         # Synchronous fallback (no active response, or not gathered): one query,

data/lib/pipeloader/field_exact.rb

@@ -180,7 +180,7 @@ module Pipeloader
   # key, single), :by_fk_one (has_one, demux by FK, first) or :by_fk_many (has_many,
   # demux by FK, array). All fused lookups on a connection share ONE FusionSource.
   def self.fuse(dataloader, model, kind, key, columns, value)
-    dataloader.with(FusionSource, model.connection.raw_connection)
+    dataloader.with(FusionSource, model.connection)
               .load([kind, model, key, columns, value].freeze)
   end
 
@@ -192,15 +192,15 @@ module Pipeloader
   # WITHOUT forcing (`request`), then force them together — so a whole level's fused
   # lookups collapse into one pipeline burst and round trips stay = tree depth.
   class FusionSource < GraphQL::Dataloader::Source
-    def initialize(pg)
-      @pg = pg
+    def initialize(conn)
+      @conn = conn
     end
 
     # descriptors: [kind, model, key, columns, value], deduped by Dataloader (so two
     # parents sharing a belongs_to target hit the DB once). Returns one demuxed value
     # per descriptor, in order.
     def fetch(descriptors)
-      src = @dataloader.with(Pipeloader::Source, @pg)
+      src = @dataloader.with(Pipeloader::Source, @conn)
 
       # One `WHERE key = ANY($1)` per distinct query shape, enqueued but not forced.
       pending = descriptors.group_by { |d| d[0, 4] }.map do |(kind, model, key, columns), ds|

data/lib/pipeloader/pipeliner.rb

@@ -5,8 +5,9 @@ module Pipeloader
   module Pipeliner
     module_function
 
-    # queries: array of [sql, params]. Returns array of [columns, rows] (raw
-    # strings), in the same order, having sent them all in a single round trip.
+    # queries: array of [sql, params]. Returns array of [columns, rows, oids]
+    # (raw string values + per-column [oid, fmod] so the Source can type them),
+    # in the same order, having sent them all in a single round trip.
     #
     # Prepared statements are cached for the lifetime of the REQUEST (the cache and
     # name space are set up by Pipeloader::Trace per multiplex), so a shape is
@@ -71,10 +72,14 @@ module Pipeloader
         break if status == PG::PGRES_PIPELINE_SYNC
 
         if status == PG::PGRES_TUPLES_OK && results
-          # Raw strings, so ActiveRecord casts via its own column types (and so we
-          # never disturb the connection's type map that AR relies on).
+          # Read values as strings (so we never disturb the connection's type map
+          # that AR relies on), and capture each column's result OID + modifier so
+          # the Source can resolve the real type via the adapter's get_oid_type —
+          # including computed/aliased columns the model has no column type for.
+          # ftype/fmod are result metadata, unaffected by the all-strings map.
           result.type_map = PG::TypeMapAllStrings.new
-          results << [result.fields, result.values]
+          oids = Array.new(result.nfields) { |i| [result.ftype(i), result.fmod(i)] }
+          results << [result.fields, result.values, oids]
         elsif status != PG::PGRES_COMMAND_OK && capture_error
           begin
             result.check

data/lib/pipeloader/source.rb

@@ -3,8 +3,12 @@ module Pipeloader
   # and runs them as one pipelined burst, returning an ActiveRecord::Result per
   # query (so AR builds models normally).
   class Source < GraphQL::Dataloader::Source
-    def initialize(pg)
-      @pg = pg
+    # conn: the AR connection threaded in from the call site (the QueryCache
+    # patch's own connection, or the model's in FusionSource). @pg drives the
+    # pipeline; @conn supplies the OID -> type lookup for building typed results.
+    def initialize(conn)
+      @conn = conn
+      @pg = conn.raw_connection
     end
 
     # keys: array of [sql, params], deduplicated by Dataloader. Must return one
@@ -13,7 +17,27 @@ module Pipeloader
       batch = Pipeliner.pipeline_batch(@pg, keys)
       Pipeloader.round_trips += 1
       Pipeloader.queries += keys.size
-      batch.map { |columns, rows| ActiveRecord::Result.new(columns, rows) }
+      batch.map { |columns, rows, oids| to_ar_result(columns, rows, oids) }
+    end
+
+    private
+
+    # Build a typed ActiveRecord::Result from the raw-string rows. The model casts
+    # its own table columns, but a computed/aliased column (`COUNT(*) AS n`,
+    # `view_count > 1 AS hot`) has no model type, so without help it would stay the
+    # raw Postgres string — and "f" is truthy in Ruby. Resolve each column's type
+    # from its result OID via the adapter's own get_oid_type (exactly what AR does
+    # for a normal query), keyed by both name and index so AR's Result finds it on
+    # every supported version (7.x looks up column_types by name, 8.x by index).
+    def to_ar_result(columns, rows, oids)
+      column_types = {}
+      columns.each_with_index do |name, i|
+        oid, fmod = oids[i]
+        type = @conn.send(:get_oid_type, oid, fmod, name)
+        column_types[name] = type
+        column_types[i] = type
+      end
+      ActiveRecord::Result.new(columns, rows, column_types)
     end
   end
 end

data/lib/pipeloader/version.rb

@@ -1,3 +1,3 @@
 module Pipeloader
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pipeloader
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Joshua Hull