sbf-data_objects 0.10.17

data/lib/data_objects/pooling.rb

@@ -0,0 +1,243 @@
+module DataObjects
+  def self.exiting=(bool)
+    DataObjects::Pooling.scavenger&.wakeup if bool && DataObjects.const_defined?('Pooling') && DataObjects::Pooling.scavenger?
+    @exiting = true
+  end
+
+  def self.exiting
+    return @exiting if defined?(@exiting)
+
+    @exiting = false
+  end
+
+  # ==== Notes
+  # Provides pooling support to class it got included in.
+  #
+  # Pooling of objects is a faster way of acquiring instances
+  # of objects compared to regular allocation and initialization
+  # because instances are kept in memory reused.
+  #
+  # Classes that include Pooling module have re-defined new
+  # method that returns instances acquired from pool.
+  #
+  # Term resource is used for any type of pool-able objects
+  # and should NOT be thought as DataMapper Resource or
+  # ActiveResource resource and such.
+  #
+  # In Data Objects connections are pooled so that it is
+  # unnecessary to allocate and initialize connection object
+  # each time connection is needed, like per request in a
+  # web application.
+  #
+  # Pool obviously has to be thread safe because state of
+  # object is reset when it is released.
+  module Pooling
+    def self.scavenger?
+      defined?(@scavenger) && !@scavenger.nil? && @scavenger.alive?
+    end
+
+    def self.scavenger
+      unless scavenger?
+        @scavenger = Thread.new do
+          running = true
+          while running
+            # Sleep before we actually start doing anything.
+            # Otherwise we might clean up something we just made
+            sleep(scavenger_interval)
+
+            lock.synchronize do
+              pools.each do |pool|
+                # This is a useful check, but non-essential, and right now it breaks lots of stuff.
+                # if pool.expired?
+                pool.lock.synchronize do
+                  pool.dispose if pool.expired?
+                end
+                # end
+              end
+
+              # The pool is empty, we stop the scavenger
+              # It wil be restarted if new resources are added again
+              running = false if pools.empty?
+            end
+          end
+        end
+      end
+
+      @scavenger.priority = -10
+      @scavenger
+    end
+
+    def self.pools
+      @pools ||= Set.new
+    end
+
+    def self.append_pool(pool)
+      lock.synchronize do
+        pools << pool
+      end
+      DataObjects::Pooling.scavenger
+    end
+
+    def self.lock
+      @lock ||= Mutex.new
+    end
+
+    class InvalidResourceError < StandardError
+    end
+
+    def self.included(target)
+      lock.synchronize do
+        unless target.respond_to? :__pools
+          target.class_eval do
+            class << self
+              alias_method :__new, :new
+            end
+
+            @__pools     = {}
+            @__pool_lock = Mutex.new
+            @__pool_wait = ConditionVariable.new
+
+            def self.__pool_lock
+              @__pool_lock
+            end
+
+            def self.__pool_wait
+              @__pool_wait
+            end
+
+            def self.new(*args)
+              (@__pools[args] ||= __pool_lock.synchronize { Pool.new(pool_size, self, args) }).new
+            end
+
+            def self.__pools
+              @__pools
+            end
+
+            def self.pool_size
+              8
+            end
+          end
+        end
+      end
+    end
+
+    def release
+      @__pool&.release(self)
+    end
+
+    def detach
+      @__pool&.delete(self)
+    end
+
+    class Pool
+      attr_reader :available, :used
+
+      def initialize(max_size, resource, args)
+        raise ArgumentError, "+max_size+ should be an Integer but was #{max_size.inspect}" unless max_size.is_a?(Integer)
+        raise ArgumentError, "+resource+ should be a Class but was #{resource.inspect}" unless resource.is_a?(Class)
+
+        @max_size = max_size
+        @resource = resource
+        @args = args
+
+        @available = []
+        @used      = {}
+        DataObjects::Pooling.append_pool(self)
+      end
+
+      def lock
+        @resource.__pool_lock
+      end
+
+      def wait
+        @resource.__pool_wait
+      end
+
+      def scavenge_interval
+        @resource.scavenge_interval
+      end
+
+      def new
+        instance = nil
+        loop do
+          lock.synchronize do
+            if @available.size.positive?
+              instance = @available.pop
+              @used[instance.object_id] = instance
+            elsif @used.size < @max_size
+              instance = @resource.__new(*@args)
+              raise InvalidResourceError, "#{@resource} constructor created a nil object" if instance.nil?
+              raise InvalidResourceError, "#{instance} is already part of the pool" if @used.include? instance
+
+              instance.instance_variable_set(:@__pool, self)
+              instance.instance_variable_set(:@__allocated_in_pool, Time.now)
+              @used[instance.object_id] = instance
+            else
+              # Wait for another thread to release an instance.
+              # If we exhaust the pool and don't release the active instance,
+              # we'll wait here forever, so it's *very* important to always
+              # release your services and *never* exhaust the pool within
+              # a single thread.
+              wait.wait(lock)
+            end
+          end
+          break if instance
+        end
+        instance
+      end
+
+      def release(instance)
+        lock.synchronize do
+          instance.instance_variable_set(:@__allocated_in_pool, Time.now)
+          @used.delete(instance.object_id)
+          @available.push(instance) unless @available.include?(instance)
+          wait.signal
+        end
+        nil
+      end
+
+      def delete(instance)
+        lock.synchronize do
+          instance.instance_variable_set(:@__pool, nil)
+          @used.delete(instance.object_id)
+          wait.signal
+        end
+        nil
+      end
+
+      def size
+        @used.size + @available.size
+      end
+      alias length size
+
+      def inspect
+        "#<DataObjects::Pooling::Pool<#{@resource.name}> available=#{@available.size} used=#{@used.size} size=#{@max_size}>"
+      end
+
+      def flush!
+        @available.pop.dispose until @available.empty?
+      end
+
+      def dispose
+        flush!
+        @resource.__pools.delete(@args)
+        !DataObjects::Pooling.pools.delete?(self).nil?
+      end
+
+      def expired?
+        @available.each do |instance|
+          next unless DataObjects.exiting ||
+                      instance.instance_variable_get(:@__allocated_in_pool) + DataObjects::Pooling.scavenger_interval <= (Time.now + 0.02)
+
+          instance.dispose
+          @available.delete(instance)
+        end
+        size.zero?
+      end
+    end
+
+    def self.scavenger_interval
+      60
+    end
+  end
+end

