activerecord-jdbc-adapter 1.2.5 → 1.2.8

data/test/models/entry.rb

@@ -25,7 +25,7 @@ end
 class CreateUsers < ActiveRecord::Migration
   def self.up
     create_table "users", :force => true do |t|
-      t.column :login, :string, :limit => 100
+      t.column :login, :string, :limit => 100, :null => false
     end
   end
 

data/test/models/string_id.rb

@@ -1,7 +1,7 @@
 class CreateStringIds < ActiveRecord::Migration
   def self.up
     create_table "string_ids", :force => true, :id => false do |t|
-      t.string :id
+      t.string :id, :null => false
     end
   end
 
@@ -11,7 +11,7 @@ class CreateStringIds < ActiveRecord::Migration
 end
 
 class StringId < ActiveRecord::Base
-  def self.table_name () "string_ids" end
+  def self.table_name; "string_ids"; end
   # Fake out a table without a primary key
   self.primary_key = "id"
 end

data/test/models/thing.rb

@@ -2,9 +2,9 @@ class CreateThings < ActiveRecord::Migration
   def self.up
     create_table :things, :id => false do |t|
       t.string :name
-
       t.timestamps
     end
+    add_index :things, :name, :unique => true
   end
 
   def self.down

data/test/models/topic.rb

@@ -0,0 +1,32 @@
+class Topic < ActiveRecord::Base
+  serialize :content
+end
+
+class ImportantTopic < Topic
+  serialize :important, Hash
+end
+
+class TopicMigration < ActiveRecord::Migration
+
+  def self.up
+    create_table :topics, :force => true do |t|
+      t.string :title
+      # use VARCHAR2(4000) instead of CLOB datatype as CLOB data type has many limitations in
+      # Oracle SELECT WHERE clause which causes many unit test failures
+      #if current_adapter?(:OracleAdapter)
+        #t.string :content, :limit => 4000
+        #t.string :important, :limit => 4000
+      #else
+        t.text :content
+        t.text :important
+      #end
+      t.string :type
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :topics
+  end
+
+end

data/test/mssql_legacy_types_test.rb

@@ -29,7 +29,7 @@ class MsSQLLegacyTypesTest < Test::Unit::TestCase
 
   def setup
     CreateArticles.up
-    @connection = ActiveRecord::Base.connection
+    ActiveRecord::Base.connection
   end
 
   def teardown

data/test/mssql_limit_offset_test.rb

@@ -88,7 +88,7 @@ class MsSQLLimitOffsetTest < Test::Unit::TestCase
     CreateLongShips.up
     CreateVikings.up
     CreateNoIdVikings.up
-    @connection = ActiveRecord::Base.connection
+    ActiveRecord::Base.connection
   end
 
   def teardown
@@ -102,7 +102,7 @@ class MsSQLLimitOffsetTest < Test::Unit::TestCase
   def test_limit_with_no_id_column_available
     NoIdViking.create!(:name => 'Erik')
     assert_nothing_raised(ActiveRecord::StatementInvalid) do 
-      NoIdViking.find(:first)
+      NoIdViking.first
     end
   end
 
@@ -162,5 +162,15 @@ class MsSQLLimitOffsetTest < Test::Unit::TestCase
     assert_equal(["Adam", "Carl", "Ben"], vikings.map(&:name))
 
   end
-  
+ 
+  def test_offset_without_limit
+    %w(one two three four five six seven eight).each do |name|
+      LongShip.create!(:name => name)
+    end
+    error = assert_raise ActiveRecord::ActiveRecordError do
+      LongShip.find(:all, :offset => 2)
+    end
+    assert_equal("You must specify :limit with :offset.", error.message)
+  end
+
 end

data/test/mssql_serialize_test.rb

@@ -0,0 +1,6 @@
+require 'db/mssql'
+require 'serialize'
+
+class MsSQLSerializeTest < Test::Unit::TestCase
+  include SerializeTestMethods
+end

data/test/mysql_binary_test.rb

