db_memoize 0.1.6 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2134329e831a84420b606a2f64aeae8703ebcd7a
-  data.tar.gz: 2abf35de9b06d53424513a0432cb884c73f1f4cd
+  metadata.gz: 254ec2be767020e1ff61a4b5ddbfc561f894b716
+  data.tar.gz: b27ccaf67e4a4dc32901fe802ab6b7da5872d9ba
 SHA512:
-  metadata.gz: 208ba78d6912596d059e40e4f77f9393025a926c4c973a2599882a6980ce836c008442466d3db0c84fd8e1a9e2a625ca901f26d697f64054abdccf7976c700f9
-  data.tar.gz: 994bdc8506e1886f57276380da78431812d9c74b99c66ea9f02ce9bffef87b1f13e27182c556ba5dab8363f8896de9c4ae9d2442be214a1c324cf007cb416c9f
+  metadata.gz: e430b58340a10f27910e558068cca7ac75ab8e07ec9d0aa5898d340aeeaa142dc3241779d3f1c02d16755d8390ddaee44518a704c563e9c5b7a5aa2ac670ea36
+  data.tar.gz: 82949ec2ac4094966459edbeadb5f34c91f03d9f20cda7e98ee9c1978b3b6fb12a671623473fdb7db88554a01f0ec9fcfb28c8fe8da873f5f218adbd1d07b430

data/.gitignore

@@ -7,3 +7,4 @@
 /pkg/
 /spec/reports/
 /tmp/
+/log/

data/.travis.yml

@@ -4,5 +4,6 @@ rvm:
   - 2.3.1
 before_install: gem install bundler -v 1.13.6
 script:
+  - bundle exec rake db:test:create
   - bundle exec rspec
   - bundle exec rubocop

data/README.md

@@ -35,10 +35,8 @@ will call the original method only once. Consecutive calls will return a cached
 
 If the method takes arguments..
 
-```
-record.hello('Maria')
-record.hello('John')
-```
+    record.hello('Maria')
+    record.hello('John')
 
 a cached value will be created for every set of arguments.
 
@@ -46,67 +44,47 @@ a cached value will be created for every set of arguments.
 
 To clear cached values for a single method
 
-```
-record.unmemoize(:hello)
-```
+    record.unmemoize(:hello)
 
 To clear all cached values of one record
 
-```
-record.unmemoize
-```
+    record.unmemoize
 
 To clear cached values of given records for a single method
 
-```
-Letter.unmemoize([letter1, letter2], :hello)
-```
+    Letter.unmemoize([letter1, letter2], :hello)
 
 To clear all cached values of given records
 
-```
-Letter.unmemoize([letter1, letter2])
-```
+    Letter.unmemoize([letter1, letter2])
 
 Instead of ActiveRecord instances it's sufficient to pass in the ids of the records, too
 
-```
-Letter.unmemoize([23,24])
-```
+    Letter.unmemoize([23,24])
 
 ### Gotchas
 
 As the cached values themselves are writtten to the database, are ActiveRecord records (of type `DbMemoize::Value`) and are reqistered as an association you can access all of the cached values of an object like this:
 
-```
-record.memoized_values
-```
+    record.memoized_values
 
 This means you can also very easily perform eager loading on them:
 
-```
-Letter.includes(:memoized_values).all
-```
+    Letter.includes(:memoized_values).all
 
 DbMemoize by default will write log output to STDOUT. You can change this by setting another logger like so:
 
-```
-DbMemoize.logger = your_logger
-```
+    DbMemoize.logger = your_logger
 
 ### Rake Tasks
 
 To _warmup_ your cache you can pre-generate cached values via a rake task like this (only works for methods not depending on arguments)
 
-```
-bundle exec rake db_memoize:warmup class=Letter methods=hello,bye
-```
+    bundle exec rake db_memoize:warmup class=Letter methods=hello,bye
 
 Similarly you can wipe all cached values for a given class
 
-```
-bundle exec rake db_memoize:clear class=Letter
-```
+    bundle exec rake db_memoize:clear class=Letter
 
 ### Setup
 

data/Rakefile

@@ -3,4 +3,9 @@ require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task "db:test:create" do
+  Rake.sh "dropdb db_memoize_test || true"
+  Rake.sh "createdb db_memoize_test"
+end
+
+task :default => %w(db:test:create spec)

data/db_memoize.gemspec

@@ -25,7 +25,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'activerecord', '~> 4.2'
 
   spec.add_development_dependency 'rake', '~> 10.5'
-  spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'pg'
   spec.add_development_dependency 'rspec-rails', '~> 3.4'
   spec.add_development_dependency 'pry', '~> 0.10'
   spec.add_development_dependency 'pry-byebug', '~> 2.0'

data/lib/db_memoize.rb

@@ -2,7 +2,9 @@ require 'active_record'
 require 'active_support'
 require 'digest'
 require 'benchmark'
