activerecord-metal 0.1.0

data/README.md

@@ -0,0 +1,126 @@
+# activerecord-metal
+
+Because sometimes you need just SQL only.
+
+## Installation
+
+    gem install activerecord-metal
+
+## Usage - Querying
+
+The initial impulse to build activerecord-metal is that I needed to run custom SQL
+queries and wanted properly typed results - something that ActiveRecord gives you
+only for columns that are defined in the table layout, (and "count", probably), 
+but not for custom calculated values.
+
+So there is support for queries.
+
+    # use the current ActiveRecord::Base connection
+    metal = ActiveRecord::Metal.new
+
+    # ask for single results
+    metal.ask "SELECT 2+4"        # => 6
+    metal.ask "SELECT '2+4=6'"    # => '2+4=6'
+
+    # properly deduce types
+    metal.ask "SELECT '1999-01-01 00:00:00'::timestamp"     # => returns a Time object
+
+    # iterate over results
+    metal.exec("SELECT id, name FROM users") do |id, name| 
+      # do something with id and name
+      # ...
+    end
+
+    # also metal.exec returns all rows in an array, which also
+    # contains some type information.
+    results = metal.exec("SELECT id, name FROM users")      # => ary
+    results.types                                           # => [ Numerical, String ]
+    results.columns                                         # => [ "id", "name" ]
+
+    # This information is contained in each of the rows also
+    row = results.first
+    row.types                                               # => [ Numerical, String ]
+    row.columns                                             # => [ "id", "name" ]
+
+    # use positional parameters: note: Rails' '?' placeholders don't work here,
+    # only what is the database's default; and Postgresql uses $1, $2, ...
+    metal.exec("SELECT id, name FROM users WHERE name=$1", "me")
+
+## Usage - Mass import
+
+    # Mass imports for array records
+    #
+    records = [
+      [1, "first user"],
+      [2, "second user"],
+      [3, "third user"]
+    ]
+    
+    # 
+    metal.import "users", records                                     # fill from left
+    metal.import "users", records, :columns => [ "id", "name" ]       # preferred
+
+    # Mass imports for hash records
+    #
+    records = [
+      {id:1, name:"first user", email:"first-user@inter.net"},
+      {id:2, name:"second user"},
+      {id:3, name:"third user"}
+    ]
+    
+    # 
+    metal.import "users", records
+
+### How fast is the mass import?
+
+The metal's importer is faster than ActiveRecord::Base's, because:
+
+- 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)
+
+    1.9.2 ~/projects/gem/activerecord-metal[master] > bundle exec script/console 
+    Loaded /Users/eno/.irbrc
+    irb(main):001:0> ActiveRecord::Metal::Postgresql.etest 
+    Loaded suite ActiveRecord::Metal::Postgresql::Etest
+    Started
+    ....
+    INFO -- : 7.8 msecs INSERT 100 hashes into alloys
+    INFO -- : 6.8 msecs INSERT 100 arrays into alloys
+    INFO -- : 63.6 msecs Import 100 hashes via ActiveRecord::Base
+    INFO -- : 670.3 msecs INSERT 10000 hashes into alloys
+    INFO -- : 676.9 msecs INSERT 10000 arrays into alloys
+    INFO -- : 6520.9 msecs Import 10000 hashes via ActiveRecord::Base
+
+A 10 times speed up sounds massive (and will probably become even faster once
+the `COPY FROM STDIN` importer is completed)), but on the other hand 
+ActiveRecord::Base imports a single record in less than 700 microseconds, 
+which is probably fast enough for most cases.
+
+## Why not ActiveRecord::Base?
+
+ActiveRecord::Base is limited in several ways. It does not
+
+- defer data types from what is in the database - unless it is a column in one of your models.
+- sometimes builds very slow queries
+- use prepared statements (AFAIK)
+- activerecord < 4 does not make use of hstore types
+
+## Why not ActiveRecord::Metal?
+
+ActiveRecord::Metal depends heavily on features of specific databases and 
+adapters. It currently works only on Postgres. Your SQL must be adapted 
+to the database server. There is no validation (except what you are 
+implementing in SQL). And of course: the code base is not exactly mature ;)
+
+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
+
+## 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.rb

