activerecord-jdbc-adapter-ficoh 1.3.21-java

data/lib/arjdbc/mysql/bulk_change_table.rb

@@ -0,0 +1,150 @@
+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

@@ -0,0 +1,167 @@
+module ArJdbc
+  module MySQL
+
+    # @see ActiveRecord::ConnectionAdapters::JdbcColumn#column_types
+    def self.column_selector
+      [ /mysql/i, lambda { |config, column| column.extend(ColumnMethods) } ]
+    end
+
+    # Column behavior based on (abstract) MySQL adapter in Rails.
+    # @see ActiveRecord::ConnectionAdapters::JdbcColumn
+    module ColumnMethods
+
+      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
+
+#    def self.const_missing(name)
+#      if name.to_sym == :Column
+#        ArJdbc.deprecate("#{self.name}::Column will change to refer to the actual column class, please use ColumnMethods instead", :once)
+#        return ColumnMethods
+#      end
+#      super
+#    end
+
+  end
+end

data/lib/arjdbc/mysql/connection_methods.rb

@@ -0,0 +1,137 @@
+ArJdbc::ConnectionMethods.module_eval do
+  def mysql_connection(config)
+    config[:adapter_spec] ||= ::ArJdbc::MySQL
+    config[:adapter_class] = ActiveRecord::ConnectionAdapters::MysqlAdapter unless config.key?(:adapter_class)
+
+    return jndi_connection(config) if jndi_config?(config)
+
+    driver = config[:driver] ||= 'com.mysql.jdbc.NonRegisteringDriver'
+    mysql_driver = driver.start_with?('com.mysql.')
+    ArJdbc.load_driver(:MySQL) if mysql_driver && config[:load_driver] != false
+
+    config[:username] = 'root' unless config.key?(:username)
+    # jdbc:mysql://[host][,failoverhost...][:port]/[database]
+    # - if the host name is not specified, it defaults to 127.0.0.1
+    # - if the port is not specified, it defaults to 3306
+    # - alternate fail-over syntax: [host:port],[host:port]/[database]
+    unless config[:url]
+      host = config[:host]; host = host.join(',') if host.respond_to?(:join)
+      url = "jdbc:mysql://#{host}"
+      url << ":#{config[:port]}" if config[:port]
+      url << "/#{config[:database]}"
+      config[:url] = url
+    end
+
+    mariadb_driver = ! mysql_driver && driver.start_with?('org.mariadb.')
+
+    properties = ( config[:properties] ||= {} )
+    if mysql_driver
+      properties['zeroDateTimeBehavior'] ||= 'convertToNull'
+      properties['jdbcCompliantTruncation'] ||= 'false'
+      # NOTE: this is "better" than passing what users are used to set on MRI
+      # e.g. 'utf8mb4' will fail cause the driver will check for a Java charset
+      # ... it's smart enough to detect utf8mb4 from server variables :
+      # "character_set_client" && "character_set_connection" (thus UTF-8)
+      if encoding = config[:encoding]
+        properties['characterEncoding'] = convert_mysql_encoding(encoding) || encoding
+        # driver also executes: "SET NAMES " + (useutf8mb4 ? "utf8mb4" : "utf8")
+        config[:encoding] = nil # thus no need to do it on configure_connection
+      end
+      # properties['useUnicode'] is true by default
+      if ! ( reconnect = config[:reconnect] ).nil?
+        properties['autoReconnect'] ||= reconnect.to_s
+        # properties['maxReconnects'] ||= '3'
+        # with reconnect fail-over sets connection read-only (by default)
+        # properties['failOverReadOnly'] ||= 'false'
+      end
+    end
+    if config[:sslkey] || sslcert = config[:sslcert] # || config[:use_ssl]
+      properties['useSSL'] ||= true # supported by MariaDB as well
+      if mysql_driver
+        properties['requireSSL'] ||= true if mysql_driver
+        properties['clientCertificateKeyStoreUrl'] ||= begin
+          java.io.File.new(sslcert).to_url.to_s
+        end if sslcert
+        if sslca = config[:sslca]
+          properties['trustCertificateKeyStoreUrl'] ||= begin
+            java.io.File.new(sslca).to_url.to_s
+          end
+        else
+          properties['verifyServerCertificate'] ||= false if mysql_driver
+        end
+      end
+      if mariadb_driver
+        properties['verifyServerCertificate'] ||= false
+      end
+    end
+    if socket = config[:socket]
+      properties['localSocket'] ||= socket if mariadb_driver
+    end
+
+    jdbc_connection(config)
+  end
+  alias_method :jdbcmysql_connection, :mysql_connection
+  alias_method :mysql2_connection, :mysql_connection
+
+  def mariadb_connection(config)
+    config[:adapter_spec] ||= ::ArJdbc::MySQL
+    config[:adapter_class] = ActiveRecord::ConnectionAdapters::MysqlAdapter unless config.key?(:adapter_class)
+
+    return jndi_connection(config) if jndi_config?(config)
+
+    ArJdbc.load_driver(:MariaDB) unless config[:load_driver] == false
+    config[:driver] ||= 'org.mariadb.jdbc.Driver'
+
+    mysql_connection(config)
+  end
+  alias_method :jdbcmariadb_connection, :mariadb_connection
+
+  private
+
+  @@mysql_encodings = nil
+
+  def convert_mysql_encoding(encoding) # from mysql2's ruby_enc_to_mysql
+    ( @@mysql_encodings ||= {
+      "big5" => "Big5",
+      "dec8" => nil,
+      "cp850" => "CP850",
+      "hp8" => nil,
+      "koi8r" => "KOI8-R",
+      "latin1" => "ISO-8859-1",
+      "latin2" => "ISO-8859-2",
+      "swe7" => nil,
+      "ascii" => "US-ASCII",
+      #"ujis" => "eucJP-ms",
+      #"sjis" => "Shift_JIS",
+      "hebrew" => "ISO-8859-8",
+      #"tis620" => "TIS-620",
+      #"euckr" => "EUC-KR",
+      #"koi8u" => "KOI8-R",
+      #"gb2312" => "GB2312",
+      "greek" => "ISO-8859-7",
+      "cp1250" => "Windows-1250",
+      #"gbk" => "GBK",
+      "latin5" => "ISO-8859-9",
+      "armscii8" => nil,
+      "utf8" => "UTF-8",
+      "ucs2" => "UTF-16BE",
+      "cp866" => "IBM866",
+      "keybcs2" => nil,
+      #"macce" => "macCentEuro",
+      #"macroman" => "macRoman",
+      "cp852" => "CP852",
+      "latin7" => "ISO-8859-13",
+      "utf8mb4" => "UTF-8",
+      "cp1251" => "Windows-1251",
+      "utf16" => "UTF-16",
+      "cp1256" => "Windows-1256",
+      "cp1257" => "Windows-1257",
+      "utf32" => "UTF-32",
+      "binary" => "ASCII-8BIT",
+      "geostd8" => nil,
+      #"cp932" => "Windows-31J",
+      #"eucjpms" => "eucJP-ms"
+    } )[ encoding ]
+  end
+
+end