smql 0.0.0

data/README.md

@@ -0,0 +1,27 @@
+Idea
+====
+
+Similar to MQL:  SMQL allowes SQL-queries on your database but in a JSON-based language.
+
+This query language is SQL-injection-safe.
+Only expencive queries can slow down your machine.
+
+Usage
+=====
+
+Easy query in ruby:
+User is a AR-Model and has a column username.
+We want to find all users which has the username "auser".
+
+	require 'smql'
+
+	SmqlToAR.to_ar User, '{"username": "auser"}' # Query in JSON
+	SmqlToAR.to_ar User, username: "auser"       # Query in Ruby
+
+In Rails:
+
+	SmqlToAR.to_ar User, params[:smql]
+
+Don't forget to add gem to Gemfile:
+
+	gem 'smql'

data/TODO

@@ -0,0 +1 @@
+1) gem-plugin

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/lib/smql.rb

@@ -0,0 +1,7 @@
+require 'active_support/benchmarkable'
+require 'active_support/core_ext/array.rb'
+require 'active_record'
+require 'json'
+require 'smql_to_ar'
+require 'smql_to_ar/condition_types'
+require 'smql_to_ar/query_builder'

data/lib/smql_to_ar/condition_types.rb

@@ -0,0 +1,327 @@
+# SmqlToAR - Parser: Converts SMQL to ActiveRecord
+# Copyright (C) 2011 Denis Knauf
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+class SmqlToAR
+	#############################################################################
+	# Alle Subklassen (qualitativ: ConditionTypes::*), die als Superklasse Condition haben,
+	#  stellen eine Regel dar,  unter diesen sie das gesuchte Objekt annehmen.
+	# Nimmt eine solche Klasse ein Object nicht an,  so wird die naechste Klasse ausprobiert.
+	# Es wird in der Reihenfolge abgesucht,  in der #constants die Klassen liefert,
+	#  wobei angenommen wird,  dass diese nach dem Erstellungszeitpunkt sortiert sind,
+	#  aeltere zuerst.
+	# Nimmt eine Klasse ein Objekt an,  so soll diese Klasse instanziert werden.
+	# Alles weitere siehe Condition.
+	module ConditionTypes
+		class <<self
+			# Ex: 'givenname|surname|nick' => [:givenname, :surname, :nick]
+			def split_keys k
+				k.split( '|').collect &:to_sym
+			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
+					raise UnexpectedColOpError.new( model, colop, val)  unless colop =~ /^(?:\d*:)?(.*?)(\W*)$/
+					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
+				r
+			end
+
+			# Alle Regeln parsen.  Die Regeln sind in einem Hash der Form {colop => val}
+			# Ex: Person, {"givenname=", "Peter", "surname=", "Mueller"}
+			def try_parse model, colopvals
+				colopvals.collect do |colop, val|
+					#p :try_parse => { colop: colop, val: val, model: model }
+					try_parse_it model, colop, val
+				end
+			rescue SMQLError => e
+				raise SubSMQLError.new( colopvals, model, e)
+			end
+
+			# Erstellt eine Condition fuer eine Regel.
+			def simple_condition superclass, op = nil, where = nil, expected = nil
+				cl = Class.new superclass
+				cl.const_set :Operator, op  if op
+				cl.const_set :Where, where  if where
+				cl.const_set :Expected, expected  if expected
+				cl
+			end
+		end
+
+		class Condition
+			attr_reader :value, :cols
+			Operator = nil
+			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? {|i| i === val }
+			end
+
+			def initialize model, cols, val
+				@model, @cols = model, cols
+				@value = case val
+					when Hash, Range then val
+					else Array.wrap val
+					end
+				verify
+			end
+
+			def verify
+				@cols.each do |col|
+					verify_column col
+					verify_allowed col
+				end
+			end
+
+			# 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?
+			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?
+			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.
+			# Ex:
+			# 1) {"givenname=", "Peter"} #=> givenname = 'Peter'
+			# 2) {"givenname=", ["Peter", "Hans"]} #=> ( givenname = 'Peter' OR givenname = 'Hans' )
+			# 3) {"givenname|surname=", ["Peter", "Mueller"]}
+			#       #=> ( givenname = 'Peter' OR surname = 'Peter' ) AND ( givenname = 'Mueller' OR surname = 'Mueller' )
+			def build builder, table
+				values = Hash[ @value.collect {|value| [ builder.vid, value ] } ]
+				values.each {|k, v| builder.wobs k.sym => v }
+				if 1 == @cols.length
+					@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 ] }
+					end
+				else
+					values.keys.each do |vid|
+						builder.where *@cols.collect {|col|
+								col.joins builder, table
+								col = builder.column table+col.path, col.col
+								self.class::Where % [ col, vid.to_s ]
+							}
+					end
+				end
+				self
+			end
+		end
+
+		class NotInRange < Condition
+			Operator = '!..'
+			Where = "%s NOT BETWEEN %s AND %s"
+			Expected = [Range, lambda {|val| Array === val && 2 == val.length } ]
+
+			def initialze model, cols, val
+				if Array === val && 2 == val.length
+					f, l = val
+					f, l = Time.parse(f), Time.parse(l)  if f.kind_of? String
+					val = f..l
+				end
+				super model, cols, val
+			end
+
+			def build builder, table
+				builder.wobs (v1 = builder.vid) => @value.begin, (v2 = builder.vid) => @value.end
+				@cols.each do |col|
+					col.joins builder, table
+					builder.where self.class::Where % [ builder.column( table+col.path, col.col), v1, v2]
+				end
+				self
+			end
+		end
+		InRange = simple_condition NotInRange, '..', "%s BETWEEN %s AND %s"
+
+		class NotIn < Condition
+			Operator = '!|='
+			Where = "%s NOT IN (%s)"
+			Expected = [Array]
+
+			def build builder, table
+				builder.wobs (v = builder.vid).to_sym => @value
+				@cols.each do |col|
+					col.joins builder, table
+					builder.where self.class::Where % [ builder.column( table, col), v.to_s]
+				end
+				self
+			end
+		end
+
+		In = simple_condition NotIn, '|=', '%s IN (%s)', [Array]
+		In2 = simple_condition In, '', nil, [Array]
+		NotEqual = simple_condition Condition, /\!=|<>/, "%s <> %s", [Array, String, Numeric]
+		GreaterThanOrEqual = simple_condition Condition, '>=', "%s >= %s", [Array, Numeric]
+		LesserThanOrEqual = simple_condition Condition, '<=', "%s <= %s", [Array, Numeric]
+		class EqualJoin <Condition
+			Operator = '='
+			Expected = [Hash]
+
+			def initialize *pars
+				super( *pars)
+				cols = {}
+				@cols.each do |col|
+					col_model = SmqlToAR.model_of col.last_model, col.col
+					#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
+				#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)
+					sub[1..-1].each {|one| one.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]
+		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]
+
+		####### No Operator #######
+		Join = simple_condition EqualJoin, '', nil, [Hash]
+		InRange2 = simple_condition InRange, '', nil, [Range]
+		class Select < Condition
+			Operator = ''
+			Expected = [nil]
+
+			def verify_column col
+				raise NonExistingSelectableError.new( col)  unless col.exist_in? or SmqlToAR.model_of( col.last_model, col.col)
+			end
+
+			def build builder, table
+				@cols.each do |col|
+					if col.exist_in?
+						col.joins builder, table
+						builder.select table+col.to_a
+					else
+						col.joins {|j, m| builder.includes table+j }
+						builder.includes table+col.to_a
+					end
+				end
+				self
+			end
+		end
+
+		class Functions < Condition
+			Operator = ':'
+			Expected = [String, Array, Hash, Numeric, nil]
+
+			class Function
+				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 }
+				end
+
+				def initialize model, func, args
+					@model, @func, @args = model, func, args
+				end
+			end
+
+			class Order < Function
+				Name = :order
+				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?
+						[col, o]
+					end
+					SmqlToAR.logger.info( {args: args}.inspect)
+					super model, func, args
+				end
+
+				def build builder, table
+					return  if @args.blank?
+					@args.each do |o|
+						col, o = o
+						col.joins builder, table
+						t = table + col.path
+						raise OnlyOrderOnBaseError.new( t)  unless 1 == t.length
+						builder.order t, col.col, o
+					end
+				end
+			end
+
+			def self.new model, col, val
+				SmqlToAR.logger.info( { function: col.first.to_sym }.inspect)
+				r = nil
+				constants.each do |c|
+					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
+			end
+		end
+	end
+end

