activerecord-metal 0.1.0 → 0.1.2

data/README.md

@@ -46,6 +46,26 @@ So there is support for queries.
     # only what is the database's default; and Postgresql uses $1, $2, ...
     metal.exec("SELECT id, name FROM users WHERE name=$1", "me")
 
+## Usage - prepared queries
+
+ActiveRecord::Metal uses prepared queries whenever a query uses parameters. They
+are managed automatically behind your back. You can also explicitely prepare
+queries:
+
+    prepared_query = metal.prepare(sql)
+
+and use the prepared_query instead of the sql string.
+
+    metal.ask prepared_query, arg1, arg2, ...
+
+To unprepare the query use 
+
+    metal.unprepare(prepared_query)
+    metal.unprepare(sql)
+
+**Note:** ActiveRecord::Metal currently does not automatically unprepare
+queries.
+
 ## Usage - Mass import
 
     # Mass imports for array records
@@ -73,14 +93,11 @@ So there is support for queries.
 
 ### How fast is the mass import?
 
-The metal's importer is faster than ActiveRecord::Base's, because:
+The metal's importer is fast, ceause it just does importing data - that 
+means it does not fetch ids, it does not validate records, does not call
+callbacks.
 
-- it is using one prepared statement per import session, as (AFAIK, again)
-  one prepared statement per individual record
-- it does not fetch ids etc.
-- it does not do all the rails shananiggins: no 
-  
-Hmm, lets see: (Note: This is on a Macbook Air w/Ruby 1.9.2 and activerecord 2.3 - YMMV)
+This results in an impressive speedup compared to ActiveRecord::Base:
 
     1.9.2 ~/projects/gem/activerecord-metal[master] > bundle exec script/console 
     Loaded /Users/eno/.irbrc
@@ -121,6 +138,13 @@ And documentation is still missing. Code coverage is good, though:
     All Files (97.22% covered at 88.78 hits/line)
     6 files in total. 288 relevant lines. 280 lines covered and 8 lines missed
 
+## Hacking ActiveRecord::Metal
+
+The following gives you a IRB console
+
+    bundle exec script/console
+
 ## License
 
 The activerecord-metal gem is distributed under the terms of the Modified BSD License, see LICENSE.BSD for details.
+

data/lib/active_record/metal/logging.rb

@@ -40,4 +40,16 @@ module ActiveRecord::Metal::Logging
     @benchmark_depth -= 1
     log_benchmark severity, Time.now - started_at, msg
   end
+  
+  private
+  
+  def log_error(exception, query, *args)
+    unless args.empty?
+      args = "w/#{args.map(&:inspect).join(", ")}"
+    else
+      args = ""
+    end
+
+    ActiveRecord::Metal.logger.error "#{exception} on #{resolve_query(query)} #{args}"
+  end
 end

data/lib/active_record/metal/postgresql/aggregate.rb

@@ -0,0 +1,5 @@
+module ActiveRecord::Metal::Postgresql::Aggregate
+  def count(table_name)
+    ask "SELECT COUNT(*) FROM #{table_name}"
+  end
+end

data/lib/active_record/metal/postgresql/conversions.rb

@@ -72,6 +72,10 @@ module ActiveRecord::Metal::Postgresql::Conversions::Time
   def _timestamptz(s)
     T.parse(s)
   end
+  
+  def _interval(s)
+    raise "ActiveRecord::Metal does not yet support the type '_interval': #{s.inspect}"
+  end
 end
 
 module ActiveRecord::Metal::Postgresql::Conversions::Boolean

data/lib/active_record/metal/postgresql/exec.rb

