"self" and or
=============
This lines mean the same:
User.smql :self => {:id => 1}
User.smql :id => 1
User.smql 'self.id' => 1
User.smql 'self.self.self.self.id' => 1
self is like a reflection to itself.
Very userful if you need the new disjunction:
User.smql :self => [{:surname => 'Mueller', :givenname => 'Michael'}, {:givenname => 'Horst', :surname => 'Schlemmer'}], :firm => {:name => 'Hotel an der Elbe'}
SmqlToAR::Column
----------------
Rejects every `self`, so it is really like no self,
but you use `'self'` as like as a simple reflection.
You can ask, if it is self via Column#self?
SmqlToAR::QueryBuilder
======================
joins: The old `#join`. Renames because SmqlToAR::And and SmqlToAR::Or which has Array#join,
so we cannot delegate `#join` to the QueryBuilder.
`#where`
--------
Now only one argument! Needed for SmqlToAR::And and SmqlToAR::Or.
`#build` will generates LEFT OUTER JOINS now. Needed for disjunctions.
The most queries will work like before.
Problems:
User.smql :articles => {}
Before it will return all users with articles, now it will return also users without articles.
If you want to have only all users with articles, you ask:
User.smql :articles => {:id => true}
Will fail if id IS NULL, but this should not happen. ;)
`SmqlToAR::And` and `SmqlToAR::Or`
==================================
`SmqlToAR::QueryBuilder`-proxies. QueryBuilder let them build where-clauses.
And will will produce a conjunction and Or a disjunction of course.
They delegates all QueryBuilder-methods to QueryBuilder.
Only `#where` will stored local and `#build` will do it partial.
They have the same superclass: `SmqlToAR::SubBuilder`.
The small changes
=================
* `SmqlToAR.reload_library`: Reloads SmqlToAR-lib. Useful while development.
* `SmqlToAR::ConditionTypes#conditions`: Return all Conditions. `#try_parse` uses it.
* Some classes have a new `#inspect`.
* `SmqlToAR::ConditionTypes#Exists` / `NotExists`:
`{:id => true}` / `{:id => false}`:
This object has setted an id or not? `#id` must exists as column of course!
Uses `IS NOT NULL` and `IS NULL`.
subqueries
Denis Knauf
parent
93fd3eeda4
commit
2fdc45d1d5
|
|
@ -107,7 +107,9 @@ class SmqlToAR
|
|||
|
||||
# Model der Relation `rel` von `model`
|
||||
def self.model_of model, rel
|
||||
model.reflections[ rel.to_sym].andand.klass
|
||||
rel = rel.to_sym
|
||||
r = model.reflections[ rel].andand.klass
|
||||
r.nil? && :self == rel ? model : r
|
||||
end
|
||||
|
||||
# Eine Spalte in einer Tabelle, relativ zu `Column#model`.
|
||||
|
|
@ -121,7 +123,7 @@ class SmqlToAR
|
|||
def initialize model, *col
|
||||
@model = model
|
||||
@last_model = nil
|
||||
*@path, @col = Array.wrap( col).collect( &it.to_s.split( /[.\/]/)).flatten.collect( &:to_sym)
|
||||
*@path, @col = *Array.wrap( col).collect( &it.to_s.split( /[.\/]/)).flatten.collect( &:to_sym).reject( &it==:self)
|
||||
end
|
||||
|
||||
def last_model
|
||||
|
|
@ -131,9 +133,12 @@ class SmqlToAR
|
|||
def each
|
||||
model = @model
|
||||
@path.each do |rel|
|
||||
model = SmqlToAR.model_of model, rel
|
||||
return false unless model
|
||||
yield rel, model
|
||||
rel = rel.to_sym
|
||||
unless :self == rel
|
||||
model = SmqlToAR.model_of model, rel
|
||||
return false unless model
|
||||
yield rel, model
|
||||
end
|
||||
end
|
||||
model
|
||||
end
|
||||
|
|
@ -158,20 +163,21 @@ class SmqlToAR
|
|||
def joins builder = nil, table = nil, &exe
|
||||
pp = []
|
||||
table = Array.wrap table
|
||||
exe ||= builder ? lambda {|j, m| builder.join table+j, m} : Array.method( :[])
|
||||
exe ||= builder ? lambda {|j, m| builder.joins table+j, m} : Array.method( :[])
|
||||
collect do |rel, model|
|
||||
pp.push rel
|
||||
exe.call pp, model
|
||||
end
|
||||
end
|
||||
def length() @path.length+1 end
|
||||
def size() @path.size+1 end
|
||||
def to_a() @path+[@col] end
|
||||
def self?() !@col end
|
||||
def length() @path.length+(self.self? ? 0 : 1) end
|
||||
def size() @path.size+(self.self? ? 0 : 1) end
|
||||
def to_a() @path+(self.self? ? [] : [@col]) end
|
||||
def to_s() to_a.join '.' end
|
||||
def to_sym() to_s.to_sym end
|
||||
def to_json() to_s end
|
||||
def inspect() "#<Column: #{model} #{to_s}>" end
|
||||
def relation() SmqlToAR.model_of last_model, @col end
|
||||
def relation() self.self? ? model : SmqlToAR.model_of( last_model, @col) end
|
||||
def allowed?() ! self.protected? end
|
||||
def child?() @path.empty? and !!relation end
|
||||
end
|
||||
|
|
@ -225,9 +231,9 @@ class SmqlToAR
|
|||
self
|
||||
end
|
||||
|
||||
def build prefix = nil, base_table = nil
|
||||
def build prefix = nil
|
||||
benchmark 'SMQL build query' do
|
||||
@builder = QueryBuilder.new @model, prefix, base_table
|
||||
@builder = QueryBuilder.new @model, prefix
|
||||
table = @builder.base_table
|
||||
@conditions.each &it.build( builder, table)
|
||||
end
|
||||
|
|
@ -252,4 +258,12 @@ class SmqlToAR
|
|||
def self.to_ar *params
|
||||
new( *params).to_ar
|
||||
end
|
||||
|
||||
def self.reload_library
|
||||
lib_dir = File.dirname __FILE__
|
||||
fj = lambda {|*a| File.join lib_dir, *a }
|
||||
load fj.call( 'smql_to_ar.rb')
|
||||
load fj.call( 'smql_to_ar', 'condition_types.rb')
|
||||
load fj.call( 'smql_to_ar', 'query_builder.rb')
|
||||
end
|
||||
end
|
||||
|
|
|
|||
|
|
@ -33,15 +33,29 @@ class SmqlToAR
|
|||
k.split( '|').collect &:to_sym
|
||||
end
|
||||
|
||||
def conditions &e
|
||||
unless block_given?
|
||||
r = Enumerator.new( self, :conditions)
|
||||
s = self
|
||||
r.define_singleton_method :[] do |k|
|
||||
s.conditions.select {|c| c::Operator === k }
|
||||
end
|
||||
return r
|
||||
end
|
||||
constants.each do |c|
|
||||
next if :Condition == c
|
||||
c = const_get c
|
||||
next if Condition === c
|
||||
yield c
|
||||
end
|
||||
end
|
||||
|
||||
# Eine Regel parsen.
|
||||
# Ex: Person, "givenname=", "Peter"
|
||||
def try_parse_it model, colop, val
|
||||
r = nil
|
||||
#p :try_parse => { :model => model, :colop => colop, :value => val }
|
||||
constants.each do |c|
|
||||
next if :Condition == c
|
||||
c = const_get c
|
||||
next if Condition === c
|
||||
conditions.each do |c|
|
||||
raise_unless colop =~ /^(?:\d*:)?(.*?)(\W*)$/, UnexpectedColOpError.new( model, colop, val)
|
||||
col, op = $1, $2
|
||||
col = split_keys( col).collect {|c| Column.new model, c }
|
||||
|
|
@ -81,11 +95,17 @@ class SmqlToAR
|
|||
Expected = []
|
||||
Where = nil
|
||||
|
||||
# Versuche das Objekt zu erkennen. Operator und Expected muessen passen.
|
||||
# Passt das Object, die Klasse instanzieren.
|
||||
def self.try_parse model, cols, op, val
|
||||
#p :self => name, :try_parse => op, :cols => cols, :with => self::Operator, :value => val, :expected => self::Expected, :model => model.name
|
||||
new model, cols, val if self::Operator === op and self::Expected.any?( &it === val)
|
||||
class <<self
|
||||
# Versuche das Objekt zu erkennen. Operator und Expected muessen passen.
|
||||
# Passt das Object, die Klasse instanzieren.
|
||||
def try_parse model, cols, op, val
|
||||
#p :self => name, :try_parse => op, :cols => cols, :with => self::Operator, :value => val, :expected => self::Expected, :model => model.name
|
||||
new model, cols, val if self::Operator === op and self::Expected.any?( &it === val)
|
||||
end
|
||||
|
||||
def inspect
|
||||
"#{self.name}(:operator=>#{self::Operator.inspect}, :expected=>#{self::Expected.inspect}, :where=>#{self::Where.inspect})"
|
||||
end
|
||||
end
|
||||
|
||||
def initialize model, cols, val
|
||||
|
|
@ -97,6 +117,10 @@ class SmqlToAR
|
|||
verify
|
||||
end
|
||||
|
||||
def inspect
|
||||
"#<#{self.class.name}:0x#{(self.object_id<<1).to_s 16} model: #{self.class.name}, cols: #{@cols.inspect}, value: #{@value.inspect}>"
|
||||
end
|
||||
|
||||
def verify
|
||||
@cols.each do |col|
|
||||
verify_column col
|
||||
|
|
@ -118,8 +142,8 @@ class SmqlToAR
|
|||
end
|
||||
|
||||
# Erstelle alle noetigen Klauseln. builder nimmt diese entgegen,
|
||||
# wobei builder.join, builder.select, builder.where und builder.wobs von interesse sind.
|
||||
# mehrere Schluessel bedeuten, dass die Values _alle_ zutreffen muessen, wobei die Schluessel geodert werden.
|
||||
# wobei builder.joins, builder.select, builder.where und builder.wobs von interesse sind.
|
||||
# mehrere Schluessel bedeuten, dass die Values _alle_ zutreffen muessen, wobei die Schluessel geODERt werden.
|
||||
# Ex:
|
||||
# 1) {"givenname=", "Peter"} #=> givenname = 'Peter'
|
||||
# 2) {"givenname=", ["Peter", "Hans"]} #=> ( givenname = 'Peter' OR givenname = 'Hans' )
|
||||
|
|
@ -132,11 +156,11 @@ class SmqlToAR
|
|||
@cols.each do |col|
|
||||
col.joins builder, table
|
||||
col = builder.column table+col.path, col.col
|
||||
builder.where *values.keys.collect {|vid| self.class::Where % [ col, vid.to_s ] }
|
||||
builder.where values.keys.collect {|vid| self.class::Where % [ col, vid.to_s ] }
|
||||
end
|
||||
else
|
||||
values.keys.each do |vid|
|
||||
builder.where *@cols.collect {|col|
|
||||
builder.where @cols.collect {|col|
|
||||
col.joins builder, table
|
||||
col = builder.column table+col.path, col.col
|
||||
self.class::Where % [ col, vid.to_s ]
|
||||
|
|
@ -189,19 +213,26 @@ class SmqlToAR
|
|||
|
||||
In = simple_condition NotIn, '|=', '%s IN (%s)', [Array]
|
||||
In2 = simple_condition In, '', nil, [Array]
|
||||
NotEqual = simple_condition Condition, /\!=|<>/, "%s <> %s", [Array, String, Numeric]
|
||||
NotEqual = simple_condition Condition, '!=', "%s <> %s", [Array, String, Numeric]
|
||||
NotEqual2 = simple_condition Condition, '<>', "%s <> %s", [Array, String, Numeric]
|
||||
GreaterThanOrEqual = simple_condition Condition, '>=', "%s >= %s", [Array, Numeric]
|
||||
LesserThanOrEqual = simple_condition Condition, '<=', "%s <= %s", [Array, Numeric]
|
||||
|
||||
# Examples:
|
||||
# { 'articles=>' => { id: 1 } }
|
||||
# { 'articles=>' => [ { id: 1 }, { id: 2 } ] }
|
||||
class EqualJoin <Condition
|
||||
Operator = '='
|
||||
Expected = [Hash]
|
||||
Operator = '=>'
|
||||
Expected = [Hash, lambda {|x| x.kind_of?( Array) and x.all?( &it.kind_of?( Hash))}]
|
||||
|
||||
def initialize *pars
|
||||
super( *pars)
|
||||
@value = Array.wrap @value
|
||||
cols = {}
|
||||
p self: self, cols: @cols
|
||||
@cols.each do |col|
|
||||
col_model = col.relation
|
||||
cols[col] = [col_model] + ConditionTypes.try_parse( col_model, @value)
|
||||
cols[col] = [col_model] + @value.collect {|val| ConditionTypes.try_parse( col_model, val) }
|
||||
end
|
||||
@cols = cols
|
||||
end
|
||||
|
|
@ -212,11 +243,14 @@ class SmqlToAR
|
|||
|
||||
def build builder, table
|
||||
@cols.each do |col, sub|
|
||||
model, *sub = sub
|
||||
t = table + col.path + [col.col]
|
||||
col.joins.each {|j, m| builder.join table+j, m }
|
||||
builder.join t, sub[0]
|
||||
sub[1..-1].each &it.build( builder, t)
|
||||
col.joins.each {|j, m| builder.joins table+j, m }
|
||||
builder.joins t, model
|
||||
b2 = 1 == sub.length ? builder : Or.new( builder)
|
||||
sub.each {|i| i.collect( &it.build( And.new( b2), t)); p 'or' => b2 }
|
||||
end
|
||||
ap '=>' => builder
|
||||
self
|
||||
end
|
||||
end
|
||||
|
|
@ -250,7 +284,7 @@ class SmqlToAR
|
|||
def build builder, table
|
||||
@cols.each do |col, sub|
|
||||
t = table+col.to_a
|
||||
builder.sub_join t, col, *sub[0..1]
|
||||
builder.sub_joins t, col, *sub[0..1]
|
||||
sub[2..-1].each &it.build( builder, t)
|
||||
end
|
||||
self
|
||||
|
|
@ -263,8 +297,9 @@ class SmqlToAR
|
|||
LesserThan = simple_condition Condition, '<', "%s < %s", [Array, Numeric]
|
||||
NotIlike = simple_condition Condition, '!~', "%s NOT ILIKE %s", [Array, String]
|
||||
Ilike = simple_condition Condition, '~', "%s ILIKE %s", [Array, String]
|
||||
Exists = simple_condition Condition, '', '%s IS NOT NULL', [true]
|
||||
NotExists = simple_condition Condition, '', '%s IS NULL', [false]
|
||||
|
||||
####### No Operator #######
|
||||
Join = simple_condition EqualJoin, '', nil, [Hash]
|
||||
InRange2 = simple_condition InRange, '', nil, [Range]
|
||||
class Select < Condition
|
||||
|
|
@ -299,9 +334,15 @@ class SmqlToAR
|
|||
Expected = []
|
||||
attr_reader :model, :func, :args
|
||||
|
||||
def self.try_parse model, func, args
|
||||
SmqlToAR.logger.info( { try_parse: [func,args]}.inspect)
|
||||
self.new model, func, args if self::Name === func and self::Expected.any?( &it === args)
|
||||
class <<self
|
||||
def try_parse model, func, args
|
||||
SmqlToAR.logger.info( { try_parse: [func,args]}.inspect)
|
||||
self.new model, func, args if self::Name === func and self::Expected.any?( &it === args)
|
||||
end
|
||||
|
||||
def inspect
|
||||
"#{self.name}(:name=>#{self::Name}, :expected=>#{self::Expected})"
|
||||
end
|
||||
end
|
||||
|
||||
def initialize model, func, args
|
||||
|
|
|
|||
|
|
@ -29,30 +29,34 @@ class SmqlToAR
|
|||
end
|
||||
|
||||
attr_reader :table_alias, :model, :table_model, :base_table, :_where, :_select, :_wobs, :_joins, :prefix, :_vid
|
||||
attr_accessor :logger
|
||||
attr_accessor :logger, :limit, :offset
|
||||
|
||||
def initialize model, prefix = nil, base_table
|
||||
def initialize model, prefix = nil
|
||||
@prefix = "smql"
|
||||
@logger = SmqlToAR.logger
|
||||
@table_alias = Hash.new do |h, k|
|
||||
k = Array.wrap k
|
||||
h[k] = "#{@prefix},#{k.join(',')}"
|
||||
j = Array.wrap( k).compact
|
||||
h[k] = h.key?(j) ? h[j] : "#{@prefix},#{j.join(',')}"
|
||||
end
|
||||
@_vid, @_where, @_wobs, @model, @quoter = 0, [], {}, model, model.connection
|
||||
@base_table = base_table.blank? ? [model.table_name.to_sym] : Array.wrap( base_table)
|
||||
@_vid, @_where, @_wobs, @model, @quoter = 0, SmqlToAR::And[], {}, model, model.connection
|
||||
@base_table = [model.table_name.to_sym]
|
||||
@table_alias[ @base_table] = @base_table.first
|
||||
t = quote_table_name @table_alias[ @base_table]
|
||||
@_select, @_joins, @_joined, @_includes, @_order = ["DISTINCT #{t}.*"], "", [], [], []
|
||||
@_select, @_joins, @_joined, @_includes, @_order = ["DISTINCT #{t}.*"], "", [@base_table], [], []
|
||||
@table_model = {@base_table => @model}
|
||||
end
|
||||
|
||||
def vid() Vid.new( @_vid+=1) end
|
||||
|
||||
def inspect
|
||||
"#<#{self.class.name}:#{"0x%x"% (self.object_id<<1)}|#{@prefix}:#{@base_table}:#{@model} vid=#{@_vid} where=#{@_where} wobs=#{@_wobs} select=#{@_select} aliases=#{@_table_alias}>"
|
||||
end
|
||||
|
||||
# Jede via where uebergebene Condition wird geodert und alle zusammen werden geundet.
|
||||
# "Konjunktive Normalform". Allerdings duerfen Conditions auch Komplexe Abfragen enthalten.
|
||||
# Ex: builder.where( 'a = a', 'b = c').where( 'c = d', 'e = e').where( 'x = y').where( '( m = n AND o = p )', 'f = g')
|
||||
# Ex: builder.where( ['a = a', 'b = c']).where( ['c = d', 'e = e']).where( 'x = y').where( ['( m = n AND o = p )', 'f = g'])
|
||||
# #=> WHERE ( a = a OR b = c ) AND ( c = d OR e = e ) AND x = y ( ( m = n AND o = p ) OR f = g )
|
||||
def where *cond
|
||||
def where cond
|
||||
@_where.push cond
|
||||
self
|
||||
end
|
||||
|
|
@ -75,12 +79,12 @@ class SmqlToAR
|
|||
end
|
||||
|
||||
def build_join orig, pretable, table, prekey, key
|
||||
" JOIN #{orig} AS #{quote_table_name table} ON #{column pretable, prekey} = #{column table, key} "
|
||||
" LEFT OUTER JOIN #{orig} AS #{quote_table_name table} ON #{column pretable, prekey} = #{column table, key} "
|
||||
end
|
||||
|
||||
def sub_join table, col, model, query
|
||||
prefix, base_table = "#{@prefix}_sub", col.col
|
||||
join_ table, model, "(#{query.build( prefix, base_table).ar.to_sql})"
|
||||
def sub_joins table, col, model, query
|
||||
prefix, base_table = "#{@prefix}_sub", col.relation.table_name
|
||||
join_ table, model, "(#{query.build( prefix).ar.to_sql})"
|
||||
end
|
||||
|
||||
def join_ table, model, query, pretable = nil
|
||||
|
|
@ -116,7 +120,8 @@ class SmqlToAR
|
|||
self
|
||||
end
|
||||
|
||||
def join table, model
|
||||
def joins table, model
|
||||
table = table.flatten.compact
|
||||
return self if @_joined.include? table # Already joined
|
||||
join_ table, model, quote_table_name( model.table_name)
|
||||
@_joined.push table
|
||||
|
|
@ -136,40 +141,22 @@ class SmqlToAR
|
|||
@_order.push "#{column table, col} #{:DESC == o ? :DESC : :ASC}"
|
||||
end
|
||||
|
||||
def limit count
|
||||
@_limit = count
|
||||
end
|
||||
|
||||
def offset count
|
||||
@_offset = count
|
||||
end
|
||||
|
||||
class Dummy
|
||||
def method_missing m, *a, &e
|
||||
#p :dummy => m, :pars => a, :block => e
|
||||
self
|
||||
end
|
||||
end
|
||||
|
||||
def build_ar
|
||||
where_str = @_where.collect do |w|
|
||||
w = Array.wrap w
|
||||
1 == w.length ? w.first : "( #{w.join( ' OR ')} )"
|
||||
end.join ' AND '
|
||||
where_str = @_where.type_correction!.optimize!.tap {|x| p x }.build_where
|
||||
incls = {}
|
||||
@_includes.each do |inc|
|
||||
b = incls
|
||||
inc[1..-1].collect {|rel| b = b[rel] ||= {} }
|
||||
end
|
||||
@logger.debug incls: incls, joins: @_joins
|
||||
@logger.info where: where_str, wobs: @_wobs
|
||||
@model = @model.
|
||||
select( @_select.join( ', ')).
|
||||
joins( @_joins).
|
||||
where( where_str, @_wobs).
|
||||
order( @_order.join( ', ')).
|
||||
includes( incls)
|
||||
@model = @model.limit @_limit if @_limit
|
||||
@model = @model.offset @_offset if @_offset
|
||||
@model = @model.limit @limit if @limit
|
||||
@model = @model.offset @offset if @offset
|
||||
@model
|
||||
end
|
||||
|
||||
|
|
@ -189,4 +176,73 @@ class SmqlToAR
|
|||
@model
|
||||
end
|
||||
end
|
||||
|
||||
class SubBuilder < Array
|
||||
attr_reader :parent, :_where
|
||||
delegate :wobs, :joins, :includes, :sub_joins, :vid, :quote_column_name, :quoter, :quote_table_name, :column, :to => :parent
|
||||
|
||||
def initialize parent, tmp = false
|
||||
p init: self, parent: parent
|
||||
@parent = parent
|
||||
@parent.where self unless @parend.nil? && tmp
|
||||
end
|
||||
|
||||
def new parent, tmp = false
|
||||
super parent, tmp
|
||||
#return parent if self.class == parent.class
|
||||
#super parent
|
||||
end
|
||||
|
||||
alias where push
|
||||
|
||||
def type_correction!
|
||||
collect! do |sub|
|
||||
if sub.kind_of? Array
|
||||
sub = default[ *sub] unless sub.respond_to?( :type_correction!)
|
||||
sub.type_correction!
|
||||
end
|
||||
sub
|
||||
end
|
||||
self
|
||||
end
|
||||
|
||||
def optimize!
|
||||
p optimize: self
|
||||
ext = []
|
||||
collect! do |sub|
|
||||
sub = sub.optimize! if sub.kind_of? Array
|
||||
if self.class == sub.class
|
||||
ext.push *sub
|
||||
nil
|
||||
elsif sub.blank?
|
||||
nil
|
||||
else
|
||||
sub
|
||||
end
|
||||
end.compact!
|
||||
p optimized: self
|
||||
p ext: ext
|
||||
push *ext
|
||||
self
|
||||
end
|
||||
|
||||
def inspect
|
||||
"#{self.class.name.sub( /.*::/, '')}[ #{collect(&:inspect).join ', '}]"
|
||||
end
|
||||
def default() SmqlToAR::And end
|
||||
def default_new( parent) default.new self, parent, false end
|
||||
end
|
||||
|
||||
class And < SubBuilder
|
||||
def default; SmqlToAR::Or; end
|
||||
def build_where
|
||||
join ' AND '
|
||||
end
|
||||
end
|
||||
|
||||
class Or < SubBuilder
|
||||
def build_where
|
||||
join ' OR '
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
|
|||
Loading…
Reference in New Issue