Class: TdModel::Base

Inherits:
Object
  • Object
show all
Includes:
Sql
Defined in:
lib/td_model/base.rb

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Sql

query

Constructor Details

#initialize(args = nil) ⇒ Base

Returns a new instance of Base.



10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
# File 'lib/td_model/base.rb', line 10

def initialize(args=nil)
  self.class.set_column(:time) unless self.class.attr_types.keys.include?(:time)
  @attr_values = self.class.attr_default_values.clone
  @select_keys = []
  @attr_values.keys.each do |col|
    proc = Proc.new { @attr_values[col] }
    set_proc = Proc.new { |val| @attr_values.store(col, val) }

    self.class_eval { define_method(col, proc) }
    self.class_eval { define_method("#{col}=", set_proc) }
  end

  unless args.nil?
    args.each do |key, val|
      @attr_values.store(key, val)
    end
  end
end

Instance Attribute Details

#attr_values ⇒ Object

Returns the value of attribute attr_values.



8
9
10
 
# File 'lib/td_model/base.rb', line 8

def attr_values
  @attr_values
end

#limit_sql ⇒ Object

Returns the value of attribute limit_sql.



8
9
10
 
# File 'lib/td_model/base.rb', line 8

def limit_sql
  @limit_sql
end

#order_sql ⇒ Object

Returns the value of attribute order_sql.



8
9
10
 
# File 'lib/td_model/base.rb', line 8

def order_sql
  @order_sql
end

#select_keys ⇒ Object

Returns the value of attribute select_keys.



8
9
10
 
# File 'lib/td_model/base.rb', line 8

def select_keys
  @select_keys
end

#select_sql ⇒ Object

Returns the value of attribute select_sql.



8
9
10
 
# File 'lib/td_model/base.rb', line 8

def select_sql
  @select_sql
end

#sql ⇒ Object

Returns the value of attribute sql.



8
9
10
 
# File 'lib/td_model/base.rb', line 8

def sql
  @sql
end

#table_name ⇒ Object

Returns the value of attribute table_name.



8
9
10
 
# File 'lib/td_model/base.rb', line 8

def table_name
  @table_name
end

#where_sql ⇒ Object

Returns the value of attribute where_sql.



8
9
10
 
# File 'lib/td_model/base.rb', line 8

def where_sql
  @where_sql
end

Class Method Details

.attr_default_values ⇒ Object 



33
34
35
 
# File 'lib/td_model/base.rb', line 33

def self.attr_default_values
  {}
end

.attr_types ⇒ Object 



29
30
31
 
# File 'lib/td_model/base.rb', line 29

def self.attr_types
  {}
end

.create(args) ⇒ Object 



70
71
72
73
74
75
 
# File 'lib/td_model/base.rb', line 70

def self.create(args)
  res = self.new(args)
  res.valid!(args)
  TD.event.post(self.table_name, args)
  res
end

.init_type_value(obj) ⇒ Object 



86
87
88
89
90
91
92
93
 
# File 'lib/td_model/base.rb', line 86

def self.init_type_value(obj)
  case obj.to_s
    when "Integer"
      0
    else
      nil
  end
end

.limit(num = nil) ⇒ Object 



162
163
164
 
# File 'lib/td_model/base.rb', line 162

def self.limit(num=nil)
  self.new.limit(num)
end

.order(col, sort = nil) ⇒ Object 



130
131
132
 
# File 'lib/td_model/base.rb', line 130

def self.order(col, sort=nil)
  self.new.order(col, sort)
end

.query_execute ⇒ Object 



173
174
175
 
# File 'lib/td_model/base.rb', line 173

def self.query_execute
  self.new.query_execute
end

.reverse_order(col) ⇒ Object 



154
155
156
 
# File 'lib/td_model/base.rb', line 154

def self.reverse_order(col)
  self.new.reverse_order(col)
end

.select(args) ⇒ Object 



204
205
206
 
# File 'lib/td_model/base.rb', line 204

def self.select(args)
  self.new.select(args)
end

.set_column(name, type = nil) ⇒ Object 



37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/td_model/base.rb', line 37

def self.set_column(name, type=nil)
  attr_types = self.attr_types
  attr_types.store(name, type)
  self.define_singleton_method :attr_types do
    attr_types
  end

  attr_default_values = self.attr_default_values
  attr_default_values.store(name, self.init_type_value(type))
  self.define_singleton_method :attr_default_values do
    attr_default_values
  end
