sbf-data_objects 0.10.17

data/lib/data_objects/transaction.rb

@@ -0,0 +1,111 @@
+require 'English'
+require 'socket'
+require 'digest'
+require 'digest/sha2'
+
+module DataObjects
+  class Transaction
+    # The local host name. Do not attempt to resolve in DNS to prevent potentially long delay
+    HOST = begin
+      Socket.gethostname.to_s
+    rescue
+      'localhost'
+    end
+    @@counter = 0
+
+    # The connection object allocated for this transaction
+    attr_reader :connection
+    # A unique ID for this transaction
+    attr_reader :id
+
+    # Instantiate the Transaction subclass that's appropriate for this uri scheme
+    def self.create_for_uri(uri)
+      uri = URI.parse(uri) if uri.is_a?(String)
+      DataObjects.const_get(uri.scheme.capitalize)::Transaction.new(uri)
+    end
+
+    #
+    # Creates a Transaction bound to a connection for the given DataObjects::URI
+    #
+    def initialize(uri, connection = nil)
+      @connection = connection || DataObjects::Connection.new(uri)
+      # PostgreSQL can't handle the full 64 bytes.  This should be enough for everyone.
+      @id = Digest::SHA256.hexdigest("#{HOST}:#{$PROCESS_ID}:#{Time.now.to_f}:#{@@counter += 1}")[0..-2]
+    end
+
+    # Close the connection for this Transaction
+    def close
+      @connection.close
+    end
+
+    def begin
+      run 'BEGIN'
+    end
+
+    def commit
+      run 'COMMIT'
+    end
+
+    def rollback
+      run 'ROLLBACK'
+    end
+
+    def prepare
+      not_implemented
+    end
+
+    def begin_prepared
+      not_implemented
+    end
+
+    def commit_prepared
+      not_implemented
+    end
+
+    def rollback_prepared
+      not_implemented
+    end
+
+    def prepare
+      not_implemented
+    end
+
+    protected def run(cmd)
+      connection.create_command(cmd).execute_non_query
+    end
+
+    private def not_implemented
+      raise NotImplementedError
+    end
+  end
+
+  class SavePoint < Transaction
+    # We don't bounce through DO::<Adapter/scheme>::SavePoint because there
+    # doesn't appear to be any custom SQL to support this.
+    def self.create_for_uri(uri, connection)
+      uri = URI.parse(uri) if uri.is_a?(String)
+      DataObjects::SavePoint.new(uri, connection)
+    end
+
+    # SavePoints can only occur in the context of a Transaction, thus they
+    # re-use TXN's connection (which was acquired from the connection pool
+    # legitimately via DO::Connection.new).  We no-op #close in SP because
+    # calling DO::Connection#close will release the connection back into the
+    # pool (before the top-level Transaction might be done with it).
+    def close
+      # no-op
+    end
+
+    def begin
+      run %(SAVEPOINT "#{@id}")
+    end
+
+    def commit
+      run %(RELEASE SAVEPOINT "#{@id}")
+    end
+
+    def rollback
+      run %(ROLLBACK TO SAVEPOINT "#{@id}")
+    end
+  end
+end

data/lib/data_objects/uri.rb

