AR-through-reflections in query_builder; SmqlToAR.models returns the reflections-graph; limit, offset, sub-query "()" (not sub-conditions). unstable 0.3

.gitignore

@@ -1,2 +1,3 @@
 pkg/**
+.*.swp
 smql.gemspec

Rakefile

@@ -15,6 +15,7 @@ begin
 		gem.add_dependency 'activerecord'
 		gem.add_dependency 'activesupport'
 		gem.add_dependency 'json'
+		gem.add_dependency 'methodphitamine'
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError

VERSION

@@ -1 +1 @@
-0.0.2
+0.0.3

lib/smql_to_ar.rb

@@ -15,6 +15,18 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 class SmqlToAR
+	module Assertion
+		def raise_unless cond, exception = nil, *args
+			cond, exception, *args = yield. cond, exception, *args  if block_given?
+			raise exception || Exception, *args  unless cond
+		end
+
+		def raise_if cond, exception = nil, *args
+			cond, exception, *args = yield. cond, exception, *args  if block_given?
+			raise exception || Exception, *args  if cond
+		end
+	end
+
 	include ActiveSupport::Benchmarkable
 	############################################################################r
 	# Exceptions
@@ -77,12 +89,18 @@ class SmqlToAR
 		end
  	end
 
-	class OnlyOrderOnBaseError < SMQLError
+	class RootOnlyFunctionError < SMQLError
 		def initialize path
 			super :path => path
 		end
 	end
 
+	class ConColumnError < SMQLError
+		def initialize expected, got
+			super :expected => expected, :got => got
+		end
+	end
+
 	class BuilderError < Exception; end
 
 	#############################################################################
@@ -103,7 +121,7 @@ class SmqlToAR
 		def initialize model, *col
 			@model = model
 			@last_model = nil
-			*@path, @col = Array.wrap( col).collect {|s| s.to_s.split /[.\/]/ }.flatten.collect &:to_sym
+			*@path, @col = Array.wrap( col).collect( &it.to_s.split( /[.\/]/)).flatten.collect( &:to_sym)
 		end
 
 		def last_model
@@ -146,6 +164,8 @@ class SmqlToAR
 				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 to_s()   to_a.join '.'  end
 		def to_sym() to_s.to_sym  end
@@ -153,6 +173,7 @@ class SmqlToAR
 		def inspect()  "#<Column: #{model} #{to_s}>"  end
 		def relation()  SmqlToAR.model_of last_model, @col  end
 		def allowed?()  ! self.protected?  end
+		def child?()  @path.empty? and !!relation  end
 	end
 
 	attr_reader :model, :query, :conditions, :builder, :order
@@ -179,6 +200,23 @@ class SmqlToAR
 		#p model: @model, query: @query
 	end
 
+	def self.models models
+		models = Array.wrap models
+		r = Hash.new {|h,k| h[k] = {} }
+		while model = models.tap( &:uniq!).pop
+			refls = model.respond_to?( :reflections) && model.reflections
+			refls && refls.each do |name, refl|
+				r[model.name][name] = case refl
+					when ActiveRecord::Reflection::ThroughReflection then {:macro => refl.macro, :model => refl.klass.name, :through => refl.through_reflection.name}
+					when ActiveRecord::Reflection::AssociationReflection then {:macro => refl.macro, :model => refl.klass.name}
+					else raise "Ups: #{refl.class}"
+					end
+				models.push refl.klass  unless r.keys.include? refl.klass.name
+			end
+		end
+		r
+	end
+
 	def parse
 		benchmark 'SMQL parse' do
 			@conditions = ConditionTypes.try_parse @model, @query
@@ -187,11 +225,11 @@ class SmqlToAR
 		self
 	end
 
-	def build
+	def build prefix = nil, base_table = nil
 		benchmark 'SMQL build query' do
-			@builder = QueryBuilder.new @model
+			@builder = QueryBuilder.new @model, prefix, base_table
 			table = @builder.base_table
-			@conditions.each {|condition| condition.build builder, table }
+			@conditions.each &it.build( builder, table)
 		end
 		#p builder: @builder
 		self

lib/smql_to_ar/condition_types.rb

@@ -25,6 +25,8 @@ class SmqlToAR
 	# Nimmt eine Klasse ein Objekt an,  so soll diese Klasse instanziert werden.
 	# Alles weitere siehe Condition.
 	module ConditionTypes
+		extend SmqlToAR::Assertion
+
 		class <<self
 			# Ex: 'givenname|surname|nick' => [:givenname, :surname, :nick]
 			def split_keys k
@@ -40,13 +42,13 @@ class SmqlToAR
 					next  if :Condition == c
 					c = const_get c
 					next  if Condition === c
-					raise UnexpectedColOpError.new( model, colop, val)  unless colop =~ /^(?:\d*:)?(.*?)(\W*)$/
+					raise_unless colop =~ /^(?:\d*:)?(.*?)(\W*)$/, UnexpectedColOpError.new( model, colop, val)
 					col, op = $1, $2
 					col = split_keys( col).collect {|c| Column.new model, c }
 					r = c.try_parse model, col, op, val
 					break  if r
 				end
-				raise UnexpectedError.new( model, colop, val)  unless r
+				raise_unless r, UnexpectedError.new( model, colop, val)
 				r
 			end
 
@@ -72,6 +74,8 @@ class SmqlToAR
 		end
 
 		class Condition
+			include SmqlToAR::Assertion
+			extend SmqlToAR::Assertion
 			attr_reader :value, :cols
 			Operator = nil
 			Expected = []
@@ -81,7 +85,7 @@ class SmqlToAR
 			# 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? {|i| i === val }
+				new model, cols, val  if self::Operator === op and self::Expected.any?( &it === val)
 			end
 
 			def initialize model, cols, val
@@ -103,14 +107,14 @@ class SmqlToAR
 			# Gibt es eine Spalte diesen Namens?
 			# Oder:  Gibt es eine Relation diesen Namens?  (Hier nicht der Fall)
 			def verify_column col
-				raise NonExistingColumnError.new( %w[Column], col)  unless col.exist_in?
+				raise_unless col.exist_in?, NonExistingColumnError.new( %w[Column], col)
 			end
 
 			# Modelle koennen Spalten/Relationen verbieten mit Model#smql_protected.
 			# Dieses muss ein Object mit #include?( name_als_string) zurueckliefern,
 			# welches true fuer verboten und false fuer, erlaubt steht.
 			def verify_allowed col
-				raise ProtectedColumnError.new( col)  if col.protected?
+				raise_if col.protected?, ProtectedColumnError.new( col)
 			end
 
 			# Erstelle alle noetigen Klauseln. builder nimmt diese entgegen,
@@ -196,31 +200,64 @@ class SmqlToAR
 				super( *pars)
 				cols = {}
 				@cols.each do |col|
-					col_model = SmqlToAR.model_of col.last_model, col.col
+					col_model = col.relation
-					#p col_model: col_model.to_s, value: @value
 					cols[col] = [col_model] + ConditionTypes.try_parse( col_model, @value)
 				end
 				@cols = cols
 			end
 
 			def verify_column col
-				refl = SmqlToAR.model_of col.last_model, col.col
+				raise_unless col.relation, NonExistingRelationError.new( %w[Relation], col)
-				#p refl: refl, model: @model.name, col: col, :reflections => @model.reflections.keys
-				raise NonExistingRelationError.new( %w[Relation], col)  unless refl
 			end
 
 			def build builder, table
 				@cols.each do |col, sub|
 					t = table + col.path + [col.col]
-					#p sub: sub
-					p col: col, joins: col.joins
 					col.joins.each {|j, m| builder.join table+j, m }
-					builder.join t, SmqlToAR.model_of( col.last_model, col.col)
+					builder.join t, sub[0]
-					sub[1..-1].each {|one| one.build builder, t }
+					sub[1..-1].each &it.build( builder, t)
 				end
 				self
 			end
 		end
+
+		# Takes to Queries.
+		# First Query will be a Subquery, second a regular query.
+		# Example:
+		#   Person.smql 'sub.articles:' => [{'limit:' => 1, 'order:': 'updated_at desc'}, {'content~' => 'some text'}]
+		# Person must have as last Article (compared by updated_at) owned by Person a Artive which has 'some text' in content.
+		# The last Article needn't to have 'some text' has content,  the subquery takes it anyway.
+		# But the second query compares to it and never to any other Article,  because these are filtered by first query.
+		# The difference to
+		#   Person.smql :articles => {'content~' => 'some text', 'limit:' => 1, 'order:': 'updated_at desc'}
+		# is,  second is not allowed (limit and order must be in root) and this means something like
+		#   "Person must have the Article owned by Person which has 'some text' in content.
+		#   limit and order has no function in this query and this article needn't to be the last."
+		class SubEqualJoin < EqualJoin
+			Operator = '()'
+			Expected = [lambda {|x| x.kind_of?( Array) and (1..2).include?( x.length) and x.all?( &it.kind_of?( Hash))}]
+
+			def initialize model, cols, val
+				super model, cols, val[1]
+				# sub: model, subquery, sub(condition)
+				@cols.each {|col, sub| sub[ 1...1] = SmqlToAR.new( col.relation, val[0]).parse }
+			end
+
+			def verify_column col
+				raise_unless col.child?, ConColumnError.new( [:Column], col)
+			end
+
+			def build builder, table
+				@cols.each do |col, sub|
+					t = table+col.to_a
+					p t: t, sub: sub
+					builder.sub_join t, col, *sub[0..1]
+					sub[2..-1].each &it.build( builder, t)
+				end
+				self
+			end
+		end
+
 		Equal = simple_condition Condition, '=', "%s = %s", [Array, String, Numeric]
 		Equal2 = simple_condition Equal, '', "%s = %s", [String, Numeric]
 		GreaterThan = simple_condition Condition, '>', "%s > %s", [Array, Numeric]
@@ -236,7 +273,7 @@ class SmqlToAR
 			Expected = [nil]
 
 			def verify_column col
-				raise NonExistingSelectableError.new( col)  unless col.exist_in? or SmqlToAR.model_of( col.last_model, col.col)
+				raise_unless col.exist_in? || SmqlToAR.model_of( col.last_model, col.col), NonExistingSelectableError.new( col)
 			end
 
 			def build builder, table
@@ -258,13 +295,14 @@ class SmqlToAR
 			Expected = [String, Array, Hash, Numeric, nil]
 
 			class Function
+				include SmqlToAR::Assertion
 				Name = nil
 				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? {|e| e === args }
+					self.new model, func, args  if self::Name === func and self::Expected.any?( &it === args)
 				end
 
 				def initialize model, func, args
@@ -277,22 +315,19 @@ class SmqlToAR
 				Expected = [String, Array, Hash, nil]
 
 				def initialize model, func, args
-					SmqlToAR.logger.info( {args: args}.inspect)
 					args = case args
 						when String then [args]
 						when Array, Hash then args.to_a
 						when nil then nil
 						else raise 'Oops'
 						end
-					SmqlToAR.logger.info( {args: args}.inspect)
 					args.andand.collect! do |o|
 						o = Array.wrap o
 						col = Column.new model, o.first
 						o = 'desc' == o.last.to_s.downcase ? :DESC : :ASC
-						raise NonExistingColumnError.new( [:Column], col)  unless col.exist_in?
+						raise_unless col.exist_in?, NonExistingColumnError.new( [:Column], col)
 						[col, o]
 					end
-					SmqlToAR.logger.info( {args: args}.inspect)
 					super model, func, args
 				end
 
@@ -302,12 +337,32 @@ class SmqlToAR
 						col, o = o
 						col.joins builder, table
 						t = table + col.path
-						raise OnlyOrderOnBaseError.new( t)  unless 1 == t.length
+						raise_unless 1 == t.length, RootOnlyFunctionError.new( t)
 						builder.order t, col.col, o
 					end
 				end
 			end
 
+			class Limit < Function
+				Name = :limit
+				Expected = [Fixnum]
+
+				def build builder, table
+					raise_unless 1 == table.length, RootOnlyFunctionError.new( table)
+					builder.limit @args
+				end
+			end
+
+			class Offset < Function
+				Name = :offset
+				Expected = [Fixnum]
+
+				def build builder, table
+					raise_unless 1 == table.length, RootOnlyFunctionError.new( table)
+					builder.offset @args
+				end
+			end
+
 			def self.new model, col, val
 				SmqlToAR.logger.info( { function: col.first.to_sym }.inspect)
 				r = nil
@@ -315,9 +370,7 @@ class SmqlToAR
 					next  if [:Function, :Where, :Expected, :Operator].include? c
 					c = const_get c
 					next  if Function === c or not c.respond_to?( :try_parse)
-					SmqlToAR.logger.info( {f: c}.inspect)
 					r = c.try_parse model, col.first.to_sym, val
-					SmqlToAR.logger.info( {r: r}.inspect)
 					break  if r
 				end
 				r

lib/smql_to_ar/query_builder.rb

@@ -22,23 +22,24 @@ class SmqlToAR
 		class Vid
 			attr_reader :vid
 			def initialize( vid)  @vid = vid  end
-			def to_s() ":c#{@vid}" end
+			def to_s() ":smql_c#{@vid}" end
-			def to_sym() "c#{@vid}".to_sym end
+			def to_sym() "smql_c#{@vid}".to_sym end
 			alias sym to_sym
 			def to_i()  @vid  end
 		end
 
-		attr_reader :table_alias, :model, :table_model, :base_table, :_where, :_select, :_wobs, :_joins
+		attr_reader :table_alias, :model, :table_model, :base_table, :_where, :_select, :_wobs, :_joins, :prefix, :_vid
 		attr_accessor :logger
 
-		def initialize model
+		def initialize model, prefix = nil, base_table
+			@prefix = "smql"
 			@logger = SmqlToAR.logger
 			@table_alias = Hash.new do |h, k|
 				k = Array.wrap k
-				h[k] = "smql,#{k.join(',')}"
+				h[k] = "#{@prefix},#{k.join(',')}"
 			end
 			@_vid, @_where, @_wobs, @model, @quoter = 0, [], {}, model, model.connection
-			@base_table = [model.table_name.to_sym]
+			@base_table = base_table.blank? ? [model.table_name.to_sym] : Array.wrap( base_table)
 			@table_alias[ @base_table] = @base_table.first
 			t = quote_table_name @table_alias[ @base_table]
 			@_select, @_joins, @_joined, @_includes, @_order = ["DISTINCT #{t}.*"], "", [], [], []
@@ -74,32 +75,57 @@ class SmqlToAR
 		end
 
 		def build_join orig, pretable, table, prekey, key
-			" JOIN #{quote_table_name orig.to_sym} AS #{quote_table_name table} ON #{column pretable, prekey} = #{column table, key} "
+			" JOIN #{orig} AS #{quote_table_name table} ON #{column pretable, prekey} = #{column table, key} "
 		end
 
-		def join table, model
+		def sub_join table, col, model, query
-			return self  if @_joined.include? table # Already joined
+			pp [:sub_join, table, col. model, query]
-			pretable = table[0...-1]
+			prefix, base_table = "#{@prefix}_sub", col.col
+			join_ table, model, "(#{query.build( prefix, base_table).tap{|q| p :sub_join => q }.ar.to_sql})"
+		end
+
+		def join_ table, model, query, pretable = nil
+			pp [:join_, table, model, query]
+			pretable ||= table[0...-1]
 			@table_model[ table] = model
 			premodel = @table_model[ pretable]
 			t = @table_alias[ table]
 			pt = quote_table_name @table_alias[ table[ 0...-1]]
+			pp premodel: premodel, table: table
 			refl = premodel.reflections[table.last]
-			case refl.macro
+			case refl
-			when :has_many
+			when ActiveRecord::Reflection::ThroughReflection
-				@_joins += build_join model.table_name, pretable, t, premodel.primary_key, refl.primary_key_name
+				through = refl.through_reflection
-			when :belongs_to
+				pp refl: refl
-				@_joins += build_join model.table_name, pretable, t, refl.primary_key_name, premodel.primary_key
+				throughtable = table[0...-1]+[through.name.to_sym]
-			when :has_and_belongs_to_many
+				srctable = throughtable+[refl.source_reflection.name]
-				jointable = [','] + table
+				@table_model[ srctable] = model
-				@_joins += build_join refl.options[:join_table], pretable, @table_alias[jointable], premodel.primary_key, refl.primary_key_name
+				@table_alias[ table] = @table_alias[ srctable]
-				@_joins += build_join model.table_name, jointable, t, refl.association_foreign_key, refl.association_primary_key
+				join_ throughtable, through.klass, quote_table_name( through.table_name)
-			else raise BuilderError, "Unkown reflection macro: #{refl.macro.inspect}"
+				join_ srctable, refl.klass, query, throughtable
+			when ActiveRecord::Reflection::AssociationReflection
+				case refl.macro
+				when :has_many
+					@_joins += build_join query, pretable, t, premodel.primary_key, refl.primary_key_name
+				when :belongs_to
+					@_joins += build_join query, pretable, t, refl.primary_key_name, premodel.primary_key
+				when :has_and_belongs_to_many
+					jointable = [','] + table
+					@_joins += build_join refl.options[:join_table], pretable, @table_alias[jointable], premodel.primary_key, refl.primary_key_name
+					@_joins += build_join query, jointable, t, refl.association_foreign_key, refl.association_primary_key
+				else raise BuilderError, "Unkown reflection macro: #{refl.macro.inspect}"
+				end
+			else raise BuilderError, "Unkown reflection type: #{refl.class.name}"
 			end
-			@_joined.push table
 			self
 		end
 
+		def join table, model
+			return self  if @_joined.include? table # Already joined
+			join_ table, model, quote_table_name( model.table_name)
+			@_joined.push table
+		end
+
 		def includes table
 			@_includes.push table
 			self
@@ -114,6 +140,14 @@ 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
@@ -138,6 +172,9 @@ class SmqlToAR
 				where( where_str, @_wobs).
 				order( @_order.join( ', ')).
 				includes( incls)
+			@model = @model.limit @_limit  if @_limit
+			@model = @model.offset @_offset  if @_offset
+			@model
 		end
 
 		def fix_calculate