ibm_db 5.2.0 → 5.3.2

data/test/cases/migration/change_table_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/migration/helper"
 
 module ActiveRecord
@@ -17,28 +19,44 @@ module ActiveRecord
 
       def test_references_column_type_adds_id
         with_change_table do |t|
-          @connection.expect :add_reference, nil, [:delete_me, :customer, {}]
+          if RUBY_VERSION < "2.7"
+            @connection.expect :add_reference, nil, [:delete_me, :customer, {}]
+          else
+            @connection.expect :add_reference, nil, [:delete_me, :customer]
+          end
           t.references :customer
         end
       end
 
       def test_remove_references_column_type_removes_id
         with_change_table do |t|
-          @connection.expect :remove_reference, nil, [:delete_me, :customer, {}]
+          if RUBY_VERSION < "2.7"
+            @connection.expect :remove_reference, nil, [:delete_me, :customer, {}]
+          else
+            @connection.expect :remove_reference, nil, [:delete_me, :customer]
+          end
           t.remove_references :customer
         end
       end
 
       def test_add_belongs_to_works_like_add_references
         with_change_table do |t|
-          @connection.expect :add_reference, nil, [:delete_me, :customer, {}]
+          if RUBY_VERSION < "2.7"
+            @connection.expect :add_reference, nil, [:delete_me, :customer, {}]
+          else
+            @connection.expect :add_reference, nil, [:delete_me, :customer]
+          end
           t.belongs_to :customer
         end
       end
 
       def test_remove_belongs_to_works_like_remove_references
         with_change_table do |t|
-          @connection.expect :remove_reference, nil, [:delete_me, :customer, {}]
+          if RUBY_VERSION < "2.7"
+            @connection.expect :remove_reference, nil, [:delete_me, :customer, {}]
+          else
+            @connection.expect :remove_reference, nil, [:delete_me, :customer]
+          end
           t.remove_belongs_to :customer
         end
       end
@@ -95,7 +113,7 @@ module ActiveRecord
       def test_remove_timestamps_creates_updated_at_and_created_at
         with_change_table do |t|
           @connection.expect :remove_timestamps, nil, [:delete_me, { null: true }]
-          t.remove_timestamps({ null: true })
+          t.remove_timestamps(null: true)
         end
       end
 
@@ -108,24 +126,39 @@ module ActiveRecord
 
       def test_integer_creates_integer_column
         with_change_table do |t|
-          @connection.expect :add_column, nil, [:delete_me, :foo, :integer, {}]
-          @connection.expect :add_column, nil, [:delete_me, :bar, :integer, {}]
+          if RUBY_VERSION < "2.7"
+            @connection.expect :add_column, nil, [:delete_me, :foo, :integer, {}]
+            @connection.expect :add_column, nil, [:delete_me, :bar, :integer, {}]
+          else
+            @connection.expect :add_column, nil, [:delete_me, :foo, :integer]
+            @connection.expect :add_column, nil, [:delete_me, :bar, :integer]
+          end
           t.integer :foo, :bar
         end
       end
 
       def test_bigint_creates_bigint_column
         with_change_table do |t|
-          @connection.expect :add_column, nil, [:delete_me, :foo, :bigint, {}]
-          @connection.expect :add_column, nil, [:delete_me, :bar, :bigint, {}]
+          if RUBY_VERSION < "2.7"
+            @connection.expect :add_column, nil, [:delete_me, :foo, :bigint, {}]
+            @connection.expect :add_column, nil, [:delete_me, :bar, :bigint, {}]
+          else
+            @connection.expect :add_column, nil, [:delete_me, :foo, :bigint]
+            @connection.expect :add_column, nil, [:delete_me, :bar, :bigint]
+          end
           t.bigint :foo, :bar
         end
       end
 
       def test_string_creates_string_column
         with_change_table do |t|
-          @connection.expect :add_column, nil, [:delete_me, :foo, :string, {}]
-          @connection.expect :add_column, nil, [:delete_me, :bar, :string, {}]
+          if RUBY_VERSION < "2.7"
+            @connection.expect :add_column, nil, [:delete_me, :foo, :string, {}]
+            @connection.expect :add_column, nil, [:delete_me, :bar, :string, {}]
+          else
+            @connection.expect :add_column, nil, [:delete_me, :foo, :string]
+            @connection.expect :add_column, nil, [:delete_me, :bar, :string]
+          end
           t.string :foo, :bar
         end
       end
