pipeloader 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e89c97e574dfe8954ae5d612925c75391c10b131291e061f2bbfd92446fa8088
+  data.tar.gz: 8982f0272ae0dc1fe47b7cea62b6b01a462b47ee7447c5173f16720cd424f164
+SHA512:
+  metadata.gz: 59182c22fc62605148fa69ee580858fb670c2199628e8068ac9957fd826979634a9687179d43330013987fb18f6f33c6dad4fe0246850b47d07bfecfeed17d32
+  data.tar.gz: e9d19c2e8de08e14041c9459250c0839af2925895f20ca012e3c3abad39d9bec36ecc6bb91e9470b43c800f111f04a759bb481258d8aeb1bfd10bf52e59d781d

data/README.md

@@ -0,0 +1,224 @@
+# pipeloader
+
+Transparent libpq pipelining for **graphql-ruby on ActiveRecord**. During GraphQL
+response building, every ActiveRecord `SELECT` is routed through a libpq pipeline,
+so a nested query resolves in roughly **one round trip per tree level** — with
+**plain resolvers and plain models**. No Futures, no `dataloader.load`, no field
+changes.
+
+## Adopting it
+
+One line:
+
+```ruby
+class AppSchema < GraphQL::Schema
+  use Pipeloader
+end
+```
+
+That's the whole adoption surface. Your types and resolvers stay exactly as they
+are — ordinary ActiveRecord:
+
+```ruby
+class Types::Post < GraphQL::Schema::Object
+  field :title, String, null: false
+  field :author, Types::Author, null: false       # resolves via post.author
+  field :comments, [Types::Comment], null: false   # resolves via post.comments
+end
+```
+
+`post.author`, `post.comments`, a `has_many`, a `.where(...)` in a hand-written
+resolver — any AR SELECT issued while building the response is intercepted and
+pipelined. Because it hooks AR's query path (not the GraphQL field), nothing
+leaks back to synchronous N+1, even from custom resolver code.
+
+## What it does
+
+`example/run.rb` — plain resolvers, against a seeded database:
+
+```
+{ posts(limit: 50) { title author { name } comments { body commenter { name } } } }
+
+resolved 50 posts with PLAIN AR resolvers
+pipeline round-trips: 3
+queries pipelined:    403
+naive N+1 would be:   ~594 round trips
+```
+
+Three round trips: `posts` → (`authors` + `comments`) → `commenters`. The to-one
+`author` and the to-many `comments` are *different shapes at the same level*, yet
+collapse into a single round trip.
+
+## Benchmark
+
+The same 3-level query (`posts → author + comments → commenter`, 25 posts),
+resolved four ways, with **real** network latency added by a local TCP proxy in
+front of Postgres (`example/latency_proxy.rb` delays the request direction, so a
+synchronous query pays RTT once and a pipelined burst pays it once). Min of 3
+iterations; your numbers will vary.
+
+| approach | RTT 0 | RTT 1 ms | RTT 5 ms | round-trips |
+|---|--:|--:|--:|--:|
+| naive (N+1) | 94 ms | 505 ms | **1972 ms** | 290 |
+| AR `includes` (hand-written) | 17 ms | 22 ms | 42 ms | 4 |
+| `GraphQL::Dataloader` | 16 ms | 21 ms | 42 ms | 4 |
+| **pipeloader** | 41 ms | 45 ms | **73 ms** | **3** |
+
+Reading it honestly:
+
+- **vs the N+1 you actually have** — the headline. pipeloader turns 290 round
+  trips into 3 with zero resolver code, so at a 5 ms hop it's **~24× faster** than
+  naive. Most "there's an N+1 in here somewhere" code is the naive row.
+- **vs batching (`includes` / `GraphQL::Dataloader`)** — at low/moderate RTT,
+  batching still wins: its 4 `IN` queries do less work than pipeloader's ~400
+  prepared point queries. pipeloader prepares + caches statements per connection
+  (so parse cost is amortized to ~one parse per query shape), but it still runs
+  400 bind+executes and builds 400 results. **Pipelining cuts round trips;
+  batching cuts server work.** pipeloader does fewer round trips (3 vs 4 — it
+  collapses the to-one `author` and to-many `comments` into one burst, where
+  Dataloader runs them as two sequential sources), so it closes the gap as RTT
+  rises and passes the batchers around ~25 ms RTT (cross-region). Same
+  point-vs-batch tradeoff the Go experiments in this repo show.
+- **What pipeloader actually buys you: zero code, for any query shape.**
+  `GraphQL::Dataloader` needs a source plus a `.load` call per association;
+  `includes` must be hand-written per query and kept in sync with the selection.
+  pipeloader is `use Pipeloader` and ordinary resolvers.
+
+Run it: `ruby example/bench.rb` (needs the seeded `graphql_experiment` DB).
+
+### Scaling with tree shape
+
+That benchmark is a *narrow* tree (3 deep, 2 relations at its widest), which is
+close to the worst case for pipeloader. The gap widens with **width**, because:
+
+- **pipeloader round trips = tree depth** — one burst per level, any width.
+- **batching round trips = Σ (distinct target tables per level)** — each is its
+  own `IN` query (a Dataloader source, or an `includes` preload).
+
+A *wide* query — issues fanning out to assignee, creator, project, parent, and
+comments, those nesting to team, lead, and authors (`example/bench_wide.rb`):
+
+| approach | RTT 0 | RTT 1 ms | RTT 5 ms | round-trips |
+|---|--:|--:|--:|--:|
+| naive (N+1) | 63 ms | 278 ms | 1115 ms | 164 |
+| AR `includes` | 13 ms | 29 ms | 91 ms | 11 |
+| `GraphQL::Dataloader` | 9 ms | 20 ms | 57 ms | 7 |
+| **pipeloader** | 28 ms | 34 ms | **51 ms** | **3** |
+
+pipeloader's round trips stay at **3** (the depth) while batching climbs to 7–11,
+so at a 5 ms hop **pipeloader is the fastest of all** — the point-vs-batch
+crossover dropped from ~25 ms (narrow) to under 5 ms (wide). The wider and deeper
+the tree, the lower the RTT at which pipelining wins, because pipelining is the
+only one of the three whose round trips don't grow with the query.
+
+## How it works
+
+1. **`use GraphQL::Dataloader`** — runs resolution in fibers. This is what lets a
+   synchronous-looking `post.author` *yield* instead of blocking, so sibling
+   queries can gather before anything hits the wire.
+2. **A monkey-patch on `select_all`** — while a response is being built, AR's
+   SELECT path hands the query to a Dataloader source instead of executing it.
+   The active dataloader is **stashed on the connection** for the duration of the
+   multiplex (and cleared at the end), so the patch finds it as `self`.
+3. **The source pipelines** — when the fibers all park, it prepares each distinct
+   SQL once (cached per connection), then sends every gathered query as one libpq
+   burst (`enter_pipeline_mode` … `pipeline_sync`), reads the results, and returns
+   an `ActiveRecord::Result` per query so AR builds models normally.
+
+## Field-exact projection (opt-in)
+
+By default AR picks the columns (`SELECT *`), which keeps adoption zero-effort. If
+you want the pipeline to fetch **only the columns the query selected**, opt in and
+pipeloader narrows each SELECT using graphql-ruby's `lookahead`:
+
+```ruby
+Pipeloader.field_exact = true            # globally, before your types load, or…
+
+class Types::Post < GraphQL::Schema::Object
+  pipeloader_field_exact!                # …per type
+  field :title, String, null: false
+  field :author, Types::Author, null: false
+end
+```
+
+For `{ posts { title author { name } } }` the posts SELECT becomes
+`SELECT id, title, author_id FROM …` (PK + selected column + the FK needed to
+resolve `author`), and the authors SELECT becomes `SELECT id, name FROM …` — for
+both the root relation and the `belongs_to`.
+
+**It never breaks a field.** A classifier narrows only when it can *prove* every
+selected field reads a known column or association. The instant a selection is
+opaque — a computed field, a custom resolver, anything it can't map to a column —
+it **bails to a whole-row fetch** for that record, so a projected field can never
+raise `MissingAttributeError`.
+
+**The `selects:` escape hatch.** A computed field can declare the columns it
+reads, so projection keeps them instead of bailing to a whole row:
+
+```ruby
+field :excerpt, String, null: false, selects: %i[body]
+def excerpt = object.body[0, 200]
+```
+
+Selecting `excerpt` now adds `body` to the projection. With no opt-in (the
+default), `selects:` is accepted and ignored, and every SELECT is whole-row.
+
+## Status & caveats — this is a proof of concept
+
+- **Whole rows by default; field-exact is [opt-in](#field-exact-projection-opt-in).**
+  Off, AR picks the columns (maximum transparency); on, the pipeline projects to
+  the selected columns and bails to whole rows on anything opaque.
+- **PostgreSQL pipelines; SQLite narrows only; anything else raises.** Pipelining
+  is libpq-specific, so on PostgreSQL queries are pipelined, on SQLite they run
+  un-pipelined (the opt-in column projection still applies, useful for tests/dev),
+  and any other adapter raises a `RuntimeError` at query time rather than silently
+  misbehaving. Running SQLite un-pipelined is safe because SQLite is *embedded* —
+  its queries are in-process calls with no network round trip, so there's nothing
+  for a dataloader or a pipeline to collapse. N+1 there is just a series of cheap
+  local calls, not the latency amplification that makes N+1 catastrophic against a
+  networked database. So pipelining buys nothing on SQLite, and skipping it costs
+  nothing.
+- **Reads only.** It intercepts `select_all` (SELECTs); writes and non-SELECTs
+  fall straight through, and queries inside an open transaction are skipped.
+- **Assumes thread-isolated connections** (the ActiveRecord default): a request's
+  resolver fibers all share one connection. Under `:fiber` isolation you'd stash
+  per leased connection.
+- **Stats are process-global** single-threaded demo instrumentation.
+- Prepares and caches statements per connection, but doesn't re-prepare after a
+  reconnect / `DEALLOCATE` the way AR does. Also not hardened for multiple
+  databases, `count`/`exists?` (which route through other methods), or error
+  recovery mid-pipeline.
+
+## Running the example
+
+```bash
+# Needs a Postgres DB with posts/authors/comments/users tables. In this repo:
+#   go run ./cmd/gqlbench -reset    # seeds the graphql_experiment DB
+ruby example/run.rb        # shows the round-trip collapse
+ruby example/bench.rb      # the latency benchmark (narrow tree)
+ruby example/bench_wide.rb # the wide-tree benchmark
+```
+
+Requires `activerecord`, `graphql`, and `pg` (libpq ≥ 14 for pipelining).
+
+## Tests
+
+`rake test`. Three suites, all **parity-first** — the pipelined result must be
+byte-identical to plain ActiveRecord:
+
+- **`test/pipeloader_test.rb`** — every query runs through both a plain schema and
+  a `use Pipeloader` schema, asserting identical results across each relationship
+  kind, nullable foreign keys, empty has-many, deduplication, ordering, type
+  casting, aliases, variables, and multiplex. It also checks round-trip counts
+  (= tree depth) and that the patch leaves writes, transactions, and non-GraphQL
+  ActiveRecord untouched.
+- **`test/field_exact_test.rb`** — the opt-in projection: projected results match
+  the whole-row schema, the emitted SQL is actually narrowed (and keeps the FK),
+  the `selects:` escape hatch includes its columns, and opaque fields bail to a
+  whole-row `SELECT *` instead of raising.
+- **`test/adapter_test.rb`** — adapter handling: PostgreSQL pipelines, an
+  unsupported adapter raises, and a real in-memory **SQLite** run (in a subprocess)
+  proves projection works there with pipelining disabled.
+
+Needs a reachable Postgres (the suites create `pl_*` fixture tables in
+`graphql_experiment`).

data/lib/pipeloader/ar_patch.rb

@@ -0,0 +1,49 @@
+module Pipeloader
+  # Monkey-patch: while a Pipeloader dataloader is active (i.e. during GraphQL
+  # response building), route SELECTs through the pipelining Source instead of
+  # executing them synchronously. Everything else falls through to AR untouched.
+  module ARPatch
+    def self.install!
+      return if @installed
+
+      # select_all lives on QueryCache (ahead of AbstractAdapter in the chain),
+      # so prepend there to intercept before AR's own query cache.
+      ActiveRecord::ConnectionAdapters::QueryCache.prepend(Methods)
+      @installed = true
+    end
+
+    module Methods
+      # The active dataloader is stashed on the connection for the duration of the
+      # response phase (set/cleared by Pipeloader::Trace). The connection is the
+      # pipelining unit and is shared across the request's resolver fibers, so
+      # this is both the natural home and reliably visible here as `self`.
+      attr_accessor :pipeloader_dataloader
+
+      def select_all(arel, name = nil, binds = [], preparable: nil, async: false, allow_retry: false)
+        dl = pipeloader_dataloader
+        if dl.is_a?(GraphQL::Dataloader) && !in_transaction?
+          relation = arel_from_relation(arel)
+          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])
+          end
+        end
+        # Synchronous fallback (no active response, or not gathered): one query,
+        # one round trip.
+        result = super
+        Pipeloader.round_trips += 1
+        Pipeloader.queries += 1
+        result
+      end
+
+      private
+
+      def in_transaction?
+        current_transaction.open?
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