+
 require 'db_memoize/version'
+require 'db_memoize/metal'
 require 'db_memoize/value'
 require 'db_memoize/helpers'
 require 'db_memoize/model'

data/lib/db_memoize/helpers.rb

@@ -12,7 +12,21 @@ module DbMemoize
     end
 
     def log(model, method_name, msg)
-      DbMemoize.logger.send(DbMemoize.log_level, "DbMemoize <#{model.class.name} id: #{model.id}>##{method_name} - #{msg}")
+      DbMemoize.logger.send(DbMemoize.log_level) do
+        "DbMemoize <#{model.class.name}##{model.id}>##{method_name} - #{msg}"
+      end
+    end
+
+    def calculate_arguments_hash(arguments)
+      arguments.empty? ? nil : ::Digest::MD5.hexdigest(Marshal.dump(arguments))
+    end
+
+    def marshal(value)
+      Marshal.dump(value)
+    end
+
+    def unmarshal(value)
+      Marshal.load(value)
     end
   end
 end

data/lib/db_memoize/metal.rb

@@ -0,0 +1,102 @@
+module DbMemoize
+  module Metal
+    def self.included(base)
+      base.extend ClassMethods
+      # base.metal # initialize the metal adapter
+    end
+
+    module ClassMethods
+      def metal
+        @metal ||= Adapter.new(self)
+      end
+    end
+
+    class Adapter
+      class PkInfo
+        attr_reader :column, :type
+
+        def initialize(base_klass)
+          @column = base_klass.primary_key
+          @type   = @column && base_klass.columns_hash.fetch(@column).type
+        end
+      end
+
+      def initialize(base_klass)
+        @base_klass  = base_klass
+        @query_cache = {}
+      end
+
+      private
+
+      # setup primary key information. This is necessary to allow the create! method
+      # to return the primary key of a newly created entry.
+      def primary_key
+        @primary_key ||= PkInfo.new(@base_klass)
+      end
+
+      def table_name
+        @base_klass.table_name
+      end
+
+      def raw_connection
+        @base_klass.connection.raw_connection # do not memoize me!
+      end
+
+      def column?(column_name)
+        @base_klass.columns_hash.key?(column_name)
+      end
+
+      def insert_sql(field_names)
+        @query_cache[field_names] ||= _insert_sql(field_names)
+      end
+
+      DATABASE_IDENTIFIER_REGEX = /\A\w+\z/
+
+      def check_database_identifiers!(*strings)
+        strings.each do |s|
+          next if DATABASE_IDENTIFIER_REGEX =~ s.to_s
+          raise ArgumentError, "Invalid database identifier: #{s.inspect}"
+        end
+      end
+
+      def _insert_sql(field_names)
+        check_database_identifiers! table_name, *field_names
+
+        placeholders = 0.upto(field_names.count - 1).map { |idx| "$#{idx + 1}" }
+
+        if column?('created_at')
+          field_names << 'created_at'
+          placeholders << 'current_timestamp'
+        end
+
+        if column?('updated_at')
+          field_names << 'updated_at'
+          placeholders << 'current_timestamp'
+        end
+
+        sql = "INSERT INTO #{table_name} (#{field_names.join(',')}) VALUES(#{placeholders.join(',')})"
+        sql += " RETURNING #{primary_key.column}" if primary_key.column
+        sql
+      end
+
+      public
+
+      def create!(record)
+        keys, values = record.to_a.transpose
+
+        sql    = insert_sql(keys)
+        result = raw_connection.exec_params(sql, values)
+
+        # if we don't have an ID column then the sql does not return any value. The result
+        # object would be this: #<PG::Result status=PGRES_COMMAND_OK ntuples=0 nfields=0 cmd_tuples=1>
+        # we just return nil in that case; otherwise we return the first entry of the first result row
+        # which would be the stringified id.
+        first_row = result.each_row.first
+        return nil unless first_row
+
+        id = first_row.first
+        primary_key.type == :integer ? Integer(id) : id
+      end
+    end
+  end
+end

data/lib/db_memoize/migrations.rb

@@ -3,15 +3,27 @@ module DbMemoize
     class << self
       def create_tables(migration)
         migration.create_table :memoized_values, id: false do |t|
-          t.string :entity_table_name
-          t.integer :entity_id
-          t.string :method_name
+          t.string :entity_table_name, null: false
+          t.integer :entity_id, null: false
+          t.string :method_name, null: false
           t.string :arguments_hash
           t.binary :value
-          t.datetime :created_at
+          t.datetime :created_at, null: false
         end
 
         migration.add_index :memoized_values, [:entity_table_name, :entity_id]
