pg_exec_array_params 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 487eaa0af43d806c4d5ead7fe7ba640a23f0f382611773ed79565c583740fb5c
-  data.tar.gz: e6b1b0c0347546658a9786642a19f77acd173d1413c9174165e4ec12f312e105
+  metadata.gz: 1fdcb04ffde2b46c124f9165cfb0a383e15583d01ae52c830211e51894c44a78
+  data.tar.gz: 410af6e18d74d9feab49848f1796831ac79aefadfccd40614b40743abbacf727
 SHA512:
-  metadata.gz: c7f70ef196f4353edf9195224598e83b82be4e5811ae2610b631bf416ccdceac89cdedf133aa96ad1c706e1e6994dbf074d171584fec9bbff91e61775b3c613a
-  data.tar.gz: 4410043f791594bc5367ffc7c94d75ab56bfd5cfeaf84076b2745ae27854d56645aec7d6eea5a7bf1984f6c16d373b1da1ec5e25c13cf360d33ffd9c4bbe26f2
+  metadata.gz: d7f4877366134724817ff915786446d622657d40c820d2b3f1fb31dd3237862366b840c6c0ab483760ad91918b4c238d41db0c89db3301ac981381b032849867
+  data.tar.gz: ccf1a880c9442b5447cd43a43b262e507503b126d0854e21539ec79927a5fb17c5257f6f5d2995d9ac5cde74e3119c45fc8a9dfd1890d6825c7d368bffb02b97

data/.rubocop.yml

@@ -1,3 +1,9 @@
+AllCops:
+  NewCops: enable
+
+Metrics/ClassLength:
+  Max: 150
+
 Metrics/AbcSize:
   Max: 30
 

data/Gemfile

@@ -5,11 +5,15 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in pg_exec_array_params.gemspec
 gemspec
 
+gem 'rails'
+
 gem 'codecov', require: false
+gem 'pry-byebug', '~> 3.9'
+gem 'rake', '~> 12.0'
+gem 'rspec-github', '~> 2.3'
+gem 'rspec-its', '~> 1.3'
 gem 'rubocop', '~> 1.0'
 gem 'rubocop-rspec', '~> 2.0.0.pre'
-gem 'rspec-github', '~> 2.3'
-gem 'pry-byebug', '~> 3.9'
 gem 'simplecov', '~> 0.19'
 
 group :benchmark do

data/README.md

