simple-sql 0.3.7 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ebc8a4a49401550f8549ea98b802f8eb523d9ef4
-  data.tar.gz: d8f4339ec84a7dc8fb03088db8f38ee802072a42
+  metadata.gz: c2aa68ab4036da8b4bc0eae03f6e4245bd4e8620
+  data.tar.gz: 02eef57ff0d00d3a1d35ef861d1efc88976c1e74
 SHA512:
-  metadata.gz: 67886aafa505ee2ffe6146742a671b5cae23f4a38641fd536e24821383a30a852221e104b512041aadfd01e867c3def28654603a9b2ac19aa591ef7d3867119c
-  data.tar.gz: c858be8d0075d5b0bf448313ec1ce47ef6167d1206cc684cfc8dcea61569ad04cbe8a43eef7de5efc19e2d6382a952673fff85d90065f7812786b1e70c0776d5
+  metadata.gz: 1262f806ebf0db280660ead752521fd3890f9c9472a8ba62f21ab87aa263c369319dab4a300035dabe8288997b68fa1e250c202ba5021b33af438c536c46d63f
+  data.tar.gz: 895728b860f7861b0a7e8f46507abcbe07b70d03ec36520893c507d3939c4848e838f7b0d0804467409daa611485003c66e180c4634b1d0443ace09e3d31798c

data/.rubocop.yml

@@ -10,7 +10,7 @@ AllCops:
     - 'Rakefile'
 
 Metrics/LineLength:
-  Max: 115
+  Max: 120
 
 Style/SpecialGlobalVars:
   Enabled: false
@@ -57,3 +57,6 @@ Style/NumericPredicate:
 
 Style/RegexpLiteral:
   Enabled: false
+
+Style/ClassVars:
+  Enabled: false

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    simple-sql (0.3.7)
+    simple-sql (0.4.0)
       pg (~> 0.20)
       pg_array_parser (~> 0)
 

data/lib/simple/sql.rb

@@ -6,132 +6,50 @@ require_relative "sql/decoder.rb"
 require_relative "sql/encoder.rb"
 require_relative "sql/config.rb"
 require_relative "sql/logging.rb"
+require_relative "sql/simple_transactions.rb"
+require_relative "sql/connection_adapter.rb"
 require_relative "sql/connection.rb"
 require_relative "sql/reflection.rb"
 require_relative "sql/insert.rb"
 require_relative "sql/duplicate.rb"
 
-# rubocop:disable Metrics/MethodLength
-
 module Simple
   # The Simple::SQL module
   module SQL
     extend self
-
-    def logger
-      @logger ||= default_logger
-    end
-
-    def logger=(logger)
-      @logger = logger
-    end
-
-    def default_logger
-      logger = ActiveRecord::Base.logger if defined?(ActiveRecord)
-      return logger if logger
-
-      logger = Logger.new(STDERR)
-      logger.level = Logger::INFO
-      logger
-    end
-
-    # execute one or more sql statements. This method does not allow to pass in
-    # arguments - since the pg client does not support this - but it allows to
-    # run multiple sql statements separated by ";"
-    def exec(sql)
-      Logging.yield_logged sql do
-        connection.exec sql
-      end
-    end
-
-    # Runs a query, with optional arguments, and returns the result. If the SQL
-    # query returns rows with one column, this method returns an array of these
-    # values. Otherwise it returns an array of arrays.
-    #
-    # Example:
-    #
-    # - <tt>Simple::SQL.all("SELECT id FROM users")</tt> returns an array of id values
-    # - <tt>Simple::SQL.all("SELECT id, email FROM users")</tt> returns an array of
-    #         arrays `[ <id>, <email> ]`.
-    #
-    # Simple::SQL.all "SELECT id, email FROM users" do |id, email|
-    #   # do something
-    # end
-
-    def all(sql, *args, into: nil, &block)
-      result = exec_logged(sql, *args)
-      enumerate(result, into: into, &block)
-    end
-
-    # Runs a query and returns the first result row of a query.
-    #
-    # Examples:
-    #
-    # - <tt>Simple::SQL.ask "SELECT id FROM users WHERE email=$?", "foo@local"</tt>
-    #   returns a number (or +nil+)
-    # - <tt>Simple::SQL.ask "SELECT id, email FROM users WHERE email=$?", "foo@local"</tt>
-    #   returns an array <tt>[ <id>, <email> ]</tt> (or +nil+)
-    def ask(sql, *args, into: nil)
-      catch(:ok) do
-        all(sql, *args, into: into) { |row| throw :ok, row }
-        nil
-      end
-    end
-
-    # [Deprecated] Runs a query, with optional arguments, and returns the
-    # result as an array of Hashes.
-    def records(sql, *args, into: Hash, &block)
-      all sql, *args, into: (into || Hash), &block
-    end
-
-    # [Deprecated] Runs a query and returns the first result row of a query
-    # as a Hash.
-    def record(sql, *args, into: Hash)
-      ask sql, *args, into: (into || Hash)
-    end
-
     extend Forwardable
