predicate 2.6.0 → 2.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 4d0149b8d39635ed0f27c39362d1c4aec0dc5f2ccc1290580ed67edf18414e5b
-  data.tar.gz: a623594513754521196f1a98f5d2f682650a3ec1b02b02b4dfa703600039faa1
+SHA1:
+  metadata.gz: 9cef06edb829e0b79b74be5d6f69b329f1cc6656
+  data.tar.gz: 32535df41b6b08a634d818308c05424509683b58
 SHA512:
-  metadata.gz: dfc8fdb19e1d61171a4c91e893bfc6b6b91d559d8402f3a47dbede8d09dcb2f702f697cbd9e8b6db688e896d1831f837ace44d8c78b8c0e110d767ac0f99db05
-  data.tar.gz: 21ffbda2c7831051ac8ffba6a5c84d029735ce953e3fc969ae252945b0417ea28bc05f865e0e4e29771b542ca2993ec3720389a7be012b96b378536fb0743602
+  metadata.gz: 650836d9f3b0534271a38b2e58f59f4f93aad9fad9b60017777a0c1ab91e373ffe458d1a77bcc2309405c267b657c89121abb401f6687d19f8f79196d209dd06
+  data.tar.gz: 70a98a7269cda44050632396a4c90cfafddf16a8b06b1dc76fc1962cab7b4e8520e64244dc20cbf8e2369cbf21e7733f913d7b80cffa4dda0ec26b81decaaaae

data/README.md

@@ -274,7 +274,7 @@ given list.
 
 ```ruby
 p = Predicate.eq(x: 2, y: 4)  # x = 2 & y = 4
-p1, p2 = p.and_split([:x])    # p1 is x = 2 ; p2 is y = 4 
+p1, p2 = p.and_split([:x])    # p1 is x = 2 ; p2 is y = 4
 ```
 
 Observe that `and_split` is always possible but may degenerate to an
@@ -304,6 +304,38 @@ split = p.attr_split
 # }
 ```
 
+## Working with PostgreSQL
+
+(experimental) Predicate supports compiling certain high-level expressions
+to PostgreSQL native operators. It works in an direct or indirect way:
+
+```
+require 'predicate'
+require 'predicate/postgres'
+
+# In direct way, you simply create the predicates using PostgreSQL's own
+# operators
+p = Predicate.pg_array_overlaps(:x, ['foo', 'bar'])
+p.to_sequel
+
+# In indirect way, you use high-level predicates and convert them to
+# PostgreSQL later using `to_postgres`
+p = Predicate.interect(:x, ['foo', 'bar'])
+p = p.to_postgres
+p.to_sequel
+```
+
+Only a few array operators & translations exist, and only on `varchar[]`
+types. Additional support will be added later. The following
+translations are implemented (and methods on the right directly available
+on the `Predicate` class):
+
+```
+          -> pg_array_literal
+intersect -> pg_array_overlaps
+empty     -> pg_array_empty
+```
+
 ## Working with abstract variables
 
 WARNING: this `var` feature is only compatible with `Predicate#evaluate`

data/lib/predicate/factory.rb

@@ -201,7 +201,7 @@ class Predicate
       end
     end
 
-  protected
+  public
 
     def sexpr(expr)
       case expr
@@ -217,8 +217,12 @@ class Predicate
       end
     end
 
-    def _factor_predicate(arg)
-      sexpr(arg)
+    def _factor_predicate(arg, *mods)
+      expr = sexpr(arg)
+      mods.each do |mod|
+        expr.extend(mod)
+      end
+      expr
     end
 
     extend(self)

data/lib/predicate/grammar.sexp.yml

@@ -84,6 +84,8 @@ rules:
     - "::Predicate::Placeholder"
   opaque:
     - "::Object"
+  handler:
+    - "::Object"
   options:
     - "::Hash"
   name:

data/lib/predicate/postgres/ext/factory.rb

@@ -0,0 +1,28 @@
+class Predicate
+  module Factory
+    def pg_array_literal(value, type = :varchar)
+      _factor_predicate([
+        :pg_array_literal,
+        value,
+        type
+      ], Postgres::PgArray::Literal)
+    end
+
+    def pg_array_overlaps(left, right, type = :varchar)
+      _factor_predicate([
+        :pg_array_overlaps,
+        sexpr(left),
+        sexpr(right),
+        type
+      ], Postgres::PgArray::Overlaps)
+    end
+
+    def pg_array_empty(operand, type = :varchar)
+      _factor_predicate([
+        :pg_empty,
+        sexpr(operand),
+        type
+      ], Postgres::PgArray::Empty)
+    end
+  end
+end