@@ -0,0 +1,49 @@
+module ActiveRecord::Metal::Postgresql::Exec
+  private
+
+  # -- raw queries ----------------------------------------------------
+
+  def exec_(sql)
+    pg_conn.exec(sql)
+  end
+
+  def exec_prepared(sym, *args)
+    args = args.map do |arg|
+      if arg.is_a?(Hash)
+        ActiveRecord::Metal::Postgresql::Conversions::HStore.escape(arg)
+      else
+        arg
+      end
+    end
+
+    pg_conn.exec_prepared(sym.to_s, args)
+  end
+end
+
+module ActiveRecord::Metal::Postgresql::Exec::Etest
+  include ActiveRecord::Metal::EtestBase
+
+  def test_error_on_prepare
+    assert_raise(PG::Error) {  
+      metal.prepare "SELECT unknown_function(1)"
+    }
+  end
+
+  def test_error_on_exec
+    assert_raise(PG::Error) {  
+      metal.ask "SELECT unknown_function(1)"
+    }
+  end
+
+  def test_error_on_unprepare
+    assert_raise(PG::Error) {  
+      metal.unprepare "SELECT unknown_function(1)"
+    }
+  end
+
+  def test_error_on_exec_with_args
+    assert_raise(PG::Error) {  
+      metal.ask "SELECT num FROM alloys WHERE unknown_function(id) > $1", 1
+    }
+  end
+end

data/lib/active_record/metal/postgresql/import.rb

@@ -37,10 +37,7 @@ module ActiveRecord::Metal::Postgresql::Import
     records.each do |record|
       exec_prepared stmt, *record.values_at(*keys)
     end
-  rescue
-    logger.warn "#{$!.class.name}: #{$!}"
-    raise
-  ensure
+
     unprepare(stmt)
   end
   
@@ -57,10 +54,7 @@ module ActiveRecord::Metal::Postgresql::Import
     records.each do |record|
       exec_prepared stmt, *record
     end
-  rescue
-    logger.warn "#{$!.class.name}: #{$!}"
-    raise
-  ensure
+
     unprepare(stmt)
   end
 end

data/lib/active_record/metal/postgresql/prepared_queries.rb

@@ -0,0 +1,105 @@
+module ActiveRecord::Metal::Postgresql::PreparedQueries
+  def prepare(sql)
+    prepared_statements[sql]
+  rescue PG::Error
+    log_error $!, sql
+    raise
+  end
+
+  def unprepare(query)
+    expect! query => [ Symbol, String ]
+    case query
+    when Symbol
+      exec_("DEALLOCATE PREPARE #{query}")
+      sql = prepared_statements_by_name.delete query
+      prepared_statements.delete sql
+    when String
+      name = prepared_statement_name(query)
+      exec_("DEALLOCATE PREPARE #{name}")
+      prepared_statements.delete query
+      prepared_statements_by_name.delete name
+    end
+  rescue PG::Error
+    log_error $!, query
+    raise
+  end
+
+  private
+
+  def prepared_statements_by_name
+    @prepared_statements_by_name ||= {}
+  end
+
+  def prepared_statements
+    @prepared_statements ||= Hash.new { |hsh, sql| hsh[sql] = _prepare(sql) }
+  end
+
+  def resolve_query(query)
+    query.is_a?(Symbol) ? prepared_statements_by_name[query] : query
+  end
+
+  def _prepare(sql)
+    name = prepared_statement_name(sql)
+    pg_conn.prepare(name, sql)
+    name = name.to_sym
+    prepared_statements_by_name[name] = sql
+    name
+  end
+
+  # Name for a prepared statement. The name is derived from the SQL code, but is also
+  # specific for this ActiveRecord::Metal.instance.
+  def prepared_statement_name(sql)
+    key = "#{object_id}-#{sql}"
+    "pg_metal_#{Digest::MD5.hexdigest(key)}"
+  end
+end
+
+module ActiveRecord::Metal::Postgresql::PreparedQueries::Etest
+  include ActiveRecord::Metal::EtestBase
+
+  def test_prepared_queries_housekeeping
+    # if we have two metal adapters working on the same connection,
+    # one must not affect the prepared queries of the other.
+    alloys = metal.ask "SELECT COUNT(*) FROM alloys WHERE id >= $1", 0
+    other_metal = ActiveRecord::Metal.new
+    expect! other_metal.ask("SELECT COUNT(*) FROM alloys WHERE id >= $1", 0) => alloys
+    expect! metal.ask("SELECT COUNT(*) FROM alloys WHERE id >= $1", 0) => alloys
+  end
+
+  def test_prepared_query_fails_during_import
+    metal.ask "DELETE FROM alloys"
+    
+    # If a prepared query fails, eg. during an import, the transaction
+    # will fail and cancelled. This also means that there is no longer
+    # a way to clean up the prepared query in the transaction, because
+    # this fails with a "transaction failed already" error.
+    query = metal.prepare "INSERT INTO alloys (id, num) VALUES($1, $1)"
+
+    assert_raise(PG::Error) {  
+      records = [ [1,1], [1,1] ]
+      metal.import "alloys", records, :columns => [ "id", "num"]
+    }
+
+    # Note: after that point we can no longer do anything in this test.
+    # This is because a test is wrapped in a transaction, and this
+    # transaction is aborted.
+    # expect! metal.count("alloys") => 0
+  end
+  
+  def test_transaction_aborted
+    metal.ask "DELETE FROM alloys"
+    metal.transaction do
+      metal.ask "INSERT INTO alloys (id, num) VALUES($1, $1)", 1
+      
+      # "duplicate key value violates unique constraint"
+      assert_raise(PG::Error) {  
+        metal.ask "INSERT INTO alloys (id, num) VALUES($1, $1)", 1
+      }
+
+      # "current transaction is aborted"
+      assert_raise(PG::Error) {  
+        metal.ask "INSERT INTO alloys (id, num) VALUES($1, $1)", 2
+      }
+    end
+  end
+end