data/lib/data_objects/quoting.rb

@@ -0,0 +1,99 @@
+module DataObjects
+  module Quoting
+    # Quote a value of any of the recognised data types
+    def quote_value(value)
+      return 'NULL' if value.nil?
+
+      case value
+      when Numeric then quote_numeric(value)
+      when ::Extlib::ByteArray then quote_byte_array(value)
+      when String then quote_string(value)
+      when Time then quote_time(value)
+      when DateTime then quote_datetime(value)
+      when Date then quote_date(value)
+      when TrueClass, FalseClass then quote_boolean(value)
+      when Array then quote_array(value)
+      when Range then quote_range(value)
+      when Symbol then quote_symbol(value)
+      when Regexp then quote_regexp(value)
+      when Class then quote_class(value)
+      else
+        raise "Don't know how to quote #{value.class} objects (#{value.inspect})" unless value.respond_to?(:to_sql)
+
+        value.to_sql
+
+      end
+    end
+
+    # Convert the Symbol to a String and quote that
+    def quote_symbol(value)
+      quote_string(value.to_s)
+    end
+
+    # Convert the Numeric to a String and quote that
+    def quote_numeric(value)
+      value.to_s
+    end
+
+    # Quote a String for SQL by doubling any embedded single-quote characters
+    def quote_string(value)
+      "'#{value.gsub("'", "''")}'"
+    end
+
+    # Quote a class by quoting its name
+    def quote_class(value)
+      quote_string(value.name)
+    end
+
+    # Convert a Time to standard YMDHMS format (with microseconds if necessary)
+    def quote_time(value)
+      offset = value.utc_offset
+      if offset >= 0
+        offset_string = "+#{format('%02d', offset / 3600)}:#{format('%02d', (offset % 3600) / 60)}"
+      elsif offset < 0
+        offset_string = "-#{format('%02d', -offset / 3600)}:#{format('%02d', (-offset % 3600) / 60)}"
+      end
+      "'#{value.strftime('%Y-%m-%dT%H:%M:%S')}" << (if value.usec > 0
+                                                      ".#{value.usec.to_s.rjust(6,
+                                                                                '0')}"
+                                                    else
+                                                      ''
+                                                    end) << offset_string << "'"
+    end
+
+    # Quote a DateTime by relying on it's own to_s conversion
+    def quote_datetime(value)
+      "'#{value.dup}'"
+    end
+
+    # Convert a Date to standard YMD format
+    def quote_date(value)
+      "'#{value.strftime('%Y-%m-%d')}'"
+    end
+
+    # Quote true, false as the strings TRUE, FALSE
+    def quote_boolean(value)
+      value.to_s.upcase
+    end
+
+    # Quote an array as a list of quoted values
+    def quote_array(value)
+      "(#{value.map { |entry| quote_value(entry) }.join(', ')})"
+    end
+
+    # Quote a range by joining the quoted end-point values with AND.
+    # It's not clear whether or when this is a useful or correct thing to do.
+    def quote_range(value)
+      "#{quote_value(value.first)} AND #{quote_value(value.last)}"
+    end
+
+    # Quote a Regex using its string value. Note that there's no attempt to make a valid SQL "LIKE" string.
+    def quote_regexp(value)
+      quote_string(value.source)
+    end
+
+    def quote_byte_array(value)
+      quote_string(value)
+    end
+  end
+end

