Class: Predicate

Inherits:
Object
  • Object
show all
Extended by:
Factory, Sugar
Defined in:
lib/predicate.rb,
lib/predicate/dsl.rb,
lib/predicate/sugar.rb,
lib/predicate/sequel.rb,
lib/predicate/factory.rb,
lib/predicate/grammar.rb,
lib/predicate/version.rb,
lib/predicate/nodes/eq.rb,
lib/predicate/nodes/gt.rb,
lib/predicate/nodes/in.rb,
lib/predicate/nodes/lt.rb,
lib/predicate/nodes/or.rb,
lib/predicate/nodes/and.rb,
lib/predicate/nodes/gte.rb,
lib/predicate/nodes/lte.rb,
lib/predicate/nodes/neq.rb,
lib/predicate/nodes/not.rb,
lib/predicate/nodes/var.rb,
lib/predicate/nodes/expr.rb,
lib/predicate/nodes/empty.rb,
lib/predicate/nodes/match.rb,
lib/predicate/placeholder.rb,
lib/predicate/nodes/exists.rb,
lib/predicate/nodes/native.rb,
lib/predicate/nodes/opaque.rb,
lib/predicate/nodes/set_op.rb,
lib/predicate/nodes/subset.rb,
lib/predicate/nodes/literal.rb,
lib/predicate/nodes/has_size.rb,
lib/predicate/nodes/superset.rb,
lib/predicate/nodes/intersect.rb,
lib/predicate/nodes/tautology.rb,
lib/predicate/processors/to_s.rb,
lib/predicate/nodes/identifier.rb,
lib/predicate/nodes/nadic_bool.rb,
lib/predicate/nodes/unary_func.rb,
lib/predicate/sequel/to_sequel.rb,
lib/predicate/nodes/binary_func.rb,
lib/predicate/nodes/dyadic_comp.rb,
lib/predicate/postgres/pg_array.rb,
lib/predicate/postgres/rewriter.rb,
lib/predicate/processors/binder.rb,
lib/predicate/processors/renamer.rb,
lib/predicate/nodes/contradiction.rb,
lib/predicate/postgres/ext/factory.rb,
lib/predicate/processors/qualifier.rb,
lib/predicate/postgres/ext/to_sequel.rb,
lib/predicate/processors/unqualifier.rb,
lib/predicate/postgres/pg_array/empty.rb,
lib/predicate/postgres/pg_array/literal.rb,
lib/predicate/nodes/qualified_identifier.rb,
lib/predicate/postgres/pg_array/overlaps.rb

Defined Under Namespace

Modules: And, BinaryFunc, Contradiction, DyadicComp, Empty, Eq, Exists, Expr, Factory, Grammar, Gt, Gte, HasSize, Identifier, In, Intersect, Literal, Lt, Lte, Match, NadicBool, Native, Neq, Not, Opaque, Or, Postgres, QualifiedIdentifier, SetOp, Subset, Sugar, Superset, Tautology, UnaryFunc, Var, Version Classes: Binder, Dsl, Error, NotSupportedError, Placeholder, Qualifier, Renamer, ToS, ToSequel, TypeError, UnboundError, Unqualifier

Constant Summary collapse

TupleLike = 
->(t){ t.is_a?(Hash) }
SexprLike = 
->(x) { x.is_a?(Array) && x.first.is_a?(Symbol) }
VERSION = 
"#{Version::MAJOR}.#{Version::MINOR}.#{Version::TINY}"

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Sugar

between, is_null, match, max_size, min_size

Methods included from Factory

_factor_predicate, and, comp, contradiction, empty, from_hash, h, has_size, identifier, in, literal, match, native, not, opaque, or, pg_array_empty, pg_array_literal, pg_array_overlaps, placeholder, qualified_identifier, tautology, var, vars

Constructor Details

#initialize(sexpr) ⇒ Predicate

Returns a new instance of Predicate.



20
21
22
 
# File 'lib/predicate.rb', line 20

def initialize(sexpr)
  @sexpr = sexpr
end

Instance Attribute Details

#sexpr ⇒ Object (readonly) Also known as: expr

Returns the value of attribute sexpr.



23
24
25
 
# File 'lib/predicate.rb', line 23

def sexpr
  @sexpr
end

Class Method Details

.coerce(arg) ⇒ Object Also known as: parse 



30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/predicate.rb', line 30

def coerce(arg)
  case arg
  when Predicate   then arg
  when TrueClass   then tautology
  when FalseClass  then contradiction
  when Symbol      then identifier(arg)
  when Proc        then native(arg)
  when Hash        then from_hash(arg)
  else
    raise ArgumentError, "Unable to coerce `#{arg}` to a predicate"
  end
end

.currying(var = var(".", :dig), &bl) ⇒ Object 



48
49
50
 
# File 'lib/predicate.rb', line 48

def currying(var = var(".", :dig), &bl)
  Predicate::Dsl.new(var, true).instance_eval(&bl)
end

