Class: SQLite3Hash

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

Defined Under Namespace

Classes: MissingDBPath

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(db = nil, init = nil, table = 'sqlite3hash', &default_proc) ⇒ SQLite3Hash

new(db) new(db, default_obj) new(db, hash) new(db, default_obj, table_name) new(db, hash, table_name)

All of the above with block specified (default_proc)

Raises:



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/sqlite3_hash.rb', line 40

def initialize(db=nil, init=nil, table='sqlite3hash', &default_proc)
	raise SQLite3Hash::MissingDBPath unless db
	@db = db

	@sqldb = SQLite3::Database.open(@db)

	# Handle args
	@default = (init.class==Hash) ? nil : init
	@default_proc = block_given? ? default_proc : nil

	# Safely quote table
	@table = table
	@table = table.gsub( /'/, "''" )

	createTable

	# Init from hash
	init.each { |k,v| set(k,v) } if init.class==Hash
end

Class Method Details

.[](*a) ⇒ Object

Raises:

  • (NotImplementedError) 


339
340
341
 
# File 'lib/sqlite3_hash.rb', line 339

def self.[](*a)
	raise NotImplementedError
end

.try_convert(incoming, *args) ⇒ Object

Like ‘new’ but we call try_convert



61
62
63
64
65
66
67
68
 
# File 'lib/sqlite3_hash.rb', line 61

def SQLite3Hash.try_convert(incoming, *args)
	shash = SQLite3Hash.new(*args)
	return shash unless incoming
	h = Hash.try_convert(incoming)
	return shash unless h
	h.each { |k,v| shash[k]=v }
	shash
end

Instance Method Details

#==(otherHash) ⇒ Object Also known as: eql? 



270
271
272
 
# File 'lib/sqlite3_hash.rb', line 270

def ==(otherHash)
	to_hash.==(otherHash)
end

#[](key) ⇒ Object 



70
71
72
73
74
 
# File 'lib/sqlite3_hash.rb', line 70

def [](key)
	return nil unless @sqldb
	row = @sqldb.get_first_row( "select * from '#{@table}' where key = ?", Marshal.dump(key))
	row ? (row2value(row)) : default(key)
end

#[]=(key, value) ⇒ Object Also known as: set, write, hsh, store 



94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
 
# File 'lib/sqlite3_hash.rb', line 94

def []=(key,value)
	return unless @sqldb
	# Unlike a Hash, can't store with key nil, we could use quoting to change this if needed
	return unless key

	rows = {
		'valueString' => nil,
		'valueSymbol' => nil,
		'valueInteger' => nil,
		'valueFloat' => nil,
		'valueMarshal' => nil,
	}
	rowname,value = rowValue(value)
	rows[rowname] = value
	keys = ['key']
	# Key is always marshalled - it can be many types and needs to be a unique index
	values = [Marshal.dump(key)]
	rows.each { |k,v|
		keys.push(k)
		values.push(v)
	}
	@sqldb.execute("insert or replace into '#{@table}'(#{keys.join(',')}) VALUES(#{(['?']*values.size).join(',')})",values)
end

#assoc(key) ⇒ Object 



86
87
88
 
# File 'lib/sqlite3_hash.rb', line 86

def assoc(key)
	has_key?(key) ? [key,get(key)] : nil
end

#clear(replaceHash = nil) ⇒ Object Also known as: replace 



229
230
231
232
 
# File 'lib/sqlite3_hash.rb', line 229

def clear(replaceHash = nil)
	@sqldb.execute("drop table '#{@table}'")
	createTable(replaceHash)
end

#compare_by_identity ⇒ Object

Raises:

  • (NotImplementedError) 


333
334
335
 
# File 'lib/sqlite3_hash.rb', line 333

def compare_by_identity
	raise NotImplementedError
end

#compare_by_identity? ⇒ Boolean

Returns:

  • (Boolean) 


336
337
338
 
# File 'lib/sqlite3_hash.rb', line 336

def compare_by_identity?
	false
end

#default(key = nil) ⇒ Object 



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

def default(key=nil)
	(key && @default_proc) ? @default_proc.call(self,key) : @default
end

#default=(v) ⇒ Object 



80
81
82
 
# File 'lib/sqlite3_hash.rb', line 80

def default=(v)
	@default = v
end

#default_proc ⇒ Object 



83
84
85
 
# File 'lib/sqlite3_hash.rb', line 83

def default_proc
	@default_proc
end

#del(key) ⇒ Object Also known as: delete 



170
171
172
173
174
 
# File 'lib/sqlite3_hash.rb', line 170

def del(key)
#puts "delete key #{key}"
	return unless @sqldb
	@sqldb.execute("delete from '#{@table}' where key = ?",Marshal.dump(key))
end

#delete_if ⇒ Object 



184
185
186
187
188
189
190
191
 
# File 'lib/sqlite3_hash.rb', line 184

def delete_if
	return Enumerator.new { |y|
		each { |k,v| delete(k) if y.yield(k,v) }
		self
	} unless block_given?
	each { |k,v| delete(k) if yield(k,v) }
	return self
end

#dumpTable ⇒ Object

For debug



319
320
321
322
323
324
325
326
327
 
# File 'lib/sqlite3_hash.rb', line 319

def dumpTable
	h = Hash.new
	return puts "NO CONNECTION" unless @sqldb
	@sqldb.execute("select * from '#{@table}'") { |row|
		row[0] = Marshal.load(row[0])
		p row
	}
	h
end

#each ⇒ Object Also known as: each_pair 



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

def each
	return Enumerator.new { |y| rows { |row| y.yield(Marshal.load(row[0]),row2value(row)) } } unless block_given?
	rows { |row| yield(Marshal.load(row[0]),row2value(row)) }
end

#each_key ⇒ Object 



136
137
138
139
 
# File 'lib/sqlite3_hash.rb', line 136

def each_key
	return Enumerator.new { |y| rows { |row| y.yield(Marshal.load(row[0])) } } unless block_given?
	rows { |row| yield(Marshal.load(row[0])) }
end

#each_value ⇒ Object 



140
141
142
143
 
# File 'lib/sqlite3_hash.rb', line 140

def each_value
	return Enumerator.new { |y| rows { |row| y.yield(row2value(row)) } } unless block_given?
	rows { |row| yield(row2value(row)) }
end

#empty? ⇒ Boolean

Returns:

  • (Boolean) 


166
167
168
 
# File 'lib/sqlite3_hash.rb', line 166

def empty?
	size==0 ? true : false
end

#fetch(key, default = nil) ⇒ Object 



122
123
124
125
126
127
128
 
# File 'lib/sqlite3_hash.rb', line 122

def fetch(key,default = nil)
	v = get(key)
	return v if v
	return default if default
	return yield(key) if block_given?
	return raise KeyError
end

#flatten(level = 1) ⇒ Object 



155
156
157
158
159
 
# File 'lib/sqlite3_hash.rb', line 155

def flatten(level=1)
	arr = []
	each { |k,v| arr.push([k,v]) }
	arr.flatten(level)
end

#get ⇒ Object 



75
76
77
78
79
 
# File 'lib/sqlite3_hash.rb', line 75

def [](key)
	return nil unless @sqldb
	row = @sqldb.get_first_row( "select * from '#{@table}' where key = ?", Marshal.dump(key))
	row ? (row2value(row)) : default(key)
end

#has_key?(k) ⇒ Boolean Also known as: include?, key?, member?

Returns:

  • (Boolean) 


235
236
237
 
# File 'lib/sqlite3_hash.rb', line 235

def has_key?(k)
	@sqldb.get_first_row( "select * from '#{@table}' where key = ?", Marshal.dump(k)) ? true : false
end

#has_value?(v) ⇒ Boolean Also known as: value?

Returns:

  • (Boolean) 


248
249
250
 
# File 'lib/sqlite3_hash.rb', line 248

def has_value?(v)
	index(v) ? true : false
end

#hash ⇒ Object 



274
275
276
 
# File 'lib/sqlite3_hash.rb', line 274

def hash
	to_hash.hash
end

#index(value) ⇒ Object Also known as: key 



242
243
244
245
246
 
# File 'lib/sqlite3_hash.rb', line 242

def index(value)
	rowname,value = rowValue(value)
	row = @sqldb.get_first_row( "select * from '#{@table}' where #{rowname} = ?", value)
	row ? Marshal.load(row[0]) : nil
end

#inspect ⇒ Object 



309
310
311
312
313
 
# File 'lib/sqlite3_hash.rb', line 309

def inspect
	inspect = "SQLite3Hash[#{@db}:#{@table}]"
	return "#<#{inspect} - no database connection>" unless @sqldb
	return "#<#{inspect} #{to_hash.inspect}>"
end

#invert ⇒ Object 



277
278
279
 
# File 'lib/sqlite3_hash.rb', line 277

def invert
	to_hash.invert
end

#keep_if ⇒ Object 



176
177
178
179
180
181
182
183
 
# File 'lib/sqlite3_hash.rb', line 176

def keep_if
	return Enumerator.new { |y|
		each { |k,v| delete(k) unless y.yield(k,v) }
		self
	} unless block_given?
	each { |k,v| delete(k) unless yield(k,v) }
	return self
end

#keys ⇒ Object 



144
145
146
 
# File 'lib/sqlite3_hash.rb', line 144

def keys
	rows.map { |row| Marshal.load(row[0]) }
end

#merge(otherHash, &block) ⇒ Object 



280
281
282
 
# File 'lib/sqlite3_hash.rb', line 280

def merge(otherHash,&block)
	to_hash.merge(otherHash,&block)
end

#merge!(otherHash) ⇒ Object Also known as: update 



283
284
285
286
287
288
289
290
291
292
 
# File 'lib/sqlite3_hash.rb', line 283

def merge!(otherHash)
	if block_given?
		otherHash.each { |key,newval|
			oldval = get(key)
			set(key,oldval ? yield(key,oldval,newval) : newval)
		}
	else
		otherHash.each { |k,v| set(k,v) }
	end
end

#rassoc(value) ⇒ Object 



89
90
91
92
 
# File 'lib/sqlite3_hash.rb', line 89

def rassoc(value)
	key = key(value)
	key ? [key,value] : nil
end

#read ⇒ Object 



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

def [](key)
	return nil unless @sqldb
	row = @sqldb.get_first_row( "select * from '#{@table}' where key = ?", Marshal.dump(key))
	row ? (row2value(row)) : default(key)
end

#rehash ⇒ Object

Not implemented

Raises:

  • (NotImplementedError) 


330
331
332
 
# File 'lib/sqlite3_hash.rb', line 330

def rehash
	raise NotImplementedError
end

#reject ⇒ Object 



192
193
194
195
196
 
# File 'lib/sqlite3_hash.rb', line 192

def reject
	hash = Hash.new
	each { |k,v| hash[k] = v unless yield(k,v) }
	return hash
end

#reject! ⇒ Object 



197
198
199
200
201
202
203
204
205
206
207
208
209
 
# File 'lib/sqlite3_hash.rb', line 197

def reject!
	changes = 0
	en = Enumerator.new { |y|
		each { |k,v|
			next unless y.yield(k,v)
			delete(k)
			changes += 1
		}
		changes==0 ? nil : self
	}
	return en unless block_given?
	en.each { |k,v| yield(k,v) }
end

#select ⇒ Object 



210
211
212
213
214
 
# File 'lib/sqlite3_hash.rb', line 210

def select
	hash = Hash.new
	each { |k,v| hash[k] = v if yield(k,v) }
	return hash
end

#select! ⇒ Object 



215
216
217
218
219
220
221
222
223
224
225
226
227
 
# File 'lib/sqlite3_hash.rb', line 215

def select!
	changes = 0
	en = Enumerator.new { |y|
		each { |k,v|
			next if y.yield(k,v)
			delete(k)
			changes += 1
		}
		changes==0 ? nil : self
	}
	return en unless block_given?
	en.each { |k,v| yield(k,v) }
end

#shift ⇒ Object 



253
254
255
256
257
258
259
260
261
 
# File 'lib/sqlite3_hash.rb', line 253

def shift
	row = @sqldb.get_first_row("select * from '#{@table}'")
# TODO - what if we have a default_proc and we shift out?
	return default(nil) unless row
	key = Marshal.load(row[0])
	value = row2value(row)
	delete(key)
	[key,value]
end

#size ⇒ Object Also known as: length 



161
162
163
164
 
# File 'lib/sqlite3_hash.rb', line 161

def size
	got = @sqldb.get_first_row("select count(*) from '#{@table}'")
	return got && got.class==Array ? got[0] : nil
end

#sort ⇒ Object 



305
306
307
 
# File 'lib/sqlite3_hash.rb', line 305

def sort
	to_a.sort
end

#to_a ⇒ Object 



299
300
301
302
303
304
 
# File 'lib/sqlite3_hash.rb', line 299

def to_a
	a = Array.new
	return a unless @sqldb
	each { |k,v| a.push([k,v]) }
	a
end

#to_h ⇒ Object Also known as: to_hash 



263
264
265
266
267
268
 
# File 'lib/sqlite3_hash.rb', line 263

def to_h
	h = Hash.new
	return h unless @sqldb
	each { |k,v| h[k] = v }
	h
end

#to_s ⇒ Object 



314
315
316
 
# File 'lib/sqlite3_hash.rb', line 314

def to_s
	to_hash.to_s
end

#values ⇒ Object 



147
148
149
 
# File 'lib/sqlite3_hash.rb', line 147

def values
	rows.map { |row| row2value(row) }
end

#values_at(*keys) ⇒ Object

Values for a given set of keys



151
152
153
 
# File 'lib/sqlite3_hash.rb', line 151

def values_at(*keys)
	keys.map { |key| get(key) }
end