@@ -133,16 +166,26 @@ module ActiveRecord
       if current_adapter?(:PostgreSQLAdapter)
         def test_json_creates_json_column
           with_change_table do |t|
-            @connection.expect :add_column, nil, [:delete_me, :foo, :json, {}]
-            @connection.expect :add_column, nil, [:delete_me, :bar, :json, {}]
+            if RUBY_VERSION < "2.7"
+              @connection.expect :add_column, nil, [:delete_me, :foo, :json, {}]
+              @connection.expect :add_column, nil, [:delete_me, :bar, :json, {}]
+            else
+              @connection.expect :add_column, nil, [:delete_me, :foo, :json]
+              @connection.expect :add_column, nil, [:delete_me, :bar, :json]
+            end
             t.json :foo, :bar
           end
         end
 
         def test_xml_creates_xml_column
           with_change_table do |t|
-            @connection.expect :add_column, nil, [:delete_me, :foo, :xml, {}]
-            @connection.expect :add_column, nil, [:delete_me, :bar, :xml, {}]
+            if RUBY_VERSION < "2.7"
+              @connection.expect :add_column, nil, [:delete_me, :foo, :xml, {}]
+              @connection.expect :add_column, nil, [:delete_me, :bar, :xml, {}]
+            else
+              @connection.expect :add_column, nil, [:delete_me, :foo, :xml]
+              @connection.expect :add_column, nil, [:delete_me, :bar, :xml]
+            end
             t.xml :foo, :bar
           end
         end
@@ -150,29 +193,54 @@ module ActiveRecord
 
       def test_column_creates_column
         with_change_table do |t|
-          @connection.expect :add_column, nil, [:delete_me, :bar, :integer, {}]
+          if RUBY_VERSION < "2.7"
+            @connection.expect :add_column, nil, [:delete_me, :bar, :integer, {}]
+          else
+            @connection.expect :add_column, nil, [:delete_me, :bar, :integer]
+          end
           t.column :bar, :integer
         end
       end
 
       def test_column_creates_column_with_options
         with_change_table do |t|
-          @connection.expect :add_column, nil, [:delete_me, :bar, :integer, {:null => false}]
-          t.column :bar, :integer, :null => false
+          if RUBY_VERSION < "2.7"
+            @connection.expect :add_column, nil, [:delete_me, :bar, :integer, { null: false }]
+          else
+            @connection.expect :add_column, nil, [:delete_me, :bar, :integer, { null: false }]
+          end
+          t.column :bar, :integer, null: false
+        end
+      end
+
+      def test_column_creates_column_with_index
+        with_change_table do |t|
+          if RUBY_VERSION < "2.7"
+            @connection.expect :add_column, nil, [:delete_me, :bar, :integer, {}]
+            @connection.expect :add_index, nil, [:delete_me, :bar, {}]
+          else
+            @connection.expect :add_column, nil, [:delete_me, :bar, :integer]
+            @connection.expect :add_index, nil, [:delete_me, :bar]
+          end
+          t.column :bar, :integer, index: true
         end
       end
 
       def test_index_creates_index
         with_change_table do |t|
-          @connection.expect :add_index, nil, [:delete_me, :bar, {}]
+          if RUBY_VERSION < "2.7"
+            @connection.expect :add_index, nil, [:delete_me, :bar, {}]
+          else
+            @connection.expect :add_index, nil, [:delete_me, :bar]
+          end
           t.index :bar
         end
       end
 
       def test_index_creates_index_with_options
         with_change_table do |t|
-          @connection.expect :add_index, nil, [:delete_me, :bar, {:unique => true}]
-          t.index :bar, :unique => true
+          @connection.expect :add_index, nil, [:delete_me, :bar, { unique: true }]
+          t.index :bar, unique: true
         end
       end
 
@@ -185,8 +253,8 @@ module ActiveRecord
 
       def test_index_exists_with_options
         with_change_table do |t|
-          @connection.expect :index_exists?, nil, [:delete_me, :bar, {:unique => true}]
-          t.index_exists?(:bar, :unique => true)
+          @connection.expect :index_exists?, nil, [:delete_me, :bar, { unique: true }]
+          t.index_exists?(:bar, unique: true)
         end
       end
 