+    delegate [:ask, :all, :each] => :connection
     delegate [:transaction, :wait_for_notify] => :connection
 
-    private
+    delegate [:logger, :logger=] => ::Simple::SQL::Logging
 
-    def exec_logged(sql, *args)
-      Logging.yield_logged sql, *args do
-        connection.exec_params(sql, Encoder.encode_args(args))
-      end
-    end
-
-    def enumerate(result, into:, &block)
-      decoder = Decoder.new(result, into: into)
-
-      if block
-        result.each_row do |row|
-          yield decoder.decode(row)
-        end
-        self
-      else
-        ary = []
-        result.each_row { |row| ary << decoder.decode(row) }
-        ary
-      end
-    end
-
-    def resolve_type(ftype, fmod)
-      @resolved_types ||= {}
-      @resolved_types[[ftype, fmod]] ||= connection.exec("SELECT format_type($1,$2)", [ftype, fmod]).getvalue(0, 0)
-    end
+    private
 
     def connection
-      @connector.call
+      connector.call
     end
 
+    # The connector attribute returns a lambda, which, when called, returns a connection
+    # object.
+    #
+    # If this seems weird: this is for interacting with ActiveRecord. To be in sync how
+    # Rails handles ActiveRecord connections (it checks it out of a connection pool when
+    # needed for the first time in a request cycle, and checks it in afterwards) we need
+    # to make sure not to keep a reference to the actual connection object around. Instead
+    # we need to be able to call a function (in that case ActiveRecord::Base.connection).
+    #
+    # In non-Rails mode the connector really is a lambda which just returns an object.
+    #
+    # In any case the connector is stored in a thread-safe fashion. This is not necessary
+    # in Rails mode (because AR::B.connection itself is thread-safe already), but in non-
+    # Rails-mode we make sure to manage one connection per thread.
     def connector=(connector)
-      @connector = connector
+      Thread.current[:"Simple::SQL.connector"] = connector
     end
 
-    self.connector = lambda {
-      connect_to_active_record
-    }
+    def connector
+      Thread.current[:"Simple::SQL.connector"] ||= lambda { connect_to_active_record }
+    end
 
     def connect_to_active_record
       return Connection.active_record_connection if defined?(ActiveRecord)
@@ -161,12 +79,17 @@ module Simple
     def connect!(database_url = :auto)
       database_url = Config.determine_url if database_url == :auto
 
-      logger.info "Connecting to #{database_url}"
+      Logging.info "Connecting to #{database_url}"
       config = Config.parse_url(database_url)
 
       require "pg"
       connection = Connection.pg_connection(PG::Connection.new(config))
       self.connector = lambda { connection }
     end
+
+    # disconnects the current connection.
+    def disconnect!
+      self.connector = nil
+    end
   end
 end

data/lib/simple/sql/connection.rb

@@ -1,6 +1,3 @@
-# rubocop:disable Metrics/MethodLength
-# rubocop:disable Style/IfUnlessModifier
-
 # private
 module Simple::SQL::Connection
   def self.active_record_connection
@@ -11,60 +8,34 @@ module Simple::SQL::Connection
     PgConnection.new(connection)
   end
 
+  # A PgConnection object is built around a raw connection. It includes
+  # the ConnectionAdapter, which implements ask, all, + friends, and also
+  # includes a quiet simplistic Transaction implementation
   class PgConnection
