Class: QRuby::Builder

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

Constant Summary collapse

@@escape_character = 
"\\"

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Builder

Returns a new instance of Builder.



7
8
9
10
11
 
# File 'lib/qruby.rb', line 7

def initialize
  @select = "*"
  @table, @join, @where, @group_by, @having, @order_by, @limit, @last_query = "", "", "", "", "", "", "", ""
  @operators = ["=", "!=", "<", ">", "<=", ">=", "<>"]
end

Class Method Details

.escape_character=(character) ⇒ Object 



203
204
205
 
# File 'lib/qruby.rb', line 203

def self.escape_character=(character)
  @@escape_character = character
end

Instance Method Details

#alter(command, column, data_type = "") ⇒ Object 



180
181
182
183
184
 
# File 'lib/qruby.rb', line 180

def alter(command, column, data_type = "")
  query = "ALTER TABLE #{@table} #{command.gsub('_', ' ').upcase} #{column}"
  query += " #{data_type}" if !data_type.empty?
  end_query query
end

#between(field, value1, value2, type = "", and_or = "AND") ⇒ Object 



77
78
79
80
 
# File 'lib/qruby.rb', line 77

def between(field, value1, value2, type = "", and_or = "AND")
  @where += @where.empty? ? "#{field} #{type}BETWEEN #{escape(value1)} AND #{escape(value2)}" : " #{and_or} #{field} #{type}BETWEEN #{escape(value1)} AND #{escape(value2)}"
  self
end

#delete ⇒ Object 



166
167
168
169
170
171
172
173
 
# File 'lib/qruby.rb', line 166

def delete
  query = "DELETE FROM #{@table}"
  query += " WHERE #{@where}" if !@where.empty?
  query += " ORDER BY #{@order_by}" if !@order_by.empty?
  query += " LIMIT #{@limit}" if !@limit.to_s.empty?
  query = "TRUNCATE TABLE #{@table}" if query == "DELETE FROM #{@table}"
  end_query query
end

#drop(check_exists = false) ⇒ Object 



175
176
177
178
 
# File 'lib/qruby.rb', line 175

def drop(check_exists = false)
  query = "DROP TABLE#{check_exists ? " IF EXISTS" : ""} #{@table}"
  end_query query
end

#get ⇒ Object 



130
131
132
133
 
# File 'lib/qruby.rb', line 130

def get
  @limit = 1
  get_all
end

#get_all ⇒ Object 



135
136
137
138
139
140
141
142
143
144
 
# File 'lib/qruby.rb', line 135

def get_all
  query = "SELECT #{@select} FROM #{@table}"
  query += "#{@join}" if !@join.empty?
  query += " WHERE #{@where}" if !@where.empty?
  query += " GROUP BY #{@group_by}" if !@group_by.empty?
  query += " HAVING #{@having}" if !@having.empty?
  query += " ORDER BY #{@order_by}" if !@order_by.empty?
  query += " LIMIT #{@limit}" if !@limit.to_s.empty?
  end_query query
end

#group_by(field) ⇒ Object 



114
115
116
117
 
# File 'lib/qruby.rb', line 114

def group_by(field)
  @group_by = field.is_a?(Array) ? field.join(", ") : field
  self
end

#having(field, operator, val = nil) ⇒ Object 



119
120
121
122
123
124
125
126
127
128
 
# File 'lib/qruby.rb', line 119

def having(field, operator, val = nil)
  if operator.is_a?(Array)
    query = ""
    field.split("?").map.with_index { |val, i| query += i < operator.size ? "#{val}#{escape(operator[i])}" : "#{val}" }
    @having = query
  else
    @having = @operators.include?(operator.to_s) ? "#{field} #{operator} #{escape(val)}" : "#{field} > #{escape(operator)}"
  end
  self
end

#in(field, values, type = "", and_or = "AND") ⇒ Object 



64
65
66
67
68
69
 
# File 'lib/qruby.rb', line 64

def in(field, values, type = "", and_or = "AND")
  keys = [] 
  values.each { |val| keys << "#{escape(val)}" }
  @where += @where.empty? ? "#{field} #{type}IN (#{keys.join(", ")})" : " #{and_or} #{field} #{type}IN (#{keys.join(", ")})"
  self