data/lib/predicate/postgres/ext/to_sequel.rb

@@ -0,0 +1,26 @@
+class Predicate
+  module Postgres
+    module ToSequel
+      def on_pg_array_literal(sexpr)
+        PgArray.to_pg_array(sexpr[1], sexpr[2])
+      end
+
+      def on_pg_array_overlaps(sexpr)
+        type = sexpr.last
+        l = PgArray.to_pg_array(apply(sexpr.left), type)
+        r = PgArray.to_pg_array(apply(sexpr.right), type)
+        l.overlaps(r)
+      end
+
+      def on_pg_array_empty(sexpr)
+        left = PgArray.to_pg_array(apply(sexpr.operand))
+        right = PgArray.to_pg_array([], sexpr.last)
+        ::Sequel.expr(left => right)
+      end
+    end
+  end
+end
+
+class Predicate::ToSequel
+  include Predicate::Postgres::ToSequel
+end

data/lib/predicate/postgres/ext.rb

@@ -0,0 +1,2 @@
+require_relative 'ext/factory'
+require_relative 'ext/to_sequel'

data/lib/predicate/postgres/pg_array/empty.rb

@@ -0,0 +1,10 @@
+class Predicate
+  module Postgres
+    module PgArray
+      module Empty
+        include Predicate::UnaryFunc
+
+      end # module Empty
+    end # module PgArray
+  end # module Postgres
+end # class Predicate

data/lib/predicate/postgres/pg_array/literal.rb

@@ -0,0 +1,10 @@
+class Predicate
+  module Postgres
+    module PgArray
+      module Literal
+        include Predicate::Literal
+
+      end # module Literal
+    end # module PgArray
+  end # module Postgres
+end # class Predicate

data/lib/predicate/postgres/pg_array/overlaps.rb

@@ -0,0 +1,10 @@
+class Predicate
+  module Postgres
+    module PgArray
+      module Overlaps
+        include Predicate::BinaryFunc
+
+      end # module Overlaps
+    end # module PgArray
+  end # module Postgres
+end # class Predicate

data/lib/predicate/postgres/pg_array.rb

@@ -0,0 +1,25 @@
+class Predicate
+  module Postgres
+    module PgArray
+
+      def to_pg_array(arg, type = :varchar)
+        if arg.is_a?(Sequel::Postgres::PGArray)
+          arg
+        elsif arg.is_a?(Sequel::SQL::Wrapper)
+          ::Sequel.pg_array(arg.value, type)
+        elsif arg.is_a?(Array)
+          ::Sequel.pg_array(arg, type)
+        elsif arg.respond_to?(:pg_array)
+          arg.pg_array
+        else
+          raise NotSupportedError, "Unexpected pg_array arg `#{arg}`::`#{arg.class}`"
+        end
+      end
+      module_function :to_pg_array
+
+    end # module PgArray
+  end # module Postgres
+end # class Predicate
+require_relative 'pg_array/empty'
+require_relative 'pg_array/overlaps'
+require_relative 'pg_array/literal'

data/lib/predicate/postgres/rewriter.rb

@@ -0,0 +1,49 @@
+class Predicate
+  module Postgres
+    class Rewriter < Sexpr::Rewriter
+      grammar Grammar
+
+      class ToLiteral < Sexpr::Rewriter
+        grammar Grammar
+
+        def on_literal(sexpr)
+          if sexpr.last.is_a?(Array)
+            [ :pg_array_literal, sexpr.last, :varchar ]
+          else
+            sexpr
+          end
+        end
+
+        alias :on_missing :copy_and_apply
+      end
+
+      def on_intersect(sexpr)
+        rewriter = ToLiteral.new
+        rewritten = sexpr[1..-1]
+          .map{|expr| rewriter.call(expr) }
+          .unshift(:pg_array_overlaps)
+        rewritten.extend(PgArray::Overlaps)
+      end
+
+      def on_empty(sexpr)
+        rewritten = sexpr[1..-1]
+          .map{|expr| apply(expr) }
+          .unshift(:pg_array_empty)
+          .push(:varchar)
+        rewritten.extend(PgArray::Empty)
+      end
+
+      alias :on_missing :copy_and_apply
+    end
+  end
+
+  module Expr
+    def to_postgres(*args)
+      Postgres::Rewriter.new(*args).call(self)
+    end
+  end
+
+  def to_postgres(*args)
+    Predicate.new(expr.to_postgres(*args))
+  end
+end

