Class: UserQuery::Schema

Inherits:
Object
  • Object
show all
Defined in:
lib/user_query/schema.rb

Constant Summary collapse

@@empty_hash = 
{ }

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(*opts) ⇒ Schema

Returns a new instance of Schema.



19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
# File 'lib/user_query/schema.rb', line 19

def initialize(*opts)
  @opt = Hash[*opts]

  @verbose = @opt[:verbose]

  @field_by_name = { }
  @field = [ ]

  field = @opt[:field]
  field = [ field ] unless field.kind_of?(Array)
  field.each{|x| add_field(x)}

  # Interpret ActiveRecord::Base subclass
  cls = @opt[:table]
  if is_active_record?(cls)
    columns = cls.columns
    table_name = cls.table_name;
    columns.each do |col|
      field = {
        :table => table_name,
        :name => col.name,
        :type => col.type,
      }
      field = add_field(field)
      # $stderr.puts "AR::Base column #{col.inspect} =>\n  #{field.inspect}"
    end
  end

end

Instance Attribute Details

#verbose ⇒ Object

Returns the value of attribute verbose.



17
18
19
 
# File 'lib/user_query/schema.rb', line 17

def verbose
  @verbose
end

Instance Method Details

#is_active_record?(cls) ⇒ Boolean

Returns:

  • (Boolean) 


49
50
51
52
53
54
55
56
57
58
 
# File 'lib/user_query/schema.rb', line 49

def is_active_record?(cls)
  return false unless cls.kind_of?(Class)
  while cls
    if cls == @@active_record_base
      return true;
    end
    cls = cls.superclass
  end
  false
end

#sql(parameters, record = nil) ⇒ Object 



106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
 
# File 'lib/user_query/schema.rb', line 106

def sql(parameters, record = nil)
  record ||= parameters if parameters.respond_to?(:errors)
  

  sql = @field.map do |field| 
    f_sql = nil
    begin
      name = field[:name]
      type = field[:type]

      verbose = field[:verbose] || @verbose

      target = sql_expr(field)

      parameter = parameters.kind_of?(Hash) ?
      parameters[name] :
        parameters.send(name)
      
      query_expr = UserQuery::Parser.
        new(:type => type, 
            :verbose => verbose).
        parse(parameter)
      
      f_sql = UserQuery::Generator.
        new(:type => type,
            :target => target,
            :verbose => verbose).
        sql(query_expr)
      
      if verbose 
        $stderr.puts "name   = #{name.inspect}"
        $stderr.puts "target = #{target.inspect}"
        $stderr.puts "type   = #{type.inspect}"
        $stderr.puts "query  = #{parameter.inspect}"
        $stderr.puts "sql    = #{f_sql.inspect}"
      end
      
    rescue UserQuery::Parser::SyntaxError => err
      record.errors.add(name, err.to_s) if record
      $stderr.puts "\n#{self.class.name}: Error: #{err}" if verbose
      f_sql = nil
    end
    
    f_sql
  end.compact.join(' AND ')

  sql = nil if sql.empty?

  sql
end