@@ -0,0 +1,109 @@
+require 'addressable/uri'
+
+module DataObjects
+  # A DataObjects URI is of the form scheme://user:password@host:port/path#fragment
+  #
+  # The elements are all optional except scheme and path:
+  # scheme:: The name of a DBMS for which you have a do_\<scheme\> adapter gem installed.
+  #          If scheme is *jdbc*, the actual DBMS is in the _path_ followed by a colon.
+  # user:: The name of the user to authenticate to the database
+  # password:: The password to use in authentication
+  # host:: The domain name (defaulting to localhost) where the database is available
+  # port:: The TCP/IP port number to use for the connection
+  # path:: The name or path to the database
+  # query:: Parameters for the connection, for example encoding=utf8
+  # fragment:: Not currently known to be in use, but available to the adapters
+  class URI
+    attr_reader :scheme, :subscheme, :user, :password, :host, :port, :path, :query, :fragment
+
+    # Make a DataObjects::URI object by parsing a string. Simply delegates to Addressable::URI::parse.
+    def self.parse(uri)
+      return uri if uri.is_a?(self)
+
+      if uri.is_a?(Addressable::URI)
+        scheme = uri.scheme
+      elsif uri[0, 4] == 'jdbc'
+        scheme = uri[0, 4]
+        uri       = Addressable::URI.parse(uri[5, uri.length])
+        subscheme = uri&.scheme
+      else
+        uri       = Addressable::URI.parse(uri)
+        scheme    = uri&.scheme
+        subscheme = nil
+      end
+
+      new(
+        scheme: scheme,
+        subscheme: subscheme,
+        user: uri&.user,
+        password: uri&.password,
+        host: uri&.host,
+        port: uri&.port,
+        path: uri&.path,
+        query: uri&.query_values,
+        fragment: uri&.fragment,
+        relative: !uri.to_s.index('//').nil? # basic (naive) check for relativity / opaqueness
+      )
+    end
+
+    def initialize(*args)
+      if (component = args.first).is_a?(Hash)
+        @scheme     = component[:scheme]
+        @subscheme  = component[:subscheme]
+        @user       = component[:user]
+        @password   = component[:password]
+        @host       = component[:host]
+        @port       = component[:port]
+        @path       = component[:path]
+        @query      = component[:query]
+        @fragment   = component[:fragment]
+        @relative   = component[:relative]
+      elsif args.size > 1
+        warn "DataObjects::URI.new with arguments is deprecated, use a Hash of URI components (#{caller.first})"
+        @scheme, @user, @password, @host, @port, @path, @query, @fragment = *args
+      else
+        raise ArgumentError, "argument should be a Hash of URI components, was: #{args.inspect}"
+      end
+    end
+
+    def opaque?
+      !@relative
+    end
+
+    def relative?
+      @relative
+    end
+
+    # Display this URI object as a string
+    def to_s
+      string = ''
+      string << "#{scheme}:"     if scheme
+      string << "#{subscheme}:"  if subscheme
+      string << '//'             if relative?
+      if user
+        string << user.to_s
+        string << '@'
+      end
+      string << host.to_s        if host
+      string << ":#{port}"       if port
+      string << path.to_s
+      if query
+        string << '?' << query.map do |key, value|
+          "#{key}=#{value}"
+        end.join('&')
+      end
+      string << "##{fragment}" if fragment
+      string
+    end
+
+    # Compare this URI to another for hashing
+    def eql?(other)
+      to_s.eql?(other.to_s)
+    end
+
+    # Hash this URI
+    def hash
+      to_s.hash
+    end
+  end
+end

data/lib/data_objects/utilities.rb

@@ -0,0 +1,18 @@
+# This is here to remove DataObject's dependency on Extlib.
+
+module DataObjects
+  # @param name<String> The name of the constant to get, e.g. "Merb::Router".
+  #
+  # @return <Object> The constant corresponding to the name.
+  def self.full_const_get(name)
+    list = name.split('::')
+    list.shift if list.first.nil? || list.first&.strip&.empty?
+    obj = ::Object
+    list.each do |x|
+      # This is required because const_get tries to look for constants in the
+      # ancestor chain, but we only want constants that are HERE
+      obj = obj.const_defined?(x) ? obj.const_get(x) : obj.const_missing(x)
+    end
+    obj
+  end
+end

data/lib/data_objects/version.rb

@@ -0,0 +1,3 @@
+module DataObjects
+  VERSION = '0.10.17'.freeze
+end

data/lib/data_objects.rb

@@ -0,0 +1,20 @@
+require 'data_objects/version'
+require 'data_objects/utilities'
+require 'data_objects/logger'
+require 'data_objects/byte_array'
+require 'data_objects/pooling'
+require 'data_objects/connection'
+require 'data_objects/uri'
+require 'data_objects/transaction'
+require 'data_objects/command'
+require 'data_objects/result'
+require 'data_objects/reader'
+require 'data_objects/quoting'
+require 'data_objects/extension'
+require 'data_objects/error'
+require 'data_objects/error/sql_error'
+require 'data_objects/error/connection_error'
+require 'data_objects/error/data_error'
+require 'data_objects/error/integrity_error'
+require 'data_objects/error/syntax_error'
+require 'data_objects/error/transaction_error'