data/lib/active_record/metal/postgresql/queries.rb

@@ -96,6 +96,9 @@ module ActiveRecord::Metal::Postgresql::Queries
     end
 
     ArrayWithTypeInfo.new rows, result.columns, result.types
+  rescue PG::Error
+    log_error $!, sql, *args
+    raise
   ensure
     log_benchmark :debug, Time.now - started_at, 
                   "SQL: {{runtime}} %s %s" % [ sql.is_a?(Symbol) ? "[P]" : "   ", resolve_query(sql) ]

data/lib/active_record/metal/postgresql.rb

@@ -1,84 +1,6 @@
 require "digest/md5"
 
 module ActiveRecord::Metal::Postgresql
-  private
-
-  def prepared_statements_by_name
-    @prepared_statements_by_name ||= {}
-  end
-  
-  def prepared_statements
-    @prepared_statements ||= Hash.new { |hsh, sql| hsh[sql] = _prepare(sql) }
-  end
-
-  def resolve_query(query)
-    query.is_a?(Symbol) ? prepared_statements_by_name[query] : query
-  end
-
-  def _prepare(sql)
-    name = prepared_statement_name(sql)
-    pg_conn.prepare(name, sql)
-    name = name.to_sym
-    prepared_statements_by_name[name] = sql
-    name
-  end
-  
-  public
-  
-  def prepare(sql)
-    prepared_statements[sql]
-  end
-
-  def unprepare(query)
-    expect! query => [ Symbol, String ]
-    case query
-    when Symbol
-      exec_("DEALLOCATE PREPARE #{query}")
-      sql = prepared_statements_by_name.delete query
-      prepared_statements.delete sql
-    when String
-      name = prepared_statement_name(query)
-      exec_("DEALLOCATE PREPARE #{name}")
-      prepared_statements.delete query
-      prepared_statements_by_name.delete name
-    end
-  end
-  
-  def unprepare_all  
-    exec_ "DEALLOCATE PREPARE ALL"
-    @prepared_statements_by_name = @prepared_statements = nil
-  end
-  
-  private
-  
-  # -- raw queries ----------------------------------------------------
-  
-  def exec_(sql)
-    # STDERR.puts "exec_ --> #{sql}"
-    result = pg_conn.exec sql
-    result.check
-    result
-  end
-
-  def exec_prepared(sym, *args)
-    # STDERR.puts "exec_prepared: #{sym.inspect}"
-    args = args.map do |arg|
-      if arg.is_a?(Hash)
-        ActiveRecord::Metal::Postgresql::Conversions::HStore.escape(arg)
-      else
-        arg
-      end
-    end
-
-    result = pg_conn.exec_prepared(sym.to_s, args)
-    result.check
-    result
-  end
-  
-  def prepared_statement_name(sql)
-    "pg_metal_#{Digest::MD5.hexdigest(sql)}"
-  end
-
   # -- initialisation -------------------------------------------------
   
   attr :pg_types, :pg_conn
