activerecord-jdbc-adapter 5.0.pre1 → 50.0

data/lib/arjdbc/mysql/bulk_change_table.rb

@@ -1,150 +0,0 @@
-module ArJdbc
-  module MySQL
-    module BulkChangeTable
-
-      # @private
-      AR41 = ::ActiveRecord::VERSION::STRING >= '4.1'
-
-      # @private
-      #ActiveRecordError = ActiveRecord::ActiveRecordError
-
-      # @private
-      ChangeColumnDefinition = ::ActiveRecord::ConnectionAdapters::ChangeColumnDefinition if AR41
-
-      # @override
-      def supports_bulk_alter?; true end
-
-      def bulk_change_table(table_name, operations)
-        sqls = operations.map do |command, args|
-          table, arguments = args.shift, args
-          method = :"#{command}_sql"
-
-          if respond_to?(method, true)
-            send(method, table, *arguments)
-          else
-            raise "Unknown method called : #{method}(#{arguments.inspect})"
-          end
-        end
-        sqls.flatten!
-
-        execute("ALTER TABLE #{quote_table_name(table_name)} #{sqls.join(", ")}")
-      end
-
-      protected
-
-      def add_column_sql(table_name, column_name, type, options = {})
-        add_column_sql = "ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
-        add_column_options!(add_column_sql, options)
-        add_column_position!(add_column_sql, options)
-        add_column_sql
-      end unless AR41
-
-      def add_column_sql(table_name, column_name, type, options = {})
-        td = create_table_definition table_name, options[:temporary], options[:options]
-        cd = td.new_column_definition(column_name, type, options)
-        schema_creation.visit_AddColumn cd
-      end if AR41
-
-      def change_column_sql(table_name, column_name, type, options = {})
-        column = column_for(table_name, column_name)
-
-        unless options_include_default?(options)
-          options[:default] = column.default
-        end
-
-        unless options.has_key?(:null)
-          options[:null] = column.null
-        end
-
-        change_column_sql = "CHANGE #{quote_column_name(column_name)} #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
-        add_column_options!(change_column_sql, options)
-        add_column_position!(change_column_sql, options)
-        change_column_sql
-      end unless AR41
-
-      def change_column_sql(table_name, column_name, type, options = {})
-        column = column_for(table_name, column_name)
-
-        unless options_include_default?(options)
-          options[:default] = column.default
-        end
-
-        unless options.has_key?(:null)
-          options[:null] = column.null
-        end
-
-        options[:name] = column.name
-        schema_creation.accept ChangeColumnDefinition.new column, type, options
-      end if AR41
-
-      def rename_column_sql(table_name, column_name, new_column_name)
-        options = {}
-
-        if column = columns(table_name).find { |c| c.name == column_name.to_s }
-          options[:default] = column.default
-          options[:null] = column.null
-          options[:auto_increment] = (column.extra == "auto_increment")
-        else
-          raise ActiveRecordError, "No such column: #{table_name}.#{column_name}"
-        end
-
-        current_type = select_one("SHOW COLUMNS FROM #{quote_table_name(table_name)} LIKE '#{column_name}'", 'SCHEMA')["Type"]
-        rename_column_sql = "CHANGE #{quote_column_name(column_name)} #{quote_column_name(new_column_name)} #{current_type}"
-        add_column_options!(rename_column_sql, options)
-        rename_column_sql
-      end unless AR41
-
-      def rename_column_sql(table_name, column_name, new_column_name)
-        options = { :name => new_column_name }
-
-        if column = columns(table_name).find { |c| c.name == column_name.to_s }
-          options[:default] = column.default
-          options[:null] = column.null
-          options[:auto_increment] = (column.extra == "auto_increment")
-        else
-          raise ActiveRecordError, "No such column: #{table_name}.#{column_name}"
-        end
-
-        current_type = select_one("SHOW COLUMNS FROM #{quote_table_name(table_name)} LIKE '#{column_name}'", 'SCHEMA')["Type"]
-        schema_creation.accept ChangeColumnDefinition.new column, current_type, options
-      end if AR41
-
-      def remove_column_sql(table_name, column_name, type = nil, options = nil)
-        "DROP #{quote_column_name(column_name)}"
-      end
-
-      def remove_columns_sql(table_name, *column_names)
-        column_names.map { |column_name| remove_column_sql(table_name, column_name) }
-      end
-
-      def add_index_sql(table_name, column_name, options = {})
-        index_name, index_type, index_columns = add_index_options(table_name, column_name, options)
-        "ADD #{index_type} INDEX #{index_name} (#{index_columns})"
-      end
-
-      def remove_index_sql(table_name, options = {})
-        index_name = index_name_for_remove(table_name, options)
-        "DROP INDEX #{index_name}"
-      end
-
-      def add_timestamps_sql(table_name, options = {})
-        [add_column_sql(table_name, :created_at, :datetime, options), add_column_sql(table_name, :updated_at, :datetime, options)]
-      end
-
-      def remove_timestamps_sql(table_name, options = nil)
-        [remove_column_sql(table_name, :updated_at), remove_column_sql(table_name, :created_at)]
-      end
-
-      private
-
-      def add_column_position!(sql, options)
-        if options[:first]
-          sql << " FIRST"
-        elsif options[:after]
-          sql << " AFTER #{quote_column_name(options[:after])}"
-        end
-      end
-
-    end
-  end
-end