data/lib/pipeloader/field_exact.rb

@@ -0,0 +1,99 @@
+module Pipeloader
+  # Opt-in, off by default. Set true before your schema's types are defined to
+  # turn on projection everywhere; or opt in per type with `pipeloader_field_exact!`.
+  class << self
+    attr_accessor :field_exact
+  end
+  self.field_exact = false
+
+  # Per-type opt-in, mixed into every GraphQL::Schema::Object.
+  module TypeOptIn
+    def pipeloader_field_exact!(value = true)
+      @pipeloader_field_exact = value
+    end
+
+    def pipeloader_field_exact?
+      return @pipeloader_field_exact if defined?(@pipeloader_field_exact)
+
+      superclass.respond_to?(:pipeloader_field_exact?) && superclass.pipeloader_field_exact?
+    end
+  end
+
+  # Monkey-patches `field` to (a) accept the `selects:` escape hatch and (b)
+  # attach the projection extension when this field's type has opted in.
+  module FieldSelects
+    attr_reader :pipeloader_selects
+
+    def initialize(*args, selects: nil, owner: nil, extensions: [], **kwargs, &block)
+      @pipeloader_selects = selects && Array(selects).map(&:to_s)
+      if Pipeloader.field_exact || (owner.respond_to?(:pipeloader_field_exact?) && owner.pipeloader_field_exact?)
+        extensions = extensions + [ProjectionExtension]
+      end
+      super(*args, owner: owner, extensions: extensions, **kwargs, &block)
+    end
+  end
+
+  # Narrows a returned ActiveRecord::Relation to exactly the columns the query
+  # needs — and bails to a whole-row fetch the moment a selected field can't be
+  # proven to read only known columns, so it can never raise MissingAttributeError.
+  class ProjectionExtension < GraphQL::Schema::FieldExtension
+    extras [:lookahead]
+
+    def resolve(object:, arguments:, context:, **)
+      lookahead = arguments[:lookahead]
+      inner = arguments.key?(:lookahead) ? arguments.reject { |k, _| k == :lookahead } : arguments
+
+      # A belongs_to is loaded whole-row by `object.assoc`, so resolve it via a
+      # projected query instead (still pipelined). Skipped if the type defines a
+      # custom resolver, or the selection is opaque (then fall through to default).
+      record = object.respond_to?(:object) ? object.object : object
+      if lookahead && record.is_a?(ActiveRecord::Base) &&
+         !field.owner.instance_methods(false).include?(field.resolver_method) &&
+         (assoc = record.class.reflect_on_association(field.method_str.to_sym))&.belongs_to?
+        fk = record.public_send(assoc.foreign_key)
+        return nil if fk.nil?
+
+        cols = Pipeloader.project_columns(assoc.klass, lookahead)
+        return assoc.klass.where(assoc.klass.primary_key => fk).select(*cols).first if cols
+      end
+
+      value = yield(object, inner)
+      return value unless lookahead && value.is_a?(ActiveRecord::Relation)
+
+      cols = Pipeloader.project_columns(value.klass, lookahead)
+      return value unless cols # opaque field selected -> fetch whole rows
+
+      # Keep a has_many's foreign key so AR can still group / wire the inverse.
+      if value.respond_to?(:proxy_association) && (proxy = value.proxy_association)
+        cols += Array(proxy.reflection.foreign_key)
+      end
+      value.select(*cols.uniq)
+    end
+  end
+
+  # Returns the exact column list for a model + selection, or nil meaning
+  # "can't prove it's safe — fetch whole rows."
+  def self.project_columns(model, lookahead)
+    columns = model.column_names
+    needed = [model.primary_key]
+    lookahead.selections.each do |sel|
+      field = sel.field
+      if field.respond_to?(:pipeloader_selects) && field.pipeloader_selects
+        needed.concat(field.pipeloader_selects)                 # explicit escape hatch
+      elsif field.owner.instance_methods(false).include?(field.resolver_method)
+        return nil                                              # custom resolver: opaque
+      elsif columns.include?(field.method_str)
+        needed << field.method_str                              # plain column
+      elsif (assoc = model.reflect_on_association(field.method_str.to_sym))
+        needed << assoc.foreign_key if assoc.belongs_to?        # FK for a belongs_to
+        # has_many keys off the model's PK, already included
+      else
+        return nil                                              # unknown accessor: opaque
+      end
+    end
+    needed.compact.uniq.map(&:to_s)
+  end
+end
+
+GraphQL::Schema::Field.prepend(Pipeloader::FieldSelects)
+GraphQL::Schema::Object.extend(Pipeloader::TypeOptIn)