data/lib/data_objects/reader.rb

@@ -0,0 +1,45 @@
+module DataObjects
+  # Abstract class to read rows from a query result
+  class Reader
+    include Enumerable
+
+    # Return the array of field names
+    def fields
+      raise NotImplementedError
+    end
+
+    # Return the array of field values for the current row. Not legal after next! has returned false or before it's been called
+    def values
+      raise NotImplementedError
+    end
+
+    # Close the reader discarding any unread results.
+    def close
+      raise NotImplementedError
+    end
+
+    # Discard the current row (if any) and read the next one (returning true), or return nil if there is no further row.
+    def next!
+      raise NotImplementedError
+    end
+
+    # Return the number of fields in the result set.
+    def field_count
+      raise NotImplementedError
+    end
+
+    # Yield each row to the given block as a Hash
+    def each
+      begin
+        while next!
+          row = {}
+          fields.each_with_index { |field, index| row[field] = values[index] }
+          yield row
+        end
+      ensure
+        close
+      end
+      self
+    end
+  end
+end

data/lib/data_objects/result.rb

@@ -0,0 +1,21 @@
+module DataObjects
+  # The Result class is returned from Connection#execute_non_query.
+  class Result
+    # The ID of a row inserted by the Command
+    attr_accessor :insert_id
+    # The number of rows affected by the Command
+    attr_accessor :affected_rows
+
+    # Create a new Result. Used internally in the adapters.
+    def initialize(command, affected_rows, insert_id = nil)
+      @command = command
+      @affected_rows = affected_rows
+      @insert_id = insert_id
+    end
+
+    # Return the number of affected rows
+    def to_i
+      @affected_rows
+    end
+  end
+end

data/lib/data_objects/spec/lib/pending_helpers.rb

@@ -0,0 +1,13 @@
+module DataObjects
+  module Spec
+    module PendingHelpers
+      def pending_if(message, boolean, &block)
+        if boolean
+          pending(message, &block)
+        else
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/data_objects/spec/lib/ssl.rb