data/lib/arjdbc/mysql/column.rb

@@ -1,162 +0,0 @@
-module ArJdbc
-  module MySQL
-
-    # @see ActiveRecord::ConnectionAdapters::JdbcColumn#column_types
-    def self.column_selector
-      [ /mysql/i, lambda { |config, column| column.extend(Column) } ]
-    end
-
-    # Column behavior based on (abstract) MySQL adapter in Rails.
-    # @see ActiveRecord::ConnectionAdapters::JdbcColumn
-    module Column
-
-      attr_reader :collation, :strict, :extra
-
-      def initialize(name, default, sql_type = nil, null = true, collation = nil, strict = false, extra = '')
-        if name.is_a?(Hash)
-          super # first arg: config
-        else
-          @strict = strict; @collation = collation; @extra = extra
-          super(name, default, sql_type, null)
-          # base 4.1: (name, default, sql_type = nil, null = true)
-        end
-      end unless AR42
-
-      def initialize(name, default, cast_type, sql_type = nil, null = true, collation = nil, strict = false, extra = '')
-        if name.is_a?(Hash)
-          super # first arg: config
-        else
-          @strict = strict; @collation = collation; @extra = extra
-          super(name, default, cast_type, sql_type, null)
-          # base 4.2: (name, default, cast_type, sql_type = nil, null = true)
-          #assert_valid_default(default) done with #extract_default
-          #@default = null || ( strict ? nil : '' ) if blob_or_text_column?
-        end
-      end if AR42
-
-      def extract_default(default)
-        if blob_or_text_column?
-          return null || strict ? nil : '' if default.blank?
-          raise ArgumentError, "#{type} columns cannot have a default value: #{default.inspect}"
-        elsif missing_default_forged_as_empty_string?(default)
-          nil
-        else
-          super
-        end
-      end
-
-      def has_default?
-        return false if blob_or_text_column? #mysql forbids defaults on blob and text columns
-        super
-      end
-
-      def blob_or_text_column?
-        sql_type.index('blob') || type == :text
-      end
-
-      def case_sensitive?
-        collation && !collation.match(/_ci$/)
-      end
-
-      def ==(other)
-        collation == other.collation &&
-        strict == other.strict &&
-        extra == other.extra &&
-        super
-      end if AR42
-
-      def simplified_type(field_type)
-        if adapter && adapter.emulate_booleans?
-          return :boolean if field_type.downcase.index('tinyint(1)')
-        end
-
-        case field_type
-        when /enum/i, /set/i then :string
-        when /year/i then :integer
-        # :tinyint : {:name=>"tinyint", :limit=>3}
-        # :"tinyint unsigned" : {:name=>"tinyint unsigned", :limit=>3}
-        # :bigint : {:name=>"bigint", :limit=>19}
-        # :"bigint unsigned" : {:name=>"bigint unsigned", :limit=>20}
-        # :integer : {:name=>"integer", :limit=>10}
-        # :"integer unsigned" : {:name=>"integer unsigned", :limit=>10}
-        # :int : {:name=>"int", :limit=>10}
-        # :"int unsigned" : {:name=>"int unsigned", :limit=>10}
-        # :mediumint : {:name=>"mediumint", :limit=>7}
-        # :"mediumint unsigned" : {:name=>"mediumint unsigned", :limit=>8}
-        # :smallint : {:name=>"smallint", :limit=>5}
-        # :"smallint unsigned" : {:name=>"smallint unsigned", :limit=>5}
-        when /int/i then :integer
-        when /double/i then :float # double precision (alias)
-        when 'bool' then :boolean
-        when 'char' then :string
-        # :mediumtext => {:name=>"mediumtext", :limit=>16777215}
-        # :longtext => {:name=>"longtext", :limit=>2147483647}
-        # :text => {:name=>"text"}
-        # :tinytext => {:name=>"tinytext", :limit=>255}
-        when /text/i then :text
-        when 'long varchar' then :text
-        # :"long varbinary" => {:name=>"long varbinary", :limit=>16777215}
-        # :varbinary => {:name=>"varbinary", :limit=>255}
-        when /binary/i then :binary
-        # :mediumblob => {:name=>"mediumblob", :limit=>16777215}
-        # :longblob => {:name=>"longblob", :limit=>2147483647}
-        # :blob => {:name=>"blob", :limit=>65535}
-        # :tinyblob => {:name=>"tinyblob", :limit=>255}
-        when /blob/i then :binary
-        when /^bit/i then :binary
-        else
-          super
-        end
-      end
-
-      def extract_limit(sql_type)
-        case sql_type
-        when /blob|text/i
-          case sql_type
-          when /tiny/i
-            255
-          when /medium/i
-            16777215
-          when /long/i
-            2147483647 # mysql only allows 2^31-1, not 2^32-1, somewhat inconsistently with the tiny/medium/normal cases
-          else
-            super # we could return 65535 here, but we leave it undecorated by default
-          end
-        when /^bigint/i;    8
-        when /^int/i;       4
-        when /^mediumint/i; 3
-        when /^smallint/i;  2
-        when /^tinyint/i;   1
-        when /^enum\((.+)\)/i # 255
-          $1.split(',').map{ |enum| enum.strip.length - 2 }.max
-        when /^(bool|date|float|int|time)/i
-          nil
-        else
-          super
-        end
-      end unless AR42 # on AR 4.2 limit is delegated to cast_type.limit
-
-      private
-
-      # MySQL misreports NOT NULL column default when none is given.
-      # We can't detect this for columns which may have a legitimate ''
-      # default (string) but we can for others (integer, datetime, boolean,
-      # and the rest).
-      #
-      # Test whether the column has default '', is not null, and is not
-      # a type allowing default ''.
-      def missing_default_forged_as_empty_string?(default)
-        type != :string && ! null && default == ''
-      end
-
-      def attributes_for_hash; super + [collation, strict, extra] end
-
-      def adapter; end
-
-    end
-
-    # @private backwards-compatibility
-    ColumnExtensions = Column
-
-  end
-end

