sqlite3_cache 0.16

data/CHANGELOG.md

@@ -0,0 +1 @@
+0.08 - Removed dependency on Bundler and fixed spec temp files...

data/README.md

@@ -0,0 +1,3 @@
+# SQLite3::Cache
+## What?
+SQLite3::Cache

data/ROADMAP.md

@@ -0,0 +1 @@
+Performance improvements?? Bug fixes? 

data/lib/sqlite3_cache.rb

@@ -0,0 +1,193 @@
+require 'sqlite3'
+require 'logger'
+require 'thread'
+
+module SQLite3
+  class Cache
+    # @param options [Hash] hash of options
+    # see method for options description...
+    # options are...
+    #   :file       - sqlite3 file to use as persistence
+    #   :namespace  - specify cache namespace (must be a string)
+    #   :expiration - number of seconds until keys expire
+    #   :timestamp_on_read - note the last time we touched a record...
+    def initialize(options)
+      @OPTIONS = options
+      raise "Must supply :file!" unless @OPTIONS[:file]
+      raise "Must supply :namespace!" unless @OPTIONS[:namespace]
+      raise "Must supply :expiration" unless @OPTIONS[:expiration]
+      @LOGGER = Logger.new(STDOUT)
+      if @OPTIONS[:debug]
+        @LOGGER.level = Logger::DEBUG
+      else
+        @LOGGER.level = Logger::WARN
+      end
+
+      unless @OPTIONS[:timestamp_on_read] == nil
+        @OPTIONS[:timestamp_on_read] = false
+      end
+
+      begin
+        @MUTEX = Mutex.new
+        @SQLITE3 = SQLite3::Database.new(@OPTIONS[:file])
+        @SQLITE3.busy_timeout = 60000
+      rescue => e
+        raise "Unable to open #{@OPTIONS[:file]}: #{e.message}"
+      end
+    end
+
+    # @param expiration [Integer] number of seconds before keys expire
+    # @return the value that was passed in
+    def expiration=(expiration)
+      @OPTIONS[:expiration] = expiration
+    end
+
+    # @param key [String] key the key to delete
+    # deletes a key from the cache
+    def delete!(key)
+      @LOGGER.debug {"Deleting #{key} from namespace #{@OPTIONS[:namespace]}"}
+      @SQLITE3.execute("delete from #{@OPTIONS[:namespace]} where key = ?", key)
+    end
+
+    # @param key [String] key to save
+    # @param value [String] value to persist
+    # sets a value in the cache
+    def []=(key, value)
+      @LOGGER.debug {"Setting #{key} to #{value} for namespace: #{@OPTIONS[:namespace]}"}
+      # make sure that table exists...
+      table_init(@OPTIONS[:namespace])
+      # see if the key exists...
+      existing_key = nil
+      @MUTEX.synchronize do
+        @SQLITE3.transaction do
+          @SQLITE3.execute("select key from #{@OPTIONS[:namespace]} where key = ?", key) do |row|
+            existing_key = row[0]
+          end
+          begin
+            unless existing_key
+              @SQLITE3.execute("insert into #{@OPTIONS[:namespace]} (key, created, value) values (?, ?, ?)", key, Time.now.to_s, Marshal.dump(value))
+            else
+              @SQLITE3.execute("update #{@OPTIONS[:namespace]} set created = ?, value = ? where key = ?", Time.now.to_s, Marshal.dump(value), key)
+            end
+          rescue => e
+            raise e
+          end
+          return value
+        end
+      end
+    end
+
+    # @param key [String] key to test for existence
+    # @return true if exist, false if not
+    # checks to see if we have a given key...
+    def exist?(key)
+      @LOGGER.debug {"Checking for existence of key: #{key}"}
+      @MUTEX.synchronize do
+        @SQLITE3.transaction do
+          unless table_exists?(@OPTIONS[:namespace])
+            return nil
+          end
+        end
+      end
+      @SQLITE3.execute("SELECT * from #{@OPTIONS[:namespace]} where key = ?", key) do |row|
+        return true
+      end
+      return false
+    end
+
+    # @param key [String] key to retrieve
+    # @return value of the key or nil
+    # retrieves a value from the cache
+    def [](key)
+      @LOGGER.debug {"Retreiving key: #{key} for namespace: #{@OPTIONS[:namespace]}"}
+      value = nil
+      @MUTEX.synchronize do
+        @SQLITE3.transaction do
+          unless table_exists?(@OPTIONS[:namespace])
+            return nil
+          end
+          @SQLITE3.results_as_hash = true
+          value = nil
+          @SQLITE3.execute("SELECT * from #{@OPTIONS[:namespace]} where key = ?", key) do |row|
+            value = Marshal.load(row["value"])
+            if value
+              @LOGGER.debug {"Cache hit!"}
+            else
+              @LOGGER.debug {"Cache miss!"}
+            end
+          end
+        end
+        if @OPTIONS[:timestamp_on_read]
+          # now update access time and count...
+          @SQLITE3.execute("UPDATE #{@OPTIONS[:namespace]} SET accessed = ? where key = ?", Time.now.to_s, key)
+          # retrieve count...
+          access_count = nil
+          @SQLITE3.execute("SELECT ACCESS_COUNT from #{@OPTIONS[:namespace]} where key = ?", key) do |row|
+            access_count = row[0]
+          end
+          if access_count
+            @SQLITE3.execute("UPDATE #{@OPTIONS[:namespace]} set access_count = ? where key = ?", access_count + 1, key)
+          end
+        end
+      end
+      return value
+    end
+
+    # gets rid of ALL keys in this cache...
+    def purge!
+      @SQLITE3.execute("DROP TABLE #{@OPTIONS[:namespace]}") if table_exists?(@OPTIONS[:namespace])
+    end
+
+    # purge any expired keys...
+    def purge_expired!
+      # okay, so see if any objects are older than
+      # CURRENT_TIME - @OPTIONS[:expiration]
+      expire_time = (Time.now - @OPTIONS[:expiration]).to_s
+      if table_exists?(@OPTIONS[:namespace])
+        @SQLITE3.execute("DELETE FROM #{@OPTIONS[:namespace]} where created < ?", expire_time)
+      end
+    end
+
+    # iterate over each key and value in the namespace
+    def each_pair(&block)
+      @SQLITE3.results_as_hash = true
+      @SQLITE3.execute("SELECT * from #{@OPTIONS[:namespace]}") do |row|
+        key = row["key"]
+        value = Marshal.load(row["value"])
+        yield key, value
+      end
+    end
+
+    # @return list of keys
+    def keys
+      @SQLITE3.results_as_hash = true
+      keys = []
+      @SQLITE3.execute("SELECT key from #{@OPTIONS[:namespace]}") do |row|
+        key = row["key"]
+        if block_given?
+        yield key
+        else
+        keys << key
+        end
+      end
+      return keys
+    end
+
+    private
+
+    def table_exists?(table)
+      @SQLITE3.execute("SELECT CASE WHEN tbl_name = ? THEN 1 ELSE 0 END FROM sqlite_master WHERE tbl_name = ? AND type = 'table'", table, table) do |row|
+        return row[0] == 1 ? true : false
+      end
+      return false
+    end
+
+    def table_init(table)
+      query = "create table if not exists #{table}(key text primary key, created timestamp, accessed timestamp, access_count timestamp, value blob)"
+      @SQLITE3.execute(query)
+      query = "create index if not exists key_index on #{table} (key)"
+      @SQLITE3.execute(query)
+    end
+
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: sqlite3_cache
+version: !ruby/object:Gem::Version
+  version: '0.16'
+  prerelease: 
+platform: ruby
+authors:
+- Joshua Harding
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Cache module that uses SQLite3 as backend
+email:
+- josh@statewidesoftware.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/sqlite3_cache.rb
+- LICENSE
+- README.md
+- ROADMAP.md
+- CHANGELOG.md
+homepage: http://statewidesoftware.com
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Cache module that uses SQLite3 as backend
+test_files: []