.dsl(var = var(".", :dig), &bl) ⇒ Object 



44
45
46
 
# File 'lib/predicate.rb', line 44

def dsl(var = var(".", :dig), &bl)
  Predicate::Dsl.new(var, false).instance_eval(&bl)
end

Instance Method Details

#! ⇒ Object 



100
101
102
 
# File 'lib/predicate.rb', line 100

def !
  Predicate.new(!expr)
end

#&(other) ⇒ Object 



88
89
90
91
92
 
# File 'lib/predicate.rb', line 88

def &(other)
  return self  if other.tautology? or other==self
  return other if tautology?
  Predicate.new(expr & other.expr)
end

#==(other) ⇒ Object Also known as: eql? 



149
150
151
 
# File 'lib/predicate.rb', line 149

def ==(other)
  other.is_a?(Predicate) && (other.expr==expr)
end

#and_split(attr_list) ⇒ Object

Splits this predicate, say P, as too predicates P1 & P2 such that P <=> P1 & P2 and P2 makes no reference to any attribute in attr_list.



131
132
133
 
# File 'lib/predicate.rb', line 131

def and_split(attr_list)
  expr.and_split(attr_list).map{|e| Predicate.new(e)}
end

#attr_split ⇒ Object

Returns a hash (attr -> Pattr) associating attribute names to predicates, so that each predicate Pattr only makes reference to the corresponding attribute name attr, while the conjunction of Pattrs is still equivalent to the original predicate.

A nil key may map a predicate that still makes references to more than one attribute.



143
144
145
146
147
 
# File 'lib/predicate.rb', line 143

def attr_split
  expr.attr_split.each_pair.each_with_object({}) do |(k,v),h|
    h[k] = Predicate.new(v)
  end
end

#bind(binding) ⇒ Object 



116
117
118
 
# File 'lib/predicate.rb', line 116

def bind(binding)
  Predicate.new(expr.bind(binding))
end

#call(tuple) ⇒ Object 



124
125
126
 
# File 'lib/predicate.rb', line 124

def call(tuple)
  expr.evaluate(tuple)
end

#constant_variables ⇒ Object 



80
81
82
 
# File 'lib/predicate.rb', line 80

def constant_variables
  expr.constant_variables
end

#constants ⇒ Object 



84
85
86
 
# File 'lib/predicate.rb', line 84

def constants
  expr.constants
end

#contradiction? ⇒ Boolean

Returns:

  • (Boolean) 


72
73
74
 
# File 'lib/predicate.rb', line 72

def contradiction?
  expr.contradiction?
end

#evaluate(tuple) ⇒ Object 



120
121
122
 
# File 'lib/predicate.rb', line 120

def evaluate(tuple)
  expr.evaluate(tuple)
end

#free_variables ⇒ Object 



76
77
78
 
# File 'lib/predicate.rb', line 76

def free_variables
  expr.free_variables
end

#hash ⇒ Object 



154
155
156
 
# File 'lib/predicate.rb', line 154

def hash
  expr.hash
end

#native? ⇒ Boolean

Returns:

  • (Boolean) 


64
65
66
 
# File 'lib/predicate.rb', line 64

def native?
  Native===expr
end

#qualify(qualifier) ⇒ Object 



104
105
106
 
# File 'lib/predicate.rb', line 104

def qualify(qualifier)
  Predicate.new(expr.qualify(qualifier))
end

#rename(renaming) ⇒ Object 



112
113
114
 
# File 'lib/predicate.rb', line 112

def rename(renaming)
  Predicate.new(expr.rename(renaming))
end

#tautology? ⇒ Boolean

Returns:

  • (Boolean) 


68
69
70
 
# File 'lib/predicate.rb', line 68

def tautology?
  expr.tautology?
end

#to_hash ⇒ Object

If possible, converts this predicate back to a { attr: value, ... } hash. Raises an IllegalArgumentError if the predicate cannot be represented that way.



165
166
167
 
# File 'lib/predicate.rb', line 165

def to_hash
  expr.to_hash
end

#to_postgres(*args) ⇒ Object 



46
47
48
 
# File 'lib/predicate/postgres/rewriter.rb', line 46

def to_postgres(*args)
  Predicate.new(expr.to_postgres(*args))
end

#to_s(scope = nil) ⇒ Object 



158
159
160
 
# File 'lib/predicate.rb', line 158

def to_s(scope = nil)
  expr.to_s(scope)
end

#to_sequel ⇒ Object

module Expr



11
12
13
 
# File 'lib/predicate/sequel.rb', line 11

def to_sequel
  expr.to_sequel
end

#unqualify ⇒ Object 



108
109
110
 
# File 'lib/predicate.rb', line 108

def unqualify
  Predicate.new(expr.unqualify)
end

#|(other) ⇒ Object 



94
95
96
97
98
 
# File 'lib/predicate.rb', line 94

def |(other)
  return self  if other.contradiction? or other==self
  return other if contradiction?
  Predicate.new(expr | other.expr)
end