data/spec/command_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe DataObjects::Command do
+  before do
+    @connection = DataObjects::Connection.new('mock://localhost')
+    @command = DataObjects::Command.new(@connection, 'SQL STRING')
+  end
+
+  after do
+    @connection.close
+  end
+
+  %w(connection execute_non_query execute_reader set_types).each do |meth|
+    it "responds to ##{meth}" do
+      expect(@command).to respond_to(meth.intern)
+    end
+  end
+
+  %w(execute_non_query execute_reader set_types).each do |meth|
+    it "raises NotImplementedError on ##{meth}" do
+      expect { @command.send(meth.intern, nil) }.to raise_error(NotImplementedError)
+    end
+  end
+end

data/spec/connection_spec.rb

@@ -0,0 +1,31 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+require 'stringio'
+
+describe DataObjects::Connection do
+  subject { connection }
+
+  let(:connection) { described_class.new(uri) }
+
+  after { connection.close }
+
+  context 'defines a standard API' do
+    let(:uri) { 'mock://localhost' }
+
+    it { is_expected.to respond_to(:dispose) }
+    it { is_expected.to respond_to(:create_command) }
+
+    its(:to_s) { is_expected.to eq 'mock://localhost' }
+  end
+
+  describe 'initialization' do
+    context 'with a connection uri as a Addressable::URI' do
+      let(:uri) { Addressable::URI.parse('mock://localhost/database') }
+
+      it { is_expected.to be_kind_of(DataObjects::Mock::Connection) }
+      it { is_expected.to be_kind_of(DataObjects::Pooling)          }
+
+      its(:to_s) { is_expected.to eq 'mock://localhost/database' }
+    end
+
+  end
+end

data/spec/do_mock.rb

@@ -0,0 +1,29 @@
+module DataObjects
+  module Mock
+    class Connection < DataObjects::Connection
+      def initialize(uri)
+        @uri = uri
+      end
+
+      def dispose
+        nil
+      end
+    end
+
+    class Command < DataObjects::Command
+      def execute_non_query(*_args)
+        Result.new(self, 0, nil)
+      end
+
+      def execute_reader(*_args)
+        Reader.new
+      end
+    end
+
+    class Result < DataObjects::Result
+    end
+
+    class Reader < DataObjects::Reader
+    end
+  end
+end

data/spec/do_mock2.rb

@@ -0,0 +1,29 @@
+module DataObjects
+  module Mock2
+    class Connection < DataObjects::Connection
+      def initialize(uri)
+        @uri = uri
+      end
+
+      def dispose
+        nil
+      end
+    end
+
+    class Command < DataObjects::Command
+      def execute_non_query(*_args)
+        Result.new(self, 0, nil)
+      end
+
+      def execute_reader(*_args)
+        Reader.new
+      end
+    end
+
+    class Result < DataObjects::Result
+    end
+
+    class Reader < DataObjects::Reader
+    end
+  end
+end

data/spec/pooling_spec.rb

@@ -0,0 +1,153 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+require 'timeout'
+
+describe 'DataObjects::Pooling' do
+  before do
+    Object.send(:remove_const, :Person) if defined?(Person)
+
+    class ::Person
+      include DataObjects::Pooling
+
+      attr_accessor :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      def dispose
+        @name = nil
+      end
+    end
+
+    Object.send(:remove_const, :Overwriter) if defined?(Overwriter)
+    class ::Overwriter
+      def self.new(*args)
+        instance = allocate
+        instance.send(:initialize, *args)
+        instance.overwritten = true
+        instance
+      end
+
+      include DataObjects::Pooling
+
+      attr_accessor :name
+
+      def initialize(name)
+        @name = name
+        @overwritten = false
+      end
+
+      def overwritten?
+        @overwritten
+      end
+
+      attr_writer :overwritten
+
+      class << self
+        remove_method :pool_size if instance_methods(false).any? { |m| m.to_sym == :pool_size }
+        def pool_size
+          2
+        end
+      end
+
+      def dispose
+        @name = nil
+      end
+    end
+  end
+
+  after :each do
+    DataObjects::Pooling.lock.synchronize do
+      DataObjects::Pooling.pools.each do |pool|
+        pool.lock.synchronize do
+          pool.dispose
+        end
+      end
+    end
+  end
+
+  it 'maintains a size of 1' do
+    bob = Person.new('Bob')
+    fred = Person.new('Fred')
+    ted = Person.new('Ted')
+
+    Person.__pools.each_value do |pool|
+      expect(pool.size).to eq 1
+    end
+
+    bob.release
+    fred.release
+    ted.release
+
+    Person.__pools.each_value do |pool|
+      expect(pool.size).to eq 1
+    end
+  end
+
+  it 'tracks the initialized pools' do
+    bob = Person.new('Bob') # Ensure the pool is "primed"
+    expect(bob.name).to eq 'Bob'
+    expect(bob.instance_variable_get(:@__pool)).not_to be_nil
+    expect(Person.__pools.size).to eq 1
+    bob.release
+    expect(Person.__pools.size).to eq 1
+
+    expect(DataObjects::Pooling.pools).not_to be_empty
+
+    sleep(1.2)
+
+    # NOTE: This assertion is commented out, as our MockConnection objects are
+    #       currently in the pool.
+    # expect(DataObjects::Pooling::pools).to be_empty
+    expect(bob.name).to be_nil
+  end
+
+  it 'allows you to overwrite Class#new' do
+    bob = Overwriter.new('Bob')
+    expect(bob).to be_overwritten
+    bob.release
+  end
+
+  it 'allows multiple threads to access the pool' do
+    t1 = Thread.new do
+      bob = Person.new('Bob')
+      sleep(1)
+      bob.release
+    end
+
+    expect do
+      bob = Person.new('Bob')
+      t1.join
+      bob.release
+    end.not_to raise_error
+  end
+
+  it 'allows you to flush a pool' do
+    bob = Overwriter.new('Bob')
+    Overwriter.new('Bob').release
+    bob.release
+
+    expect(bob.name).to eq 'Bob'
+
+    expect(Overwriter.__pools[['Bob']].size).to eq 2
+    Overwriter.__pools[['Bob']].flush!
+    expect(Overwriter.__pools[['Bob']].size).to eq 0
+
+    expect(bob.name).to be_nil
+  end
+
+  it 'wakes up the scavenger thread when exiting' do
+    bob = Person.new('Bob')
+    bob.release
+    DataObjects.exiting = true
+    sleep(1)
+    expect(DataObjects::Pooling.scavenger?).to be false
+  end
+
+  it 'detaches an instance from the pool' do
+    bob = Person.new('Bob')
+    expect(Person.__pools[['Bob']].size).to eq 1
+    bob.detach
+    expect(Person.__pools[['Bob']].size).to eq 0
+  end
+end

data/spec/reader_spec.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe DataObjects::Reader do
+  subject { command.execute_reader }
+
+  let(:connection) { DataObjects::Connection.new('mock://localhost') }
+  let(:command) { connection.create_command('SELECT * FROM example') }
+
+  after { connection.close }
+
+  context 'defines a standard API' do
+    it { is_expected.to be_a(Enumerable) }
+    it { is_expected.to respond_to(:close) }
+    it { is_expected.to respond_to(:next!) }
+    it { is_expected.to respond_to(:values) }
+    it { is_expected.to respond_to(:fields) }
+    it { is_expected.to respond_to(:each) }
+  end
+end

data/spec/result_spec.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe DataObjects::Result do
+  subject { command.execute_non_query }
+
+  let(:connection) { DataObjects::Connection.new('mock://localhost') }
+  let(:command) { connection.create_command('SELECT * FROM example') }
+
+  after { connection.close }
+
+  context 'defines a standard API' do
+    it 'provides the number of affected rows' do
+      is_expected.to respond_to(:to_i)
+      expect(subject.to_i).to eq 0
+    end
+
+    it 'provides the id of the inserted row' do
+      is_expected.to respond_to(:insert_id)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'data_objects'
+require 'rspec'
+require 'rspec/its'
+
+module DataObjects
+  module Pooling
+    class << self
+      remove_method :scavenger_interval if instance_methods(false).any? { |m| m.to_sym == :scavenger_interval }
+      def scavenger_interval
+        0.5
+      end
+    end
+  end
+end
+
+require File.expand_path(File.join(File.dirname(__FILE__), 'do_mock'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'do_mock2'))

data/spec/transaction_spec.rb

@@ -0,0 +1,37 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe DataObjects::Transaction do
+  before :each do
+    @connection = double('connection')
+    expect(DataObjects::Connection).to receive(:new).with('mock://mock/mock').once.and_return(@connection)
+    @transaction = DataObjects::Transaction.new('mock://mock/mock')
+  end
+
+  it 'has a HOST constant' do
+    expect(DataObjects::Transaction::HOST).not_to eq nil?
+  end
+
+  describe '#initialize' do
+    it 'provides a connection' do
+      expect(@transaction.connection).to eq @connection
+    end
+    it 'provides an id' do
+      expect(@transaction.id).not_to be_nil
+    end
+    it 'provides a unique id' do
+      expect(DataObjects::Connection).to receive(:new).with('mock://mock/mock2').once.and_return(@connection)
+      expect(@transaction.id).not_to eq DataObjects::Transaction.new('mock://mock/mock2').id
+    end
+  end
+  describe '#close' do
+    it 'closes its connection' do
+      expect(@connection).to receive(:close).once
+      expect { @transaction.close }.not_to raise_error
+    end
+  end
+  %i(prepare commit_prepared rollback_prepared).each do |meth|
+    it "raises NotImplementedError on #{meth}" do
+      expect { @transaction.send(meth) }.to raise_error(NotImplementedError)
+    end
+  end
+end

data/spec/uri_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe DataObjects::URI do
+  subject { described_class.parse(uri) }
+
+  context 'parsing parts' do
+    let(:uri) { 'mock://username:password@localhost:12345/path?encoding=utf8#fragment' }
+
+    its(:scheme) { is_expected.to eq 'mock' }
+    its(:user) { is_expected.to eq 'username' }
+    its(:password) { is_expected.to eq 'password' }
+    its(:host) { is_expected.to eq 'localhost' }
+    its(:port) { is_expected.to eq 12_345 }
+    its(:path) { is_expected.to eq '/path' }
+    its(:query) { is_expected.to eq({'encoding' => 'utf8'}) }
+    its(:fragment) { is_expected.to eq 'fragment' }
+
+    it 'provides a correct string representation' do
+      expect(subject.to_s).to eq 'mock://username@localhost:12345/path?encoding=utf8#fragment'
+    end
+  end
+
+end

data/tasks/release.rake

@@ -0,0 +1,14 @@
+desc 'Builds all gems (native, binaries for JRuby and Windows)'
+task :build_all do
+  `rake clean`
+  `rake build`
+end
+
+desc 'Release all gems (native, binaries for JRuby and Windows)'
+task release_all: :build_all do
+  Dir.children("pkg").each do |gem_path|
+    command = "gem push pkg/#{gem_path}"
+    puts "Executing #{command.inspect}:"
+    sh command
+  end
+end

data/tasks/spec.rake

@@ -0,0 +1,10 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = './spec/**/*_spec.rb'
+
+  require 'simplecov'
+  SimpleCov.start do
+    minimum_coverage 100
+  end
+end

data/tasks/yard.rake

@@ -0,0 +1,9 @@
+begin
+  require 'yard'
+
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yard do
+    abort 'YARD is not available. In order to run yard, you must: gem install yard'
+  end
+end