@@ -0,0 +1,67 @@
+require "active_record"
+
+class ActiveRecord::Metal
+  attr :connection
+  
+  def initialize(connection = ActiveRecord::Base.connection)
+    @connection = connection
+    
+    extend implementation
+    
+    initialize_implementation
+  end
+  
+  private
+  
+  # To be overridden by the implementation
+  def initialize_implementation
+  end
+  
+  def implementation
+    case connection
+    when ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+      require_relative "metal/postgresql"
+      ActiveRecord::Metal::Postgresql
+    end
+  end
+end
+
+require_relative "metal/logging"
+require_relative "metal/transaction"
+
+class ActiveRecord::Metal
+  include Transaction
+  
+  include Logging
+  extend Logging
+end
+
+module ActiveRecord::Metal::EtestBase
+  SELF = self
+  
+  def self.load_expectation_assertions
+    require "expectation/assertions"
+    extend Expectation::Assertions
+  end
+  
+  def setup
+    SELF.load_expectation_assertions
+  end
+  
+  def metal
+    @metal ||= ActiveRecord::Metal.new
+  end
+end
+
+module ActiveRecord::Metal::Etest
+  include ActiveRecord::Metal::EtestBase
+
+  def metal
+    @metal ||= ActiveRecord::Metal.new
+  end
+
+  def test_pg_connection
+    expect! metal.connection => ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+    expect! metal.is_a?(ActiveRecord::Metal::Postgresql)
+  end
+end

data/lib/active_record/metal/logging.rb

@@ -0,0 +1,43 @@
+module ActiveRecord::Metal::Logging
+  SELF = self
+  
+  @@logger = nil
+  
+  def self.logger
+    @@logger ||= ActiveRecord::Base.logger
+  end
+
+  def self.logger=(logger)
+    @@logger = logger
+  end
+
+  def log_benchmark(severity, runtime, msg)
+    @benchmark_depth ||= 0
+    return if @benchmark_depth > 0
+    return unless logger = SELF.logger
+
+    threshold = ActiveRecord::Base.auto_explain_threshold_in_seconds
+    if threshold
+      return if runtime < threshold
+      severity = :info if severity == :debug
+    end
+
+    runtime = "%.1f msecs" % (runtime * 1000)
+
+    unless msg.gsub!(/\{\{runtime\}\}/, runtime)
+      msg = "#{runtime} #{msg}"
+    end
+
+    logger.send severity, msg
+  end
+  
+  def benchmark(msg, severity = :info)
+    @benchmark_depth ||= 0
+    @benchmark_depth += 1
+    started_at = Time.now
+    yield
+  ensure
+    @benchmark_depth -= 1
+    log_benchmark severity, Time.now - started_at, msg
+  end
+end

data/lib/active_record/metal/postgresql.rb

@@ -0,0 +1,126 @@
+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
+
+  def initialize_implementation
+    @pg_conn = connection.instance_variable_get("@connection")
+    @pg_types = load_pg_types
+    
+    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
+  end
+  
+  def load_pg_types
+    Hash.new("_default").tap do |hsh|
+      hsh[17] = "bytea"
+
+      connection.select_all("SELECT typelem, typname FROM pg_type").
+      each do |record|
+        typelem, typname = record.values_at "typelem", "typname"
+        hsh[typelem.to_i] = typname
+      end
+    end
+  end
+  
+  public
+
+  def has_table?(name)
+    ask "SELECT 't'::BOOLEAN FROM pg_tables WHERE tablename=$1", name
+  end
+  
+  def has_index?(name)
+    ask "SELECT 't'::BOOLEAN FROM pg_indexes WHERE indexname=$1", name
+  end
+end
+
+require_relative "postgresql/conversions"
+require_relative "postgresql/queries"
+require_relative "postgresql/import"
+
+module ActiveRecord::Metal::Postgresql
+  include Queries
+  include Import
+end

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