@@ -0,0 +1,19 @@
+require 'pathname'
+require 'cgi'
+
+module SSLHelpers
+  CERTS_DIR = Pathname(__FILE__).dirname.join('ssl_certs').to_s
+
+  CONFIG = OpenStruct.new
+  CONFIG.ca_cert     = File.join(CERTS_DIR, 'ca-cert.pem')
+  CONFIG.ca_key      = File.join(CERTS_DIR, 'ca-key.pem')
+  CONFIG.server_cert = File.join(CERTS_DIR, 'server-cert.pem')
+  CONFIG.server_key  = File.join(CERTS_DIR, 'server-key.pem')
+  CONFIG.client_cert = File.join(CERTS_DIR, 'client-cert.pem')
+  CONFIG.client_key  = File.join(CERTS_DIR, 'client-key.pem')
+  CONFIG.cipher      = 'AES128-SHA'
+
+  def self.query(*keys)
+    keys.map { |key| "ssl[#{key}]=#{CGI.escape(CONFIG.send(key))}" }.join('&')
+  end
+end

data/lib/data_objects/spec/setup.rb

@@ -0,0 +1,5 @@
+RSpec::Matchers.define :be_array_case_insensitively_equal_to do |attribute|
+  match do |model|
+    model.map(&:downcase) == attribute
+  end
+end

data/lib/data_objects/spec/shared/command_spec.rb

