skiima 0.1.000 → 0.2.2

data/lib/skiima/db/connector.rb

@@ -0,0 +1,195 @@
+# encoding: utf-8
+
+module Skiima
+  module Db
+    module Connector
+      class Base
+        extend Forwardable
+
+        class << self
+          extend Forwardable
+
+          def create_connector(config, logger = nil, opts = {})
+            pool = config['pool']
+            adapter = create_adapter(config, logger, pool)
+            new(adapter, logger, config)
+          end
+        end
+
+        attr_accessor :config, :orm
+        attr_accessor :logger, :adapter
+
+        alias_method :klass, :class
+        delegate helpers_module: :klass
+
+        def initialize(adapter, logger, config = {})
+          @adapter, @logger = adapter, logger
+
+          set_config(config)
+          include_helpers_on_adapter
+        end
+
+        private
+
+        def set_config(opts = {})
+          @config = opts
+        end
+
+        def include_helpers_on_adapter
+          adapter.singleton_class.class_eval "include #{helpers_module.to_s}"
+        end
+      end
+    end
+  end
+end
+
+# encoding: utf-8
+#module Skiima
+#  module DbAdapters
+#    class Base
+#      attr_accessor :version
+#
+#      def initialize(connection, logger = nil) #:nodoc:
+#        super()
+#
+#        @active              = nil
+#        @connection          = connection
+#        @in_use              = false
+#        @last_use            = false
+#        @logger              = logger
+#        @visitor             = nil
+#      end
+#
+#      def adapter_name
+#        'Base'
+#      end
+#
+#      def supports_ddl_transactions?
+#        false
+#      end
+#
+#      # Does this adapter support savepoints? PostgreSQL and MySQL do,
+#      # SQLite < 3.6.8 does not.
+#      def supports_savepoints?
+#        false
+#      end
+#
+#      def active?
+#        @active != false
+#      end
+#
+#      # Disconnects from the database if already connected, and establishes a
+#      # new connection with the database.
+#      def reconnect!
+#        @active = true
+#      end
+#
+#      # Disconnects from the database if already connected. Otherwise, this
+#      # method does nothing.
+#      def disconnect!
+#        @active = false
+#      end
+#
+#      # Reset the state of this connection, directing the DBMS to clear
+#      # transactions and other connection-related server-side state. Usually a
+#      # database-dependent operation.
+#      #
+#      # The default implementation does nothing; the implementation should be
+#      # overridden by concrete adapters.
+#      def reset!
+#        # this should be overridden by concrete adapters
+#      end
+#
+#      ###
+#      # Clear any caching the database adapter may be doing, for example
+#      # clearing the prepared statement cache. This is database specific.
+#      def clear_cache!
+#        # this should be overridden by concrete adapters
+#      end
+#
+#      # Returns true if its required to reload the connection between requests for development mode.
+#      # This is not the case for Ruby/MySQL and it's not necessary for any adapters except SQLite.
+#      def requires_reloading?
+#        false
+#      end
+#
+#      # Checks whether the connection to the database is still active (i.e. not stale).
+#      # This is done under the hood by calling <tt>active?</tt>. If the connection
+#      # is no longer active, then this method will reconnect to the database.
+#      def verify!(*ignored)
+#        reconnect! unless active?
+#      end
+#
+#      # Provides access to the underlying database driver for this adapter. For
+#      # example, this method returns a Mysql object in case of MysqlAdapter,
+#      # and a PGconn object in case of PostgreSQLAdapter.
+#      #
+#      # This is useful for when you need to call a proprietary method such as
+#      # PostgreSQL's lo_* methods.
+#      def raw_connection
+#        @connection
+#      end
+#
+#      attr_reader :open_transactions
+#
+#      def increment_open_transactions
+#        @open_transactions += 1
+#      end
+#
+#      def decrement_open_transactions
+#        @open_transactions -= 1
+#      end
+#
+#      def transaction_joinable=(joinable)
+#        @transaction_joinable = joinable
+#      end
+#
+#      def create_savepoint
+#      end
+#
+#      def rollback_to_savepoint
+#      end
+#
+#      def release_savepoint
+#      end
+#
+#      def current_savepoint_name
+#        "active_record_#{open_transactions}"
+#      end
+#
+#      # Check the connection back in to the connection pool
+#      def close
+#        disconnect!
+#      end
+#
+#      # Disconnects from the database if already connected. Otherwise, this
+#      # method does nothing.
+#      def disconnect!
+#        clear_cache!
+#        @connection.close rescue nil
+#      end
+#
+#      protected
+#
+#      def log(sql, name = "SQL", binds = [])
+#        @logger.debug("Executing SQL Statement: #{name}")
+#        @logger.debug(sql)
+#        result = yield
+#        @logger.debug("SUCCESS!")
+#        result
+#      rescue Exception => e
+#        message = "#{e.class.name}: #{e.message}: #{sql}"
+#        @logger.debug message if @logger
+#        exception = translate_exception(e, message)
+#        exception.set_backtrace e.backtrace
+#        raise exception
+#      end
+#
+#      def translate_exception(e, message)
+#        # override in derived class
+#        raise "override in derived class"
+#      end
+#
+#    end
+#  end
+#end

