activerecord-jdbc-adapter 1.2.5 → 1.2.8

data/README.rdoc

@@ -1,214 +0,0 @@
-= Activerecord-jdbc-adapter
-
-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 JRuby {mailing list}[http://jruby.org/community] 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 (activerecord-jdbc-adapter). Supports all available databases via
-  JDBC, but requires you to download and manually install the database vendor's
-  JDBC driver .jar file.
-- mysql (activerecord-jdbcmysql-adapter)
-- postgresql (activerecord-jdbcpostgresql-adapter)
-- sqlite3 (activerecord-jdbcsqlite3-adapter)
-- derby (activerecord-jdbcderby-adapter)
-- hsqldb (activerecord-jdbchsqldb-adapter)
-- h2 (activerecord-jdbch2-adapter)
-- mssql (activerecord-jdbcmssql-adapter). Does not support SQL Azure by default,
-  see the {project's readme}[https://github.com/jruby/activerecord-jdbc-adapter/blob/master/activerecord-jdbcmssql-adapter/README.rdoc]
-  for more information.
-
-2a. For Rails 3, if you're generating a new application, use the
-following command to generate your application:
-
-   jruby -S rails new sweetapp
-
-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):
-
-    platforms :ruby do
-      gem 'sqlite3'
-    end
-
-    platforms :jruby do
-      gem 'jruby-openssl'
-      gem 'activerecord-jdbcsqlite3-adapter'
-    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:
-      host: 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
-
-   If you're really old school you might want to use ARJDBC with a DB2 on z/OS.
-
-    development:
-      adapter: jdbc
-      encoding: unicode
-      url: jdbc:db2j:net://mightyzoshost:446/RAILS_DBT1
-      driver: com.ibm.db2.jcc.DB2Driver
-      schema: DB2XB12
-      database: RAILS_DB1
-      tablespace: TSDE911
-      lob_tablespaces:
-        first_table: TSDE912
-      username: scott
-      password: lion
-
-=== 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/jruby/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://jruby.org/community
-* Issues: https://github.com/jruby/activerecord-jdbc-adapter/issues
-* Source: git://github.com/jruby/activerecord-jdbc-adapter.git
-
-== 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.  You can control the host and port the tests will attempt to
-by setting the environment variables PGHOST and PGPORT.
-
-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'
-
-To execute a single test case, you can run:
-
-  rake appraisal:{version} test_{db} TEST=test/{tests file}
-
-Substitute the version of ActiveRecord for version, which can be one of: 
-  rails23, rails30, rails31, or rails32
-The db can be one of these: 
-  mssql, mysql, oracle, postgres, sybase, sqlite3, db2, derby, h2 
-Finally, the tests file will be whichever test case you want to run.
-
-== 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
-
-== Travis Build Status {<img src="https://secure.travis-ci.org/jruby/activerecord-jdbc-adapter.png"/>}[http://travis-ci.org/#!/jruby/activerecord-jdbc-adapter]
-
-== 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.txt
-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/test/db/logger.rb

@@ -1,3 +0,0 @@
-require 'logger'
-ActiveRecord::Base.logger = Logger.new($stdout)
-ActiveRecord::Base.logger.level = $DEBUG || ENV['DEBUG'] ? Logger::DEBUG : Logger::WARN

data/test/derby_multibyte_test.rb

@@ -1,11 +0,0 @@
-# To run this script, run the following in a mysql instance:
-#
-#   drop database if exists weblog_development;
-#   create database weblog_development;
-#   grant all on weblog_development.* to blog@localhost;
-
-require 'jdbc_common'
-
-class DerbyMultibyteTest < Test::Unit::TestCase
-  include MultibyteTestMethods
-end

data/test/mysql_info_test.rb

@@ -1,123 +0,0 @@
-require 'jdbc_common'
-require 'db/mysql'
-begin; require 'active_support/core_ext/numeric/bytes'; rescue LoadError; end
-
-class DBSetup < ActiveRecord::Migration
-
-  def self.up
-    create_table :books do |t|
-      t.string :title
-      t.timestamps
-    end
-
-    create_table :cars, :primary_key => 'legacy_id' do |t|
-      t.string :name
-      t.date :production_started_on
-    end
-
-    create_table :cats, :id => false do |t|
-      t.string :name
-    end
-
-    create_table :memos do |t|
-      t.text :text, :limit => 16.megabytes
-    end
-  end
-
-  def self.down
-    drop_table :books
-    drop_table :cars
-    drop_table :cats
-    drop_table :memos
-  end
-
-end
-
-class MysqlInfoTest < Test::Unit::TestCase
-
-  def setup
-    DBSetup.up
-    @connection = ActiveRecord::Base.connection
-  end
-
-  def teardown
-    DBSetup.down
-  end
-
-  ## primary_key
-  def test_should_return_the_primary_key_of_a_table
-    assert_equal 'id', @connection.primary_key('books')
-  end
-
-  def test_should_be_able_to_return_a_custom_primary_key
-    assert_equal 'legacy_id', @connection.primary_key('cars')
-  end
-
-  def test_should_return_nil_for_a_table_without_a_primary_key
-    assert_nil @connection.primary_key('cats')
-  end
-
-  ## structure_dump
-  def test_should_include_the_tables_in_a_structure_dump
-    # TODO: Improve these tests, I added this one because no other tests exists for this method.
-    dump = @connection.structure_dump
-    assert dump.include?('CREATE TABLE `books`')
-    assert dump.include?('CREATE TABLE `cars`')
-    assert dump.include?('CREATE TABLE `cats`')
-    assert dump.include?('CREATE TABLE `memos`')
-  end
-
-  def test_should_include_longtext_in_schema_dump
-    strio = StringIO.new
-    ActiveRecord::SchemaDumper::dump(@connection, strio)
-    dump = strio.string
-    assert_match %r{t.text\s+"text",\s+:limit => 2147483647$}, dump
-  end
-
-  # JRUBY-5040
-  def test_schema_dump_should_not_have_limits_on_datetime
-    strio = StringIO.new
-    ActiveRecord::SchemaDumper::dump(@connection, strio)
-    dump = strio.string
-    dump.lines.grep(/datetime/).each {|line| assert line !~ /limit/ }
-  end
-
-  def test_schema_dump_should_not_have_limits_on_date
-    strio = StringIO.new
-    ActiveRecord::SchemaDumper::dump(@connection, strio)
-    dump = strio.string
-    dump.lines.grep(/date/).each {|line| assert line !~ /limit/ }
-  end
-
-  def test_should_include_limit
-    text_column = @connection.columns('memos').find { |c| c.name == 'text' }
-    assert_equal 2147483647, text_column.limit
-  end
-
-  def test_should_set_sqltype_to_longtext
-    text_column = @connection.columns('memos').find { |c| c.name == 'text' }
-    assert text_column.sql_type =~ /^longtext/i
-  end
-
-  def test_should_set_type_to_text
-    text_column = @connection.columns('memos').find { |c| c.name == 'text' }
-    assert_equal :text, text_column.type
-  end
-
-  def test_verify_url_has_options
-    url = @connection.config[:url]
-    assert url =~ /characterEncoding=utf8/
-    assert url =~ /useUnicode=true/
-    assert url =~ /zeroDateTimeBehavior=convertToNull/
-  end
-
-  def test_no_limits_for_some_data_types
-    DbTypeMigration.up
-    strio = StringIO.new
-    ActiveRecord::SchemaDumper.dump(@connection, strio)
-    dump_lines = strio.string
-    assert_nil dump_lines.lines.detect {|l| l =~ /\.(float|date|datetime|integer|time|timestamp) .* :limit/ && l !~ /sample_integer/ }
-  ensure
-    DbTypeMigration.down
-  end
-end