skiima 0.1.000 → 0.2.2

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

@@ -0,0 +1,39 @@
+# encoding: utf-8
+require 'skiima/db/helpers/postgresql' unless defined? Skiima::Db::Helpers::Postgresql
+require 'skiima/db/connector/active_record/base_connector' unless defined? Skiima::Db::Connector::ActiveRecord::BaseConnector
+require 'active_record/connection_adapters/postgresql_adapter' unless defined? ActiveRecord::ConnectionAdapters::PostreSQLAdapter
+
+module Skiima
+  module Db
+    module Connector
+      module ActiveRecord
+
+        class PostgresqlConnector < Skiima::Db::Connector::ActiveRecord::BaseConnector
+          delegate [:local_tz, :column_names, :check_psql_version,
+                    :table_exists?, :index_exists?, :rule_exists?,
+                    :view_exists?, :schema_exists?] => :adapter
+
+          def initialize(adapter, logger, config = {})
+            super
+            check_psql_version
+          end
+
+          class << self
+            delegate postgresql_connection: :active_record_resolver_klass
+
+            def create_adapter(config, logger, pool)
+              case ::ActiveRecord::VERSION::MAJOR
+                when 3,4 then send('postgresql_connection', config)
+              end
+            end
+
+            def helpers_module
+              Skiima::Db::Helpers::Postgresql
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/skiima/db/helpers/mysql.rb

@@ -0,0 +1,230 @@
+module Skiima
+  module Db
+    module Helpers
+      module Mysql
+        #attr_accessor :version
+
+        def supported_objects
+          [:database, :table, :view, :index, :proc]
+        end
+
+        def execute(sql, name = nil)
+          # relying on formatting inside the file is precisely what i wanted to avoid...
+          results = sql.split(/^--={4,}/).map do |line|
+            super(line)
+          end
+
+          results.first
+        end
+
+        def exec_query(sql, name = 'SQL')
+          log(sql, name) do
+            exec_stmt(sql, name) do |cols, stmt|
+              stmt.to_a
+            end
+          end
+        end
+
+        #override?
+        def tables(name = nil, database = nil, like = nil)
+          sql = "SHOW FULL TABLES "
+          sql << "IN #{database} " if database
+          sql << "WHERE table_type = 'BASE TABLE' "
+          sql << "LIKE '#{like}' " if like
+
+          execute_and_free(sql, 'SCHEMA') do |result|
+            result.collect { |field| field.first }
+          end
+        end
+
+        def views(name = nil, database = nil, like = nil)
+          sql = "SHOW FULL TABLES "
+          sql << "IN #{database} " if database
+          sql << "WHERE table_type = 'VIEW' "
+          sql << "LIKE '#{like}' " if like
+
+          execute_and_free(sql, 'SCHEMA') do |result|
+            result.collect { |field| field.first }
+          end
+        end
+
+        def indexes(name = nil, database = nil, table = nil)
+          sql = "SHOW INDEX "
+          sql << "IN #{table} "
+          sql << "IN #{database} " if database
+          sql << "WHERE key_name = '#{name}'" if name
+
+          execute_and_free(sql, 'SCHEMA') do |result|
+            result.collect { |field| field[2] }
+          end
+        end
+
+        def procs(name = nil, database = nil, like = nil)
+          sql = "SELECT r.routine_name "
+          sql << "FROM information_schema.routines r "
+          sql << "WHERE r.routine_type = 'PROCEDURE' "
+          sql << "AND r.routine_name LIKE '#{like}' " if like
+          sql << "AND r.routine_schema = #{database} " if database
+
+          execute_and_free(sql, 'SCHEMA') do |result|
+            result.collect { |field| field.first }
+          end
+        end
+
+        # needed?
+        #def column_definitions(table_name)
+        #  # "SHOW FULL FIELDS FROM #{quote_table_name(table_name)}"
+        #end
+
+        # keep?
+        #def column_names(table_name)
+        #  sql = "SHOW FULL FIELDS FROM #{quote_table_name(table_name)}"
+        #  execute_and_free(sql, 'SCHEMA') do |result|
+        #    result.collect { |field| field.first }
+        #  end
+        #end
+
+        def column_names(table_name)
+          columns(table_name).map(&:name)
+        end
+
+        # schema matchers
+        def object_exists?(type, name, opts = {})
+          send("#{type}_exists?", name, opts) if supported_objects.include? type.to_sym
+        end
+
+        def database_exists?(name)
+          #stub
+        end
+
+        def table_exists?(name)
+          return false unless name
+          return true if tables(nil, nil, name).any?
+
+          name          = name.to_s
+          schema, table = name.split('.', 2)
+
+          unless table # A table was provided without a schema
+            table  = schema
+            schema = nil
+          end
+
+          tables(nil, schema, table).any?
+        end
+
+        def view_exists?(name)
+          return false unless name
+          return true if views(nil, nil, name).any?
+
+          name          = name.to_s
+          schema, view = name.split('.', 2)
+
+          unless view # A table was provided without a schema
+            view   = schema
+            schema = nil
+          end
+
+          views(nil, schema, view).any?
+        end
+
+        def index_exists?(name, opts = {})
+          target = opts[:attr] ? opts[:attr][0] : nil
+          raise "requires target object" unless target
+
+          return false unless table_exists?(target) #mysql blows up when table doesn't exist
+          return false unless name
+          return true if indexes(name, nil, target).any?
+
+          name           = name.to_s
+          schema, target = name.split('.', 2)
+
+          unless target # A table was provided without a schema
+            target  = schema
+            schema = nil
+          end
+
+          indexes(name, schema, target).any?
+        end
+
+        def proc_exists?(name, opts = {})
+          return false unless name
+          return true if procs(nil, nil, name).any?
+
+          name = name.to_s
+          schema, proc = name.split('.', 2)
+
+          unless proc # A table was provided without a schema
+            proc  = schema
+            schema = nil
+          end
+
+          procs(name, schema, proc).any?
+        end
+
+        # queries
+        def drop(type, name, opts = {})
+          send("drop_#{type}", name, opts) if supported_objects.include? type.to_sym
+        end
+
+        def drop_database(name, opts = {})
+          "DROP DATABASE IF EXISTS #{name}"
+        end
+
+        def drop_table(name, opts = {})
+          "DROP TABLE IF EXISTS #{name}"
+        end
+
+        def drop_view(name, opts = {})
+          "DROP VIEW IF EXISTS #{name}"
+        end
+
+        def drop_proc(name, opts = {})
+          "DROP PROCEDURE IF EXISTS #{name}"
+        end
+
+        def drop_index(name, opts = {})
+          target = opts[:attr].first if opts[:attr]
+          raise "requires target object" unless target
+
+          "DROP INDEX #{name} ON #{target}"
+        end
+
+        protected
+
+        #def translate_exception(exception, message)
+        #  exception
+        #  # case error_number(exception)
+        #  # when 1062
+        #  #   RecordNotUnique.new(message, exception)
+        #  # when 1452
+        #  #   InvalidForeignKey.new(message, exception)
+        #  # else
+        #  #   super
+        #  # end
+        #end
+      end
+    end
+  end
+end
+
+## encoding: utf-8
+#module Skiima
+#  module DbAdapters
+#    class BaseMysqlAdapter < Base
+#      attr_accessor :version
+#
+#      LOST_CONNECTION_ERROR_MESSAGES = [
+#          "Server shutdown in progress",
+#          "Broken pipe",
+#          "Lost connection to MySQL server during query",
+#          "MySQL server has gone away" ]
+#
+#      # FIXME: Make the first parameter more similar for the two adapters
+#      def initialize(connection, logger, connection_options, config)
+#        super(connection, logger)
+#        @connection_options, @config = connection_options, config
+#        @quoted_column_names, @quoted_table_names = {}, {}
+#      end
+#    end
+#  end
+#end