data/lib/skiima/db/connector/active_record.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+module Skiima
+  module Db
+    module Connector
+      module ActiveRecord
+
+      end
+    end
+  end
+end

data/lib/skiima/db/connector/active_record/base_connector.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+require 'active_record' unless defined? ActiveRecord
+require 'active_support' unless defined? ActiveSupport
+
+module Skiima
+  module Db
+    module Connector
+      module ActiveRecord
+
+        class BaseConnector < Skiima::Db::Connector::Base
+          delegate [:version, :execute,
+                    :adapter_name, :supported_objects,
+                    :supports_ddl_transactions?,
+                    :drop, :active?, :object_exists?,
+                    :reconnect!, :disconnect!, :close,
+                    :reset!, :verify!, :raw_connection,
+                    :begin_db_transaction, :rollback_db_transaction] => :adapter
+
+          #alias_method :connection, :raw_connection
+
+          class << self
+            def active_record_resolver_klass
+              case ::ActiveRecord::VERSION::MAJOR
+                when 4 then ::ActiveRecord::ConnectionHandling
+                when 3 then ::ActiveRecord::Base
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/skiima/db/connector/active_record/mysql2_connector.rb

@@ -0,0 +1,147 @@
+# encoding: utf-8
+require 'skiima/db/helpers/mysql' unless defined? Skiima::Db::Helpers::Mysql
+require 'skiima/db/connector/active_record/base_connector' unless defined? Skiima::Db::Connector::ActiveRecord::BaseConnector
+require 'active_record/connection_adapters/mysql2_adapter' unless defined? ActiveRecord::ConnectionAdapters::Mysql2Adapter
+
+module Skiima
+  module Db
+    module Connector
+      module ActiveRecord
+        class Mysql2Connector < Skiima::Db::Connector::ActiveRecord::BaseConnector
+          delegate [:table_exists?, :index_exists?, :proc_exists?,
+                    :view_exists?, :schema_exists?] => :adapter
+
+          class << self
+            delegate mysql2_connection: :active_record_resolver_klass
+
+            def create_adapter(config, logger, pool)
+              case ::ActiveRecord::VERSION::MAJOR
+                when 3,4 then send('mysql2_connection', config)
+              end
+            end
+
+            def helpers_module
+              Skiima::Db::Helpers::Mysql
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+## encoding: utf-8
+#require 'skiima/db_adapters/base_mysql_adapter'
+#
+#gem 'mysql2', '~> 0.3.10'
+#require 'mysql2'
+#
+#module Skiima
+#  def self.mysql2_connection(logger, config)
+#    config = Skiima.symbolize_keys(config)
+#    config[:username] = 'root' if config[:username].nil?
+#
+#    if Mysql2::Client.const_defined? :FOUND_ROWS
+#      config[:flags] = Mysql2::Client::FOUND_ROWS
+#    end
+#
+#    client = Mysql2::Client.new(config)
+#    options = [config[:host], config[:username], config[:password], config[:database], config[:port], config[:socket], 0]
+#    Skiima::DbAdapters::Mysql2Adapter.new(client, logger, options, config)
+#  end
+#
+#  module DbAdapters
+#    class Mysql2Adapter < BaseMysqlAdapter
+#      ADAPTER_NAME = 'Mysql2'
+#
+#      def initialize(connection, logger, connection_options, config)
+#        super
+#        configure_connection
+#      end
+#
+#      def supports_explain?
+#        true
+#      end
+#
+#      def error_number(exception)
+#        exception.error_number if exception.respond_to?(:error_number)
+#      end
+#
+#      def active?
+#        return false unless @connection
+#        @connection.ping
+#      end
+#
+#      def reconnect!
+#        disconnect!
+#        connect
+#      end
+#
+#      # Disconnects from the database if already connected.
+#      # Otherwise, this method does nothing.
+#      def disconnect!
+#        unless @connection.nil?
+#          @connection.close
+#          @connection = nil
+#        end
+#      end
+#
+#      def reset!
+#        disconnect!
+#        connect
+#      end
+#
+#      def execute(sql, name = nil)
+#        # make sure we carry over any changes to ActiveRecord::Base.default_timezone that have been
+#        # made since we established the connection
+#        # @connection.query_options[:database_timezone] = ActiveRecord::Base.default_timezone
+#
+#        # relying on formatting inside the file is precisely what i wanted to avoid...
+#        results = sql.split(/^--={4,}/).map do |spider_monkey|
+#          super(spider_monkey)
+#        end
+#
+#        results.first
+#      end
+#
+#      def exec_query(sql, name = 'SQL', binds = [])
+#        result = execute(sql, name)
+#        ActiveRecord::Result.new(result.fields, result.to_a)
+#      end
+#
+#      alias exec_without_stmt exec_query
+#
+#      private
+#
+#      def connect
+#        @connection = Mysql2::Client.new(@config)
+#        configure_connection
+#      end
+#
+#      def configure_connection
+#        @connection.query_options.merge!(:as => :array)
+#
+#        variable_assignments = get_var_assignments
+#        execute("SET #{variable_assignments.join(', ')}", :skip_logging)
+#
+#        version
+#      end
+#
+#      def get_var_assignments
+#        # By default, MySQL 'where id is null' selects the last inserted id.
+#        # Turn this off. http://dev.rubyonrails.org/ticket/6778
+#        variable_assignments = ['SQL_AUTO_IS_NULL=0']
+#        encoding = @config[:encoding]
+#
+#        # make sure we set the encoding
+#        variable_assignments << "NAMES '#{encoding}'" if encoding
+#
+#        # increase timeout so mysql server doesn't disconnect us
+#        wait_timeout = @config[:wait_timeout]
+#        wait_timeout = 2592000 unless wait_timeout.is_a?(Fixnum)
+#        variable_assignments << "@@wait_timeout = #{wait_timeout}"
+#      end
+#
+#    end
+#  end
+#end

