smql/lib/smql_to_ar.rb

214 lines
5.2 KiB
Ruby
Raw Normal View History

2011-09-08 17:03:52 +02:00
# SmqlToAR - Base library: 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
include ActiveSupport::Benchmarkable
############################################################################r
# Exceptions
class SMQLError < Exception
attr_reader :data
def initialize data
@data = data
super data.inspect
end
end
# Ein Fehler ist in einem Subquery aufgetreten.
# Die eigentliche Exception wird in @data[:exception] hinterlegt.
class SubSMQLError < SMQLError
def initialize query, model, exception
ex = {:class => exception.class, :message => exception.message}
ex[:data] = exception.data if exception.respond_to? :data
super :query => query, :model => model.to_s, :exception => ex
set_backtrace exception.backtrace
end
end
class ParseError < SMQLError; end
# Malformed ColOp
class UnexpectedColOpError < ParseError
def initialize model, colop, val
super :got => colop, :val => val, :model => model.to_s
end
end
class UnexpectedError < ParseError
def initialize model, colop, val
super :got => {colop => val}, :model => model.to_s
end
end
class NonExistingSelectableError < SMQLError
def initialize got
super :got => got
end
end
class NonExistingColumnError < SMQLError
def initialize expected, got
super :expected => expected, :got => got
end
end
class NonExistingRelationError < SMQLError
def initialize expected, got
super :expected => expected, :got => got
end
end
class ProtectedColumnError < SMQLError
def initialize protected_column
super :protected_column => protected_column
end
end
class OnlyOrderOnBaseError < SMQLError
def initialize path
super :path => path
end
end
class BuilderError < Exception; end
#############################################################################
# Model der Relation `rel` von `model`
def self.model_of model, rel
model.reflections[ rel.to_sym].andand.klass
end
# Eine Spalte in einer Tabelle, relativ zu `Column#model`.
# Kann auch einen Pfad `Column#path` haben, wobei `Column#col` dann
# eine Relation von dem Model der letzten Relation von `Column#path` ist.
class Column
include Enumerable
attr_reader :path, :col
attr_accessor :model
def initialize model, *col
@model = model
@last_model = nil
*@path, @col = Array.wrap( col).collect {|s| s.to_s.split /[.\/]/ }.flatten.collect &:to_sym
end
def last_model
@last_model ||= each{}
end
def each
model = @model
@path.each do |rel|
model = SmqlToAR.model_of model, rel
return false unless model
yield rel, model
end
model
end
def exist_in?
model = last_model
return false unless model
model.column_names.include? @col.to_s
end
def protected?
model = @model
each do |rel, _model|
pr = Array.wrap model.respond_to?( :smql_protected) ? model.smql_protected : nil
pr.include? rel.to_s
model = _model
end
pr = Array.wrap model.respond_to?( :smql_protected) ? model.smql_protected : nil
pr.include? @col.to_s
end
def joins builder = nil, table = nil, &exe
pp = []
table = Array.wrap table
exe ||= builder ? lambda {|j, m| builder.join table+j, m} : Array.method( :[])
collect do |rel, model|
pp.push rel
exe.call pp, model
end
end
def to_a() @path+[@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 allowed?() ! self.protected? end
end
attr_reader :model, :query, :conditions, :builder, :order
attr_accessor :logger
@@logger = if Object.const_defined?( :Rails)
Rails.logger
else
require 'logger'
Logger.new $stdout
end
class <<self
def logger=(logger) @@logger = logger end
def logger() @@logger end
end
def initialize model, query, order = nil
query = JSON.parse query if query.kind_of? String
@model, @query, @logger, @order = model, query, @@logger, order
#p model: @model, query: @query
end
def parse
benchmark 'SMQL parse' do
@conditions = ConditionTypes.try_parse @model, @query
end
#p conditions: @conditions
self
end
def build
benchmark 'SMQL build query' do
@builder = QueryBuilder.new @model
table = @builder.base_table
@conditions.each {|condition| condition.build builder, table }
end
#p builder: @builder
self
end
def ar
@ar ||= benchmark 'SMQL ar' do
@builder.to_ar
end
end
def to_ar
benchmark 'SMQL' do
parse
build
ar.tap {|ar| logger.info ar.to_sql }
end
end
def self.to_ar *params
new( *params).to_ar
end
end