+        migrate_empty_arguments_support(migration)
+      end
+
+      def migrate_empty_arguments_support(migration)
+        # entity_id/entity_table_name should have a better chance to be useful, since
+        # there is more variance in entity_ids than there is in entity_table_names.
+        migration.remove_index :memoized_values, [:entity_table_name, :entity_id]
+        migration.add_index :memoized_values, [:entity_id, :entity_table_name]
+
+        # add an index to be useful to look up entries where arguments_hash is NULL.
+        # (which is the case for plain attributes of an object)
+        migration.execute 'CREATE INDEX memoized_attributes_idx ON memoized_values((arguments_hash IS NULL))'
       end
     end
   end

data/lib/db_memoize/model.rb

@@ -8,11 +8,11 @@ module DbMemoize
       end
 
       value         = nil
-      args_hash     = ::Digest::MD5.hexdigest(Marshal.dump(args))
+      args_hash     = Helpers.calculate_arguments_hash(args)
       cached_value  = find_memoized_value(method_name, args_hash)
 
       if cached_value
-        value = Marshal.load(cached_value.value)
+        value = Helpers.unmarshal(cached_value.value)
         Helpers.log(self, method_name, 'cache hit')
       else
         time = ::Benchmark.realtime do
@@ -44,7 +44,8 @@ module DbMemoize
     #                          autocomplete_info: "my autocomplete_info"
     #
     def memoize_values(values, *args)
-      args_hash = ::Digest::MD5.hexdigest(Marshal.dump(args))
+      # [TODO] - when creating many memoized values: should we even support arguments here?
+      args_hash = Helpers.calculate_arguments_hash(args)
 
       values.each do |name, value|
         create_memoized_value(name, args_hash, value)
@@ -53,16 +54,14 @@ module DbMemoize
 
     private
 
-    def create_memoized_value(method_name, args_hash, value)
-      # [TODO] - It would be nice to have an optimized, pg-based inserter
-      #          here, for up to 10 times speed. However, the memoized_values
-      #          array must then be properly reset.
-      memoized_values.create!(
-        entity_table_name: self.class.table_name,
-        method_name: method_name.to_s,
-        arguments_hash: args_hash,
-        value: Marshal.dump(value)
-      )
+    def create_memoized_value(method_name, arguments_hash, value)
+      ::DbMemoize::Value.metal.create! entity_table_name: self.class.table_name,
+                                       entity_id: id,
+                                       method_name: method_name.to_s,
+                                       arguments_hash: arguments_hash,
+                                       value: Helpers.marshal(value)
+
+      @association_cache.delete :memoized_values
     end
 
     def find_memoized_value(method_name, args_hash)
@@ -101,19 +100,18 @@ module DbMemoize
       end
 
       def memoize_values(records_or_ids, values, *args)
+        # [TODO] - when creating many memoized values: should we even support arguments here?
         transaction do
-          ids        = Helpers.find_ids(records_or_ids)
-          args_hash  = ::Digest::MD5.hexdigest(Marshal.dump(args))
+          ids            = Helpers.find_ids(records_or_ids)
+          arguments_hash = Helpers.calculate_arguments_hash(args)
 
           ids.each do |id|
-            values.each do |name, value|
-              DbMemoize::Value.create!(
-                entity_table_name: table_name,
-                entity_id: id,
-                method_name: name,
-                arguments_hash: args_hash,
-                value: Marshal.dump(value)
-              )
+            values.each do |method_name, value|
+              ::DbMemoize::Value.metal.create! entity_table_name: table_name,
+                                               entity_id: id,
+                                               method_name: method_name.to_s,
+                                               arguments_hash: arguments_hash,
+                                               value: Helpers.marshal(value)
             end
           end
         end

data/lib/db_memoize/value.rb

@@ -1,5 +1,7 @@
 module DbMemoize
   class Value < ActiveRecord::Base
     self.table_name = 'memoized_values'
+
+    include DbMemoize::Metal
   end
 end

data/lib/db_memoize/version.rb

@@ -1,3 +1,3 @@
 module DbMemoize
-  VERSION = '0.1.6'.freeze
+  VERSION = '0.2.1'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: db_memoize
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.2.1
 platform: ruby
 authors:
 - johannes-kostas goetzinger
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-01-31 00:00:00.000000000 Z
+date: 2017-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -53,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '10.5'
 - !ruby/object:Gem::Dependency
-  name: sqlite3
+  name: pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -240,6 +240,7 @@ files:
 - db_memoize.gemspec
 - lib/db_memoize.rb
 - lib/db_memoize/helpers.rb
+- lib/db_memoize/metal.rb
 - lib/db_memoize/migrations.rb
 - lib/db_memoize/model.rb
 - lib/db_memoize/railtie.rb
@@ -247,6 +248,7 @@ files:
 - lib/db_memoize/version.rb
 - lib/tasks/clear.rake
 - lib/tasks/warmup.rake
+- log/.keep
 homepage: https://github.com/mediapeers/db_memoize
 licenses:
 - MIT