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

data/README.txt

@@ -1,181 +0,0 @@
-activerecord-jdbc-adapter is a database adapter for Rails' ActiveRecord
-component that can be used with JRuby[http://www.jruby.org/]. It allows use of
-virtually any JDBC-compliant database with your JRuby on Rails application.
-
-== Databases
-
-Activerecord-jdbc-adapter provides full or nearly full support for:
-MySQL, PostgreSQL, SQLite3, Oracle, Microsoft SQL Server, DB2,
-FireBird, Derby, HSQLDB, H2, and Informix.
-
-Other databases will require testing and likely a custom configuration module.
-Please join the activerecord-jdbc
-mailing-lists[http://kenai.com/projects/activerecord-jdbc/lists] to help us discover
-support for more databases.
-
-== Using ActiveRecord JDBC
-
-=== Inside Rails
-
-To use activerecord-jdbc-adapter with JRuby on Rails:
-
-1. Choose the adapter you wish to gem install. The following pre-packaged
-adapters are available:
-
-  * base jdbc (<tt>activerecord-jdbc-adapter</tt>). Supports all available databases via JDBC, but requires you to download and manually install the database vendor's JDBC driver .jar file.
-  * mysql (<tt>activerecord-jdbcmysql-adapter</tt>)
-  * postgresql (<tt>activerecord-jdbcpostgresql-adapter</tt>)
-  * sqlite3 (<tt>activerecord-jdbcsqlite3-adapter</tt>)
-  * derby (<tt>activerecord-jdbcderby-adapter</tt>)
-  * hsqldb (<tt>activerecord-jdbchsqldb-adapter</tt>)
-  * h2 (<tt>activerecord-jdbch2-adapter</tt>)
-  * mssql (<tt>activerecord-jdbcmssql-adapter</tt>)
-
-2a. For Rails 3, if you're generating a new application, use the
-following command to generate your application:
-
-   jruby -S rails new sweetapp -m http://jruby.org/rails3.rb
-
-2b. Otherwise, you'll need to perform some extra configuration steps
-to prepare your Rails application for JDBC.
-
-If you're using Rails 3, you'll need to modify your Gemfile to use the
-activerecord-jdbc-adapter gem under JRuby. Change your Gemfile to look
-like the following (using sqlite3 as an example):
-
-    if defined?(JRUBY_VERSION)
-      gem 'activerecord-jdbc-adapter'
-      gem 'jdbc-sqlite3'
-    else
-      gem 'sqlite3-ruby', :require => 'sqlite3'
-    end
-
-If you're using Rails 2:
-
-    jruby script/generate jdbc
-
-3. Configure your database.yml in the normal Rails style. 
-
-Legacy configuration: If you use one of the convenience
-'activerecord-jdbcXXX-adapter' adapters, you can still put a 'jdbc'
-prefix in front of the database adapter name as below.
-
-    development:
-      adapter: jdbcmysql
-      username: blog
-      password:
-      hostname: localhost
-      database: weblog_development
-
-For other databases, you'll need to know the database driver class and
-URL. Example:
-
-    development:
-      adapter: jdbc
-      username: blog
-      password:
-      driver: com.mysql.jdbc.Driver
-      url: jdbc:mysql://localhost:3306/weblog_development
-
-   For JNDI data sources, you may simply specify the JNDI location as follows
-   (the adapter will be automatically detected):
-
-    production:
-      adapter: jdbc
-      jndi: jdbc/mysqldb
-
-=== Standalone, with ActiveRecord
-
-1. Install the gem with JRuby:
-
-    jruby -S gem install activerecord-jdbc-adapter
-
-If you wish to use the adapter for a specific database, you can
-install it directly and a driver gem will be installed as well:
-
-    jruby -S gem install activerecord-jdbcderby-adapter
-
-2. After this you can establish a JDBC connection like this:
-
-    ActiveRecord::Base.establish_connection(
-      :adapter => 'jdbcderby',
-      :database => "db/my-database"
-    )
-
-or like this (but requires that you manually put the driver jar on the classpath):
-
-    ActiveRecord::Base.establish_connection(
-      :adapter => 'jdbc',
-      :driver => 'org.apache.derby.jdbc.EmbeddedDriver',
-      :url => 'jdbc:derby:test_ar;create=true'
-    )
-
-== Extending AR-JDBC
-
-You can create your own extension to AR-JDBC for a JDBC-based database
-that core AR-JDBC does not support. We've created an example project
-for the Intersystems Cache database that you can examine as a
-template. See the project for more information at the following URL:
-
-  http://github.com/nicksieger/activerecord-cachedb-adapter
-
-== Getting the source
-
-The source for activerecord-jdbc-adapter is available using git.
-
-  git clone git://github.com/nicksieger/activerecord-jdbc-adapter.git
-
-== Feedback
-
-Please file bug reports at
-http://kenai.com/jira/browse/ACTIVERECORD_JDBC. If you're not sure if
-something's a bug, feel free to pre-report it on the mailing lists.
-
-== Project Info
-
-* Mailing Lists: http://kenai.com/projects/activerecord-jdbc/lists
-* Issues: http://kenai.com/jira/browse/ACTIVERECORD_JDBC
-* Source:
- git://github.com/nicksieger/activerecord-jdbc-adapter.git
- git://kenai.com/activerecord-jdbc~main 
-
-== Running AR-JDBC's Tests
-
-Drivers for 6 open-source databases are included. Provided you have
-MySQL installed, you can simply type <tt>jruby -S rake</tt> to run the
-tests. A database named <tt>weblog_development</tt> is needed
-beforehand with a connection user of "blog" and an empty password. You
-alse need to grant "blog" create privileges on
-'test_rake_db_create.*'.
-
-If you also have PostgreSQL available, those tests will be run if the
-`psql' executable can be found. Also ensure you have a database named
-<tt>weblog_development</tt> and a user named "blog" and an empty
-password.
-
-If you want rails logging enabled during these test runs you can edit 
-test/jdbc_common.rb and add the following line:
-
-require 'db/logger'
-
-== Running AR Tests
-
-To run the current AR-JDBC sources with ActiveRecord, just use the
-included "rails:test" task. Be sure to specify a driver and a path to
-the ActiveRecord sources.
-
-  jruby -S rake rails:test DRIVER=mysql RAILS=/path/activerecord_source_dir
-
-== Authors
-
-This project was written by Nick Sieger <nick@nicksieger.com> and Ola Bini
-<olabini@gmail.com> with lots of help from the JRuby community.
-
-== License
-
-activerecord-jdbc-adapter is released under a BSD license. See the LICENSE file
-included with the distribution for details.
-
-Open-source driver gems for activerecord-jdbc-adapter are licensed under the
-same license the database's drivers are licensed. See each driver gem's
-LICENSE.txt file for details.

data/lib/active_record/connection_adapters/oracle_adapter.rb

@@ -1 +0,0 @@
-require 'arjdbc/oracle'

data/lib/arel/engines/sql/compilers/db2_compiler.rb

@@ -1,9 +0,0 @@
-require 'arel/engines/sql/compilers/ibm_db_compiler'
-
-module Arel
-  module SqlCompiler
-    class DB2Compiler < IBM_DBCompiler
-    end
-  end
-end
-

data/lib/arel/engines/sql/compilers/derby_compiler.rb

@@ -1,6 +0,0 @@
-module Arel
-  module SqlCompiler
-    class DerbyCompiler < GenericCompiler
-    end
-  end
-end

data/lib/arel/engines/sql/compilers/h2_compiler.rb

@@ -1,6 +0,0 @@
-module Arel
-  module SqlCompiler
-    class H2Compiler < GenericCompiler
-    end
-  end
-end

data/lib/arel/engines/sql/compilers/hsqldb_compiler.rb

@@ -1,15 +0,0 @@
-module Arel
-  module SqlCompiler
-    class HsqldbCompiler < GenericCompiler
-      def select_sql
-        # HSQLDB needs to add LIMIT in right after SELECT
-        query = super
-        offset = relation.skipped
-        limit = relation.taken
-        @engine.connection.add_limit_offset!(query, :limit => limit,
-                                             :offset => offset) if offset || limit
-        query
-      end
-    end
-  end
-end

data/lib/arel/engines/sql/compilers/jdbc_compiler.rb

@@ -1,6 +0,0 @@
-module Arel
-  module SqlCompiler
-    class JDBCCompiler < GenericCompiler
-    end
-  end
-end

data/lib/arel/engines/sql/compilers/mssql_compiler.rb

@@ -1,46 +0,0 @@
-module Arel
-  module SqlCompiler
-    class MsSQLCompiler < GenericCompiler
-      def select_sql
-        projections = @relation.projections
-        offset = relation.skipped
-        limit = relation.taken
-        if Count === projections.first && projections.size == 1 &&
-          (relation.taken.present? || relation.wheres.present?) && relation.joins(self).blank?
-          subquery = [
-            "SELECT * FROM #{relation.from_clauses}", build_clauses
-          ].join ' '
-          @engine.connection.add_limit_offset!(subquery, :limit => limit, :offset => offset) if offset || limit
-          query = "SELECT COUNT(*) AS count_id FROM (#{subquery}) AS subquery"
-        else
-          query = [
-            "SELECT     #{relation.select_clauses.join(', ')}",
-            "FROM       #{relation.from_clauses}",
-            build_clauses
-          ].compact.join ' '
-          @engine.connection.add_limit_offset!(query, :limit => limit, :offset => offset) if offset || limit
-        end
-        query
-      end
-
-      def build_clauses
-        joins   = relation.joins(self)
-        wheres  = relation.where_clauses
-        groups  = relation.group_clauses
-        havings = relation.having_clauses
-        orders  = relation.order_clauses
-
-        clauses = [ "",
-          joins,
-          ("WHERE     #{wheres.join(' AND ')}" unless wheres.empty?),
-          ("GROUP BY  #{groups.join(', ')}" unless groups.empty?),
-          ("HAVING    #{havings.join(' AND ')}" unless havings.empty?),
-          ("ORDER BY  #{orders.join(', ')}" unless orders.empty?)
-        ].compact.join ' '
-
-        clauses << " #{locked}" unless locked.blank?
-        clauses unless clauses.blank?
-      end
-    end
-  end
-end

data/lib/arel/visitors/mssql.rb

@@ -1,44 +0,0 @@
-module Arel
-  module Visitors
-    class SQLServer < Arel::Visitors::ToSql
-      include ArJdbc::MsSQL::LimitHelpers::SqlServerReplaceLimitOffset
-
-      def select_count? o
-        sel = o.cores.length == 1 && o.cores.first
-        projections = sel.projections.length == 1 && sel.projections
-        Arel::Nodes::Count === projections.first
-      end
-
-      # Need to mimic the subquery logic in ARel 1.x for select count with limit
-      # See arel/engines/sql/compilers/mssql_compiler.rb for details
-      def visit_Arel_Nodes_SelectStatement o
-        order = "ORDER BY #{o.orders.map { |x| visit x }.join(', ')}" unless o.orders.empty?
-        if o.limit
-          if select_count?(o)
-            subquery = true
-            sql = o.cores.map do |x|
-              x = x.dup
-              x.projections = [Arel::Nodes::SqlLiteral.new("*")]
-              visit_Arel_Nodes_SelectCore x
-            end.join
-          else
-            sql = o.cores.map { |x| visit_Arel_Nodes_SelectCore x }.join
-          end
-
-          order ||= "ORDER BY #{@connection.determine_order_clause(sql)}"
-          replace_limit_offset!(sql, o.limit.to_i, o.offset && o.offset.value.to_i, order)
-          sql = "SELECT COUNT(*) AS count_id FROM (#{sql}) AS subquery" if subquery
-        elsif order
-          sql << " #{order}"
-        else
-          sql = super
-        end
-        sql
-      end
-    end
-
-    class SQLServer2000 < SQLServer
-      include ArJdbc::MsSQL::LimitHelpers::SqlServer2000ReplaceLimitOffset
-    end
-  end
-end

data/lib/arjdbc/jdbc/compatibility.rb

@@ -1,51 +0,0 @@
-# AR's 2.2 version of this method is sufficient, but we need it for
-# older versions
-if ActiveRecord::VERSION::MAJOR <= 2 && ActiveRecord::VERSION::MINOR < 2
-  module ActiveRecord
-    module ConnectionAdapters # :nodoc:
-      module SchemaStatements
-        # Convert the speficied column type to a SQL string.
-        def type_to_sql(type, limit = nil, precision = nil, scale = nil)
-          if native = native_database_types[type]
-            column_type_sql = (native.is_a?(Hash) ? native[:name] : native).dup
-
-            if type == :decimal # ignore limit, use precision and scale
-              scale ||= native[:scale]
-
-              if precision ||= native[:precision]
-                if scale
-                  column_type_sql << "(#{precision},#{scale})"
-                else
-                  column_type_sql << "(#{precision})"
-                end
-              elsif scale
-                raise ArgumentError, "Error adding decimal column: precision cannot be empty if scale if specified"
-              end
-
-            elsif limit ||= native.is_a?(Hash) && native[:limit]
-              column_type_sql << "(#{limit})"
-            end
-
-            column_type_sql
-          else
-            type
-          end
-        end
-      end
-    end
-  end
-end
-
-module ActiveRecord
-  module ConnectionAdapters
-    module CompatibilityMethods
-      def self.needed?(base)
-        !base.instance_methods.include?("quote_table_name")
-      end
-
-      def quote_table_name(name)
-        quote_column_name(name)
-      end
-    end
-  end
-end

data/lib/arjdbc/jdbc/core_ext.rb

@@ -1,24 +0,0 @@
-module ActiveRecord # :nodoc:
-  # Represents exceptions that have propagated up through the JDBC API.
-  class JDBCError < ActiveRecordError
-    # The vendor code or error number that came from the database
-    attr_accessor :errno
-
-    # The full Java SQLException object that was raised
-    attr_accessor :sql_exception
-  end
-
-  module ConnectionAdapters     # :nodoc:
-    # Allows properly re-wrapping/re-defining methods that may already
-    # be alias_method_chain'd.
-    module ShadowCoreMethods
-      def alias_chained_method(meth, feature, target)
-        if instance_methods.include?("#{meth}_without_#{feature}")
-          alias_method "#{meth}_without_#{feature}".to_sym, target
-        else
-          alias_method meth, target if meth != target
-        end
-      end
-    end
-  end
-end

data/lib/arjdbc/jdbc/discover.rb

@@ -1,18 +0,0 @@
-module ArJdbc
-  def self.discover_extensions
-    if defined?(::Gem)
-      files = Gem.find_files('arjdbc/discover')
-    else
-      files = $LOAD_PATH.map do |p|
-        discover = File.join(p, 'arjdbc','discover.rb')
-        File.exist?(p) ? discover : nil
-      end.compact
-    end
-    files.each do |f|
-      puts "Loading #{f}" if $DEBUG
-      require f
-    end
-  end
-
-  discover_extensions
-end

data/lib/arjdbc/jdbc/driver.rb

@@ -1,44 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters
-    class JdbcDriver
-      def initialize(name)
-        @name = name
-      end
-
-      def driver_class
-        @driver_class ||= begin
-          driver_class_const = (@name[0...1].capitalize + @name[1..@name.length]).gsub(/\./, '_')
-          Jdbc::Mutex.synchronized do
-            unless Jdbc.const_defined?(driver_class_const)
-              driver_class_name = @name
-              Jdbc.module_eval do
-                include_class(driver_class_name) { driver_class_const }
-              end
-            end
-          end
-          driver_class = Jdbc.const_get(driver_class_const)
-          raise "You specify a driver for your JDBC connection" unless driver_class
-          driver_class
-        end
-      end
-
-      def load
-        Jdbc::DriverManager.registerDriver(create)
-      end
-
-      def connection(url, user, pass)
-        Jdbc::DriverManager.getConnection(url, user, pass)
-      rescue
-        # bypass DriverManager to get around problem with dynamically loaded jdbc drivers
-        props = java.util.Properties.new
-        props.setProperty("user", user)
-        props.setProperty("password", pass)
-        create.connect(url, props)
-      end
-
-      def create
-        driver_class.new
-      end
-    end
-  end
-end