data/lib/pipeloader/pipeliner.rb

@@ -0,0 +1,49 @@
+require "pg"
+
+module Pipeloader
+  # Runs a batch of SELECTs as one libpq pipelined burst on a PG::Connection.
+  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.
+    def pipeline_batch(pg, queries)
+      prepared = pg.instance_variable_get(:@pipeloader_prepared)
+      unless prepared
+        prepared = {}
+        pg.instance_variable_set(:@pipeloader_prepared, prepared)
+      end
+
+      # Prepare any unseen SQL before entering pipeline mode (Parse can't be
+      # issued synchronously mid-pipeline). GraphQL has a bounded set of query
+      # shapes, so this amortizes to ~one parse per shape for the connection's
+      # life; thereafter every execution reuses the named statement.
+      queries.each do |sql, _params|
+        prepared[sql] ||= begin
+          name = "pipeloader_#{prepared.size}"
+          pg.prepare(name, sql)
+          name
+        end
+      end
+
+      pg.enter_pipeline_mode
+      queries.each { |sql, params| pg.send_query_prepared(prepared[sql], params) }
+      pg.pipeline_sync
+
+      results = []
+      loop do
+        result = pg.get_result
+        break if result.nil?
+        break if result.result_status == PG::PGRES_PIPELINE_SYNC
+
+        # Raw strings, so ActiveRecord casts via its own column types (and so we
+        # never disturb the connection's type map that AR relies on).
+        result.type_map = PG::TypeMapAllStrings.new
+        results << [result.fields, result.values]
+        pg.get_result # per-query nil delimiter
+      end
+      pg.exit_pipeline_mode
+      results
+    end
+  end
+end