@@ -0,0 +1,6 @@
+require 'db/mysql'
+require 'binary'
+
+class MySQLBinaryTest < Test::Unit::TestCase
+  include BinaryTestMethods
+end

data/test/mysql_schema_dump_test.rb

@@ -0,0 +1,220 @@
+require 'db/mysql'
+require 'schema_dump'
+begin; require 'active_support/core_ext/numeric/bytes'; rescue LoadError; end
+
+class MysqlSchemaDumpTest < Test::Unit::TestCase
+  include SchemaDumpTestMethods
+  
+  def self.startup
+    super
+    MigrationSetup.setup!
+  end
+  
+  def self.shutdown
+    MigrationSetup.teardown!
+    super
+  end
+
+  def setup!; end # MigrationSetup#setup!
+  def teardown!; end # MigrationSetup#teardown!
+  
+  ActiveRecord::Schema.define do
+    create_table :big_fields, :force => true do |t|
+      t.binary :tiny_blob,   :limit => 255
+      t.binary :normal_blob, :limit => 65535
+      t.binary :medium_blob, :limit => 16777215
+      t.binary :long_blob,   :limit => 2147483647
+      t.text   :tiny_text,   :limit => 255
+      t.text   :normal_text, :limit => 65535
+      t.text   :medium_text, :limit => 16777215
+      t.text   :long_text,   :limit => 2147483647
+      t.text   :just_text, :null => false
+      # MySQL does not allow default values for blobs. 
+      # Fake it out with a big varchar below.
+      t.string :string_col, :null => true, :default => '', :limit => 1024
+    end
+  end
+  
+  def test_schema_dump_should_not_add_default_value_for_mysql_text_field
+    output = standard_dump
+    assert_match %r{t.text\s+"just_text",\s+:null => false$}, output
+  end
+  
+  def test_schema_dump_includes_length_for_mysql_blob_and_text_fields
+    output = standard_dump   
+    assert_match %r{t.binary\s+"tiny_blob",\s+:limit => 255$}, output
+    assert_match %r{t.binary\s+"normal_blob"$}, output
+    assert_match %r{t.binary\s+"medium_blob",\s+:limit => 16777215$}, output
+    assert_match %r{t.binary\s+"long_blob",\s+:limit => 2147483647$}, output
+    assert_match %r{t.text\s+"tiny_text",\s+:limit => 255$}, output
+    assert_match %r{t.text\s+"normal_text"$}, output
+    assert_match %r{t.text\s+"medium_text",\s+:limit => 16777215$}, output
+    assert_match %r{t.text\s+"long_text",\s+:limit => 2147483647$}, output
+  end
+  
+end
+
+class MysqlInfoTest < Test::Unit::TestCase
+  
+  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
+  
+  def self.startup
+    super
+    DBSetup.up
+  end
+
+  def self.shutdown
+    DBSetup.down
+    super
+  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
+    dump = schema_dump
+    dump.lines.grep(/datetime/).each {|line| assert line !~ /limit/ }
+  end
+
+  def test_schema_dump_should_not_have_limits_on_date
+    dump = schema_dump
+    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
+    #
+    # AR-3.2 :
+    # 
+    #  create_table "db_types", :force => true do |t|
+    #    t.datetime "sample_timestamp"
+    #    t.datetime "sample_datetime"
+    #    t.date     "sample_date"
+    #    t.time     "sample_time"
+    #    t.decimal  "sample_decimal",                           :precision => 15, :scale => 0
+    #    t.decimal  "sample_small_decimal",                     :precision => 3,  :scale => 2
+    #    t.decimal  "sample_default_decimal",                   :precision => 10, :scale => 0
+    #    t.float    "sample_float"
+    #    t.binary   "sample_binary"
+    #    t.boolean  "sample_boolean"
+    #    t.string   "sample_string",                                                           :default => ""
+    #    t.integer  "sample_integer",              :limit => 8
+    #    t.integer  "sample_integer_with_limit_2", :limit => 2
+    #    t.integer  "sample_integer_with_limit_8", :limit => 8
+    #    t.integer  "sample_integer_no_limit"
+    #    t.integer  "sample_integer_neg_default",                                              :default => -1
+    #    t.text     "sample_text"
+    #  end
+    #
+    # AR-2.3 :
+    # 
+    #  create_table "db_types", :force => true do |t|
+    #    t.datetime "sample_timestamp"
+    #    t.datetime "sample_datetime"
+    #    t.date     "sample_date"
+    #    t.time     "sample_time"
+    #    t.integer  "sample_decimal",              :limit => 15, :precision => 15, :scale => 0
+    #    t.decimal  "sample_small_decimal",                      :precision => 3,  :scale => 2
+    #    t.integer  "sample_default_decimal",      :limit => 10, :precision => 10, :scale => 0
+    #    t.float    "sample_float"
+    #    t.binary   "sample_binary"
+    #    t.boolean  "sample_boolean"
+    #    t.string   "sample_string",                                                            :default => ""
+    #    t.integer  "sample_integer",              :limit => 8
+    #    t.integer  "sample_integer_with_limit_2", :limit => 2
+    #    t.integer  "sample_integer_with_limit_8", :limit => 8
+    #    t.integer  "sample_integer_no_limit"
+    #    t.integer  "sample_integer_neg_default",                                               :default => -1
+    #    t.text     "sample_text"
+    #  end
+    #
+    dump = schema_dump
+    if ar_version('3.0')
+      assert_nil dump.lines.detect {|l| l =~ /\.(float|date|datetime|integer|time|timestamp) .* :limit/ && l !~ /sample_integer/ }, dump
+    else
+      puts "test_no_limits_for_some_data_types assertion skipped on #{ActiveRecord::VERSION::STRING}"
+    end
+  ensure
+    DbTypeMigration.down
+  end
+  
+end