-    extend Forwardable
-    delegate %w(exec_params exec escape wait_for_notify) => :@raw_connection
+    attr_reader :raw_connection
 
     def initialize(raw_connection)
       @raw_connection = raw_connection
-      @tx_nesting_level = 0
     end
 
-    private
-
-    def transaction(&_block)
-      # Notes: by using "ensure" (as opposed to rescue) we are rolling back
-      # both when an exception was raised and when a value was thrown. This
-      # also means we have to track whether or not to rollback. i.e. do roll
-      # back when we yielded to &block but not otherwise.
-      #
-      # Also the transaction support is a bit limited: you cannot rollback.
-      # Rolling back from inside a nested transaction would require SAVEPOINT
-      # support; without the code is simpler at least :)
-
-      if @tx_nesting_level == 0
-        exec "BEGIN"
-        tx_started = true
-      end
-
-      @tx_nesting_level += 1
+    include ::Simple::SQL::ConnectionAdapter          # all, ask, first, etc.
+    include ::Simple::SQL::SimpleTransactions         # transactions
 
-      return_value = yield
-
-      # Only commit if we started a transaction here.
-      if tx_started
-        exec "COMMIT"
-        tx_committed = true
-      end
-
-      return_value
-    ensure
-      @tx_nesting_level -= 1
-      if tx_started && !tx_committed
-        exec "ROLLBACK"
-      end
-    end
+    extend Forwardable
+    delegate [:wait_for_notify] => :raw_connection    # wait_for_notify
   end
 
   module ActiveRecordConnection
     extend self
 
+    extend ::Simple::SQL::ConnectionAdapter           # all, ask, first, etc.
+
     extend Forwardable
-    delegate %w(exec_params exec escape wait_for_notify) => :raw_connection
-    delegate [:transaction] => :connection
+    delegate [:transaction] => :connection            # transactions
+    delegate [:wait_for_notify] => :connection        # wait_for_notify
 
     def raw_connection
-      connection.raw_connection
+      ActiveRecord::Base.connection.raw_connection
     end
 
     def connection

data/lib/simple/sql/connection_adapter.rb

@@ -0,0 +1,81 @@
+# rubocop:disable Metrics/MethodLength
+
+# This module implements an adapter between the Simple::SQL interface
+# (i.e. ask, all, first, transaction) and a raw connection.
+#
+# This module can be mixed onto objects that implement a raw_connection
+# method, which must return a Pg::Connection.
+module Simple::SQL::ConnectionAdapter
+  Logging = Simple::SQL::Logging
+  Encoder = Simple::SQL::Encoder
+  Decoder = Simple::SQL::Decoder
+
+  # execute one or more sql statements. This method does not allow to pass in
+  # arguments - since the pg client does not support this - but it allows to
+  # run multiple sql statements separated by ";"
+  def exec(sql)
+    Logging.yield_logged sql do
+      raw_connection.exec sql
+    end
+  end
+
+  # Runs a query, with optional arguments, and returns the result. If the SQL
+  # query returns rows with one column, this method returns an array of these
+  # values. Otherwise it returns an array of arrays.
+  #
+  # Example:
+  #
+  # - <tt>Simple::SQL.all("SELECT id FROM users")</tt> returns an array of id values
+  # - <tt>Simple::SQL.all("SELECT id, email FROM users")</tt> returns an array of
+  #         arrays `[ <id>, <email> ]`.
+  #
+  # Simple::SQL.all "SELECT id, email FROM users" do |id, email|
+  #   # do something
+  # end
+
+  def all(sql, *args, into: nil, &block)
+    result = exec_logged(sql, *args)
+    enumerate(result, into: into, &block)
+  end
+
+  # Runs a query and returns the first result row of a query.
+  #
+  # Examples:
+  #
+  # - <tt>Simple::SQL.ask "SELECT id FROM users WHERE email=$?", "foo@local"</tt>
+  #   returns a number (or +nil+)
+  # - <tt>Simple::SQL.ask "SELECT id, email FROM users WHERE email=$?", "foo@local"</tt>
+  #   returns an array <tt>[ <id>, <email> ]</tt> (or +nil+)
+  def ask(sql, *args, into: nil)
+    catch(:ok) do
+      all(sql, *args, into: into) { |row| throw :ok, row }
+      nil
+    end
+  end
+
+  def exec_logged(sql, *args)
+    Logging.yield_logged sql, *args do
+      raw_connection.exec_params(sql, Encoder.encode_args(raw_connection, args))
+    end
+  end
+
+  def enumerate(result, into:, &block)
+    decoder = Decoder.new(self, result, into: into)
+
+    if block
+      result.each_row do |row|
+        yield decoder.decode(row)
+      end
+      self
+    else
+      ary = []
+      result.each_row { |row| ary << decoder.decode(row) }
+      ary
+    end
+  end
+
+  def resolve_type(ftype, fmod)
+    @resolved_types ||= {}
+    @resolved_types[[ftype, fmod]] ||= raw_connection.exec("SELECT format_type($1,$2)", [ftype, fmod]).getvalue(0, 0)
+  end
+end