end

#insert(datas) ⇒ Object 



146
147
148
149
150
151
152
 
# File 'lib/qruby.rb', line 146

def insert(datas)
  fields = datas.keys
  values = [] 
  datas.values.each { |val| values << "#{escape(val)}" }
  query = "INSERT INTO #{@table} (#{fields.join(", ")}) VALUES (#{values.join(", ")})"
  end_query query
end

#join(table, field1, field2 = nil, type = "") ⇒ Object 



33
34
35
36
 
# File 'lib/qruby.rb', line 33

def join(table, field1, field2 = nil, type = "")
  @join += field2.nil? ? " #{type}JOIN #{table} ON #{field1}" : " #{type}JOIN #{table} ON #{field1} = #{field2}"
  self
end

#last_query ⇒ Object 



199
200
201
 
# File 'lib/qruby.rb', line 199

def last_query
  @last_query
end

#like(field, value, type = "", and_or = "AND") ⇒ Object 



88
89
90
91
 
# File 'lib/qruby.rb', line 88

def like(field, value, type = "", and_or = "AND")
  @where += @where.empty? ? "#{field} #{type}LIKE #{escape(value)}" : " #{and_or} #{field} #{type}LIKE #{escape(value)}"
  self
end

#limit(limit, limit_end = nil) ⇒ Object 



99
100
101
102
 
# File 'lib/qruby.rb', line 99

def limit(limit, limit_end = nil)
  @limit = !limit_end.nil? ? "#{limit}, #{limit_end}" : "#{limit}"
  self
end

#order_by(field, dir = nil) ⇒ Object 



104
105
106
107
108
109
110
111
112
 
# File 'lib/qruby.rb', line 104

def order_by(field, dir = nil)
  if !dir.nil?
    order_by = "#{field} #{dir.upcase}"
  else
    order_by = (field.include?(" ") || field == "rand()") ? field : "#{field} ASC"
  end
  @order_by += @order_by.empty? ? order_by : ", #{order_by}"
  self
end

#query(sql, params) ⇒ Object 



186
187
188
189
190
 
# File 'lib/qruby.rb', line 186

def query(sql, params)
  query = ""
  sql.split("?").map.with_index { |val, i| query += i < params.size ? "#{val}#{escape(params[i])}" : "#{val}" }
  end_query query
end

#select(fields) ⇒ Object 



18
19
20
21
22
 
# File 'lib/qruby.rb', line 18

def select(fields)
  value = fields.is_a?(Array) ? fields.join(", ") : fields.to_s
  @select = (@select<=>"*").eql?(0) ? value : "#{@select}, #{value}"
  self
end

#table(name) ⇒ Object 



13
14
15
16
 
# File 'lib/qruby.rb', line 13

def table(name)
  @table = name.is_a?(Array) ? name.join(", ") : name.to_s
  self
end

#update(datas) ⇒ Object 



154
155
156
157
158
159
160
161
162
163
164
 
# File 'lib/qruby.rb', line 154

def update(datas)
  query = "UPDATE #{@table} SET"
  fields = datas.keys
  values = [] 
  datas.values.map.with_index { |val, i| values << "#{fields[i]} = #{escape(val)}" }
  query += " #{values.join(", ")}"
  query += " WHERE #{@where}" if !@where.empty?
  query += " ORDER BY #{@order_by}" if !@order_by.empty?
  query += " LIMIT #{@limit}" if !@limit.to_s.empty?
  end_query query
end

#where(field, operator, val = nil, type = "", and_or = "AND") ⇒ Object 



44
45
46
47
48
49
50
51
52
53
54
55
56
 
# File 'lib/qruby.rb', line 44

def where(field, operator, val = nil, type = "", and_or = "AND")
  if operator.is_a?(Array)
    query = ""
    field.split("?").map.with_index { |val, i| query += i < operator.size ? "#{type}#{val}#{escape(operator[i])}" : "#{val}" }
    where = query
  elsif @operators.include?(operator.to_s)
    where = "#{type}#{field} #{operator} #{escape(val)}"
  else
    where = "#{type}#{field} = #{escape(operator)}"
  end
  @where += @where.empty? ? where : " #{and_or} #{where}"
  self
end