data/test/mysql_serialize_test.rb

@@ -0,0 +1,6 @@
+require 'db/mysql'
+require 'serialize'
+
+class MySQLSerializeTest < Test::Unit::TestCase
+  include SerializeTestMethods
+end

data/test/mysql_simple_test.rb

@@ -48,9 +48,9 @@ class MysqlSimpleTest < Test::Unit::TestCase
     user_1 = User.create :login => 'user_1'
     user_2 = User.create :login => 'user_2'
 
-    entry_1 = Entry.create :title => 'title_1', :content => 'content_1', :rating => 0,
+    Entry.create :title => 'title_1', :content => 'content_1', :rating => 0,
     :user_id => user_1.id
-    entry_2 = Entry.create :title => 'title_2', :content => 'content_2', :rating => 1,
+    Entry.create :title => 'title_2', :content => 'content_2', :rating => 1,
     :user_id => user_2.id
 
     all_entries = Entry.joins(:user).where('users.id' => user_1.id).
@@ -103,6 +103,26 @@ class MysqlSimpleTest < Test::Unit::TestCase
       User.table_name  = old_users_table_name
     end
   end
+
+  include ExplainSupportTestMethods if ar_version("3.1")
+  
+  def test_update_sql_public_and_returns_rows_affected
+    ActiveRecord::Base.connection.update_sql "UPDATE entries SET title = NULL"
+    
+    e1 = Entry.create! :title => 'a some', :content => 'brrrr', :rating => 10.8
+    e2 = Entry.create! :title => 'another', :content => 'meee', :rating => 40.2
+    rows_affected = ActiveRecord::Base.connection.update_sql "UPDATE entries " + 
+      "SET content='updated content' WHERE rating > 10 AND title IS NOT NULL"
+    assert_equal 2, rows_affected
+    assert_equal 'updated content', e1.reload.content
+    assert_equal 'updated content', e2.reload.content
+  end
+
+  def test_reports_server_version
+    assert_instance_of Array, ActiveRecord::Base.connection.send(:version)
+    assert_equal 3, ActiveRecord::Base.connection.send(:version).size
+  end
+  
 end
 
 class MysqlHasManyThroughTest < Test::Unit::TestCase

data/test/mysql_test.rb