data/lib/predicate/postgres.rb

@@ -0,0 +1,4 @@
+require_relative 'sequel'
+require_relative 'postgres/pg_array'
+require_relative 'postgres/rewriter'
+require_relative 'postgres/ext'

data/lib/predicate/sequel/to_sequel.rb

@@ -106,6 +106,7 @@ class Predicate
 
       def on_opaque(sexpr)
         return [sexpr.last] if sexpr.last.respond_to?(:sql_literal)
+        return [sexpr.last] if sexpr.last.respond_to?(:sql)
         raise Error, "Unable to compile #{sexpr} to Sequel"
       end
 

data/lib/predicate/version.rb

@@ -1,7 +1,7 @@
 class Predicate
   module Version
     MAJOR = 2
-    MINOR = 6
+    MINOR = 7
     TINY  = 0
   end
   VERSION = "#{Version::MAJOR}.#{Version::MINOR}.#{Version::TINY}"

data/lib/predicate.rb

@@ -51,8 +51,12 @@ class Predicate
 
   private
 
-    def _factor_predicate(arg)
-      Predicate.new Grammar.sexpr(arg)
+    def _factor_predicate(arg, *mods)
+      expr = Grammar.sexpr(arg)
+      mods.each do |mod|
+        expr.extend(mod)
+      end
+      Predicate.new(expr)
     end
 
   end

data/spec/postgres/test_factory.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+class Predicate
+  describe 'pg_factory' do
+
+    subject{
+      predicate
+    }
+
+    let(:predicate) {
+      Predicate.tautology
+    }
+
+    it_should_behave_like "a predicate"
+
+    context 'pg_array_literal' do
+      let(:predicate) do
+        Predicate.pg_array_literal([12])
+      end
+    end
+
+    context 'pg_array_empty' do
+      let(:predicate) do
+        Predicate.pg_array_empty(:x)
+      end
+    end
+
+    context 'pg_array_overlaps' do
+      let(:predicate) do
+        Predicate.pg_array_overlaps(:x, [1,2,3])
+      end
+
+      it 'has expected free variables' do
+        expect(subject.free_variables).to eql([:x])
+      end
+    end
+
+    context 'pg_array_overlaps (2)' do
+      let(:predicate) do
+        Predicate.pg_array_overlaps(:x, :y)
+      end
+
+      it 'has expected free variables' do
+        expect(subject.free_variables).to eql([:x, :y])
+      end
+    end
+  end
+end

data/spec/postgres/test_to_postgres.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+class Predicate
+  describe 'to_postgres' do
+    subject {
+      predicate.to_postgres
+    }
+
+    context 'on an intersect' do
+      let(:predicate){
+        Predicate.intersect(:x, [1, 2, 3])
+      }
+
+      it 'returns another predicate' do
+        expect(subject).to be_a(Predicate)
+      end
+
+      it 'replaces intersect by pg_array_overlaps' do
+        expect(subject.sexpr).to eql([
+          :pg_array_overlaps,
+          [ :identifier, :x ],
+          [ :pg_array_literal, [1, 2, 3], :varchar ]
+        ])
+      end
+    end
+
+    context 'on an intersect' do
+      let(:predicate){
+        Predicate.empty(:x)
+      }
+
+      it 'replaces empty by pg_array_empty' do
+        expect(subject.sexpr).to eql([
+          :pg_array_empty,
+          [ :identifier, :x ],
+          :varchar
+        ])
+      end
+    end
+  end
+end