end

.table_name ⇒ Object 



57
58
59
 
# File 'lib/td_model/base.rb', line 57

def self.table_name
  self.to_s.underscore
end

.table_name=(name) ⇒ Object 



51
52
53
54
55
 
# File 'lib/td_model/base.rb', line 51

def self.table_name=(name)
  self.define_singleton_method :table_name do
    name
  end
end

.where(obj) ⇒ Object 



95
96
97
 
# File 'lib/td_model/base.rb', line 95

def self.where(obj)
  self.new.where(obj)
end

Instance Method Details

#create ⇒ Object 



65
66
67
68
 
# File 'lib/td_model/base.rb', line 65

def create
  self.valid!(@attr_values)
  TD.event.post(self.table_name, @attr_values)
end

#limit(num = nil) ⇒ Object 



166
167
168
169
170
171
 
# File 'lib/td_model/base.rb', line 166

def limit(num=nil)
  if num.present?
    @limit_sql = "LIMIT #{num}"
  end
  self
end

#order(col, sort = nil) ⇒ Object 



134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
 
# File 'lib/td_model/base.rb', line 134

def order(col, sort=nil)
  if col.instance_of?(Array)
    col.each do |column|
      self.order(column, sort)
    end
  end

  if col.instance_of?(String) || col.instance_of?(Symbol)
    if @order_sql.blank?
      @order_sql = "ORDER BY #{self.table_name}.#{col} #{sort}"
    else
      @order_sql += " ,#{self.table_name}.#{col}"
    end
  else
    raise "ERROR"
  end

  self
end

#query_execute ⇒ Object 



177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
 
# File 'lib/td_model/base.rb', line 177

def query_execute
  if @select_sql.blank?
    @select_keys = []
    self.class.attr_types.keys.each do |key|
      if @select_sql.blank?
        @select_sql = ''
        @select_sql += "SELECT #{self.table_name}.#{key}"
      else
        @select_sql += " ,#{self.table_name}.#{key}"
      end
      @select_keys << key
    end
  end
  @sql = "#{@select_sql} FROM #{self.table_name} #{@where_sql} #{@order_sql} #{@limit_sql}"
  res = ::TdModel::Sql.query(@sql)

  result = []
  res.each do |td_response|
    result_val = {}
    @select_keys.each_with_index do |key, ix|
      result_val.store(key, td_response[ix])
    end
    result << self.class.new(result_val)
  end
  result
end

#reverse_order(col) ⇒ Object 



158
159
160
 
# File 'lib/td_model/base.rb', line 158

def reverse_order(col)
  self.order(col, 'DESC')
end

#select(args) ⇒ Object 



208
209
210
211
212
213
214
215
216
217
218
219
220
 
# File 'lib/td_model/base.rb', line 208

def select(args)
  @select_sql = ''
  @select_keys = []
  [args].flatten.each do |col|
    if @select_sql.blank?
      @select_sql += "SELECT #{self.table_name}.#{col}"
    else
      @select_sql += " ,#{self.table_name}.#{col}"
    end
    @select_keys << key
  end
  self
end

#valid!(args) ⇒ Object 



77
78
79
80
81
82
83
84
 
# File 'lib/td_model/base.rb', line 77

def valid!(args)
  self.class.attr_types.each do |key, val|
    next if val.nil?
    unless args[key].kind_of?(val)
      raise ::TdModel::Errors::FailedToTypeValidationOfColumnError
    end
  end
end

#where(obj) ⇒ Object 



99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
 
# File 'lib/td_model/base.rb', line 99

def where(obj)
  if obj.instance_of?(Hash)
    obj.each do |key, val|
      if @where_sql.present?
        where = "AND"
      else
        @where_sql = ''
        where = "WHERE"
      end

      if obj.instance_of?(Array)
        @where_sql += " #{where} #{self.table_name}.#{key} IN [#{val.join(',')}]"
      else
        @where_sql += " #{where} #{self.table_name}.#{key} = #{val}"
      end
    end
  elsif obj.instance_of?(String)
    if @where_sql.present?
      where = "AND"
    else
      @where_sql = ''
      where = "WHERE"
    end
    @where_sql += " #{where} #{obj}"
  else
    raise "Error"
  end
  self
end