data/lib/arjdbc/mysql/explain_support.rb

@@ -1,82 +0,0 @@
-module ArJdbc
-  module MySQL
-    module ExplainSupport
-      def supports_explain?
-        true
-      end
-
-      def explain(arel, binds = [])
-        sql = "EXPLAIN #{to_sql(arel, binds)}"
-        start = Time.now.to_f
-        result = exec_query(sql, "EXPLAIN", binds)
-        elapsed = Time.now.to_f - start
-        ExplainPrettyPrinter.new.pp result, elapsed
-      end
-
-      # @private
-      class ExplainPrettyPrinter
-        # Pretty prints the result of a EXPLAIN in a way that resembles the output of the
-        # MySQL shell:
-        #
-        # +----+-------------+-------+-------+---------------+---------+---------+-------+------+-------------+
-        # | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
-        # +----+-------------+-------+-------+---------------+---------+---------+-------+------+-------------+
-        # | 1 | SIMPLE | users | const | PRIMARY | PRIMARY | 4 | const | 1 | |
-        # | 1 | SIMPLE | posts | ALL | NULL | NULL | NULL | NULL | 1 | Using where |
-        # +----+-------------+-------+-------+---------------+---------+---------+-------+------+-------------+
-        # 2 rows in set (0.00 sec)
-        #
-        # This is an exercise in Ruby hyperrealism :).
-        def pp(result, elapsed)
-          widths = compute_column_widths(result)
-          separator = build_separator(widths)
-
-          pp = []
-
-          pp << separator
-          pp << build_cells(result.columns, widths)
-          pp << separator
-
-          result.rows.each do |row|
-            pp << build_cells(row, widths)
-          end
-
-          pp << separator
-          pp << build_footer(result.rows.length, elapsed)
-
-          pp.join(sep = "\n") << sep
-        end
-
-        private
-
-        def compute_column_widths(result)
-          [].tap do |widths|
-            result.columns.each_with_index do |column, i|
-              cells_in_column = [column] + result.rows.map {|r| r[i].nil? ? 'NULL' : r[i].to_s}
-              widths << cells_in_column.map(&:length).max
-            end
-          end
-        end
-
-        def build_separator(widths)
-          padding = 1; "+#{widths.map { |w| '-' * (w + (padding * 2 )) }.join('+')}+"
-        end
-
-        def build_cells(items, widths)
-          cells = []
-          items.each_with_index do |item, i|
-            item = 'NULL' if item.nil?
-            justifier = item.is_a?(Numeric) ? 'rjust' : 'ljust'
-            cells << item.to_s.send(justifier, widths[i])
-          end
-          "|#{cells.join(' | ')}|"
-        end
-
-        def build_footer(nrows, elapsed)
-          rows_label = nrows == 1 ? 'row' : 'rows'
-          "#{nrows} #{rows_label} in set (%.2f sec)" % elapsed
-        end
-      end
-    end
-  end
-end