@@ -0,0 +1,201 @@
+shared_examples 'a Command' do
+  before :all do
+    setup_test_environment
+  end
+
+  before do
+    @connection  = DataObjects::Connection.new(CONFIG.uri)
+    @command     = @connection.create_command('INSERT INTO users (name) VALUES (?)')
+    @reader      = @connection.create_command('SELECT code, name FROM widgets WHERE ad_description = ?')
+    @arg_command = @connection.create_command('INSERT INTO users (name, fired_at) VALUES (?, ?)')
+    @arg_reader  = @connection.create_command('SELECT code, name FROM widgets WHERE ad_description = ? AND whitepaper_text = ?')
+  end
+
+  after do
+    @connection.close
+  end
+
+  it { expect(@command).to be_kind_of(DataObjects::Command) }
+
+  it { expect(@command).to respond_to(:execute_non_query) }
+
+  describe 'execute_non_query' do
+    describe 'with an invalid statement' do
+      before do
+        @invalid_command = @connection.create_command('INSERT INTO non_existent_table (tester) VALUES (1)')
+      end
+
+      it 'raises an error on an invalid query' do
+        expect { @invalid_command.execute_non_query }.to raise_error(DataObjects::SQLError)
+      end
+
+      it 'raises an error with too many binding parameters' do
+        expect { @arg_command.execute_non_query('Too', Date.today, 'Many') }.to raise_error(ArgumentError,
+                                                                                            /Binding mismatch: 3 for 2/)
+      end
+
+      it 'raises an error with too few binding parameters' do
+        expect { @arg_command.execute_non_query('Few') }.to raise_error(ArgumentError,
+                                                                        /Binding mismatch: 1 for 2/)
+      end
+    end
+
+    describe 'with a valid statement' do
+      it 'does not raise an error with an explicit nil as parameter' do
+        expect { @arg_command.execute_non_query(nil, nil) }.not_to raise_error
+      end
+    end
+
+    describe 'with a valid statement and ? inside quotes' do
+      before do
+        @command_with_quotes = @connection.create_command("INSERT INTO users (name) VALUES ('will it work? ')")
+      end
+
+      it 'does not raise an error' do
+        expect { @command_with_quotes.execute_non_query }.not_to raise_error
+      end
+    end
+  end
+
+  it { expect(@command).to respond_to(:execute_reader) }
+
+  describe 'execute_reader' do
+    describe 'with an invalid reader' do
+      before do
+        @invalid_reader = @connection.create_command('SELECT * FROM non_existent_widgets WHERE ad_description = ? AND white_paper_text = ?')
+      end
+
+      it 'raises an error on an invalid query' do
+        # FIXME: JRuby (and MRI): Should this be an ArgumentError or DataObjects::SQLError?
+        expect { @invalid_reader.execute_reader }.to raise_error(DataObjects::SQLError) # (ArgumentError, DataObjects::SQLError)
+      end
+
+      it 'raises an error with too many few binding parameters' do
+        expect { @arg_reader.execute_reader('Too', 'Many', 'Args') }.to raise_error(ArgumentError,
+                                                                                    /Binding mismatch: 3 for 2/)
+      end
+
+      it 'raises an error with too few binding parameters' do
+        expect { @arg_reader.execute_reader('Few') }.to raise_error(ArgumentError,
+                                                                    /Binding mismatch: 1 for 2/)
+      end
+    end
+
+    describe 'with a valid reader' do
+      it 'does not raise an error with an explicit nil as parameter' do
+        expect { @arg_reader.execute_reader(nil, nil) }.not_to raise_error
+      end
+
+      it 'returns an empty reader if the query does not return a result' do
+        runs_command = @connection.create_command("UPDATE widgets SET name = '' WHERE name = ''")
+        res = runs_command.execute_reader
+        expect(res.fields).to eq []
+        expect(res.next!).to be false
+      end
+    end
+
+    describe 'with a valid reader and ? inside column alias' do
+      before do
+        @reader_with_quotes = @connection.create_command('SELECT code AS "code?", name FROM widgets WHERE ad_description = ?')
+      end
+
+      it 'does not raise an error' do
+        expect { @reader_with_quotes.execute_reader(nil) }.not_to raise_error
+      end
+    end
+  end
+
+  it { expect(@command).to respond_to(:set_types) }
+
+  describe 'set_types' do
+    describe 'is invalid when used with a statement' do
+      before do
+        @command.set_types(String)
+      end
+
+      it 'raises an error when types are set' do
+        expect { @arg_command.execute_non_query('Few') }.to raise_error(ArgumentError)
+      end
+    end
+
+    describe 'with an invalid reader' do
+      it 'raises an error with too few types' do
+        @reader.set_types(String)
+        expect { @reader.execute_reader('One parameter') }.to raise_error(ArgumentError,
+                                                                          /Field-count mismatch. Expected 1 fields, but the query yielded 2/)
+      end
+
+      it 'raises an error with too many types' do
+        @reader.set_types(String, String, BigDecimal)
+        expect { @reader.execute_reader('One parameter') }.to raise_error(ArgumentError,
+                                                                          /Field-count mismatch. Expected 3 fields, but the query yielded 2/)
+      end
+    end
+
+    describe 'with a valid reader' do
+      it 'does not raise an error with correct number of types' do
+        @reader.set_types(String, String)
+        expect { @result = @reader.execute_reader('Buy this product now!') }.not_to raise_error
+        expect { @result.next!  }.not_to raise_error
+        expect { @result.values }.not_to raise_error
+        @result.close
+      end
+
+      it 'also supports old style array argument types' do
+        @reader.set_types([String, String])
+        expect { @result = @reader.execute_reader('Buy this product now!') }.not_to raise_error
+        expect { @result.next!  }.not_to raise_error
+        expect { @result.values }.not_to raise_error
+        @result.close
+      end
+
+      it 'allows subtype types' do
+        class MyString < String; end
+        @reader.set_types(MyString, String)
+        expect { @result = @reader.execute_reader('Buy this product now!') }.not_to raise_error
+        expect { @result.next!  }.not_to raise_error
+        expect { @result.values }.not_to raise_error
+        @result.close
+      end
+    end
+  end
+
+  it { expect(@command).to respond_to(:to_s) }
+
+  describe 'to_s' do
+    # Tests not implemented
+  end
+end
+
+shared_examples 'a Command with async' do
+  before :all do
+    setup_test_environment
+  end
+
+  describe 'running queries in parallel' do
+    before do
+      threads = []
+
+      @start = Time.now
+      4.times do |_i|
+        threads << Thread.new do
+          connection = DataObjects::Connection.new(CONFIG.uri)
+          command = connection.create_command(CONFIG.sleep)
+          if CONFIG.sleep =~ /^SELECT/i
+            reader = command.execute_reader
+            reader.next!
+            reader.close
+          else
+            command.execute_non_query
+          end
+        ensure
+          # Always make sure the connection gets released back into the pool.
+          connection.close
+        end
+      end
+
+      threads.each(&:join)
+      @finish = Time.now
+    end
+  end
+end