data/lib/simple/sql/decoder.rb

@@ -4,12 +4,12 @@ require "time"
 module Simple::SQL::Decoder
   extend self
 
-  def new(result, into:)
-    if into == Hash           then HashRecord.new(result)
-    elsif into == :struct     then StructRecord.new(result)
-    elsif into                then Record.new(result, into: into)
-    elsif result.nfields == 1 then SingleColumn.new(result)
-    else                           MultiColumns.new(result)
+  def new(connection, result, into:)
+    if into == Hash           then HashRecord.new(connection, result)
+    elsif into == :struct     then StructRecord.new(connection, result)
+    elsif into                then Record.new(connection, result, into: into)
+    elsif result.nfields == 1 then SingleColumn.new(connection, result)
+    else                           MultiColumns.new(connection, result)
     end
   end
 
@@ -82,8 +82,8 @@ module Simple::SQL::Decoder
 end
 
 class Simple::SQL::Decoder::SingleColumn
-  def initialize(result)
-    typename = ::Simple::SQL.send(:resolve_type, result.ftype(0), result.fmod(0))
+  def initialize(connection, result)
+    typename = connection.resolve_type(result.ftype(0), result.fmod(0))
     @field_type = typename.to_sym
   end
 
@@ -94,9 +94,9 @@ class Simple::SQL::Decoder::SingleColumn
 end
 
 class Simple::SQL::Decoder::MultiColumns
-  def initialize(result)
+  def initialize(connection, result)
     @field_types = 0.upto(result.fields.length - 1).map do |idx|
-      typename = ::Simple::SQL.send(:resolve_type, result.ftype(idx), result.fmod(idx))
+      typename = connection.resolve_type(result.ftype(idx), result.fmod(idx))
       typename.to_sym
     end
   end
@@ -109,8 +109,8 @@ class Simple::SQL::Decoder::MultiColumns
 end
 
 class Simple::SQL::Decoder::HashRecord < Simple::SQL::Decoder::MultiColumns
-  def initialize(result)
-    super(result)
+  def initialize(connection, result)
+    super(connection, result)
     @field_names = result.fields.map(&:to_sym)
   end
 
@@ -121,8 +121,8 @@ class Simple::SQL::Decoder::HashRecord < Simple::SQL::Decoder::MultiColumns
 end
 
 class Simple::SQL::Decoder::Record < Simple::SQL::Decoder::HashRecord
-  def initialize(result, into:)
-    super(result)
+  def initialize(connection, result, into:)
+    super(connection, result)
     @into = into
   end
 
@@ -134,8 +134,8 @@ end
 class Simple::SQL::Decoder::StructRecord < Simple::SQL::Decoder::MultiColumns
   @@struct_cache = {}
 
-  def initialize(result)
-    super(result)
+  def initialize(connection, result)
+    super(connection, result)
 
     field_names = result.fields.map(&:to_sym)
     @into = @@struct_cache[field_names] ||= Struct.new(*field_names)

data/lib/simple/sql/encoder.rb

@@ -1,15 +1,12 @@
 # private
 module Simple::SQL::Encoder
   extend self
-  extend Forwardable
 
-  delegate connection: ::Simple::SQL
-
-  def encode_args(args)
-    args.map { |arg| encode_arg(arg) }
+  def encode_args(connection, args)
+    args.map { |arg| encode_arg(connection, arg) }
   end
 
-  def encode_arg(arg)
+  def encode_arg(connection, arg)
     return arg unless arg.is_a?(Array)
 
     if arg.first.is_a?(String)