data/lib/pipeloader/source.rb

@@ -0,0 +1,19 @@
+module Pipeloader
+  # A GraphQL::Dataloader source that gathers every SELECT parked at a fiber tick
+  # 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
+    end
+
+    # keys: array of [sql, params], deduplicated by Dataloader. Must return one
+    # result per key, in order.
+    def fetch(keys)
+      batch = Pipeliner.pipeline_batch(@pg, keys)
+      Pipeloader.round_trips += 1
+      Pipeloader.queries += keys.size
+      batch.map { |columns, rows| ActiveRecord::Result.new(columns, rows) }
+    end
+  end
+end

data/lib/pipeloader/version.rb

@@ -0,0 +1,3 @@
+module Pipeloader
+  VERSION = "0.0.1"
+end

data/lib/pipeloader.rb

@@ -0,0 +1,72 @@
+require "pg"
+require "graphql"
+require "active_record"
+
+require_relative "pipeloader/version"
+require_relative "pipeloader/pipeliner"
+require_relative "pipeloader/source"
+require_relative "pipeloader/ar_patch"
+require_relative "pipeloader/field_exact"
+
+# Pipeloader makes a graphql-ruby query resolve its ActiveRecord SELECTs through
+# a libpq pipeline: one round trip per tree level, transparently. Resolvers stay
+# plain AR — no Futures, no dataloader.load, no field changes — because AR's own
+# query path is intercepted during response building.
+#
+#   class AppSchema < GraphQL::Schema
+#     use Pipeloader     # adds GraphQL::Dataloader (fibers) + the AR patch
+#   end
+module Pipeloader
+  class << self
+    # Per-query stats (single-threaded; reset at the start of each query).
+    attr_accessor :round_trips, :queries
+  end
+  self.round_trips = 0
+  self.queries = 0
+
+  def self.reset_stats!
+    self.round_trips = 0
+    self.queries = 0
+  end
+
+  def self.use(schema)
+    schema.use(GraphQL::Dataloader) # run resolution in fibers so SELECTs can gather
+    ARPatch.install!
+    schema.trace_with(Trace)
+  end
+
+  # Pipelining is libpq-specific. PostgreSQL pipelines; SQLite can't, but the
+  # opt-in column projection is plain ActiveRecord and still applies, so SQLite
+  # is allowed with pipelining disabled. Any other adapter is unsupported.
+  #
+  # Running SQLite un-pipelined is safe because SQLite is embedded: its queries
+  # are in-process calls with no network round trip, so there's nothing for a
+  # dataloader or pipeline to collapse. N+1 there is just cheap local calls, not
+  # the latency amplification pipelining exists to remove.
+  def self.pipelining_supported?(conn)
+    case conn.adapter_name
+    when "PostgreSQL" then true
+    when "SQLite"     then false
+    else
+      raise "Pipeloader supports PostgreSQL (pipelined) and SQLite " \
+            "(field narrowing only); #{conn.adapter_name} is not supported."
+    end
+  end
+
+  # Stash the active dataloader on the connection for the whole response phase,
+  # and clear it at the end. This is done at *multiplex* scope, not per-query,
+  # because under Dataloader resolution is deferred to the multiplex's fiber run
+  # loop — a per-query hook would clear the stash before resolvers ever run.
+  module Trace
+    def execute_multiplex(multiplex:)
+      Pipeloader.reset_stats!
+      conn = ActiveRecord::Base.connection
+      # Raises on an unsupported adapter; on SQLite, leaves the stash unset so
+      # select_all never pipelines (column projection still applies).
+      conn.pipeloader_dataloader = multiplex.dataloader if Pipeloader.pipelining_supported?(conn)
+      super
+    ensure
+      conn.pipeloader_dataloader = nil if conn
+    end
+  end
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: pipeloader
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Joshua Hull
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: graphql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13'
+description: During GraphQL response building, Pipeloader routes ActiveRecord SELECTs
+  through a libpq pipeline so a query tree resolves in roughly one round trip per
+  level — with plain resolvers and plain models, no Futures, no dataloader.load, no
+  resolver changes.
+email:
+- josh@fireflop.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/pipeloader.rb
+- lib/pipeloader/ar_patch.rb
+- lib/pipeloader/field_exact.rb
+- lib/pipeloader/pipeliner.rb
+- lib/pipeloader/source.rb
+- lib/pipeloader/version.rb
+homepage: https://github.com/joshbuddy/pipeloader
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Transparent libpq pipelining for graphql-ruby on ActiveRecord
+test_files: []