@@ -199,15 +267,19 @@ module ActiveRecord
 
       def test_change_changes_column
         with_change_table do |t|
-          @connection.expect :change_column, nil, [:delete_me, :bar, :string, {}]
+          if RUBY_VERSION < "2.7"
+            @connection.expect :change_column, nil, [:delete_me, :bar, :string, {}]
+          else
+            @connection.expect :change_column, nil, [:delete_me, :bar, :string]
+          end
           t.change :bar, :string
         end
       end
 
       def test_change_changes_column_with_options
         with_change_table do |t|
-          @connection.expect :change_column, nil, [:delete_me, :bar, :string, {:null => true}]
-          t.change :bar, :string, :null => true
+          @connection.expect :change_column, nil, [:delete_me, :bar, :string, { null: true }]
+          t.change :bar, :string, null: true
         end
       end
 
@@ -218,24 +290,46 @@ module ActiveRecord
         end
       end
 
+      def test_change_null_changes_column
+        with_change_table do |t|
+          @connection.expect :change_column_null, nil, [:delete_me, :bar, true, nil]
+          t.change_null :bar, true
+        end
+      end
+
       def test_remove_drops_single_column
         with_change_table do |t|
-          @connection.expect :remove_columns, nil, [:delete_me, :bar]
+          if RUBY_VERSION < "2.7"
+            @connection.expect :remove_columns, nil, [:delete_me, :bar, {}]
+          else
+            @connection.expect :remove_columns, nil, [:delete_me, :bar]
+          end
           t.remove :bar
         end
       end
 
       def test_remove_drops_multiple_columns
         with_change_table do |t|
-          @connection.expect :remove_columns, nil, [:delete_me, :bar, :baz]
+          if RUBY_VERSION < "2.7"
+            @connection.expect :remove_columns, nil, [:delete_me, :bar, :baz, {}]
+          else
+            @connection.expect :remove_columns, nil, [:delete_me, :bar, :baz]
+          end
           t.remove :bar, :baz
         end
       end
 
+      def test_remove_drops_multiple_columns_when_column_options_are_given
+        with_change_table do |t|
+          @connection.expect :remove_columns, nil, [:delete_me, :bar, :baz, type: :string, null: false]
+          t.remove :bar, :baz, type: :string, null: false
+        end
+      end
+
       def test_remove_index_removes_index_with_options
         with_change_table do |t|
-          @connection.expect :remove_index, nil, [:delete_me, {:unique => true}]
-          t.remove_index :unique => true
+          @connection.expect :remove_index, nil, [:delete_me, :bar, { unique: true }]
+          t.remove_index :bar, unique: true
         end
       end
 
@@ -251,6 +345,20 @@ module ActiveRecord
           assert_equal :delete_me, t.name
         end
       end
+
+      def test_check_constraint_creates_check_constraint
+        with_change_table do |t|
+          @connection.expect :add_check_constraint, nil, [:delete_me, "price > discounted_price", name: "price_check"]
+          t.check_constraint "price > discounted_price", name: "price_check"
+        end
+      end
+
+      def test_remove_check_constraint_removes_check_constraint
+        with_change_table do |t|
+          @connection.expect :remove_check_constraint, nil, [:delete_me, name: "price_check"]
+          t.remove_check_constraint name: "price_check"
+        end
+      end
     end
   end
 end