@@ -87,7 +9,7 @@ module ActiveRecord::Metal::Postgresql
     @pg_conn = connection.instance_variable_get("@connection")
     @pg_types = load_pg_types
     
-    unprepare_all
+    # unprepare_all
     
     name, installed_version = exec("SELECT name, installed_version FROM pg_available_extensions WHERE name='hstore'").first
     exec_ "CREATE EXTENSION IF NOT EXISTS hstore" unless installed_version
@@ -118,9 +40,11 @@ end
 
 require_relative "postgresql/conversions"
 require_relative "postgresql/queries"
+require_relative "postgresql/prepared_queries"
+require_relative "postgresql/exec"
 require_relative "postgresql/import"
+require_relative "postgresql/aggregate"
 
 module ActiveRecord::Metal::Postgresql
-  include Queries
-  include Import
+  include Queries, PreparedQueries, Exec, Import, Aggregate
 end

data/lib/active_record/metal/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord; end
 
 class ActiveRecord::Metal
-  VERSION = "0.1.0"
+  VERSION = "0.1.2"
 end

data/lib/active_record/metal.rb

@@ -34,6 +34,9 @@ class ActiveRecord::Metal
   
   include Logging
   extend Logging
+  
+  def self.logger; Logging.logger; end
+  def self.logger=(logger); Logging.logger = logger; end
 end
 
 module ActiveRecord::Metal::EtestBase
@@ -51,6 +54,10 @@ module ActiveRecord::Metal::EtestBase
   def metal
     @metal ||= ActiveRecord::Metal.new
   end
+  
+  def count(table)
+    metal.ask("SELECT COUNT(*) FROM #{table}")
+  end
 end
 
 module ActiveRecord::Metal::Etest

data/test/pg_test.rb

@@ -12,4 +12,5 @@ class PostgresTest < Test::Unit::TestCase
   include ActiveRecord::Metal::Postgresql::Import::Etest
   include ActiveRecord::Metal::Postgresql::Conversions::Etest
   include ActiveRecord::Metal::Postgresql::Queries::Etest
+  include ActiveRecord::Metal::Postgresql::Exec::Etest
 end

data/test/test_helper.rb

@@ -3,6 +3,7 @@ $:.unshift File.expand_path("../../lib", __FILE__)
 require "bundler"
 Bundler.setup(:test)
 require "simplecov"
+SimpleCov.start
 
 require "etest-unit"
 require "active_record/metal"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-metal
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-18 00:00:00.000000000 Z
+date: 2013-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -34,10 +34,13 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/active_record/metal/logging.rb
+- lib/active_record/metal/postgresql/aggregate.rb
 - lib/active_record/metal/postgresql/conversions/etest.rb
 - lib/active_record/metal/postgresql/conversions.rb
 - lib/active_record/metal/postgresql/etest.rb
+- lib/active_record/metal/postgresql/exec.rb
 - lib/active_record/metal/postgresql/import.rb
+- lib/active_record/metal/postgresql/prepared_queries.rb
 - lib/active_record/metal/postgresql/queries.rb
 - lib/active_record/metal/postgresql.rb
 - lib/active_record/metal/transaction.rb
@@ -61,7 +64,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1973847718838922274
+      hash: 89526488637997823
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: