sbf-data_objects 0.10.17

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 244576946e544f5a11ca625f783d1a5536e77bef7437041fdb11d6abe793094f
+  data.tar.gz: 8583773433efe291633740bd2499c404d81cb6f444705e9f45d947ee709697c6
+SHA512:
+  metadata.gz: 7113134178dc9b9675801b387a91508864e2002a27a2d8c19de95edeebb82baa7b46a804a480a9738b2dd803724ec9f7d21224fcd028c718e7983ce9423ffb6a
+  data.tar.gz: 873820bd19ce5202a58c8ad2a0174de99ae1e04e23ce803b1c30a794a6e1c813fa601c823440c2094f0cebb07b2bb6dd5e01a94e46e2c236f2e53715f01ce4c8

data/ChangeLog.markdown

@@ -0,0 +1,115 @@
+## 0.10.17 2016-01-24
+
+* Enable CI with Ruby 2.3
+* Improve utf8mb4 support in do\_mysql
+* Fix memory leak in do\_mysql and do\_postgres
+* Support for MySQL 5.7 in do\_mysql
+* Fix bug with DateTime and wrong timezone offsets
+* Fix compilation on JRuby 9000
+
+## 0.10.16 2015-05-17
+
+* Fix compile issue with do\_postgres on stock OS X Ruby
+
+## 0.10.15 2015-02-15
+
+* Ruby 2.2 support
+* Double after free fix in do\_postgres
+* utf8mb4 support on do\_mysql
+
+* Windows support on 2.1.x and 2.2.x
+## 0.10.14 2014-02-13
+
+* Don't do DNS lookup in transaction loading
+
+## 0.10.13 2013-05-27
+
+* Create binaries for Ruby 2.0 on Windows
+* Fix segfault in do\_postgres
+* Fix compilation of do\_oracle for Ruby 2.0
+
+## 0.10.12 2013-01-21
+
+* Fix JRuby driver loading for newer jdbc-\* gems
+* Compatibility change for anscient MySQL versions
+
+## 0.10.11 2012-12-29
+
+* Rename C symbols to prevent name collitions
+
+## 0.10.10 2012-10-11
+
+* JRuby performance improvements
+* Reconnect added on JRuby
+* do\_sqlite3 C driver supports busy\_timeout
+
+## 0.10.9 2012-08-13
+
+* Don't try to escape queries when no binding parameters are given
+
+## 0.10.8 2012-02-10
+
+* Ruby 1.9.3 compatibility on Windows
+* Don't display password in URI
+
+## 0.10.7 2011-10-13
+
+* Ruby 1.9.3 compatibility
+
+## 0.10.6 2011-05-22
+
+Bugfixes
+* Fix an issue on some platforms when multiple DO drivers are loaded
+
+## 0.10.5 2011-05-03
+
+Bugfixes
+* Fix an issue with DateTime (do\_sqlite3)
+
+## 0.10.4 2011-04-28
+
+New features
+* Add save point to transactions (all)
+* JRuby 1.9 mode support (encodings etc.)
+
+Bugfixes
+* Fix segfault when no tuples are returned from a non select statement (do\_postgres)
+* Fix bug when using nested transactions in concurrent scenarios (all)
+* Use column aliases instead of names (jruby)
+* DST calculation fixes (all)
+* Attempt to add better support for ancient MySQL versions (do\_mysql)
+* Fix handling sub second precision for Time objects (do\_postgres)
+
+Other
+* Refactor to DRY up the adapters (all)
+* Many style fixes
+* Switch back to RSpec
+
+## 0.10.3 2011-01-30
+* Reworked transactions
+* Fix a DST bug that could cause datetimes in the wrong timezone
+
+## 0.10.2 2010-05-19
+* Support for Encoding.default_internal
+* Rework logging to adding a callback is possible
+
+## 0.10.1 2010-01-08
+
+* Removal of Extlib dependency: Pooling and Utilities code moved to DataObjects.
+* Switch to Jeweler for Gem building tasks (this change may be temporary).
+* Switch to using Bacon for running specs: This should make specs friendlier to
+  new Ruby implementations that are not yet 100% MRI-compatible, and in turn,
+  pave the road for our own IronRuby and MacRuby support.
+* Make DataObjects::Reader Enumerable.
+
+## 0.10.0 2009-09-15
+
+* No Changes since 0.9.11
+
+## 0.9.11 2009-01-19
+* Fixes
+  * Use Extlib `Object.full_const_get` instead of custom code
+  * Remove Field as it was unused
+
+## 0.9.9 2008-11-27
+* No Changes since 0.9.8

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007 - 2011 Yehuda Katz, Dirkjan Bussink
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,18 @@
+# data_objects
+
+* <http://dataobjects.info>
+
+## Description
+
+A unified Ruby API for popular databases.
+
+## License
+
+Licensed under the MIT license. Please see the {file:LICENSE} for more information.
+
+## Contact
+
+**IRC**:       **Join us on IRC in #datamapper on irc.freenode.net!**<br/>
+**Git**:       <http://github.com/firesring/datamapper-do><br/>
+**Author**:    Dirkjan Bussink<br/>
+**License**:   MIT License

data/Rakefile

@@ -0,0 +1,20 @@
+require 'pathname'
+require 'rubygems'
+require 'bundler'
+require 'rubygems/package_task'
+Bundler::GemHelper.install_tasks
+
+require 'rake'
+require 'rake/clean'
+
+ROOT = Pathname(__FILE__).dirname.expand_path
+
+# rubocop:disable Style/StringConcatenation
+require ROOT + 'lib/data_objects/version'
+# rubocop:enable Style/StringConcatenation
+
+SUDO     = 'sudo' unless ENV['SUDOLESS']
+
+CLEAN.include(%w(pkg/ **/*.rbc))
+
+FileList['tasks/**/*.rake'].each { |task| import task }

data/lib/data_objects/byte_array.rb

@@ -0,0 +1,6 @@
+# This class has exists to represent binary data. This is mainly
+# used by DataObjects. Binary data sometimes needs to be quoted differently
+# than regular string data (even if the string is just plain ASCII).
+module Extlib
+  class ByteArray < ::String; end
+end

data/lib/data_objects/command.rb

@@ -0,0 +1,79 @@
+module DataObjects
+  # Abstract base class for adapter-specific Command subclasses
+  class Command
+    # The Connection on which the command will be run
+    attr_reader :connection
+
+    # Create a new Command object on the specified connection
+    def initialize(connection, text)
+      raise ArgumentError, '+connection+ must be a DataObjects::Connection' unless connection.is_a?(DataObjects::Connection)
+
+      @connection = connection
+      @text = text
+    end
+
+    # Execute this command and return no dataset
+    def execute_non_query(*_args)
+      raise NotImplementedError
+    end
+
+    # Execute this command and return a DataObjects::Reader for a dataset
+    def execute_reader(*_args)
+      raise NotImplementedError
+    end
+
+    # Assign an array of types for the columns to be returned by this command
+    def set_types(_column_types)
+      raise NotImplementedError
+    end
+
+    # Display the command text
+    def to_s
+      @text
+    end
+
+    # Escape a string of SQL with a set of arguments.
+    # The first argument is assumed to be the SQL to escape,
+    # the remaining arguments (if any) are assumed to be
+    # values to escape and interpolate.
+    #
+    # ==== Examples
+    #   escape_sql("SELECT * FROM zoos")
+    #   # => "SELECT * FROM zoos"
+    #
+    #   escape_sql("SELECT * FROM zoos WHERE name = ?", "Dallas")
+    #   # => "SELECT * FROM zoos WHERE name = `Dallas`"
+    #
+    #   escape_sql("SELECT * FROM zoos WHERE name = ? AND acreage > ?", "Dallas", 40)
+    #   # => "SELECT * FROM zoos WHERE name = `Dallas` AND acreage > 40"
+    #
+    # ==== Warning
+    # This method is meant mostly for adapters that don't support
+    # bind-parameters.
+    private def escape_sql(args)
+      return @text if args.empty?
+
+      sql = @text.dup
+      vars = args.dup
+
+      replacements = 0
+      mismatch     = false
+
+      sql.gsub!(/'[^']*'|"[^"]*"|`[^`]*`|\?/) do |x|
+        next x unless x == '?'
+
+        replacements += 1
+        if vars.empty?
+          mismatch = true
+        else
+          var = vars.shift
+          connection.quote_value(var)
+        end
+      end
+
+      raise ArgumentError, "Binding mismatch: #{args.size} for #{replacements}" if !vars.empty? || mismatch
+
+      sql
+    end
+  end
+end

data/lib/data_objects/connection.rb

@@ -0,0 +1,95 @@
+
+module DataObjects
+  # An abstract connection to a DataObjects resource. The physical connection may be broken and re-established from time to time.
+  class Connection
+    include Logging
+
+    # Make a connection to the database using the DataObjects::URI given.
+    # Note that the physical connection may be delayed until the first command is issued, so success here doesn't necessarily mean you can connect.
+    def self.new(uri_s)
+      uri = DataObjects::URI.parse(uri_s)
+
+      driver   = uri.scheme
+      conn_uri = uri
+
+      # Exceptions to how a driver class is determined for a given URI
+      driver_class = driver.capitalize
+
+      clazz = DataObjects.const_get(driver_class)::Connection
+      unless clazz.method_defined? :close
+        clazz.class_eval do
+          include Pooling
+          alias_method :close, :release
+        end
+      end
+      clazz.new(conn_uri)
+    end
+
+    # Ensure that all Connection subclasses handle pooling and logging uniformly.
+    # See also DataObjects::Pooling and DataObjects::Logger
+    def self.inherited(target)
+      target.class_eval do
+        # Allocate a Connection object from the pool, creating one if necessary. This method is active in Connection subclasses only.
+        def self.new(*args)
+          instance = allocate
+          instance.send(:initialize, *args)
+          instance
+        end
+
+        include Quoting
+      end
+
+      return unless (driver_module_name = target.name.split('::')[-2])
+
+      driver_module = DataObjects.const_get(driver_module_name)
+      driver_module.class_eval <<-EOS, __FILE__, __LINE__ + 1
+          def self.logger
+            @logger
+          end
+
+          def self.logger=(logger)
+            @logger = logger
+          end
+      EOS
+
+      driver_module.logger = DataObjects::Logger.new(nil, :off)
+    end
+
+    #####################################################
+    # Standard API Definition
+    #####################################################
+
+    # Show the URI for this connection, without
+    # the password the connection was setup with
+    def to_s
+      @uri.to_s
+    end
+
+    def initialize(_uri) # :nodoc:
+      raise NotImplementedError
+    end
+
+    def dispose # :nodoc:
+      raise NotImplementedError
+    end
+
+    # Create a Command object of the right subclass using the given text
+    def create_command(text)
+      self.class.concrete_command.new(self, text)
+    end
+
+    def extension
+      driver_namespace.const_get('Extension').new(self)
+    end
+
+    private def driver_namespace
+      constant_name = self.class.name&.split('::')
+      DataObjects.const_get(constant_name[-2])
+    end
+
+    def self.concrete_command
+      constant_name = name&.split('::')
+      @concrete_command ||= DataObjects.const_get(constant_name[-2]).const_get('Command')
+    end
+  end
+end

data/lib/data_objects/error/connection_error.rb

@@ -0,0 +1,4 @@
+module DataObjects
+  class ConnectionError < SQLError
+  end
+end

data/lib/data_objects/error/data_error.rb

@@ -0,0 +1,4 @@
+module DataObjects
+  class DataError < SQLError
+  end
+end

data/lib/data_objects/error/integrity_error.rb

@@ -0,0 +1,4 @@
+module DataObjects
+  class IntegrityError < SQLError
+  end
+end

data/lib/data_objects/error/sql_error.rb

@@ -0,0 +1,17 @@
+module DataObjects
+  class SQLError < Error
+    attr_reader :message, :code, :sqlstate, :query, :uri
+
+    def initialize(message, code = nil, sqlstate = nil, query = nil, uri = nil)
+      @message = message
+      @code = code
+      @sqlstate = sqlstate
+      @query = query
+      @uri = uri
+    end
+
+    def to_s
+      "#{message} (code: #{code}, sql state: #{sqlstate}, query: #{query}, uri: #{uri})"
+    end
+  end
+end

data/lib/data_objects/error/syntax_error.rb

@@ -0,0 +1,4 @@
+module DataObjects
+  class SyntaxError < SQLError
+  end
+end

data/lib/data_objects/error/transaction_error.rb

@@ -0,0 +1,4 @@
+module DataObjects
+  class TransactionError < SQLError
+  end
+end

data/lib/data_objects/error.rb

@@ -0,0 +1,4 @@
+module DataObjects
+  class Error < StandardError
+  end
+end

data/lib/data_objects/extension.rb

@@ -0,0 +1,9 @@
+module DataObjects
+  class Extension
+    attr_reader :connection
+
+    def initialize(connection)
+      @connection = connection
+    end
+  end
+end

data/lib/data_objects/logger.rb

@@ -0,0 +1,247 @@
+require 'time' # httpdate
+
+module DataObjects
+  module Logging
+    def log(message)
+      logger = driver_namespace.logger
+      return unless logger.level <= DataObjects::Logger::LEVELS[:debug]
+
+      message = format('(%.6f) %s', message.duration / 1_000_000.0, message.query)
+      logger.debug message
+    end
+  end
+
+  class << self
+    # The global logger for DataObjects
+    attr_accessor :logger
+  end
+
+  # ==== Public DataObjects Logger API
+  #
+  # Logger taken from Merb :)
+  #
+  # To replace an existing logger with a new one:
+  #  DataObjects::Logger.set_log(log{String, IO},level{Symbol, String})
+  #
+  # Available logging levels are
+  #   DataObjects::Logger::{ Fatal, Error, Warn, Info, Debug }
+  #
+  # Logging via:
+  #   DataObjects.logger.fatal(message<String>)
+  #   DataObjects.logger.error(message<String>)
+  #   DataObjects.logger.warn(message<String>)
+  #   DataObjects.logger.info(message<String>)
+  #   DataObjects.logger.debug(message<String>)
+  #
+  # Flush the buffer to
+  #   DataObjects.logger.flush
+  #
+  # Remove the current log object
+  #   DataObjects.logger.close
+  #
+  # ==== Private DataObjects Logger API
+  #
+  # To initialize the logger you create a new object, proxies to set_log.
+  #   DataObjects::Logger.new(log{String, IO},level{Symbol, String})
+  #
+  # Logger will not create the file until something is actually logged
+  # This avoids file creation on DataObjects init when it creates the
+  # default logger.
+  class Logger
+    # Use asynchronous I/O?
+    attr_accessor :aio
+    # delimiter to use between message sections
+    attr_accessor :delimiter
+    # a symbol representing the log level from {:off, :fatal, :error, :warn, :info, :debug}
+    attr_reader   :level
+    # Direct access to the buffer
+    attr_reader   :buffer
+    # The name of the log file
+    attr_reader   :log
+
+    Message = Struct.new(:query, :start, :duration)
+
+    #
+    # Ruby (standard) logger levels:
+    #   off:   absolutely nothing
+    #   fatal: an unhandleable error that results in a program crash
+    #   error: a handleable error condition
+    #   warn:  a warning
+    #   info:  generic (useful) information about system operation
+    #   debug: low-level information for developers
+    #
+    # DataObjects::Logger::LEVELS[:off, :fatal, :error, :warn, :info, :debug]
+    LEVELS =
+      {
+        off: 99_999,
+        fatal: 7,
+        error: 6,
+        warn: 4,
+        info: 3,
+        debug: 0
+      }.freeze
+
+    # Set the log level (use the level symbols as documented)
+    def level=(new_level)
+      @level = LEVELS[new_level.to_sym]
+      reset_methods(:close)
+    end
+
+    # The idea here is that instead of performing an 'if' conditional check on
+    # each logging we do it once when the log object is setup
+    private def set_write_method
+      @log.instance_eval do
+        # Determine if asynchronous IO can be used
+        def aio?
+          @aio = !RUBY_PLATFORM.match(/java|mswin/) &&
+                 @log != $stdout &&
+                 @log.respond_to?(:write_nonblock)
+        end
+
+        # Define the write method based on if aio an be used
+        undef write_method if defined? write_method
+        if aio?
+          alias :write_method :write_nonblock
+        else
+          alias :write_method :write
+        end
+      end
+    end
+
+    private def initialize_log(log)
+      close if @log # be sure that we don't leave open files laying around.
+      @log = log || 'log/dm.log'
+    end
+
+    private def reset_methods(o_or_c)
+      if o_or_c == :open
+        alias internal_push push_opened
+      elsif o_or_c == :close
+        alias internal_push push_closed
+      end
+    end
+
+    private def push_opened(string)
+      message = Time.now.httpdate
+      message << delimiter
+      message << string
+      message << "\n" unless message[-1] == "\n"
+      @buffer << message
+      flush # Force a flush for now until we figure out where we want to use the buffering.
+    end
+
+    private def push_closed(string)
+      unless @log.respond_to?(:write)
+        log = Pathname(@log)
+        log.dirname.mkpath
+        @log = log.open('a')
+        @log.sync = true
+      end
+      set_write_method
+      reset_methods(:open)
+      push(string)
+    end
+
+    alias internal_push push_closed
+
+    private def prep_msg(message, level)
+      level << delimiter << message
+    end
+
+    # To initialize the logger you create a new object, proxies to set_log.
+    #   DataObjects::Logger.new(log{String, IO},level{Symbol, String})
+    #
+    # @param * [Mixed]
+    #   log<IO,String>        either an IO object or a name of a logfile.
+    #   log_level<String>     the message string to be logged
+    #   delimiter<String>     delimiter to use between message sections
+    #   log_creation<Boolean> log that the file is being created
+    public def initialize(*args)
+      set_log(*args)
+    end
+
+    # To replace an existing logger with a new one:
+    #  DataObjects::Logger.set_log(log{String, IO},level{Symbol, String})
+    #
+    #
+    # @param log<IO,String>        either an IO object or a name of a logfile.
+    # @param log_level<Symbol>     a symbol representing the log level from
+    #   {:off, :fatal, :error, :warn, :info, :debug}
+    # @param delimiter<String>     delimiter to use between message sections
+    # @param log_creation<Boolean> log that the file is being created
+    public def set_log(log, log_level = :off, delimiter = ' ~ ', log_creation = false)
+      delimiter    ||= ' ~ '
+
+      self.level = if log_level && LEVELS[log_level.to_sym]
+                     log_level.to_sym
+                   else
+                     :debug
+                   end
+
+      @buffer    = []
+      @delimiter = delimiter
+
+      initialize_log(log)
+
+      DataObjects.logger = self
+
+      info('Logfile created') if log_creation
+    end
+
+    # Flush the entire buffer to the log object.
+    #   DataObjects.logger.flush
+    #
+    public def flush
+      return unless @buffer.size.positive?
+
+      @log.write_method(@buffer.slice!(0..-1).join)
+    end
+
+    # Close and remove the current log object.
+    #   DataObjects.logger.close
+    #
+    public def close
+      flush
+      @log.close if @log.respond_to?(:close)
+      @log = nil
+    end
+
+    # Appends a string and log level to logger's buffer.
+
+    #
+    # Note that the string is discarded if the string's log level less than the
+    # logger's log level.
+    #
+    # Note that if the logger is aio capable then the logger will use
+    # non-blocking asynchronous writes.
+    #
+    #  Is this old or does the method receive mixed params? level<Fixnum>  the logging level as an integer
+    # @param string<String> the message string to be logged
+    public def push(string)
+      internal_push(string)
+    end
+    alias << push
+
+    # Generate the following logging methods for DataObjects.logger as described
+    # in the API:
+    #  :fatal, :error, :warn, :info, :debug
+    #  :off only gets an off? method
+    LEVELS.each_pair do |name, number|
+      unless name.to_sym == :off
+        class_eval <<-EOS, __FILE__, __LINE__ + 1
+          # DOC
+          def #{name}(message)
+            self.<<( prep_msg(message, "#{name}") ) if #{name}?
+          end
+        EOS
+      end
+
+      class_eval <<-EOS, __FILE__, __LINE__ + 1
+        # DOC
+        def #{name}?
+          #{number} >= level
+        end
+      EOS
+    end
+  end
+end