activerecord-jdbc-adapter 1.0.3-java → 50.1-java

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

data/lib/arjdbc/version.rb

@@ -1,8 +1,3 @@
 module ArJdbc
-  module Version
-    VERSION = "1.0.3"
-  end
+  VERSION = '50.1'
 end
-# Compatibility with older versions of ar-jdbc for other extensions out there
-JdbcAdapter = ArJdbc
-JdbcSpec = ArJdbc

data/lib/generators/jdbc/USAGE

@@ -0,0 +1,9 @@
+Description:
+    Creates stubs that ensure AR-JDBC is bootstrapped in your Rails application.
+
+Example:
+    ./script/generate jdbc
+
+    This will create:
+        config/initializers/jdbc.rb
+	    lib/tasks/jdbc.rake

data/lib/generators/jdbc/jdbc_generator.rb

@@ -6,4 +6,12 @@ class JdbcGenerator < Rails::Generators::Base
   def create_jdbc_files
     directory '.', '.'
   end
+
+  def self.desc(description=nil)
+    return super if description
+    "Description:\n" <<
+    "  Creates stubs that ensure AR-JDBC is bootstrapped in your Rails application.\n" <<
+    "  NOTE: you should not need this if you're on Rails >= 3.0 (using Bundler) ..."
+  end
+
 end

data/lib/jdbc_adapter.rb

@@ -1,2 +1,2 @@
-warn "DEPRECATED: require 'arjdbc' instead of 'jdbc_adapter'."
 require 'arjdbc'
+ArJdbc.deprecate "require 'arjdbc' instead of 'jdbc_adapter'"

data/lib/jdbc_adapter/rake_tasks.rb

@@ -1,3 +1,4 @@
-warn "DEPRECATED: require 'arjdbc/rake_tasks' instead of 'jdbc_adapter/rake_tasks'."
-require 'arjdbc/jdbc/rake_tasks'
+require 'arjdbc/tasks.rb'
 
+require 'arjdbc'
+ArJdbc.deprecate "load 'arjdbc/tasks.rb' instead of 'jdbc_adapter/rake_tasks.rb'"

data/lib/jdbc_adapter/version.rb

@@ -1,3 +1,4 @@
-warn "DEPRECATED: require 'arjdbc/version' instead of 'jdbc_adapter/version'."
 require 'arjdbc/version'
 
+require 'arjdbc'
+ArJdbc.deprecate "require 'arjdbc/version' instead of 'jdbc_adapter/version'"

data/pom.xml

@@ -0,0 +1,114 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>org.jruby.rails</groupId>
+  <artifactId>activerecord-jdbc</artifactId>
+  <packaging>jar</packaging>
+  <version>IDE-SNAPSHOT</version>
+  <name>activerecord-jdbc</name>
+  <description>
+    This POM for ActiveRecord-JDBC is just for bootstrapping IDEs.
+  </description>
+  <url>http://github.com/jruby/activerecord-jdbc-adapter/wiki</url>
+
+  <properties>
+    <jruby.version>9.1.6.0</jruby.version>
+  </properties>
+
+  <issueManagement>
+    <system>GitHub</system>
+    <url>http://github.com/jruby/activerecord-jdbc-adapter/issues</url>
+  </issueManagement>
+
+  <scm>
+    <connection>scm:git:git://github.com/jruby/activerecord-jdbc-adapter.git</connection>
+    <developerConnection>scm:git:git@github.com:jruby/activerecord-jdbc-adapter.git</developerConnection>
+    <url>https://github.com/jruby/activerecord-jdbc-adapter</url>
+  </scm>
+
+  <licenses>
+    <license>
+      <name>BSD</name>
+      <url>http://www.opensource.org/licenses/bsd-license.php</url>
+      <distribution>repo</distribution>
+    </license>
+    <license>
+      <name>MIT License</name>
+      <url>http://www.opensource.org/licenses/mit-license.php</url>
+      <distribution>repo</distribution>
+    </license>
+  </licenses>
+  <!--
+  <repositories>
+    <repository>
+      <id>codehaus</id>
+      <name>Codehaus Repository</name>
+      <releases>
+        <enabled>true</enabled>
+      </releases>
+      <snapshots>
+        <enabled>false</enabled>
+      </snapshots>
+      <url>http://repository.codehaus.org</url>
+    </repository>
+  </repositories>-->
+
+  <developers>
+    <developer>
+      <id>nicksieger</id>
+      <name>Nick Sieger</name>
+      <email>nicksieger@gmail.com</email>
+    </developer>
+    <developer>
+      <id>kares</id>
+      <name>Karol Bucek</name>
+      <email>self@kares.org</email>
+    </developer>
+  </developers>
+
+  <dependencies>
+    <dependency>
+      <groupId>org.jruby</groupId>
+      <artifactId>jruby-complete</artifactId>
+      <version>${jruby.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.postgresql</groupId>
+      <artifactId>postgresql</artifactId>
+      <version>42.1.4.jre7</version>
+    </dependency>
+  </dependencies>
+
+  <build>
+
+    <sourceDirectory>src/java</sourceDirectory>
+    <resources>
+        <resource>
+            <directory>lib</directory>
+        </resource>
+    </resources>
+    <!--
+    <testSourceDirectory>test/java</testSourceDirectory>-->
+    <testResources>
+        <testResource>
+            <directory>test</directory>
+        </testResource>
+    </testResources>
+
+    <outputDirectory>pkg/classes</outputDirectory>
+
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>2.5.1</version>
+        <configuration>
+          <source>1.7</source>
+          <target>1.7</target>
+        </configuration>
+      </plugin>
+    </plugins>
+
+  </build>
+
+</project>