@@ -0,0 +1,170 @@
+module ActiveRecord::Metal::Postgresql::Conversions
+  module Numeric; end
+  module Time; end
+  module Date; end
+  module Boolean; end
+  module String; end
+  module HStore; end
+
+  include Numeric, Time, Date, Boolean, String, HStore
+  extend self
+  
+  def resolve_type(symbol)
+    sub_converter = included_modules.detect { |mod| mod.method_defined?(symbol) }
+    sub_converter ? sub_converter::T : String
+  end
+end
+
+module ActiveRecord::Metal::Postgresql::Conversions::Numeric
+  T = ::Numeric
+  
+  def _numeric(s)
+    s =~ /\D/ ? Float(s) : Integer(s)
+  end
+
+  def _int(s)
+    Integer(s)
+  end
+
+  def _float(s);    
+    Float(s)
+  rescue ArgumentError
+    case s
+    when /^Infinity$/   then Float::INFINITY
+    when /^-Infinity$/  then -Float::INFINITY
+    when /^NaN$/        then Float::NAN
+    else raise
+    end
+  end
+
+  def _money(s)
+    Float s.gsub(/[^-0-9.]/, "")
+  end
+  
+  def _oid(s)
+    Integer(s)
+  end
+end
+
+module ActiveRecord::Metal::Postgresql::Conversions::Date
+  T = ::Date
+  
+  def _date(s)
+    T.parse(s)
+  end
+end
+
+module ActiveRecord::Metal::Postgresql::Conversions::Time
+  T = ::Time
+
+  def _time(s)
+    T.parse(s)
+  end
+  
+  def _timestamp(s)
+    T.parse(s)
+  end
+  
+  def _timetz(s)
+    T.parse(s)
+  end
+  
+  def _timestamptz(s)
+    T.parse(s)
+  end
+end
+
+module ActiveRecord::Metal::Postgresql::Conversions::Boolean
+  T = ::TrueClass
+  
+  def _bool(s);         s == "t"; end
+end
+
+module ActiveRecord::Metal::Postgresql::Conversions::String
+  T = ::String
+  
+  def _varchar(s)
+    s
+  end
+  
+  def _text(s)
+    s
+  end
+  
+  def _default(s)
+    s
+  end
+  
+  def _name(s)
+    s
+  end
+
+  def _enum(s)
+    s
+  end
+end
+
+module ActiveRecord::Metal::Postgresql::Conversions::HStore
+  SELF = self
+  
+  T = ::Hash
+  NULL = nil
+  
+  def _hstore(s)
+    SELF.unescape(s)
+  end
+  
+  HSTORE_ESCAPED = /[,\s=>\\]/
+
+  # From activerecord-postgres-hstore, r0.6
+  # Escapes values such that they will work in an hstore string
+  def self.escape_string(str)
+    if str.nil?
+      return 'NULL'
+    end
+
+    str = str.to_s
+    # backslash is an escape character for strings, and an escape character for gsub, so you need 6 backslashes to get 2 in the output.
+    # see http://stackoverflow.com/questions/1542214/weird-backslash-substitution-in-ruby for the gory details
+    str = str.gsub(/\\/, '\\\\\\')
+    # escape backslashes before injecting more backslashes
+    str = str.gsub(/"/, '\"')
+
+    if str =~ HSTORE_ESCAPED or str.empty?
+      str = '"%s"' % str
+    end
+
+    return str
+  end
+
+  def self.escape(hsh, connection=ActiveRecord::Base.connection)
+    hsh.map do |idx, val| 
+      "%s=>%s" % [escape_string(idx), escape_string(val)]
+    end * ","
+  end
+  
+  # Creates a hash from a valid double quoted hstore format, 'cause this is the format
+  # that postgresql spits out.
+  def self.unescape(str)
+    token_pairs = (str.scan(hstore_pair)).map { |k,v| [k,v =~ /^NULL$/i ? nil : v] }
+    token_pairs = token_pairs.map { |k,v|
+      [ unescape_string(k).to_sym, unescape_string(v) ]
+    }
+    ::Hash[ token_pairs ]
+  end
+
+  def self.unescape_string(str)
+    case str
+    when nil then str
+    when /\A"(.*)"\Z/m then $1.gsub(/\\(.)/, '\1')
+    else str.gsub(/\\(.)/, '\1')
+    end
+  end
+
+  def self.hstore_pair
+    quoted_string = /"[^"\\]*(?:\\.[^"\\]*)*"/
+    unquoted_string = /[^\s=,][^\s=,\\]*(?:\\.[^\s=,\\]*|=[^,>])*/
+    string = /(#{quoted_string}|#{unquoted_string})/
+    /#{string}\s*=>\s*#{string}/
+  end
+end

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

@@ -0,0 +1,122 @@
+# coding: utf-8
+#require "active_record/metal/postgresql/conversions/etest"
+
+module ActiveRecord::Metal::Postgresql::Conversions::Etest
+  include ActiveRecord::Metal::EtestBase
+  
+  def test_numeric_types
+    expect! metal.ask("SELECT 1") => 1
+
+    [ "smallint", "integer", "bigint", "decimal", "numeric", "real", "double precision" ].each do |type|
+      expect! metal.ask("SELECT 1::#{type}") => 1
+    end
+  end
+  
+  def test_special_numbers
+    expect! metal.ask("SELECT 'Infinity'::real") => Float::INFINITY
+    expect! metal.ask("SELECT '-Infinity'::real") => -Float::INFINITY 
+
+    # Can't test for NAN == NAN
+    # expect! metal.ask("SELECT 'NaN'::real") => Float::NAN 
+  end
+
+  def test_money
+    expect! metal.ask("SELECT 1234::text::money") => 1234.0
+  end
+  
+  def test_strings
+    expect! metal.ask("SELECT 'ok'")
+    expect! metal.ask("SELECT 'good      '") => 'good      '
+    expect! metal.ask("SELECT 'too long'::varchar(5)") => 'too l'
+    expect! metal.ask("SELECT 'ä'") => 'ä'
+  end
+  
+  def test_bytea
+    expect! metal.ask("SELECT '1'::bytea") => '1'
+  end
+  
+  def test_dates
+    expect! metal.ask("SELECT '1/18/1999'::date") => Date.parse("18. 1. 1999")
+    expect! metal.ask("SELECT '1999-01-08 04:05:06'::timestamp") => Time.parse("1999-01-08 04:05:06")
+    expect! metal.ask("SELECT TIMESTAMP '1999-01-08 04:05:06'") => Time.parse("1999-01-08 04:05:06")
+    expect! metal.ask("SELECT CURRENT_TIME") => Time
+    expect! metal.ask("SELECT CURRENT_TIMESTAMP") => Time
+  end
+  
+  def test_true_and_friends
+    expect! metal.ask("SELECT TRUE") => true
+    expect! metal.ask("SELECT FALSE") => false
+    expect! metal.ask("SELECT NULL") => nil
+  end
+  
+  def test_empty_result
+    expect! metal.ask("SELECT NULL WHERE FALSE") => nil
+    expect! metal.ask("SELECT 1 WHERE FALSE") => nil
+  end
+  
+  def test_column_names
+    result = metal.exec("SELECT 1 as one, 2 as two WHERE FALSE")
+    expect! result.columns == %w(one two)
+    expect! result.empty?
+
+    result = metal.exec("SELECT 1 as one, 2 as two")
+    expect! result.columns == %w(one two)
+    expect! result == [[ 1, 2 ]]
+  end
+  
+  def test_hstore
+    result = metal.ask("SELECT 'foo=>foo,bar=>NULL'::hstore")
+    assert_equal result, foo: "foo", bar: nil
+
+    # C = PgTypedQueries::Conversions
+    #
+    # assert_equal C::HStore.escape(a: 1), "'a=>1'::hstore"
+    # assert_equal C::HStore.escape(foo: "foo", bar: nil), "'foo=>foo,bar=>NULL'::hstore"
+  end
+end
+
+module ActiveRecord::Metal::Postgresql::Conversions::Etest
+  include ActiveRecord::Metal::EtestBase
+  
+  def test_numeric_types_args
+    [ "smallint", "integer", "bigint", "decimal", "numeric", "real", "double precision" ].each do |type|
+      expect! metal.ask("SELECT 1::#{type} WHERE 1=$1", 1) => 1
+    end
+  end
+  
+  def test_money_args
+    expect! metal.ask("SELECT 1234::text::money WHERE 1234::text::money=$1", 1234.0) => 1234.0
+  end
+  
+  def test_strings_args
+    expect! metal.ask("SELECT 'ok' WHERE 'ok'=$1", 'ok')    => 'ok'
+    expect! metal.ask("SELECT 'ä' WHERE 'ä'=$1", 'ä')       => 'ä'
+  end
+  
+  def test_bytea_args
+    expect! metal.ask("SELECT '1'::bytea WHERE  '1'::bytea=$1", '1') => '1'
+  end
+  
+  def test_dates_args
+    date = Date.parse("18. 1. 1999")
+    expect! metal.ask("SELECT '1/18/1999'::date WHERE '1/18/1999'::date=$1", date) => date
+
+    ts = Time.parse("1999-01-08 04:05:06")
+    expect! metal.ask("SELECT '1999-01-08 04:05:06'::timestamp WHERE '1999-01-08 04:05:06'::timestamp=$1", ts) => ts
+  end
+  
+  def test_true_and_friends_args
+    expect! metal.ask("SELECT TRUE WHERE TRUE=$1", true) => true
+    expect! metal.ask("SELECT FALSE WHERE FALSE=$1", false) => false
+  end
+  
+  def test_hstore_args
+    id = metal.ask "INSERT INTO alloys(hsh) VALUES($1) RETURNING id", foo: "foo", bar: nil
+    assert_equal metal.ask("SELECT hsh FROM alloys WHERE id=$1", id), bar: nil, foo: "foo"
+
+
+    result = metal.ask("SELECT 'foo=>foo,bar=>NULL'::hstore WHERE 'foo=>foo,bar=>NULL'::hstore=$1",
+                        foo: "foo", bar: nil)
+    assert_equal result, foo: "foo", bar: nil
+  end
+end

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

@@ -0,0 +1,79 @@
+# coding: utf-8
+
+module ActiveRecord::Metal::Postgresql::Etest
+  include ActiveRecord::Metal::EtestBase
+  
+  def test_simple_query
+    expect! metal.ask("SELECT 1") => 1
+    result = metal.exec("SELECT 1 AS number")
+    assert_equal(result, [[1]])
+    assert_equal(result.types, [Numeric])
+    assert_equal(result.columns, ["number"])
+  end
+
+  def test_null_query
+    expect! metal.ask("SELECT 1 AS number WHERE FALSE") => nil
+    result = metal.exec("SELECT 1 AS number WHERE FALSE")
+    assert_equal(result, [])
+    assert_equal(result.types, [Numeric])
+    assert_equal(result.columns, ["number"])
+  end
+
+  def test_positioned_parameters
+    expect! metal.ask("SELECT 1 AS number WHERE 1=$1", 1) => 1
+    assert_equal metal.exec("SELECT 1 AS number WHERE 1=$1", 1), [[1]]
+    assert_equal metal.exec("SELECT 1 AS value WHERE 1=$1", 1), [[1]]
+    assert_equal metal.exec("SELECT 1 AS value WHERE 1=$1", "1"), [[1]]
+  end
+  
+  def test_exceptions
+    assert_raise() {  
+        metal.exec("SELECT 1 FROM unknown")
+    }
+  end
+
+  def import_performance(count)
+    return if ENV["ARM_ENV"] == "test" && count > 10
+    
+    # -- setup records ------------------------------------------------
+
+    records = 1.upto(count).map do |rec|
+      {
+        num:    rand(100000),
+        num2:   rand(100000),
+        str1:   "alloy_#{Digest::MD5.hexdigest(rand(100000).to_s)}"
+      }
+    end
+
+    id = 0
+    values = records.map { |rec| 
+      [ (id += 1) ] + rec.values_at(:num, :num2, :str1)
+    }
+
+    # -- run tests ----------------------------------------------------
+
+    metal.ask "DELETE FROM alloys"
+
+    metal.import "alloys", records
+    metal.ask "DELETE FROM alloys"
+
+    metal.import "alloys", values
+    metal.ask "DELETE FROM alloys"
+    
+    ActiveRecord::Metal.benchmark "Import #{count} hashes via ActiveRecord::Base" do
+      Alloy.transaction do
+        records.each do |record|
+          Alloy.create! record
+        end
+      end
+    end
+
+    metal.ask "DELETE FROM alloys"
+  end
+  
+  def test_import_performance
+    import_performance(1)
+    import_performance(100)
+    import_performance(10000)
+  end
+end

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

@@ -0,0 +1,141 @@
+module ActiveRecord::Metal::Postgresql::Import
+  #
+  # Import a number of records into a table.
+  # records is either an Array of Hashes or an Array of Arrays.
+  # In the latter case each record *must* match the order of columns
+  # in the table.
+  def import(table_name, records, options = {})
+    return if records.empty?
+    importer = records.first.is_a?(Hash) ? :hashes : :arrays
+
+    benchmark "INSERT #{records.length} #{importer} into #{table_name}" do
+      expect! table_name => /^\S+$/
+      expect! records.first => [ nil, Hash, Array ]
+
+      case records.length
+      when 0 then :nop
+      when 1 then               send("import_#{importer}", table_name, records, options)
+      else        transaction { send("import_#{importer}", table_name, records, options) }
+      end
+    end
+  end
+
+  private
+  
+  def import_hashes(table_name, records, _)
+    keys = records.inject([]) do |ary, record|
+      ary | record.keys
+    end
+    
+    keys.each { |key| expect! key => Symbol }
+    keys.each { |key| expect! key.to_s => /^\S+$/ }
+
+    values = 1.upto(keys.length).map { |idx| "$#{idx}" }
+    
+    sql = "INSERT INTO #{table_name}(#{keys.join(",")}) VALUES(#{values.join(",")})"
+    stmt = prepare(sql)
+    records.each do |record|
+      exec_prepared stmt, *record.values_at(*keys)
+    end
+  rescue
+    logger.warn "#{$!.class.name}: #{$!}"
+    raise
+  ensure
+    unprepare(stmt)
+  end
+  
+  def import_arrays(table_name, records, options)
+    columns = if options[:columns]
+      "(" + options[:columns].join(",") + ")"
+    end
+    
+    values = 1.upto(records.first.length).map { |idx| "$#{idx}" }
+
+    sql = "INSERT INTO #{table_name}#{columns} VALUES(#{values.join(",")})"
+    stmt = prepare(sql)
+    
+    records.each do |record|
+      exec_prepared stmt, *record
+    end
+  rescue
+    logger.warn "#{$!.class.name}: #{$!}"
+    raise
+  ensure
+    unprepare(stmt)
+  end
+end
+
+module ActiveRecord::Metal::Postgresql::Import::Etest
+  include ActiveRecord::Metal::EtestBase
+  
+  # metal.ask "CREATE TABLE test(num INTEGER, num2 INTEGER, str1 VARCHAR)"
+
+  def test_import_none
+    metal.ask "DELETE FROM alloys"
+    metal.import "alloys", []
+    expect! metal.ask("SELECT COUNT(*) FROM alloys") => 0
+  end
+
+  def test_import_array
+    metal.ask "DELETE FROM alloys"
+    metal.import "alloys", [[1,2,"one"]], :columns => %w(num num2 str1)
+    expect! metal.ask("SELECT COUNT(*) FROM alloys") => 1
+  end
+
+  def test_import_array_wo_columns
+    metal.ask "DELETE FROM alloys"
+    metal.import "alloys", [[1,1,2,"one"]]
+    expect! metal.ask("SELECT COUNT(*) FROM alloys") => 1
+  end
+  
+  def test_import_hashes
+    metal.ask "DELETE FROM alloys"
+    metal.import "alloys", [ num: 1, num2: 1, str1: "one" ]
+    expect! metal.ask("SELECT COUNT(*) FROM alloys") => 1
+  end
+end
+
+__END__
+
+# This is example code to load a table via COPY FROM
+def flush_load(records)
+  copy_data = records.map do |name, value, timestamp, payload|
+    escaped_payload = PgTypedQueries::Conversions::HStore.escape_without_type(payload, connection) if payload
+    escaped_payload ||= "NULL"
+
+    "#{name}|#{value}|#{timestamp.to_i}|#{escaped_payload}\n"
+  end.join
+  
+  # STDERR.puts "Running COPY command with #{copy_data.bytesize} bytes for #{records.length} records"
+  
+  copy_data = StringIO.new(copy_data)
+  
+  connection.transaction do
+    conn = connection.instance_variable_get "@connection"
+    buf = ''
+    conn.exec("COPY #{table_name} FROM STDIN WITH DELIMITER '|' NULL 'NULL'")
+    begin
+      while copy_data.read(256, buf)
+        ### Uncomment this to test error-handling for exceptions from the reader side:
+        # raise Errno::ECONNRESET, "socket closed while reading"
+        # $stderr.puts "  sending %d bytes of data..." % [ buf.length ]
+        # $stderr.puts "copy #{buf}"
+        until conn.put_copy_data( buf )
+          $stderr.puts "	waiting for connection to be writable..."
+          sleep 0.1
+        end
+      end
+
+      # puts "done copying"
+    rescue Errno => err
+      errmsg = "%s while reading copy data: %s" % [ err.class.name, err.message ]
+      conn.put_copy_end(errmsg)
+    else
+      conn.put_copy_end
+      while res = conn.get_result
+        $stderr.puts "Result of COPY is: %s" % [ res.res_status(res.result_status) ]
+        $stderr.puts res.error_message()
+      end
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+module ActiveRecord::Metal::Postgresql::Queries
+  class ArrayWithTypeInfo < Array
+    attr :columns, :types
+
+    def initialize(values, columns, types)
+      @columns, @types = columns, types
+      replace(values)
+    end
+  end
+
+  class Result < Array
+    attr :columns, :types
+    
+    def initialize(metal, pg_result, *args)
+      @metal, @pg_result = metal, pg_result
+      @current_row = 0
+
+      setup_colums
+      setup_types
+    end
+
+    def next_row
+      return nil if @current_row >= @pg_result.ntuples
+      
+      values = 0.upto(@pg_result.nfields-1).map do |column_number|
+        data = @pg_result.getvalue(@current_row, column_number)
+        data = @converters[column_number].call(data) if data
+        data
+      end
+
+      ArrayWithTypeInfo.new values, columns, types
+    ensure
+      @current_row += 1
+    end
+    
+    private
+    
+    def setup_colums
+      @columns = (0 ... @pg_result.nfields).map { |i| @pg_result.fname(i) }
+    end
+    
+    Conversions = ActiveRecord::Metal::Postgresql::Conversions
+
+    def setup_types
+      metal_pg_types = @metal.send(:pg_types)
+
+      pg_types = (0 ... @pg_result.nfields).map do |i|
+        pg_type_id = @pg_result.ftype(i)
+        pg_type = metal_pg_types[pg_type_id] || raise("Unknown pg_type_id: #{pg_type_id}")
+        pg_type.gsub(/\d+$/, "").to_sym
+      end
+      
+      # -- ruby types -------------------------------------------------
+
+      @types = pg_types.map do |pg_type| 
+        Conversions.resolve_type(pg_type)
+      end
+
+      # -- converters -------------------------------------------------
+
+      pg_conn = @metal.send(:pg_conn)
+      unescape_bytea = lambda { |s| pg_conn.unescape_bytea(s) }
+
+      @converters = pg_types.map do |pg_type|
+        if pg_type == :_bytea
+          unescape_bytea
+        else
+          Conversions.method(pg_type)
+        end
+      end
+    end
+  end
+
+  def exec(sql, *args, &block)
+    started_at = Time.now
+    
+    # prepared queries - denoted by symbols - are executed as such, and
+    # not cleaned up. A caller can get a prepared query by calling 
+    # metal.prepare.
+    if sql.is_a?(Symbol)
+      pg_result = exec_prepared(sql, *args)
+    elsif args.empty?
+      pg_result = exec_(sql)
+    else
+      name = prepare(sql)
+      pg_result = exec_prepared(name, *args)
+      unprepare(sql)
+    end
+
+    result = Result.new(self, pg_result, *args)
+
+    rows = []
+    while row = result.next_row
+      yield row if block
+      rows << row
+    end
+
+    ArrayWithTypeInfo.new rows, result.columns, result.types
+  ensure
+    log_benchmark :debug, Time.now - started_at, 
+                  "SQL: {{runtime}} %s %s" % [ sql.is_a?(Symbol) ? "[P]" : "   ", resolve_query(sql) ]
+  end
+  
+  def ask(sql, *args)
+    first_row = nil
+    
+    catch(:received_first_row) do
+      exec(sql, *args) do |row|
+        first_row = row
+        throw :received_first_row
+      end
+    end
+    
+    first_row && first_row.first
+  end
+end
+
+module ActiveRecord::Metal::Postgresql::Queries::Etest
+  include ActiveRecord::Metal::EtestBase
+
+  def test_benchmark
+    metal.ask("SELECT 1")
+    metal.ask("SELECT 1 WHERE 1=$1", 1)
+    query = metal.prepare("SELECT 1 WHERE 1=$1")
+    metal.ask(query, 1)
+    metal.unprepare(query)
+  end
+end
+

data/lib/active_record/metal/transaction.rb

@@ -0,0 +1,42 @@
+module ActiveRecord::Metal::Transaction
+  # We use ActiveRecord::Base's transaction, because this one supports
+  # nested transactions by automatically falling back to savepoints
+  # when needed.
+  def transaction(mode = :readwrite, &block)
+    if mode == :readonly
+      ro_transaction(&block)
+    else
+      connection.transaction(&block)
+    end
+  end
+  
+  private
+  
+  def ro_transaction(&block)
+    r = nil
+    connection.transaction do 
+      r = yield
+      raise ActiveRecord::Rollback
+    end
+    r
+  end
+end
+
+module ActiveRecord::Metal::Transaction::Etest
+  def test_transaction_return_values
+    expect! metal.transaction { 1 } => 1
+    expect! metal.transaction(:readonly) { 1 } => 1
+  end
+  
+  def test_transaction
+    expect! metal.ask("SELECT COUNT(*) FROM alloys") => 0
+    metal.transaction { metal.ask "INSERT INTO alloys(num) VALUES(1)" }
+    expect! metal.ask("SELECT COUNT(*) FROM alloys") => 1
+  end
+  
+  def test_ro_transaction
+    expect! metal.ask("SELECT COUNT(*) FROM alloys") => 0
+    metal.transaction(:readonly) { metal.ask "INSERT INTO alloys(num) VALUES(1)" }
+    expect! metal.ask("SELECT COUNT(*) FROM alloys") => 0
+  end
+end

data/lib/active_record/metal/version.rb

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

data/lib/activerecord-metal.rb

@@ -0,0 +1 @@
+require "active_record/metal"

data/test/pg_test.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+require_relative "test_helper"
+
+Dir.glob(File.dirname(__FILE__) + "/../lib/active_record/metal/**/etest.rb").each do |file|
+  load file
+end
+
+class PostgresTest < Test::Unit::TestCase
+  include ActiveRecord::Metal::Etest
+  include ActiveRecord::Metal::Transaction::Etest
+  include ActiveRecord::Metal::Postgresql::Etest
+  include ActiveRecord::Metal::Postgresql::Import::Etest
+  include ActiveRecord::Metal::Postgresql::Conversions::Etest
+  include ActiveRecord::Metal::Postgresql::Queries::Etest
+end

data/test/test_helper.rb

@@ -0,0 +1,37 @@
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require "bundler"
+Bundler.setup(:test)
+require "simplecov"
+
+require "etest-unit"
+require "active_record/metal"
+
+ActiveRecord::Base.establish_connection(
+  :adapter  => "postgresql",
+  :database => "activerecord_metal"
+)
+
+metal = ActiveRecord::Metal.new
+metal.ask "DROP TABLE IF EXISTS alloys"
+metal.ask <<-SQL
+CREATE TABLE alloys(
+  id SERIAL PRIMARY KEY, 
+  num INTEGER, 
+  num2 INTEGER, 
+  str1 VARCHAR, 
+  hsh hstore
+)
+SQL
+
+class Alloy < ActiveRecord::Base
+end
+
+require "logger"
+
+ENV["ARM_ENV"] = "test"
+
+# ActiveRecord::Base.logger = Logger.new File.open(File.expand_path("../../log/test.log", __FILE__), "w")
+ActiveRecord::Base.logger = Logger.new STDERR
+ActiveRecord::Base.logger.level = Logger::INFO
+# ActiveRecord::Base.auto_explain_threshold_in_seconds = 0.010

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-metal
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- radiospiel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  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: Build your tests alongside your code.
+email: eno@radiospiel.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/active_record/metal/logging.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/import.rb
+- lib/active_record/metal/postgresql/queries.rb
+- lib/active_record/metal/postgresql.rb
+- lib/active_record/metal/transaction.rb
+- lib/active_record/metal/version.rb
+- lib/active_record/metal.rb
+- lib/activerecord-metal.rb
+- README.md
+- test/pg_test.rb
+- test/test_helper.rb
+homepage: http://github.com/radiospiel/etest
+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'
+      segments:
+      - 0
+      hash: -1973847718838922274
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Build your tests alongside your code.
+test_files: []