data/test/cases/migration/check_constraint_test.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+if ActiveRecord::Base.connection.supports_check_constraints?
+  module ActiveRecord
+    class Migration
+      class CheckConstraintTest < ActiveRecord::TestCase
+        include SchemaDumpingHelper
+
+        class Trade < ActiveRecord::Base
+        end
+
+        setup do
+          @connection = ActiveRecord::Base.connection
+          @connection.create_table "trades", force: true do |t|
+            t.integer :price
+            t.integer :quantity
+          end
+        end
+
+        teardown do
+          @connection.drop_table "trades", if_exists: true rescue nil
+        end
+
+        def test_check_constraints
+          check_constraints = @connection.check_constraints("products")
+          assert_equal 1, check_constraints.size
+
+          constraint = check_constraints.first
+          assert_equal "products", constraint.table_name
+          assert_equal "products_price_check", constraint.name
+
+          if current_adapter?(:Mysql2Adapter)
+            assert_equal "`price` > `discounted_price`", constraint.expression
+          else
+            assert_equal "price > discounted_price", constraint.expression
+          end
+        end
+
+        def test_add_check_constraint
+          @connection.add_check_constraint :trades, "quantity > 0"
+
+          check_constraints = @connection.check_constraints("trades")
+          assert_equal 1, check_constraints.size
+
+          constraint = check_constraints.first
+          assert_equal "trades", constraint.table_name
+          assert_equal "chk_rails_2189e9f96c", constraint.name
+
+          if current_adapter?(:Mysql2Adapter)
+            assert_equal "`quantity` > 0", constraint.expression
+          else
+            assert_equal "quantity > 0", constraint.expression
+          end
+        end
+
+        def test_add_check_constraint_with_non_existent_table_raises
+          e = assert_raises(ActiveRecord::StatementInvalid) do
+            @connection.add_check_constraint :refunds, "quantity > 0", name: "quantity_check"
+          end
+          assert_match(/refunds/, e.message)
+        end
+
+        def test_added_check_constraint_ensures_valid_values
+          @connection.add_check_constraint :trades, "quantity > 0", name: "quantity_check"
+
+          assert_raises(ActiveRecord::StatementInvalid) do
+            Trade.create(quantity: -1)
+          end
+        end
+
+        if ActiveRecord::Base.connection.supports_validate_constraints?
+          def test_not_valid_check_constraint
+            Trade.create(quantity: -1)
+
+            @connection.add_check_constraint :trades, "quantity > 0", name: "quantity_check", validate: false
+
+            assert_raises(ActiveRecord::StatementInvalid) do
+              Trade.create(quantity: -1)
+            end
+          end
+
+          def test_validate_check_constraint_by_name
+            @connection.add_check_constraint :trades, "quantity > 0", name: "quantity_check", validate: false
+            assert_not_predicate @connection.check_constraints("trades").first, :validated?
+
+            @connection.validate_check_constraint :trades, name: "quantity_check"
+            assert_predicate @connection.check_constraints("trades").first, :validated?
+          end
+
+          def test_validate_non_existing_check_constraint_raises
+            assert_raises ArgumentError do
+              @connection.validate_check_constraint :trades, name: "quantity_check"
+            end
+          end
+        else
+          # Check constraint should still be created, but should not be invalid
+          def test_add_invalid_check_constraint
+            @connection.add_check_constraint :trades, "quantity > 0", name: "quantity_check", validate: false
+
+            check_constraints = @connection.check_constraints("trades")
+            assert_equal 1, check_constraints.size
+
+            cc = check_constraints.first
+            assert_predicate cc, :validated?
+          end
+        end
+
+        def test_remove_check_constraint
+          @connection.add_check_constraint :trades, "price > 0", name: "price_check"
+          @connection.add_check_constraint :trades, "quantity > 0", name: "quantity_check"
+
+          assert_equal 2, @connection.check_constraints("trades").size
+          @connection.remove_check_constraint :trades, name: "quantity_check"
+          assert_equal 1, @connection.check_constraints("trades").size
+
+          constraint = @connection.check_constraints("trades").first
+          assert_equal "trades", constraint.table_name
+          assert_equal "price_check", constraint.name
+
+          if current_adapter?(:Mysql2Adapter)
+            assert_equal "`price` > 0", constraint.expression
+          else
+            assert_equal "price > 0", constraint.expression
+          end
+        end
+
+        def test_remove_non_existing_check_constraint
+          assert_raises(ArgumentError) do
+            @connection.remove_check_constraint :trades, name: "nonexistent"
+          end
+        end
+      end
+    end
+  end
+else
+  module ActiveRecord
+    class Migration
+      class NoForeignKeySupportTest < ActiveRecord::TestCase
+        setup do
+          @connection = ActiveRecord::Base.connection
+        end
+
+        def test_add_check_constraint_should_be_noop
+          @connection.add_check_constraint :products, "discounted_price > 0", name: "discounted_price_check"
+        end
+
+        def test_remove_check_constraint_should_be_noop
+          @connection.remove_check_constraint :products, name: "price_check"
+        end
+
+        def test_check_constraints_should_raise_not_implemented
+          assert_raises(NotImplementedError) do
+            @connection.check_constraints("products")
+          end
+        end
+      end
+    end
+  end
+end