data/lib/skiima/db/connector/active_record/mysql_connector.rb

@@ -0,0 +1,177 @@
+# encoding: utf-8
+require 'skiima/db/helpers/mysql' unless defined? Skiima::Db::Helpers::Mysql
+require 'skiima/db/connector/active_record/base_connector' unless defined? Skiima::Db::Connector::ActiveRecord::BaseConnector
+require 'active_record/connection_adapters/mysql_adapter' unless defined? ActiveRecord::ConnectionAdapters::MysqlAdapter
+
+module Skiima
+  module Db
+    module Connector
+      module ActiveRecord
+
+        class MysqlConnector < Skiima::Db::Connector::ActiveRecord::BaseConnector
+          delegate [:tables, :indexes, :procs, :views, :schemas,
+                    :drop, :drop_table, :drop_proc, :drop_view,
+                    :drop_index, :drop_schema, :column_names,
+                    :table_exists?, :index_exists?, :proc_exists?,
+                    :view_exists?, :schema_exists?] => :adapter
+
+          class << self
+            delegate mysql_connection: :active_record_resolver_klass
+
+            def create_adapter(config, logger, pool)
+              case ::ActiveRecord::VERSION::MAJOR
+                when 3,4 then send('mysql_connection', config)
+              end
+            end
+
+            def helpers_module
+              Skiima::Db::Helpers::Mysql
+            end
+          end
+        end
+
+      end
+    end
+  end
+end
+
+## encoding: utf-8
+#require 'skiima/db_adapters/base_mysql_adapter'
+#
+#gem 'mysql', '~> 2.9.1'
+#require 'mysql'
+#
+#class Mysql
+#  class Time
+#    ###
+#    # This monkey patch is for test_additional_columns_from_join_table
+#    def to_date
+#      Date.new(year, month, day)
+#    end
+#  end
+#  class Stmt; include Enumerable end
+#  class Result; include Enumerable end
+#end
+#
+#module Skiima
+#  # Establishes a connection to the database that's used by all Active Record objects.
+#  def self.mysql_connection(logger, config) # :nodoc:
+#    config = Skiima.symbolize_keys(config)
+#    host     = config[:host]
+#    port     = config[:port]
+#    socket   = config[:socket]
+#    username = config[:username] ? config[:username].to_s : 'root'
+#    password = config[:password].to_s
+#    database = config[:database]
+#
+#    mysql = Mysql.init
+#    mysql.ssl_set(config[:sslkey], config[:sslcert], config[:sslca], config[:sslcapath], config[:sslcipher]) if config[:sslca] || config[:sslkey]
+#
+#    default_flags = Mysql.const_defined?(:CLIENT_MULTI_RESULTS) ? Mysql::CLIENT_MULTI_RESULTS : 0
+#    default_flags |= Mysql::CLIENT_FOUND_ROWS if Mysql.const_defined?(:CLIENT_FOUND_ROWS)
+#
+#    options = [host, username, password, database, port, socket, default_flags]
+#    Skiima::DbAdapters::MysqlAdapter.new(mysql, logger, options, config)
+#  end
+#
+#  module DbAdapters
+#    class MysqlAdapter < BaseMysqlAdapter
+#      attr_accessor :client_encoding
+#
+#      ADAPTER_NAME = 'MySQL'
+#
+#      # def exec_without_stmt(sql, name = 'SQL') # :nodoc:
+#      #   # Some queries, like SHOW CREATE TABLE don't work through the prepared
+#      #   # statement API. For those queries, we need to use this method. :'(
+#      #   log(sql, name) do
+#      #     result = @connection.query(sql)
+#      #     cols = []
+#      #     rows = []
+#
+#      #     if result
+#      #       cols = result.fetch_fields.map { |field| field.name }
+#      #       rows = result.to_a
+#      #       result.free
+#      #     end
+#      #     ActiveRecord::Result.new(cols, rows)
+#      #   end
+#      # end
+#
+#      def execute_and_free(sql, name = nil)
+#        result = execute(sql, name)
+#        ret = yield result
+#        result.free
+#        ret
+#      end
+#
+#      def begin_db_transaction #:nodoc:
+#        exec_without_stmt "BEGIN"
+#      rescue Mysql::Error
+#        # Transactions aren't supported
+#      end
+#
+#      private
+#
+#      def exec_stmt(sql, name)
+#        stmt = @connection.prepare(sql)
+#
+#        begin
+#          stmt.execute
+#        rescue Mysql::Error => e
+#          # Older versions of MySQL leave the prepared statement in a bad
+#          # place when an error occurs. To support older mysql versions, we
+#          # need to close the statement and delete the statement from the
+#          # cache.
+#          stmt.close
+#          raise e
+#        end
+#
+#        cols = nil
+#        if metadata = stmt.result_metadata
+#          cols = metadata.fetch_fields.map { |field| field.name }
+#        end
+#
+#        result = yield [cols, stmt]
+#
+#        stmt.result_metadata.free if cols
+#        stmt.free_result
+#        stmt.close
+#
+#        result
+#      end
+#
+#      def connect
+#        encoding = @config[:encoding]
+#        if encoding
+#          @connection.options(Mysql::SET_CHARSET_NAME, encoding) rescue nil
+#        end
+#
+#        if @config[:sslca] || @config[:sslkey]
+#          @connection.ssl_set(@config[:sslkey], @config[:sslcert], @config[:sslca], @config[:sslcapath], @config[:sslcipher])
+#        end
+#
+#        @connection.options(Mysql::OPT_CONNECT_TIMEOUT, @config[:connect_timeout]) if @config[:connect_timeout]
+#        @connection.options(Mysql::OPT_READ_TIMEOUT, @config[:read_timeout]) if @config[:read_timeout]
+#        @connection.options(Mysql::OPT_WRITE_TIMEOUT, @config[:write_timeout]) if @config[:write_timeout]
+#
+#        @connection.real_connect(*@connection_options)
+#
+#        # reconnect must be set after real_connect is called, because real_connect sets it to false internally
+#        @connection.reconnect = !!@config[:reconnect] if @connection.respond_to?(:reconnect=)
+#
+#        version #gets version
+#
+#        configure_connection
+#      end
+#
+#      def configure_connection
+#        encoding = @config[:encoding]
+#        execute("SET NAMES '#{encoding}'", :skip_logging) if encoding
+#
+#        # By default, MySQL 'where id is null' selects the last inserted id.
+#        # Turn this off. http://dev.rubyonrails.org/ticket/6778
+#        execute("SET SQL_AUTO_IS_NULL=0", :skip_logging)
+#      end
+#    end
+#  end
+#end