activerecord-jdbc-alt-adapter 50.3.0-java

data/lib/arjdbc/tasks/jdbc_database_tasks.rb

@@ -0,0 +1,169 @@
+module ArJdbc
+  module Tasks
+    # Sharing task related code between AR 3.x and 4.x
+    #
+    # @note this class needs to conform to the API available since AR 4.0
+    # mostly to be usable with ActiveRecord::Tasks::DatabaseTasks module
+    class JdbcDatabaseTasks
+
+      attr_reader :configuration
+      alias_method :config, :configuration
+
+      def initialize(configuration)
+        @configuration = configuration
+      end
+
+      delegate :connection, :establish_connection, :to => ActiveRecord::Base
+
+      def create
+        begin
+          establish_connection(config)
+          ActiveRecord::Base.connection
+          if defined? ActiveRecord::Tasks::DatabaseAlreadyExists
+            raise ActiveRecord::Tasks::DatabaseAlreadyExists # AR-4.x
+          end # silence on AR < 4.0
+        rescue #=> error # database does not exists :
+          url = config['url']
+          url = $1 if url && url =~ /^(.*(?<!\/)\/)(?=\w)/
+
+          establish_connection(config.merge('database' => nil, 'url' => url))
+
+          unless connection.respond_to?(:create_database)
+            raise "AR-JDBC adapter '#{adapter_with_spec}' does not support create_database"
+          end
+          connection.create_database(resolve_database(config), config)
+
+          establish_connection(config)
+        end
+      end
+
+      def drop
+        establish_connection(config)
+        unless ActiveRecord::Base.connection.respond_to?(:drop_database)
+          raise "AR-JDBC adapter '#{adapter_with_spec}' does not support drop_database"
+        end
+        connection.drop_database resolve_database(config)
+      end
+
+      def purge
+        establish_connection(config) # :test
+        unless ActiveRecord::Base.connection.respond_to?(:recreate_database)
+          raise "AR-JDBC adapter '#{adapter_with_spec}' does not support recreate_database (purge)"
+        end
+        db_name = ActiveRecord::Base.connection.database_name
+        ActiveRecord::Base.connection.recreate_database(db_name, config)
+      end
+
+      def charset
+        establish_connection(config)
+        if connection.respond_to?(:charset)
+          puts connection.charset
+        elsif connection.respond_to?(:encoding)
+          puts connection.encoding
+        else
+          raise "AR-JDBC adapter '#{adapter_with_spec}' does not support charset/encoding"
+        end
+      end
+
+      def collation
+        establish_connection(config)
+        if connection.respond_to?(:collation)
+          puts connection.collation
+        else
+          raise "AR-JDBC adapter '#{adapter_with_spec}' does not support collation"
+        end
+      end
+
+      def structure_dump(filename)
+        establish_connection(config)
+        if connection.respond_to?(:structure_dump)
+          File.open(filename, "w:utf-8") { |f| f << connection.structure_dump }
+        else
+          raise "AR-JDBC adapter '#{adapter_with_spec}' does not support structure_dump"
+        end
+      end
+
+      def structure_load(filename)
+        establish_connection(config)
+        if connection.respond_to?(:structure_load)
+          connection.structure_load IO.read(filename)
+        else
+          #IO.read(filename).split(/;\n*/m).each do |ddl|
+          #  connection.execute(ddl)
+          #end
+          raise "AR-JDBC adapter '#{adapter_with_spec}' does not support structure_load"
+        end
+      end
+
+      protected
+
+      def expand_path(path)
+        require 'pathname'
+        path = Pathname.new path
+        return path.to_s if path.absolute?
+        rails_root ? File.join(rails_root, path) : File.expand_path(path)
+      end
+
+      def resolve_database(config, file_paths = false)
+        config['database'] || resolve_database_from_url(config['url'] || '', file_paths)
+      end
+
+      def resolve_database_from_url(url, file_paths = false)
+        ( config = config_from_url(url, file_paths) ) ? config['database'] : nil
+      end
+
+      private
+
+      def config_from_url(url, file_paths = false)
+        match = url.match %r{
+          ^ jdbc:
+          ( [\w]+ ):         # $1 protocol
+          (?: ([\w]+) : )?   # $2 (sub-protocol)
+          (?://)?
+          (?: ([\w\-]*) (?: [/:] ([\w\-]*) )? @ (?://)? )?  # user[:password]@ or user[/password]@ ($3 $4)
+          ( [\w\.\-]+ )?   # $5 host (or database if there's nothing left)
+          (?: : (\d+) )?   # $6 port if any
+          (?: :? (/?[\w\-\./~]+) [\?;]? )? ([^/]*?) $
+          # $7 database part (ends with '?' or ';') and $8 query string - properties
+        }x
+
+        return nil unless match
+
+        config = {}
+        config['_protocol'] = match[1]
+        config['_sub_protocol'] = match[2] if match[2]
+        config['username'] = match[3] if match[3]
+        config['password'] = match[4] if match[4]
+        host = match[5]; port = match[6]
+        database = match[7]
+        if database.nil? && port.nil?
+          config['database'] = database = host
+        else
+          config['host'] = host if host
+          config['port'] = port if port
+          config['database'] = database
+        end
+        if database && ! file_paths && database[0...1] == '/'
+          config['database'] = database[1..-1]
+        end
+        if query_string = match[8]
+          properties = query_string.split('&').inject({}) do |memo, pair|
+            pair = pair.split("="); memo[ pair[0] ] = pair[1]; memo
+          end
+          config['properties'] = properties
+        end
+        config
+      end
+
+      def adapter_with_spec
+        adapter, spec = config['adapter'], config['adapter_spec']
+        spec ? "#{adapter} (#{spec})" : adapter
+      end
+
+      def rails_root
+        defined?(Rails.root) ? Rails.root : ( RAILS_ROOT )
+      end
+
+    end
+  end
+end

data/lib/arjdbc/tasks/mssql_database_tasks.rb

@@ -0,0 +1,46 @@
+require 'arjdbc/tasks/jdbc_database_tasks'
+
+module ArJdbc
+  module Tasks
+    class MSSQLDatabaseTasks < JdbcDatabaseTasks
+
+      def purge
+        test = deep_dup(configuration)
+        test_database = resolve_database(test)
+        test['database'] = 'master'
+        establish_connection(test)
+        connection.recreate_database(test_database)
+      end
+
+      def structure_dump(filename)
+        config = config_from_url_if_needed
+        `smoscript -s #{config['host']} -d #{config['database']} -u #{config['username']} -p #{config['password']} -f #{filename} -A -U`
+      end
+
+      def structure_load(filename)
+        config = config_from_url_if_needed
+        `sqlcmd -S #{config['host']} -d #{config['database']} -U #{config['username']} -P #{config['password']} -i #{filename}`
+      end
+
+      private
+
+      def config_from_url_if_needed
+        config = self.config
+        if config['url'] && ! config.key?('database')
+          config = config_from_url(config['url'])
+        end
+        config
+      end
+
+      def deep_dup(hash)
+        dup = hash.dup
+        dup.each_pair do |k,v|
+          tv = dup[k]
+          dup[k] = tv.is_a?(Hash) && v.is_a?(Hash) ? deep_dup(tv) : v
+        end
+        dup
+      end
+
+    end
+  end
+end

data/lib/arjdbc/util/quoted_cache.rb

@@ -0,0 +1,60 @@
+module ArJdbc
+  module Util
+    # Caches table and column name (quoted) outcomes.
+    # Uses {ThreadSafe::Cache} as a concurrent lock free (on JRuby) cache backend.
+    # The thread_safe gem is a dependency since ActiveSupport 4.0, when using
+    # ActiveRecord <= 3.2 one should add `gem 'thread_safe'` into the *Gemfile*
+    # as it is not forced (currently) as an explicit gem dependency.
+    #
+    # Caching can also be disabled by setting the *arjdbc.quoted_cache.disabled*
+    # system property = 'true'.
+    module QuotedCache
+
+      # @private
+      DISABLED = Java::JavaLang::Boolean.getBoolean('arjdbc.quoted_cache.disabled')
+
+      def self.included(base)
+        # the thread_safe gem is an ActiveSupport dependency (since 4.0) :
+        begin; require 'thread_safe'; rescue LoadError; end unless DISABLED
+        if ! DISABLED && defined? ThreadSafe::Cache
+          base.const_set :QUOTED_TABLE_NAMES, ThreadSafe::Cache.new
+          base.const_set :QUOTED_COLUMN_NAMES, ThreadSafe::Cache.new
+        else
+          base.const_set :QUOTED_TABLE_NAMES, nil
+          base.const_set :QUOTED_COLUMN_NAMES, nil
+        end
+      end
+
+      # Caches quoted table names, the cache is stored in the class'
+      # `QUOTED_TABLE_NAMES` constant.
+      # @return [String]
+      def quote_table_name(name, *args)
+        if cache = self.class::QUOTED_TABLE_NAMES
+          unless quoted = cache[name]
+            quoted = super
+            cache.put_if_absent name, quoted.freeze
+          end
+          quoted
+        else
+          super
+        end
+      end
+
+      # Caches quoted table names, the cache is stored in the class'
+      # `QUOTED_COLUMN_NAMES` constant.
+      # @return [String]
+      def quote_column_name(name, *args)
+        if cache = self.class::QUOTED_COLUMN_NAMES
+          unless quoted = cache[name]
+            quoted = super
+            cache.put_if_absent name, quoted.freeze
+          end
+          quoted
+        else
+          super
+        end
+      end
+
+    end
+  end
+end

data/lib/arjdbc/util/serialized_attributes.rb

@@ -0,0 +1,98 @@
+module ArJdbc
+  module Util
+    # Gets included into `ActiveRecord::Base` to support sending LOB values
+    # in a separate update SQL statement for DB adapters that need this.
+    module SerializedAttributes
+
+      # protected
+
+      def update_lob_columns
+        klass = self.class
+        return unless type = klass.lob_type # e.g. /blob/i
+        connection = klass.connection
+        if connection.respond_to?(:update_lob_values?)
+          return false unless connection.update_lob_values?
+        end
+        klass.columns.each do |column|
+          next if column.sql_type !~ type
+          next if ( value = dump_column_value(column) ).nil?
+          if connection.respond_to?(:update_lob_value?)
+            next unless connection.update_lob_value?(value, column)
+          end
+          connection.update_lob_value(self, column, value)
+        end
+      end
+
+      private
+
+      def dump_column_value(column)
+        SerializedAttributes.dump_column_value(self, column)
+      end
+
+      if defined? ActiveRecord::Type::Serialized # ArJdbc::AR42
+
+      def self.dump_column_value(record, column)
+        value = record[ column.name.to_s ]
+        column.cast_type.type_cast_for_database(value)
+      end
+
+      else
+
+      def self.dump_column_value(record, column)
+        value = record[ name = column.name.to_s ]
+        if record.class.respond_to?(:serialized_attributes)
+          if coder = record.class.serialized_attributes[name]
+            value = coder.respond_to?(:dump) ? coder.dump(value) : value.to_yaml
+          end
+        else
+          if record.respond_to?(:unserializable_attribute?)
+            value = value.to_yaml if record.unserializable_attribute?(name, column)
+          else
+            value = value.to_yaml if value.is_a?(Hash)
+          end
+        end
+        value
+      end
+
+      end
+
+      def self.setup(lob_type = nil, after_save_alias = nil)
+        ActiveRecord::Base.send :include, self # include SerializedAttributes
+        ActiveRecord::Base.lob_type = lob_type unless lob_type.nil?
+        if after_save_alias
+          ActiveRecord::Base.class_eval do
+            alias_method after_save_alias, 'update_lob_columns'
+          end
+          ActiveRecord::Base.after_save after_save_alias
+        else
+          ActiveRecord::Base.after_save 'update_lob_columns'
+        end
+      end
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+
+        def lob_type
+          @lob_type ||= begin
+            if superclass.respond_to?(:lob_type)
+              superclass.lob_type
+            else
+              /blob|clob/i
+            end
+          end
+        end
+
+        def lob_type=(type)
+          @lob_type = type
+        end
+
+      end
+
+    end
+  end
+  # @private only due backwards compatibility
+  SerializedAttributesHelper = Util::SerializedAttributes
+end

data/lib/arjdbc/util/table_copier.rb

@@ -0,0 +1,110 @@
+module ArJdbc
+  module Util
+    module TableCopier
+
+      # taken from SQLite adapter, code loosely based on http://git.io/P7tFQA
+
+      # Performs changes for table by first copying (and preserving contents)
+      # into another (temporary) table, than alters and copies all data back.
+      def alter_table(table_name, options = {})
+        table_name = table_name.to_s.downcase
+        altered_table_name = "a#{table_name}"
+        caller = lambda { |definition| yield definition if block_given? }
+
+        transaction do
+          # A temporary table might improve performance here, but
+          # it doesn't seem to maintain indices across the whole move.
+          move_table(table_name, altered_table_name, options)
+          move_table(altered_table_name, table_name, &caller)
+        end
+      end
+
+      # Move a table into another while preserving all content.
+      # @see #copy_table
+      def move_table(from, to, options = {}, &block)
+        copy_table(from, to, options, &block)
+        drop_table(from)
+      end
+
+      # @see #copy_table_contents
+      # @see #copy_table_indexes
+      def copy_table(from, to, options = {})
+        from_primary_key = primary_key(from)
+        create_table(to, options.merge(:id => false)) do |definition|
+          @definition = definition
+          @definition.primary_key(from_primary_key) if from_primary_key.present?
+          columns(from).each do |column|
+            column_name = options[:rename] ?
+              (options[:rename][column.name] ||
+               options[:rename][column.name.to_sym] ||
+               column.name) : column.name
+
+            next if column_name == from_primary_key
+
+            @definition.column(column_name, column.type,
+              :limit => column.limit, :default => column.default,
+              :precision => column.precision, :scale => column.scale,
+              :null => column.null)
+          end
+          yield @definition if block_given?
+        end
+
+        copy_table_indexes(from, to, options[:rename] || {})
+        copy_table_contents(from, to,
+          @definition.columns.map {|column| column.name},
+          options[:rename] || {})
+      end
+
+      # Copies indexes for a given table.
+      def copy_table_indexes(from, to, rename = {})
+        indexes(from).each do |index|
+          name = index.name.downcase
+          if to == "a#{from}"
+            name = "t#{name}"
+          elsif from == "a#{to}"
+            name = name[1..-1]
+          end
+
+          to_column_names = columns(to).map(&:name)
+          columns = index.columns.map { |column| rename[column] || column }
+          columns = columns.select { |column| to_column_names.include?(column) }
+
+          unless columns.empty?
+            # index name can't be the same
+            opts = { :name => name.gsub(/(^|_)(#{from})_/, "\\1#{to}_"), :internal => true }
+            opts[:unique] = true if index.unique
+            add_index(to, columns, opts)
+          end
+        end
+      end
+
+      # Copies the content of a table into another.
+      def copy_table_contents(from, to, columns, rename = {})
+        column_mappings = Hash[ columns.map { |name| [name, name] } ]
+        rename.each { |a| column_mappings[a.last] = a.first }
+        from_columns = columns(from).collect {|col| col.name}
+        columns = columns.find_all{ |col| from_columns.include?(column_mappings[col]) }
+        quoted_columns = columns.map { |col| quote_column_name(col) } * ','
+
+        quoted_to = quote_table_name(to)
+
+        raw_column_mappings = Hash[ columns(from).map { |c| [c.name, c] } ]
+
+        execute("SELECT * FROM #{quote_table_name(from)}", 'Copy Table').each do |row|
+          sql = "INSERT INTO #{quoted_to} (#{quoted_columns}) VALUES ("
+
+          column_values = columns.map do |col|
+            quote(row[column_mappings[col]], raw_column_mappings[col])
+          end
+
+          sql << column_values * ', '
+          sql << ')'
+          exec_insert sql, 'Copy Table', []
+        end
+      end
+
+    end
+  end
+  # @private @deprecated backwards compatibility
+  MissingFunctionalityHelper = Util::TableCopier
+end