data/test/cases/migration/column_attributes_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/migration/helper"
 
 module ActiveRecord
@@ -9,7 +11,7 @@ module ActiveRecord
 
       def test_add_column_newline_default
         string = "foo\nbar"
-        add_column 'test_models', 'command', :string, :default => string
+        add_column "test_models", "command", :string, default: string
         TestModel.reset_column_information
 
         assert_equal string, TestModel.new.command
@@ -18,10 +20,10 @@ module ActiveRecord
       def test_add_remove_single_field_using_string_arguments
         assert_no_column TestModel, :last_name
 
-        add_column 'test_models', 'last_name', :string
+        add_column "test_models", "last_name", :string
         assert_column TestModel, :last_name
 
-        remove_column 'test_models', 'last_name'
+        remove_column "test_models", "last_name"
         assert_no_column TestModel, :last_name
       end
 
@@ -43,11 +45,11 @@ module ActiveRecord
         assert_nil TestModel.columns_hash["description"].limit
       end
 
-      if current_adapter?(:Mysql2Adapter)
+      if current_adapter?(:Mysql2Adapter, :PostgreSQLAdapter)
         def test_unabstracted_database_dependent_types
-          add_column :test_models, :intelligence_quotient, :tinyint
+          add_column :test_models, :intelligence_quotient, :smallint
           TestModel.reset_column_information
-          assert_match(/tinyint/, TestModel.columns_hash['intelligence_quotient'].sql_type)
+          assert_match(/smallint/, TestModel.columns_hash["intelligence_quotient"].sql_type)
         end
       end
 
@@ -56,15 +58,13 @@ module ActiveRecord
         # functionality. This allows us to more easily catch INSERT being broken,
         # but SELECT actually working fine.
         def test_native_decimal_insert_manual_vs_automatic
-          correct_value = '0012345678901234567890.0123456789'.to_d
+          correct_value = "0012345678901234567890.0123456789".to_d
 
-          connection.add_column "test_models", "wealth", :decimal, :precision => '30', :scale => '10'
+          connection.add_column "test_models", "wealth", :decimal, precision: "30", scale: "10"
 
           # Do a manual insertion
           if current_adapter?(:OracleAdapter)
             connection.execute "insert into test_models (id, wealth) values (people_seq.nextval, 12345678901234567890.0123456789)"
-          elsif current_adapter?(:PostgreSQLAdapter)
-            connection.execute "insert into test_models (wealth) values (12345678901234567890.0123456789)"
           else
             connection.execute "insert into test_models (wealth) values (12345678901234567890.0123456789)"
           end
@@ -74,15 +74,13 @@ module ActiveRecord
           assert_kind_of BigDecimal, row.wealth
 
           # If this assert fails, that means the SELECT is broken!
-          unless current_adapter?(:SQLite3Adapter)
-            assert_equal correct_value, row.wealth
-          end
+          assert_equal correct_value, row.wealth
 
           # Reset to old state
           TestModel.delete_all
 
           # Now use the Rails insertion
-          TestModel.create :wealth => BigDecimal.new("12345678901234567890.0123456789")
+          TestModel.create wealth: BigDecimal("12345678901234567890.0123456789")
 
           # SELECT
           row = TestModel.first
@@ -94,26 +92,40 @@ module ActiveRecord
       end
 
       def test_add_column_with_precision_and_scale
-        connection.add_column 'test_models', 'wealth', :decimal, :precision => 9, :scale => 7
+        connection.add_column "test_models", "wealth", :decimal, precision: 9, scale: 7
 
-        wealth_column = TestModel.columns_hash['wealth']
+        wealth_column = TestModel.columns_hash["wealth"]
         assert_equal 9, wealth_column.precision
         assert_equal 7, wealth_column.scale
       end
 
+      # Test SQLite3 adapter specifically for decimal types with precision and scale
+      # attributes, since these need to be maintained in schema but aren't actually
+      # used in SQLite3 itself
       if current_adapter?(:SQLite3Adapter)