data/lib/arjdbc/mysql/schema_creation.rb

@@ -1,58 +0,0 @@
-module ArJdbc
-  module MySQL
-    # @private copied from native adapter 4.0/4.1
-    class SchemaCreation < ::ActiveRecord::ConnectionAdapters::AbstractAdapter::SchemaCreation
-
-      def visit_AddColumn(o)
-        add_column_position!(super, column_options(o))
-      end
-
-      private
-
-      def visit_DropForeignKey(name)
-        "DROP FOREIGN KEY #{name}"
-      end
-
-      def visit_TableDefinition(o)
-        name = o.name
-        create_sql = "CREATE#{' TEMPORARY' if o.temporary} TABLE #{quote_table_name(name)} "
-
-        statements = o.columns.map { |c| accept c }
-        statements.concat(o.indexes.map { |column_name, options| index_in_create(name, column_name, options) })
-
-        create_sql << "(#{statements.join(', ')}) " if statements.present?
-        create_sql << "#{o.options}"
-        create_sql << " AS #{@conn.to_sql(o.as)}" if o.as
-        create_sql
-      end if AR42
-
-      def visit_ChangeColumnDefinition(o)
-        column = o.column
-        options = o.options
-        sql_type = type_to_sql(o.type, options[:limit], options[:precision], options[:scale])
-        change_column_sql = "CHANGE #{quote_column_name(column.name)} #{quote_column_name(options[:name])} #{sql_type}"
-        add_column_options!(change_column_sql, options.merge(:column => column))
-        add_column_position!(change_column_sql, options)
-      end
-
-      def add_column_position!(sql, options)
-        if options[:first]
-          sql << " FIRST"
-        elsif options[:after]
-          sql << " AFTER #{quote_column_name(options[:after])}"
-        end
-        sql
-      end
-
-      def index_in_create(table_name, column_name, options)
-        index_name, index_type, index_columns, index_options, index_algorithm, index_using = @conn.add_index_options(table_name, column_name, options)
-        "#{index_type} INDEX #{quote_column_name(index_name)} #{index_using} (#{index_columns})#{index_options} #{index_algorithm}"
-      end
-    end
-  end
-
-  def schema_creation
-    SchemaCreation.new self
-  end
-
-end if ::ActiveRecord::ConnectionAdapters::AbstractAdapter.const_defined? :SchemaCreation