data/lib/skiima/db/helpers/postgresql.rb

@@ -0,0 +1,221 @@
+module Skiima
+  module Db
+    module Helpers
+      module Postgresql
+        attr_accessor :local_tz
+        attr_accessor :version
+
+        def execute(sql, name = nil)
+          # relying on formatting inside the file is precisely what i wanted to avoid...
+          results = sql.split(/^--={4,}/).map do |line|
+            super(line)
+          end
+
+          results.first
+        end
+
+        # skiima
+        def supported_objects
+          [:database, :schema, :table, :view, :rule, :index]
+        end
+
+        def check_psql_version
+          @version = postgresql_version
+          if @version < 80200
+            raise "Your version of PostgreSQL (#{postgresql_version}) is too old, please upgrade!"
+          end
+        end
+
+        # schema matchers
+        def object_exists?(type, name, opts = {})
+          send("#{type}_exists?", name, opts) if supported_objects.include? type.to_sym
+        end
+
+        def database_exists?(name, opts = {})
+          query(Skiima.interpolate_sql('&', <<-SQL, { :database => name }))[0][0].to_i > 0
+          SELECT COUNT(*)
+          FROM pg_databases pdb
+          WHERE pdb.datname = '&database'
+          SQL
+        end
+
+        def schema_exists?(name, opts = {})
+          query(Skiima.interpolate_sql('&', <<-SQL, { :schema => name }))[0][0].to_i > 0
+          SELECT COUNT(*)
+          FROM pg_namespace
+          WHERE nspname = '&schema'
+          SQL
+        end
+
+        def table_exists?(name, opts = {})
+          schema, table = ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::Utils.extract_schema_and_table(name.to_s)
+          vars = { :table => table,
+                   :schema => ((schema && !schema.empty?) ? "'#{schema}'" : "ANY (current_schemas(false))") }
+
+          vars.inspect
+
+          query(Skiima.interpolate_sql('&', <<-SQL, vars))[0][0].to_i > 0
+          SELECT COUNT(*)
+          FROM pg_class c
+          LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
+          WHERE c.relkind in ('r')
+          AND c.relname = '&table'
+          AND n.nspname = &schema
+          SQL
+        end
+
+        def view_exists?(name, opts = {})
+          schema, view = ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::Utils.extract_schema_and_table(name.to_s)
+          vars = { :view => view,
+                   :schema => ((schema && !schema.empty?) ? "'#{schema}'" : "ANY (current_schemas(false))") }
+
+          query(Skiima.interpolate_sql('&', <<-SQL, vars))[0][0].to_i > 0
+          SELECT COUNT(*)
+          FROM pg_class c
+          LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
+          WHERE c.relkind in ('v')
+          AND c.relname = '&view'
+          AND n.nspname = &schema
+          SQL
+        end
+
+        def rule_exists?(name, opts = {})
+          target = opts[:attr] ? opts[:attr][0] : nil
+          raise "requires target object" unless target
+          schema, rule = ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::Utils.extract_schema_and_table(name.to_s)
+          vars = { :rule => rule,
+                   :target => target,
+                   :schema => ((schema && !schema.empty?) ? "'#{schema}'" : "ANY (current_schemas(false))") }
+
+          query(Skiima.interpolate_sql('&', <<-SQL, vars))[0][0].to_i > 0
+          SELECT COUNT(*)
+          FROM pg_rules pgr
+          WHERE pgr.rulename = '&rule'
+          AND pgr.tablename = '&target'
+          AND pgr.schemaname = &schema
+          SQL
+        end
+
+        def index_exists?(name, opts = {})
+          target = opts[:attr] ? opts[:attr][0] : nil
+          raise "requires target object" unless target
+          schema, index = ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::Utils.extract_schema_and_table(name.to_s)
+          vars = { :index => index,
+                   :target => target,
+                   :schema => ((schema && !schema.empty?) ? "'#{schema}'" : "ANY (current_schemas(false))") }
+
+          query(Skiima.interpolate_sql('&', <<-SQL, vars))[0][0].to_i > 0
+          SELECT COUNT(*)
+          FROM pg_indexes pgr
+          WHERE pgr.indexname = '&index'
+          AND pgr.tablename = '&target'
+          AND pgr.schemaname = &schema
+          SQL
+        end
+
+        # queries
+        def drop(type, name, opts = {})
+          send("drop_#{type}", name, opts) if supported_objects.include? type.to_sym
+        end
+
+        def drop_database(name, opts = {})
+          "DROP DATABASE IF EXISTS #{name}"
+        end
+
+        def drop_schema(name, opts = {})
+          "DROP SCHEMA IF EXISTS #{name}"
+        end
+
+        def drop_table(name, opts = {})
+          "DROP TABLE IF EXISTS #{name}"
+        end
+
+        def drop_view(name, opts = {})
+          "DROP VIEW IF EXISTS #{name}"
+        end
+
+        def drop_rule(name, opts = {})
+          target = opts[:attr].first if opts[:attr]
+          raise "requires target object" unless target
+
+          "DROP RULE IF EXISTS #{name} ON #{target}"
+        end
+
+        def drop_index(name, opts = {})
+          "DROP INDEX IF EXISTS #{name}"
+        end
+
+        # in original? why?
+        #necessary 2 override?
+        #def translate_exception(e, message)
+        #  e
+        #  # case exception.message
+        #  # when /duplicate key value violates unique constraint/
+        #  #   RecordNotUnique.new(message, exception)
+        #  # when /violates foreign key constraint/
+        #  #   InvalidForeignKey.new(message, exception)
+        #  # else
+        #  #   super
+        #  # end
+        #end
+
+        # necessary 2 override?
+        #class PgColumn
+        #  attr_accessor :name, :deafult, :type, :null
+        #  def initialize(name, default = nil, type = nil, null = true)
+        #    @name, @default, @type, @null = name, default, type, null
+        #  end
+        #
+        #  def to_s
+        #    # to be implemented
+        #  end
+        #end
+        def column_names(table_name)
+          columns(table_name).map(&:name)
+        end
+
+        # necessary 2 override?
+        ## Close then reopen the connection.
+        #def reconnect!
+        #  clear_cache!
+        #  @connection.reset
+        #  configure_connection
+        #end
+
+        # necessary 2 override?
+        ## Is this connection alive and ready for queries?
+        #def active?
+        #  @connection.status == PGconn::CONNECTION_OK
+        #rescue PGError
+        #  false
+        #end
+
+        protected
+
+        def get_timezone
+          execute('SHOW TIME ZONE', 'SCHEMA').first["TimeZone"]
+        end
+
+        private
+
+        #necessary 2 override?
+        # Configures the encoding, verbosity, schema search path, and time zone of the connection.
+        # This is called by #connect and should not be called manually.
+        #def configure_connection
+        #  if @config[:encoding]
+        #    @connection.set_client_encoding(@config[:encoding])
+        #  end
+        #  self.client_min_messages = @config[:min_messages] if @config[:min_messages]
+        #  self.schema_search_path = @config[:schema_search_path] || @config[:schema_order]
+        #
+        #  # Use standard-conforming strings if available so we don't have to do the E'...' dance.
+        #  set_standard_conforming_strings
+        #
+        #  #configure the connection to return TIMESTAMP WITH ZONE types in UTC.
+        #  execute("SET time zone '#{@local_tz}'", 'SCHEMA') if @local_tz
+        #end
+
+      end
+    end
+  end
+end