class SQLite3Hash

# File lib/sqlite3_hash.rb, line 338
def self.[](*a)
        raise NotImplementedError
end

# File lib/sqlite3_hash.rb, line 39
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

# File lib/sqlite3_hash.rb, line 60
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

# File lib/sqlite3_hash.rb, line 269
def ==(otherHash)
        to_hash.==(otherHash)
end

# File lib/sqlite3_hash.rb, line 69
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

# File lib/sqlite3_hash.rb, line 93
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,
                'valueFixnum' => 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

# File lib/sqlite3_hash.rb, line 85
def assoc(key)
        has_key?(key) ? [key,get(key)] : nil
end

# File lib/sqlite3_hash.rb, line 228
def clear(replaceHash = nil)
        @sqldb.execute("drop table '#{@table}'")
        createTable(replaceHash)
end

# File lib/sqlite3_hash.rb, line 332
def compare_by_identity
        raise NotImplementedError
end

# File lib/sqlite3_hash.rb, line 335
def compare_by_identity?
        false
end

# File lib/sqlite3_hash.rb, line 76
def default(key=nil)
        (key && @default_proc) ? @default_proc.call(self,key) : @default
end

# File lib/sqlite3_hash.rb, line 79
def default=(v)
        @default = v
end

# File lib/sqlite3_hash.rb, line 82
def default_proc
        @default_proc
end

# File lib/sqlite3_hash.rb, line 169
        def del(key)
#puts "delete key #{key}"
                return unless @sqldb
                @sqldb.execute("delete from '#{@table}' where key = ?",Marshal.dump(key))
        end

# File lib/sqlite3_hash.rb, line 183
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

# File lib/sqlite3_hash.rb, line 318
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

# File lib/sqlite3_hash.rb, line 129
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

# File lib/sqlite3_hash.rb, line 135
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

# File lib/sqlite3_hash.rb, line 139
def each_value
        return Enumerator.new { |y| rows { |row| y.yield(row2value(row)) } } unless block_given?
        rows { |row| yield(row2value(row)) }
end

# File lib/sqlite3_hash.rb, line 165
def empty?
        size==0 ? true : false
end

# File lib/sqlite3_hash.rb, line 121
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

# File lib/sqlite3_hash.rb, line 154
def flatten(level=1)
        arr = []
        each { |k,v| arr.push([k,v]) }
        arr.flatten(level)
end

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

# File lib/sqlite3_hash.rb, line 247
def has_value?(v)
        index(v) ? true : false
end

# File lib/sqlite3_hash.rb, line 273
def hash
        to_hash.hash
end

# File lib/sqlite3_hash.rb, line 241
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

# File lib/sqlite3_hash.rb, line 308
def inspect
        inspect = "SQLite3Hash[#{@db}:#{@table}]"
        return "#<#{inspect} - no database connection>" unless @sqldb
        return "#<#{inspect} #{to_hash.inspect}>"
end

# File lib/sqlite3_hash.rb, line 276
def invert
        to_hash.invert
end

# File lib/sqlite3_hash.rb, line 175
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

# File lib/sqlite3_hash.rb, line 143
def keys
        rows.map { |row| Marshal.load(row[0]) }
end

# File lib/sqlite3_hash.rb, line 279
def merge(otherHash,&block)
        to_hash.merge(otherHash,&block)
end

# File lib/sqlite3_hash.rb, line 282
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

# File lib/sqlite3_hash.rb, line 88
def rassoc(value)
        key = key(value)
        key ? [key,value] : nil
end

# File lib/sqlite3_hash.rb, line 329
def rehash
        raise NotImplementedError
end

# File lib/sqlite3_hash.rb, line 191
def reject
        hash = Hash.new
        each { |k,v| hash[k] = v unless yield(k,v) }
        return hash
end

# File lib/sqlite3_hash.rb, line 196
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

# File lib/sqlite3_hash.rb, line 209
def select
        hash = Hash.new
        each { |k,v| hash[k] = v if yield(k,v) }
        return hash
end

# File lib/sqlite3_hash.rb, line 214
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

# File lib/sqlite3_hash.rb, line 252
        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

# File lib/sqlite3_hash.rb, line 160
def size
        got = @sqldb.get_first_row("select count(*) from '#{@table}'")
        return got && got.class==Array ? got[0] : nil
end

# File lib/sqlite3_hash.rb, line 304
def sort
        to_a.sort
end

# File lib/sqlite3_hash.rb, line 298
def to_a
        a = Array.new
        return a unless @sqldb
        each { |k,v| a.push([k,v]) }
        a
end

# File lib/sqlite3_hash.rb, line 262
def to_h
        h = Hash.new
        return h unless @sqldb
        each { |k,v| h[k] = v }
        h
end

# File lib/sqlite3_hash.rb, line 313
def to_s
        to_hash.to_s
end

# File lib/sqlite3_hash.rb, line 146
def values
        rows.map { |row| row2value(row) }
end

# File lib/sqlite3_hash.rb, line 150
def values_at(*keys)
        keys.map { |key| get(key) }
end

# File lib/sqlite3_hash.rb, line 360
def createTable(h=Hash.new)
        # Check if table exists
        return if @sqldb.get_first_value( %{select name from sqlite_master where name = :name}, {:name => @table} )
        @sqldb.execute("create table '#{@table}' (key TEXT not null unique, valueString TEXTS, valueFixnum INTEGER, valueFloat REAL, valueSymbol TEXTS, valueMarshal TEXTS)")
        h.each { |k,v| set(k,v) } if h
end

# File lib/sqlite3_hash.rb, line 356
def row2value(row)
        row[1] || row[2] || row[3] || (row[4] ? row[4].to_sym : Marshal.load(row[5]))
end

# File lib/sqlite3_hash.rb, line 350
def rowValue(value)
        c = value.class
        return ["value#{c.to_s}",value] if c==Fixnum || c==String || c==Float
        return ["value#{c.to_s}",value.to_s] if c==Symbol
        return ["valueMarshal",Marshal.dump(value)]
end

# File lib/sqlite3_hash.rb, line 344
def rows
        return @sqldb.execute("select * from '#{@table}'") unless block_given?
        @sqldb.execute("select * from '#{@table}'") { |row|
                yield row
        }
end