@@ -1,21 +1,38 @@
 # PgExecArrayParams
 
 ![](https://github.com/lunatic-cat/pg_exec_array_params/workflows/ci/badge.svg)
+[![Gem Version](https://badge.fury.io/rb/pg_exec_array_params.svg)](https://badge.fury.io/rb/pg_exec_array_params)
+[![codecov](https://codecov.io/gh/lunatic-cat/pg_exec_array_params/branch/master/graph/badge.svg?token=X5K67X3V0Z)](undefined)
 
 Use same parametized query and put `Array<T>` instead of any `T`
 
 ## Example
 
-```ruby
-query = 'select * from t1 where a1 = $1 and a2 = $2 and a3 = $3 and a4 = $4'
-params = [1, [2, 3], 'foo', ['bar', 'baz']]
+### Inside `WHERE` part
 
-# PG::Connection.exec_params called with:
-# 'SELECT * FROM "t1" WHERE "a1" = $1 AND "a2" IN ($2, $3) AND "a3" = $4 AND "a4" IN ($5, $6)'
-# [1, 2, 3, "foo", "bar", "baz"]
+```ruby
+# Instead of:
+# PG::Connection.exec_params(
+#   'SELECT * FROM "t1" WHERE "a1" = $1 AND "a3" IN ($4, $5, $6) AND "a2" IN ($2, $3)',
+#   [1, 2, 3, "foo", "bar", "baz"]
+# )
+query = 'select * from t1 where a1 = $1 and a3 = $3 and a2 = $2'
+params = [1, [2, 3], ['foo', 'bar', 'baz']]
 PgExecArrayParams.exec_array_params(conn, query, params)
 ```
 
+### Inside `SELECT` part
+
+```ruby
+# Instead of:
+# PG::Connection.exec_params(
+#   'SELECT ARRAY[$1, $2]'
+#   [1, 2]
+# )
+PgExecArrayParams.exec_array_params(conn, 'select $1', [[1, 2]])
+=> [{"array"=>"{1,2}"}]
+```
+
 ## Problem
 
 ```ruby
@@ -40,6 +57,16 @@ PgExecArrayParams.exec_array_params(conn, 'select * from users where id = $1', [
 => [{"id" => 1}, {"id" => 2}]
 ```
 
+## Batteries
+
+This can also provide more info than plain `pg_query` gem:
+
+```ruby
+sql = 'with y as (select * from s) select x1, y.y1, z.z as z1 from x join z on z.z = x join y on y.y = x'
+PgExecArrayParams::Query.new(sql, []).columns.map(&:name)
+=> ['x1', 'y1', 'z1']
+```
+
 ## Integration with 'pg' gem
 
 ```ruby

data/lib/pg_exec_array_params.rb

@@ -1,10 +1,27 @@
 # frozen_string_literal: true
 
+require 'pg_exec_array_params/error'
+require 'pg_exec_array_params/rewriters'
+require 'pg_exec_array_params/rewriters/node'
+require 'pg_exec_array_params/rewriters/res_target'
+require 'pg_exec_array_params/rewriters/a_expr'
+require 'pg_exec_array_params/sql_ref_index'
+require 'pg_exec_array_params/column'
 require 'pg_exec_array_params/query'
 require 'pg_exec_array_params/version'
 
 module PgExecArrayParams
-  class Error < StandardError; end
+  PARAM_REF = 'ParamRef'
+  REXPR = 'rexpr'
+  NUMBER = 'number'
+  LOCATION = 'location'
+
+  # AExpr['kind']
+  EQ_KIND = 0
+  IN_KIND = 7
+
+  class Optional; end
+
   module_function
 
   def exec_array_params(conn, sql, params, *args)

data/lib/pg_exec_array_params/column.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module PgExecArrayParams
+  class Column
+    attr_reader :table, :column_name, :as_name
+
+    def initialize(table:, column_name:, as_name:)
+      @table = table
+      @column_name = column_name
+      @as_name = as_name
+    end
+
+    def name
+      @as_name || @column_name
+    end
+
+    def self.from_res_target(res_target)
+      return unless (column_ref = res_target.fetch('val', {})['ColumnRef'])
+
+      idents = column_ref['fields'].map { |field| field.fetch('String', {})['str'] }
+      if idents.size <= 1
+        column_name = idents.first
+      else
+        table, column_name, = idents
+      end
+
+      return unless column_name
+
+      new(table: table, column_name: column_name, as_name: res_target['name'])
+    end
+  end
+end

data/lib/pg_exec_array_params/error.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module PgExecArrayParams
+  class Error < StandardError
+    attr_accessor :query, :node
+
+    def initialize(message, query = nil, node = nil)
+      super(message)
+      @msg = message
+      @query = query
+      @node = node
+    end
+
+    def to_s
+      "#{@msg}\n#{@query}\n#{@node}"
+    end
+  end
+end

data/lib/pg_exec_array_params/query.rb

@@ -4,16 +4,6 @@ require 'pg_query'
 
 module PgExecArrayParams
   class Query
-    PARAM_REF = 'ParamRef'
-    REXPR = 'rexpr'
-    A_EXPR = 'A_Expr'
-    KIND = 'kind'
-    LOCATION = 'location'
-    NUMBER = 'number'
-
-    EQ_KIND = 0
-    IN_KIND = 7
-
     attr_reader :query, :args
 
     def initialize(query, args = [])
@@ -26,109 +16,54 @@ module PgExecArrayParams
     end
 
     def sql
-      return query unless should_rebuild?
-
-      @sql || (rebuild_query! && @sql)
+      should_rebuild? ? (@sql || (rebuild_query! && @sql)) : query
     end
 
     def binds
-      return args unless should_rebuild?
+      should_rebuild? ? (@binds ||= args.flatten(1)) : args
+    end
 
-      @binds || (rebuild_query! && @binds)
+    def columns
+      @columns || (rebuild_query! && @columns)
     end
 
     private
 
     def should_rebuild?
-      args.any? { |param| param.is_a?(Array) }
-    end
-
-    def rebuild_query!
-      @param_idx = 0
-      @ref_idx = 1
-      @binds = []
-      each_param_ref do |value|
-        # puts({value_before: value}.inspect)
-
-        if args[@param_idx].is_a? Array
-          value[KIND] = IN_KIND
-          value[REXPR] = []
-          args[@param_idx].each do |param|
-            raise Error, "Param: #{param.inspect} not primitive" if param.respond_to?(:each)
-
-            value[REXPR] << { PARAM_REF => { NUMBER => @ref_idx } }
-            @binds << param
-            @ref_idx += 1
-          end
-        else
-          value[REXPR][PARAM_REF][NUMBER] = @ref_idx
-          @ref_idx += 1
-
-          # nested_refs == 1 unwraps, wrap it back
-          value[REXPR] = [value[REXPR]] if value[KIND] == IN_KIND
-
-          @binds << args[@param_idx]
-        end
-
-        @param_idx += 1
-        # puts({value_after_: value}.inspect)
+      args.any? do |param|
+        param.is_a?(Array) && (param.none? do |item|
+          item.respond_to?(:each) && raise(Error, "Param includes not primitive: #{item.inspect}")
+        end)
       end
-      @sql = tree.deparse
-      # puts({sql: @sql, binds: @binds}.inspect)
-      true
     end
 
     def tree
       @tree ||= PgQuery.parse(query)
     end
 
-    def each_param_ref
+    def rebuild_query!
+      @columns ||= []
       tree.send :treewalker!, tree.tree do |_expr, key, value, _location|
-        if key == A_EXPR
-          if assign_param_via_eq?(value)
-            yield value
-          elsif (nested_refs = assign_param_via_in?(value))
-            if nested_refs == 1
-              value[REXPR] = value[REXPR].first
-              yield value
-            else
-              message = [
-                'Cannot splice multiple references, leave the only one:',
-                query,
-                refs_underline(value)
-              ].join("\n")
-              raise Error, message
-            end
-          end
+        case key
+        when 'targetList'
+          @columns += value.map do |node|
+            Column.from_res_target(node['ResTarget'])
+          end.compact
+        when 'ResTarget'
+          Rewriters::ResTarget.new(value, ref_idx).process
+        when 'A_Expr'
+          Rewriters::AExpr.new(value, ref_idx).process
         end
       end
+      @sql = tree.deparse
+      true
+    rescue Error => e
+      e.query = query
+      raise e
     end
 
-    def refs_underline(value)
-      from, size = refs_at(value)
-      "#{'^'.rjust(from, ' ')}#{'-'.rjust(size, '-')}^"
-    end
-
-    def refs_at(value)
-      first_ref = value[REXPR].find { |vexpr| vexpr.key?(PARAM_REF) } [PARAM_REF]
-      last_ref = value[REXPR].reverse.find { |vexpr| vexpr.key?(PARAM_REF) } [PARAM_REF]
-      started = first_ref[LOCATION] + 1
-      ended = last_ref[LOCATION] + last_ref[NUMBER].to_s.size
-      [started, ended - started]
-    end
-
-    # = $1
-    # {"kind"=>0, "name"=>[{"String"=>{"str"=>"="}}],
-    #  "lexpr"=>{"ColumnRef"=>{"fields"=>[{"String"=>{"str"=>"companies"}}, {"String"=>{"str"=>"id"}}],
-    #                          "location"=>1242}},
-    #  "rexpr"=>{"ParamRef"=>{"number"=>4, "location"=>1261}}, "location"=>1259}
-    def assign_param_via_eq?(value)
-      (value[KIND] == EQ_KIND) && value[REXPR].is_a?(Hash) && value[REXPR].key?(PARAM_REF)
-    end
-
-    # IN ($1), returns number of nested REFs
-    def assign_param_via_in?(value)
-      (value[KIND] == IN_KIND) && value[REXPR].is_a?(Array) && value[REXPR].count { |vexpr| vexpr.key?(PARAM_REF) }
+    def ref_idx
+      @ref_idx ||= SqlRefIndex.new(args)
     end
   end
 end

data/lib/pg_exec_array_params/rewriters.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module PgExecArrayParams
+  module Rewriters
+  end
+end

data/lib/pg_exec_array_params/rewriters/a_expr.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module PgExecArrayParams
+  module Rewriters
+    class AExpr < Node
+      KIND = 'kind'
+
+      private
+
+      def should_rewrite?
+        return true if assign_param_via_eq?
+
+        if (nested_refs = assign_param_via_in?)
+          if nested_refs == 1
+            value[REXPR] = value[REXPR].first
+            return true
+          else
+            suggest_n = value[REXPR].first[PARAM_REF][NUMBER]
+            raise Error.new("Leave only `= $#{suggest_n}` and pass an array", nil, self)
+          end
+        end
+        false
+      end
+
+      def rewrite!
+        # puts({value_before: value}.inspect)
+        old_ref_idx = value[REXPR][PARAM_REF][NUMBER] - 1 # one based
+        unless (new_ref_idx = ref_idx[old_ref_idx])
+          raise Error.new("No parameter for $#{old_ref_idx + 1}", nil, self)
+        end
+
+        if new_ref_idx.is_a?(Array)
+          value[KIND] = IN_KIND
+          value[REXPR] = Range.new(*new_ref_idx).map do |param_ref_idx|
+            { PARAM_REF => { NUMBER => param_ref_idx } }
+          end
+        else
+          value[REXPR][PARAM_REF][NUMBER] = new_ref_idx
+          # nested_refs == 1 unwraps, wrap it back
+          value[REXPR] = [value[REXPR]] if value[KIND] == IN_KIND
+        end
+        # puts({value_after_: value}.inspect)
+      end
+
+      # = $1
+      # {"kind"=>0, "name"=>[{"String"=>{"str"=>"="}}],
+      #  "lexpr"=>{"ColumnRef"=>{"fields"=>[{"String"=>{"str"=>"companies"}}, {"String"=>{"str"=>"id"}}],
+      #                          "location"=>1242}},
+      #  "rexpr"=>{"ParamRef"=>{"number"=>4, "location"=>1261}}, "location"=>1259}
+      def assign_param_via_eq?
+        (value[KIND] == EQ_KIND) && value[REXPR].is_a?(Hash) && value[REXPR].key?(PARAM_REF)
+      end
+
+      # IN ($1), returns number of nested REFs
+      def assign_param_via_in?
+        (value[KIND] == IN_KIND) && value[REXPR].is_a?(Array) && value[REXPR].count { |vexpr| vexpr.key?(PARAM_REF) }
+      end
+
+      def refs_at
+        first_ref = wrap_array(value[REXPR]).find { |vexpr| vexpr.key?(PARAM_REF) }&.fetch(PARAM_REF, {})
+        last_ref = wrap_array(value[REXPR]).reverse.find { |vexpr| vexpr.key?(PARAM_REF) }&.fetch(PARAM_REF, {})
+        return unless (start_ref_loc = first_ref[LOCATION])
+
+        return unless (end_ref_loc = last_ref[LOCATION])
+
+        started = start_ref_loc + 1
+        ended = end_ref_loc + last_ref.fetch(NUMBER, '').to_s.size
+        [started, ended - started]
+      end
+
+      def wrap_array(object)
+        if object.respond_to?(:to_ary)
+          object.to_ary || [object]
+        else
+          [object]
+        end
+      end
+    end
+  end
+end

data/lib/pg_exec_array_params/rewriters/node.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module PgExecArrayParams
+  module Rewriters
+    class Node
+      attr_reader :value, :ref_idx
+
+      def initialize(value, ref_idx)
+        @value = value
+        @ref_idx = ref_idx
+      end
+
+      def process
+        rewrite! if should_rewrite?
+      end
+
+      # used in exception rendering
+      def to_s
+        return '<unknown node position>' unless (from, size = refs_at)
+
+        "#{'^'.rjust(from, ' ')}#{'-'.rjust(size, '-')}^"
+      end
+
+      private
+
+      # returns start and end index of value string repr inside query
+      # [from, size]
+      def refs_at; end
+
+      def should_rewrite?; end
+
+      def rewrite!; end
+    end
+  end
+end

data/lib/pg_exec_array_params/rewriters/res_target.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module PgExecArrayParams
+  module Rewriters
+    class ResTarget < Node
+      VAL = 'val'
+
+      def should_rewrite?
+        plain_selection?
+      end
+
+      def rewrite!
+        # puts({value_before: value}.inspect)
+        old_ref_idx = value[VAL][PARAM_REF][NUMBER] - 1 # one based
+        unless (new_ref_idx = ref_idx[old_ref_idx])
+          raise Error.new("No parameter for $#{old_ref_idx + 1}", nil, self)
+        end
+
+        if new_ref_idx.is_a?(Array)
+          elements = Range.new(*new_ref_idx).map do |param_ref_idx|
+            { PARAM_REF => { NUMBER => param_ref_idx } }
+          end
+          value[VAL] = { 'A_ArrayExpr' => { 'elements' => elements } }
+        else
+          value[VAL][PARAM_REF][NUMBER] = new_ref_idx
+        end
+        # puts({value_after_: value, 'ref_idx' => ref_idx}.inspect)
+      end
+
+      # handle "select $1"
+      # {"val"=>{"ParamRef"=>{"number"=>1, "location"=>7}}, "location"=>7}
+      # AExpr handles "select $1 + 1"
+      def plain_selection?
+        value.key?(VAL) && value[VAL].is_a?(Hash) && value[VAL].key?(PARAM_REF)
+      end
+
+      def refs_at
+        [value[VAL][PARAM_REF][LOCATION] + 1, value[VAL][PARAM_REF][NUMBER].to_s.size]
+      end
+    end
+  end
+end

data/lib/pg_exec_array_params/sql_ref_index.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module PgExecArrayParams
+  # Calculates inclusive bounds of each element in a flattened list
+  # Bounds are one-based (as sql ref indexes), single value for non-arrays
+  # [1, [2, 3], 4, [5, 6, 7]] => [1, [2, 3], 4, [5, 7]]
+  class SqlRefIndex
+    attr_reader :array
+
+    def initialize(array)
+      @array = array
+      @extra_items = 0
+    end
+
+    def [](key)
+      sql_ref_index[key]
+    end
+
+    def sql_ref_index
+      @sql_ref_index ||= array.map.with_index(1) do |item, idx|
+        if item.is_a?(Array)
+          add_extra_items = item.size
+          add_extra_items -= 1 if add_extra_items.positive?
+          [idx + @extra_items, idx + (@extra_items += add_extra_items)]
+        else
+          idx + @extra_items
+        end
+      end
+    end
+  end
+end

data/lib/pg_exec_array_params/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PgExecArrayParams
-  VERSION = '0.1.0'
+  VERSION = '0.1.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_exec_array_params
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Vlad Bokov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-31 00:00:00.000000000 Z
+date: 2020-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg_query
@@ -69,8 +69,16 @@ files:
 - Rakefile
 - benchmark.rb
 - lib/pg_exec_array_params.rb
+- lib/pg_exec_array_params/column.rb
+- lib/pg_exec_array_params/error.rb
 - lib/pg_exec_array_params/query.rb
+- lib/pg_exec_array_params/rewriters.rb
+- lib/pg_exec_array_params/rewriters/a_expr.rb
+- lib/pg_exec_array_params/rewriters/node.rb
+- lib/pg_exec_array_params/rewriters/res_target.rb
+- lib/pg_exec_array_params/sql_ref_index.rb
 - lib/pg_exec_array_params/version.rb
+- pg_exec_array_params-0.1.0.gem
 - pg_exec_array_params.gemspec
 homepage: https://github.com/lunatic-cat/pg_exec_array_params
 licenses:
@@ -93,7 +101,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.0.8
 signing_key:
 specification_version: 4
 summary: PG::Connection#exec_params with arrays