@@ -0,0 +1,93 @@
+# encoding: ASCII-8BIT
+require 'test_helper'
+
+class MySQLTest < Test::Unit::TestCase
+
+  class MySQLImpl
+    include ArJdbc::MySQL
+    def initialize; end
+  end
+  mySQL = MySQLImpl.new
+  
+  test "quotes string value" do
+    { 
+      "\x00" => "\\0", 
+      "\n" => "\\n", 
+      "\r" => "\\r",  
+      "\x1A" => "\\Z", 
+      '"' => "\\\"", 
+      "'" => "\\'", 
+      "\\" => "\\\\", 
+    }.each do |s, q|
+      assert_equal q, mySQL.quote_string(s)
+      assert_equal "string #{q}", mySQL.quote_string(v = "string #{s}"), "while quoting #{v.inspect}"
+      assert_equal " #{q}", mySQL.quote_string(v = " #{s}"), "while quoting #{v.inspect}"
+      assert_equal "#{q}str", mySQL.quote_string(v = "#{s}str"), "while quoting #{v.inspect}"
+    end
+  end
+  
+  test "quote string (with encoding mysql2 style)" do
+    s = "'' \\| \" \x00 \x01 \x1A \xA1 \r \n \\nOiZe \r\n'\x01\X\xA1\xA1\n"
+    q = "\\'\\' \\\\| \\\" \\0 \x01 \\Z \xA1 \\r \\n \\\\nOiZe \\r\\n\\'\x01X\xA1\xA1\\n"
+    if RUBY_VERSION > '1.9' # mysql2 compatibility
+      q2 = q.dup.force_encoding 'UTF-8'
+      assert_equal q2, mySQL.quote_string(s)
+    else
+      assert_equal q, mySQL.quote_string(s)
+    end
+    
+    if s.respond_to?(:force_encoding)
+      s.force_encoding('UTF-8')
+      q.force_encoding('UTF-8')
+      v = mySQL.quote_string(s)
+      assert_equal q, v
+      assert_equal q.encoding, v.encoding
+      
+      s.force_encoding('ASCII-8BIT')
+      v = mySQL.quote_string(s)
+      assert_equal q, v
+      # Mysql2::Client.new(...).escape(s) compatible :
+      assert_equal 'UTF-8', v.encoding.name
+      # Mysql.escape_string(s) returns ASCII-8BIT
+    end
+  end
+  
+  test "quote string (utf-8)" do
+    s = "\x1Akôň ůň löw9876\r\nqűáéőú\n.éáű-mehehehehehehe0 \x01\x00\x00\\\x02\\'"
+    q = "\\Zkôň ůň löw9876\\r\\nqűáéőú\\n.éáű-mehehehehehehe0 \x01\\0\\0\\\\\x02\\\\\\'"
+    if RUBY_VERSION > '1.9' # mysql2 compatibility
+      q2 = q.dup.force_encoding 'UTF-8'
+      assert_equal q2, mySQL.quote_string(s.dup)
+      
+      q.force_encoding('UTF-8')
+      s.force_encoding('UTF-8')
+      assert_equal q, mySQL.quote_string(s)
+    else
+      assert_equal q, mySQL.quote_string(s.dup)
+    end
+    assert_equal q, mySQL.quote_string(s)
+  end
+  
+  test "quote string keeps original string" do
+    s = "mehehehehehehe0 \x01 \x02 nothing-to-quote-here ..."
+    assert_equal s, mySQL.quote_string(s.dup)
+    
+    if s.respond_to?(:force_encoding)
+      s.force_encoding('UTF-8')
+      assert_equal s, mySQL.quote_string(s.dup)
+    end
+    assert_equal s, mySQL.quote_string(s)
+  end
+
+  test "quote string keeps original (utf-8)" do
+    s = "kôň ůň löw9876qűáéőú.éáű-mehehehehehehe0 \x01 \x02 nothing-to-quote"
+    assert_equal s, mySQL.quote_string(s.dup)
+    
+    if s.respond_to?(:force_encoding)
+      s.force_encoding('UTF-8')
+      assert_equal s, mySQL.quote_string(s.dup)
+    end
+    assert_equal s, mySQL.quote_string(s)
+  end
+  
+end