data/lib/simple/sql/insert.rb

@@ -1,4 +1,3 @@
-# rubocop:disable Style/ClassVars
 # rubocop:disable Metrics/AbcSize
 # rubocop:disable Metrics/LineLength
 module Simple

data/lib/simple/sql/logging.rb

@@ -1,20 +1,52 @@
-# rubocop:disable Metrics/AbcSize
-# rubocop:disable Metrics/LineLength
-
 module Simple
   module SQL
     module Logging
       extend self
 
+      # The logger object.
+      #
+      # If no logger was set via <tt>Simple::SQL::Logging.logger = <foo></tt>
+      # this returns a default logger.
+      def logger
+        @logger ||= default_logger
+      end
+
+      # The logger object.
+      def logger=(logger)
+        @logger = logger
+      end
+
+      private
+
+      def default_logger
+        # return the ActiveRecord logger, if it exists.
+        if defined?(ActiveRecord)
+          logger = ActiveRecord::Base.logger
+          return logger if logger
+        end
+
+        # returns a stderr_logger
+        @stderr_logger ||= begin
+          logger = Logger.new(STDERR)
+          logger.level = Logger::INFO
+          logger
+        end
+      end
+
+      public
+
+      extend Forwardable
+      delegate [:debug, :info, :warn, :error, :fatal] => :logger
+
       def yield_logged(sql, *args, &_block)
         r0 = Time.now
         rv = yield
         realtime = Time.now - r0
-        ::Simple::SQL.logger.debug "[sql] %.3f secs: %s" % [realtime, format_query(sql, *args)]
+        debug "[sql] %.3f secs: %s" % [realtime, format_query(sql, *args)]
         rv
       rescue StandardError => e
         realtime = Time.now - r0
-        ::Simple::SQL.logger.warn "[sql] %.3f secs: %s:\n\tfailed with error %s" % [realtime, format_query(sql, *args), e.message]
+        warn "[sql] %.3f secs: %s:\n\tfailed with error %s" % [realtime, format_query(sql, *args), e.message]
         raise
       end
 

data/lib/simple/sql/reflection.rb

@@ -47,7 +47,7 @@ module Simple
                     "table_schema || '.' || table_name AS name, *"
                   end
 
-        recs = records <<~SQL, schema
+        recs = all <<~SQL, schema, into: Hash
           SELECT #{columns}
           FROM information_schema.tables
           WHERE table_schema=$1
@@ -57,7 +57,7 @@ module Simple
 
       def column_info(table_name)
         schema, table_name = parse_table_name(table_name)
-        recs = records <<~SQL, schema, table_name
+        recs = all <<~SQL, schema, table_name, into: Hash
           SELECT
             column_name AS name,
             *

data/lib/simple/sql/simple_transactions.rb

@@ -0,0 +1,46 @@
+# rubocop:disable Metrics/MethodLength
+# rubocop:disable Style/IfUnlessModifier
+
+# private
+module Simple::SQL::SimpleTransactions
+  def tx_nesting_level
+    @tx_nesting_level ||= 0
+  end
+
+  def tx_nesting_level=(tx_nesting_level)
+    @tx_nesting_level = tx_nesting_level
+  end
+
+  def transaction(&_block)
+    # Notes: by using "ensure" (as opposed to rescue) we are rolling back
+    # both when an exception was raised and when a value was thrown. This
+    # also means we have to track whether or not to rollback. i.e. do roll
+    # back when we yielded to &block but not otherwise.
+    #
+    # Also the transaction support is a bit limited: you cannot rollback.
+    # Rolling back from inside a nested transaction would require SAVEPOINT
+    # support; without the code is simpler at least :)
+
+    if tx_nesting_level == 0
+      exec "BEGIN"
+      tx_started = true
+    end
+
+    self.tx_nesting_level += 1
+
+    return_value = yield
+
+    # Only commit if we started a transaction here.
+    if tx_started
+      exec "COMMIT"
+      tx_committed = true
+    end
+
+    return_value
+  ensure
+    self.tx_nesting_level -= 1
+    if tx_started && !tx_committed
+      exec "ROLLBACK"
+    end
+  end
+end

data/lib/simple/sql/version.rb