data/lib/smql_to_ar/query_builder.rb

@@ -0,0 +1,160 @@
+# SmqlToAR - Builds AR-querys: Converts SMQL to ActiveRecord
+# Copyright (C) 2011 Denis Knauf
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+class SmqlToAR
+	#######################################################################################
+	# Baut die Queries zusammen.
+	class QueryBuilder
+		# Erzeugt einen eindeutigen Identikator "cX", wobei X iteriert wird.
+		class Vid
+			attr_reader :vid
+			def initialize( vid)  @vid = vid  end
+			def to_s() ":c#{@vid}" end
+			def to_sym() "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_accessor :logger
+		@@logger = SmqlToAR.logger
+
+		def initialize model
+			@logger = @@logger
+			@table_alias = Hash.new do |h, k|
+				k = Array.wrap k
+				h[k] = "smql,#{k.join(',')}"
+			end
+			@_vid, @_where, @_wobs, @model, @quoter = 0, [], {}, 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}.*"], "", [], [], []
+			@table_model = {@base_table => @model}
+		end
+
+		def vid()  Vid.new( @_vid+=1)  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')
+		#        #=> 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
+			@_where.push cond
+			self
+		end
+
+		def wobs vals
+			@_wobs.update vals
+			self
+		end
+
+		def quote_column_name name
+			@quoter.quote_column_name( name).gsub /"\."/, ','
+		end
+
+		def quote_table_name name
+			@quoter.quote_table_name( name).gsub /"\."/, ','
+		end
+
+		def column table, name
+			"#{quote_table_name table.kind_of?(String) ? table : @table_alias[table]}.#{quote_column_name name}"
+		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} "
+		end
+
+		def join table, model
+			return self  if @_joined.include? table # Already joined
+			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]]
+			refl = premodel.reflections[table.last]
+			case refl.macro
+			when :has_many
+				@_joins += build_join model.table_name, pretable, t, premodel.primary_key, refl.primary_key_name
+			when :belongs_to
+				@_joins += build_join model.table_name, 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 model.table_name, jointable, t, refl.association_foreign_key, refl.association_primary_key
+			else raise BuilderError, "Unkown reflection macro: #{refl.macro.inspect}"
+			end
+			@_joined.push table
+			self
+		end
+
+		def includes table
+			@_includes.push table
+			self
+		end
+
+		def select col
+			@_select.push quote_column_name( @table_alias[col])
+			self
+		end
+
+		def order table, col, o
+			@_order.push "#{column table, col} #{:DESC == o ? :DESC : :ASC}"
+		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 '
+			incls = {}
+			@_includes.each do |inc|
+				b = incls
+				inc[1..-1].collect {|rel| b = b[rel] ||= {} }
+			end
+			@logger.debug incls: incls, joins: @_joins
+			@model = @model.
+				select( @_select.join( ', ')).
+				joins( @_joins).
+				where( where_str, @_wobs).
+				order( @_order.join( ', ')).
+				includes( incls)
+		end
+
+		def fix_calculate
+			def @model.calculate operation, column_name, options = nil
+				options = options.try(:dup) || {}
+				options[:distinct] = true  unless options.except(:distinct).present?
+				column_name = klass.primary_key  unless column_name.present?
+				super operation, column_name, options
+			end
+			self
+		end
+
+		def to_ar
+			build_ar
+			fix_calculate
+			@model
+		end
+	end
+end