Class: Hoaxdb::Table

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

Instance Method Summary collapse

Constructor Details

#initialize(name, args) ⇒ Table

Returns a new instance of Table.



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/hoaxdb/table.rb', line 33

def initialize(name,args)
    @name = name
    @base = {}
    if !args.class.eql? Hash
        raise "Incorrect base for your database"
    else
        args.each{|k,v|
            if self.valid_type(v["type"])
                self.validate(v)
                @base.store(k,v)
            else
                raise "Invalid data type #{v}"
            end    
        }
    end
    @data = []
end

Instance Method Details

#add_column(col, type) ⇒ Object 



160
161
162
163
164
165
166
167
168
169
170
171
 
# File 'lib/hoaxdb/table.rb', line 160

def add_column(col,type)
    if @base.has_key? col
        raise "Column #{col} already exists"
    end
    if valid_type(type['type'])
        self.validate(type)
        @base.store(col,type)
        @data.each do |row|
            row.store(col,@base[col]['default'])
        end
    end    
end

#alter_default(col, default) ⇒ Object 



153
154
155
156
157
158
159
 
# File 'lib/hoaxdb/table.rb', line 153

def alter_default(col,default)
    if default.class.eql? eval(@base[col]['type'])
        @base[col]['default'] = default
    else
        raise "#{default} is not of data type #{@base[col]['type']}"
    end    
end

#avg(k) ⇒ Object 



245
246
247
248
249
250
251
252
253
 
# File 'lib/hoaxdb/table.rb', line 245

def avg(k)
    if @base[k]['type'].eql? 'Integer' or @base[k]['type'].eql? 'Float'
        sum = 0
        @data.each{|row| sum += row[k]}
        return (sum.to_f/@data.size)
    else
        raise "column #{k} is not of type Float or Integer"
    end
end

#base ⇒ Object 



68
69
70
 
# File 'lib/hoaxdb/table.rb', line 68

def base
    @base.clone
end

#data ⇒ Object 



65
66
67
 
# File 'lib/hoaxdb/table.rb', line 65

def data
    @data.clone
end

#del_if(query) ⇒ Object 



218
219
220
221
222
223
224
225
226
227
228
229
230
 
# File 'lib/hoaxdb/table.rb', line 218

def del_if(query)
    rm = []
    @data = self.load(@data)
    d = Query.new.parse(query)
    for x in 0...@data.size
        row = @data[x]
        if eval(d)
            rm.push(x)
        end
    end
    rm.reverse.each{|o| @data.delete_at(o)}
    @data = self.dump_array(@data)
end

#drop_column(col) ⇒ Object 



198
199
200
201
202
203
 
# File 'lib/hoaxdb/table.rb', line 198

def drop_column(col)
    @base.delete(col)
    @data.each do |row|
        row.delete(col)
    end
end

#dump_array(data) ⇒ Object 



109
110
111
112
113
114
115
116
117
118
 
# File 'lib/hoaxdb/table.rb', line 109

def dump_array(data)
    data.each do |row|
        row.each do |k,v|
            if @base[k]['type'].eql? 'Date' or @base[k]['type'].eql? 'DateTime'
                row[k] = "#{v}"
            end    
        end
    end
    data
end

#dump_hash(data) ⇒ Object 



119
120
121
122
123
124
125
126
 
# File 'lib/hoaxdb/table.rb', line 119

def dump_hash(data)
    data.each do |k,v|
        if @base[k]['type'].eql? 'Date' or @base[k]['type'].eql? 'DateTime'
            data[k] = "#{v}"
        end    
    end
    data
end

#fields ⇒ Object 



71
72
73
 
# File 'lib/hoaxdb/table.rb', line 71

def fields
    @base.keys
end

#inject(base, data) ⇒ Object

:nodoc:#



292
293
294
295
 
# File 'lib/hoaxdb/table.rb', line 292

def inject(base,data) #:nodoc:#
    @base = base
    @data = data
end

#insert(data) ⇒ Object 



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
 
# File 'lib/hoaxdb/table.rb', line 127

def insert(data)
    data.each{|k,v|
        if @base[k]
            if @base[k]['type'].eql? 'Boolean'
                if v.class.eql? FalseClass or v.class.eql? TrueClass
                    correct = true
                else
                    raise "#{v} is not a Boolean value"
                end
            elsif !v.class.eql? eval(@base[k]['type'])
                raise "Incorrect data type for #{v} to #{@base[k]}"     
            end
        else
            raise "This field #{k} is not in #{@name} table"
        end    
    }
    data = self.dump_hash(data)
    dt = {}
    @base.each_key{|k|
        if !data[k] then dt.store(k,@base[k]['default'])
        else
            dt.store(k,data[k])
        end    
    }
    @data.push(dt)         
end

#load(data) ⇒ Object 



80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
 
# File 'lib/hoaxdb/table.rb', line 80

def load(data)
    data.each do |row|
        row.each do |k,v|
            if !v.nil?
                if @base[k]['type'].eql? 'Date'
                    row[k] = Date.parse(v)
                elsif @base[k]['type'].eql? 'DateTime'
                    row[k] = DateTime.parse(v)
                elsif !@base[k]['type'].eql? 'String' and v.class.eql? String
                    row[k] = eval(v)
                end
            end  
        end
    end
    data
