From 2fdc45d1d5fd6971ba25979fb4f6854a4ad8ca46 Mon Sep 17 00:00:00 2001 From: Denis Knauf Date: Wed, 5 Oct 2011 13:25:56 +0200 Subject: [PATCH] "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`. --- lib/smql_to_ar.rb | 38 ++++++--- lib/smql_to_ar/condition_types.rb | 91 +++++++++++++++------ lib/smql_to_ar/query_builder.rb | 128 +++++++++++++++++++++--------- 3 files changed, 184 insertions(+), 73 deletions(-) diff --git a/lib/smql_to_ar.rb b/lib/smql_to_ar.rb index 9e53dcf..34226e9 100644 --- a/lib/smql_to_ar.rb +++ b/lib/smql_to_ar.rb @@ -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() "#" 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 diff --git a/lib/smql_to_ar/condition_types.rb b/lib/smql_to_ar/condition_types.rb index 045e1a2..6061e62 100644 --- a/lib/smql_to_ar/condition_types.rb +++ b/lib/smql_to_ar/condition_types.rb @@ -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 < 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 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::Name}, :expected=>#{self::Expected})" + end end def initialize model, func, args diff --git a/lib/smql_to_ar/query_builder.rb b/lib/smql_to_ar/query_builder.rb index a8978bd..56ae0c0 100644 --- a/lib/smql_to_ar/query_builder.rb +++ b/lib/smql_to_ar/query_builder.rb @@ -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