@@ -1,5 +1,5 @@
 module Simple
   module SQL
-    VERSION = "0.3.7"
+    VERSION = "0.4.0"
   end
 end

data/scripts/watch

@@ -0,0 +1,2 @@
+#!/bin/bash
+watchr lib,spec rspec

data/spec/simple/sql_insert_spec.rb

@@ -11,7 +11,7 @@ describe "Simple::SQL.insert" do
     expect(initial_ids).not_to include(id)
     expect(SQL.ask("SELECT count(*) FROM users")).to eq(USER_COUNT+1)
 
-    user = SQL.record("SELECT * FROM users WHERE id=$1", id, into: OpenStruct)
+    user = SQL.ask("SELECT * FROM users WHERE id=$1", id, into: OpenStruct)
     expect(user.first_name).to eq("foo")
     expect(user.last_name).to eq("bar")
     expect(user.created_at).to be_a(Time)

data/spec/support/003_factories.rb

@@ -29,5 +29,5 @@ end
 def create(table)
   table_name = table.to_s.pluralize
   id = Simple::SQL.insert(table_name, attrs(table))
-  Simple::SQL.record("SELECT * FROM #{table_name} WHERE id=$1", id, into: OpenStruct)
+  Simple::SQL.ask("SELECT * FROM #{table_name} WHERE id=$1", id, into: OpenStruct)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simple-sql
 version: !ruby/object:Gem::Version
-  version: 0.3.7
+  version: 0.4.0
 platform: ruby
 authors:
 - radiospiel
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-04 00:00:00.000000000 Z
+date: 2018-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg_array_parser
@@ -170,14 +170,17 @@ files:
 - lib/simple/sql.rb
 - lib/simple/sql/config.rb
 - lib/simple/sql/connection.rb
+- lib/simple/sql/connection_adapter.rb
 - lib/simple/sql/decoder.rb
 - lib/simple/sql/duplicate.rb
 - lib/simple/sql/encoder.rb
 - lib/simple/sql/insert.rb
 - lib/simple/sql/logging.rb
 - lib/simple/sql/reflection.rb
+- lib/simple/sql/simple_transactions.rb
 - lib/simple/sql/version.rb
 - log/.gitkeep
+- scripts/watch
 - simple-sql.gemspec
 - spec/simple/sql/version_spec.rb
 - spec/simple/sql_all_into_spec.rb
@@ -189,7 +192,6 @@ files:
 - spec/simple/sql_duplicate_spec.rb
 - spec/simple/sql_duplicate_unique_spec.rb
 - spec/simple/sql_insert_spec.rb
-- spec/simple/sql_record_spec.rb
 - spec/simple/sql_reflection_spec.rb
 - spec/spec_helper.rb
 - spec/support/001_database.rb
@@ -232,7 +234,6 @@ test_files:
 - spec/simple/sql_duplicate_spec.rb
 - spec/simple/sql_duplicate_unique_spec.rb
 - spec/simple/sql_insert_spec.rb
-- spec/simple/sql_record_spec.rb
 - spec/simple/sql_reflection_spec.rb
 - spec/spec_helper.rb
 - spec/support/001_database.rb

data/spec/simple/sql_record_spec.rb

@@ -1,27 +0,0 @@
-require "spec_helper"
-
-describe "Simple::SQL.record" do
-  let!(:users) { 1.upto(USER_COUNT).map { create(:user) } }
-
-  it "calls the database" do
-    r = SQL.record("SELECT COUNT(*) AS count FROM users")
-    expect(r).to eq({count: 2}) 
-  end
-
-  it "returns nil when there is no record" do
-    r = SQL.record("SELECT * FROM users WHERE FALSE", into: OpenStruct)
-    expect(r).to be_nil
-  end
-
-  it "supports the into: option" do
-    r = SQL.record("SELECT COUNT(*) AS count FROM users", into: OpenStruct)
-    expect(r).to be_a(OpenStruct)
-    expect(r).to eq(OpenStruct.new(count: 2))
-  end
-
-  it "supports the into: option even with parameters" do
-    r = SQL.record("SELECT $1::integer AS count FROM users", 2, into: OpenStruct)
-    expect(r).to be_a(OpenStruct)
-    expect(r).to eq(OpenStruct.new(count: 2))
-  end
-end