end

#load_hash(data) ⇒ Object 



96
97
98
99
100
101
102
103
104
105
106
107
108
 
# File 'lib/hoaxdb/table.rb', line 96

def load_hash(data)
     data.each do |k,v|
        if !v.nil?
            if @base[k]['type'].eql? 'Date'
                data[k] = Date.parse(v)
            elsif @base[k]['type'].eql? 'DateTime'
                data[k] = DateTime.parse(v)
            elsif !@base[k]['type'].eql? 'String' and v.class.eql? String
                data[k] = eval(v)
            end
        end  
    end
end

#max(k) ⇒ Object 



231
232
233
234
235
236
237
 
# File 'lib/hoaxdb/table.rb', line 231

def max(k)
    if !@base[k]['type'].eql? 'Array' or !@base[k]['type'].eql? 'Hash'
        max = @data[0][k] || 0
        @data.each{|row| if row[k] > max then max = row[k] end}
        return max
    end
end

#min(k) ⇒ Object 



238
239
240
241
242
243
244
 
# File 'lib/hoaxdb/table.rb', line 238

def min(k)
    if !@base[k]['type'].eql? 'Array' or !@base[k].eql? 'Hash'
        min = @data[0][k] || 0
        @data.each{|row| if row[k] < min then min = row[k] end}
        return min
    end
end

#rename_column(col, ncol) ⇒ Object 



204
205
206
207
208
209
210
211
212
213
214
215
216
217
 
# File 'lib/hoaxdb/table.rb', line 204

def rename_column(col,ncol)
    if @base.has_key? col
        val = @base[col]
        @base.delete(col)
        @base.store(ncol,val)
        @data.each do |row|
            val = row[col]
            row.delete(col)
            row.store(ncol,val)
        end
    else
        raise "Column #{col} does not exist"
    end
end

#select_if(query, cols, limit = -1,, sort = false, desc = false) ⇒ Object 



263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
 
# File 'lib/hoaxdb/table.rb', line 263

def select_if(query,cols,limit=-1,sort=false,desc=false)
    result = []
    @data = self.load(@data)
    x = Query.new.parse(query)
    res = @data.select{|row| eval(x)}
    g = false
    if cols[0].strip.eql? "*" then g = true end
    res.each do |row|
        col = {}
        if !g
            cols.each do |e|
                col.store(e,row[e])
            end
            result.push(col)
        else
           result.push(row)
        end      
    end   
    if sort
        result = result.sort{|a,b| a[sort] <=> b[sort]}   
    end
    if desc
        result.reverse!
    end
    if limit != -1 then result = result[0...limit] end
    @data = self.dump_array(@data)  
    result = self.load(result)
    result    
end

#sum(k) ⇒ Object 



254
255
256
257
258
259
260
261
262
 
# File 'lib/hoaxdb/table.rb', line 254

def sum(k)
    if @base[k]['type'].eql? 'Integer' or @base[k]['type'].eql? 'Float'
        sum = 0
        @data.each{|row| sum += row[k]}
        return sum
    else
        raise "column #{k} is not of type Float or Integer"    
    end
end

#update(query, values) ⇒ Object 



172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
 
# File 'lib/hoaxdb/table.rb', line 172

def update(query,values)
    @data = self.load(@data)
    @data.each{|row|
        if eval(Query.new.parse(query))
            values.each{|k,v|
                if v.class.eql? String and v[0].eql? "$"
                    f = Query.new.parse_complex(v.delete("$"))                       
                    temp = (row[k]).clone
                    eval("temp#{f}")
                    if temp.class.eql? eval(@base[k]['type'])
                        row[k] = temp
                    else
                        raise "Invalid data #{temp} to #{@base[k]['type']}"
                    end
                else
                   if v.class.eql? eval(@base[k]['type'])
                        row[k] = v
                   else
                        raise "Invalid data #{v} to #{@base[k]['type']}"
                   end
                end
            }
        end
    }
    @data = self.dump_array(@data)
end

#valid_type(type) ⇒ Object 



74
75
76
77
78
79
 
# File 'lib/hoaxdb/table.rb', line 74

def valid_type(type)
    types = ['String','Integer','Float','DateTime','Date','Boolean','Array','Hash']
    found = false
    types.each{|e| if e.eql? type then found = true;break end}
    found
end

#validate(v) ⇒ Object 



50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/hoaxdb/table.rb', line 50

def validate(v)
    if v["type"].eql? 'Date' or v["type"].eql? 'DateTime' and v["default"]
        v["default"] = "#{v["default"]}"
    elsif v["type"].eql? 'Boolean' and !v["default"].nil?
        if v["default"].class.eql? TrueClass or v["default"].class.eql? FalseClass
        else
            raise "Invalid default #{v["default"]} to #{v["type"]}"
        end
    else
         if !v["default"].nil? and !v["default"].class.eql? eval(v["type"])
            raise "Invalid default #{v["default"]} to #{v["type"]}"
        end
    end
    if v["default"].nil? then v["default"] = nil end
end