data/spec/postgres/test_to_sequel.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+class Predicate
+  describe ToSequel do
+    PG_DB = Sequel.connect(ENV['PREDICATE_PG_URL'])
+
+    before(:all) do
+      create_items_database(PG_DB)
+      items = PG_DB[:items]
+    end
+
+    subject do
+      dataset = PG_DB[:items].where(predicate.to_postgres.to_sequel)
+      dataset
+    end
+
+    # after do
+    #   subject.to_a
+    # end
+
+    context 'tautology' do
+      let(:predicate) { Predicate.tautology }
+
+      it 'works as expected' do
+        expect(subject.sql).to eql(%Q{SELECT * FROM "items" WHERE true})
+      end
+    end
+
+    context 'intersect' do
+      let(:predicate) { Predicate.intersect(:x, [1, 2, 3]) }
+
+      it 'works as expected' do
+        expect(subject.sql).to eql(%Q{SELECT * FROM "items" WHERE ("x" && ARRAY[1,2,3])})
+      end
+    end
+
+    context 'empty' do
+      let(:predicate) { Predicate.empty(:x) }
+
+      it 'works as expected' do
+        expect(subject.sql).to eql(%Q{SELECT * FROM "items" WHERE ("x" = '{}'::varchar[])})
+      end
+    end
+  end if ENV['PREDICATE_PG_URL']
+end

data/spec/sequel/test_to_sequel.rb

@@ -1,19 +1,11 @@
 require 'spec_helper'
-require 'sequel'
-require 'sqlite3'
-require 'predicate/sequel'
 class Predicate
   describe ToSequel do
 
     DB = Sequel.sqlite
 
     before(:all) do
-      DB.create_table :items do
-        primary_key :id
-        String :name
-        String :address
-        Float :price
-      end
+      create_items_database(DB)
       items = DB[:items]
     end
 
@@ -229,6 +221,5 @@ class Predicate
         expect { subject }.to raise_error(NotSupportedError)
       end
     end
-
   end
 end

data/spec/shared/a_predicate.rb

@@ -4,6 +4,10 @@ shared_examples_for "a predicate" do
   let(:x){ 12 }
   let(:y){ 13 }
 
+  it 'is a Predicate' do
+    subject.should be_a(Predicate)
+  end
+
   it 'can be negated easily' do
     (!subject).should be_a(Predicate)
   end

data/spec/spec_helper.rb

@@ -1,10 +1,26 @@
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
-require "rspec"
+require 'rspec'
+require 'sequel'
+require 'sqlite3'
+require 'pg'
 require 'predicate'
+require 'predicate/sequel'
+require 'predicate/postgres'
 require_relative 'shared/a_predicate'
 
+Sequel.extension :pg_array, :pg_array_ops
 module Helpers
 
+  def create_items_database(db)
+    db.drop_table? :items
+    db.create_table :items do
+      primary_key :id
+      String :name
+      String :address
+      Float :price
+    end
+  end
+
 end
 
 RSpec.configure do |c|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: predicate
 version: !ruby/object:Gem::Version
-  version: 2.6.0
+  version: 2.7.0
 platform: ruby
 authors:
 - Bernard Lambeau
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-12-11 00:00:00.000000000 Z
+date: 2022-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sexpr
@@ -80,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Predicate provides a simple class and processors to encode and manipulate
   (tuple) predicates
 email: blambeau@gmail.com
@@ -129,6 +143,15 @@ files:
 - lib/predicate/nodes/unary_func.rb
 - lib/predicate/nodes/var.rb
 - lib/predicate/placeholder.rb
+- lib/predicate/postgres.rb
+- lib/predicate/postgres/ext.rb
+- lib/predicate/postgres/ext/factory.rb
+- lib/predicate/postgres/ext/to_sequel.rb
+- lib/predicate/postgres/pg_array.rb
+- lib/predicate/postgres/pg_array/empty.rb
+- lib/predicate/postgres/pg_array/literal.rb
+- lib/predicate/postgres/pg_array/overlaps.rb
+- lib/predicate/postgres/rewriter.rb
 - lib/predicate/processors.rb
 - lib/predicate/processors/binder.rb
 - lib/predicate/processors/qualifier.rb
@@ -191,6 +214,9 @@ files:
 - spec/nodes/qualified_identifier/test_free_variables.rb
 - spec/nodes/qualified_identifier/test_name.rb
 - spec/nodes/qualified_identifier/test_qualifier.rb
+- spec/postgres/test_factory.rb
+- spec/postgres/test_to_postgres.rb
+- spec/postgres/test_to_sequel.rb
 - spec/predicate/test_and_split.rb
 - spec/predicate/test_attr_split.rb
 - spec/predicate/test_bind.rb
@@ -222,7 +248,7 @@ homepage: http://github.com/enspirit/predicate
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -237,8 +263,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
-signing_key:
+rubyforge_project: 
+rubygems_version: 2.6.14.4
+signing_key: 
 specification_version: 4
 summary: Predicate provides a simple class and processors to encode and manipulate
   (tuple) predicates