+        def test_change_column_with_new_precision_and_scale
+          connection.add_column "test_models", "wealth", :decimal, precision: 9, scale: 7
+
+          connection.change_column "test_models", "wealth", :decimal, precision: 12, scale: 8
+          TestModel.reset_column_information
+
+          wealth_column = TestModel.columns_hash["wealth"]
+          assert_equal 12, wealth_column.precision
+          assert_equal 8, wealth_column.scale
+        end
+
         def test_change_column_preserve_other_column_precision_and_scale
-          connection.add_column 'test_models', 'last_name', :string
-          connection.add_column 'test_models', 'wealth', :decimal, :precision => 9, :scale => 7
+          connection.add_column "test_models", "last_name", :string
+          connection.add_column "test_models", "wealth", :decimal, precision: 9, scale: 7
 
-          wealth_column = TestModel.columns_hash['wealth']
+          wealth_column = TestModel.columns_hash["wealth"]
           assert_equal 9, wealth_column.precision
           assert_equal 7, wealth_column.scale
 
-          connection.change_column 'test_models', 'last_name', :string, :null => false
+          connection.change_column "test_models", "last_name", :string, null: false
           TestModel.reset_column_information
 
-          wealth_column = TestModel.columns_hash['wealth']
+          wealth_column = TestModel.columns_hash["wealth"]
           assert_equal 9, wealth_column.precision
           assert_equal 7, wealth_column.scale
         end
@@ -126,28 +138,28 @@ module ActiveRecord
           add_column "test_models", "bio", :text
           add_column "test_models", "age", :integer
           add_column "test_models", "height", :float
-          add_column "test_models", "wealth", :decimal, :precision => '30', :scale => '10'
+          add_column "test_models", "wealth", :decimal, precision: "30", scale: "10"
           add_column "test_models", "birthday", :datetime
           add_column "test_models", "favorite_day", :date
           add_column "test_models", "moment_of_truth", :datetime
           add_column "test_models", "male", :boolean
 
-          TestModel.create :first_name => 'bob', :last_name => 'bobsen',
-            :bio => "I was born ....", :age => 18, :height => 1.78,
-            :wealth => BigDecimal.new("12345678901234567890.0123456789"),
-            :birthday => 18.years.ago, :favorite_day => 10.days.ago,
-            :moment_of_truth => "1782-10-10 21:40:18", :male => true
+          TestModel.create first_name: "bob", last_name: "bobsen",
+            bio: "I was born ....", age: 18, height: 1.78,
+            wealth: BigDecimal("12345678901234567890.0123456789"),
+            birthday: 18.years.ago, favorite_day: 10.days.ago,
+            moment_of_truth: "1782-10-10 21:40:18", male: true
 
           bob = TestModel.first
-          assert_equal 'bob', bob.first_name
-          assert_equal 'bobsen', bob.last_name
+          assert_equal "bob", bob.first_name
+          assert_equal "bobsen", bob.last_name
           assert_equal "I was born ....", bob.bio
           assert_equal 18, bob.age
 
           # Test for 30 significant digits (beyond the 16 of float), 10 of them
           # after the decimal place.
 
-          assert_equal BigDecimal.new("0012345678901234567890.0123456789"), bob.wealth
+          assert_equal BigDecimal("0012345678901234567890.0123456789"), bob.wealth
 
           assert_equal true, bob.male?
 
@@ -164,11 +176,9 @@ module ActiveRecord
 
       if current_adapter?(:Mysql2Adapter, :PostgreSQLAdapter)
         def test_out_of_range_limit_should_raise
-          assert_raise(ActiveRecordError) { add_column :test_models, :integer_too_big, :integer, :limit => 10 }
-
-          unless current_adapter?(:PostgreSQLAdapter)
-            assert_raise(ActiveRecordError) { add_column :test_models, :text_too_big, :integer, :limit => 0xfffffffff }
-          end
+          assert_raise(ArgumentError) { add_column :test_models, :integer_too_big, :integer, limit: 10 }
+          assert_raise(ArgumentError) { add_column :test_models, :text_too_big, :text, limit: 0xfffffffff }
+          assert_raise(ArgumentError) { add_column :test_models, :binary_too_big, :binary, limit: 0xfffffffff }
         end
       end
     end