ibm_db 5.2.0 → 5.3.1

data/test/cases/adapters/sqlite3/sqlite3_create_folder_test.rb

@@ -1,22 +1,22 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'models/owner'
+require "models/owner"
 
 module ActiveRecord
   module ConnectionAdapters
     class SQLite3CreateFolder < ActiveRecord::SQLite3TestCase
       def test_sqlite_creates_directory
         Dir.mktmpdir do |dir|
-          begin
-            dir = Pathname.new(dir)
-            @conn = Base.sqlite3_connection :database => dir.join("db/foo.sqlite3"),
-                                 :adapter => 'sqlite3',
-                                 :timeout => 100
+          dir = Pathname.new(dir)
+          @conn = Base.sqlite3_connection database: dir.join("db/foo.sqlite3"),
+                               adapter: "sqlite3",
+                               timeout: 100
 
-            assert Dir.exist? dir.join('db')
-            assert File.exist? dir.join('db/foo.sqlite3')
-          ensure
-            @conn.disconnect! if @conn
-          end
+          assert Dir.exist? dir.join("db")
+          assert File.exist? dir.join("db/foo.sqlite3")
+        ensure
+          @conn.disconnect! if @conn
         end
       end
     end

data/test/cases/adapters/sqlite3/statement_pool_test.rb

@@ -1,20 +1,21 @@
-require 'cases/helper'
+# frozen_string_literal: true
+
+require "cases/helper"
 
 class SQLite3StatementPoolTest < ActiveRecord::SQLite3TestCase
   if Process.respond_to?(:fork)
     def test_cache_is_per_pid
-
       cache = ActiveRecord::ConnectionAdapters::SQLite3Adapter::StatementPool.new(10)
-      cache['foo'] = 'bar'
-      assert_equal 'bar', cache['foo']
+      cache["foo"] = "bar"
+      assert_equal "bar", cache["foo"]
 
       pid = fork {
-        lookup = cache['foo'];
+        lookup = cache["foo"]
         exit!(!lookup)
       }
 
       Process.waitpid pid
-      assert $?.success?, 'process should exit successfully'
+      assert $?.success?, "process should exit successfully"
     end
   end
 end

data/test/cases/adapters/sqlite3/transaction_test.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class SQLite3TransactionTest < ActiveRecord::SQLite3TestCase
+  test "shared_cached? is true when cache-mode is enabled" do
+    with_connection(flags: shared_cache_flags) do |conn|
+      assert_predicate(conn, :shared_cache?)
+    end
+  end
+
+  test "shared_cached? is false when cache-mode is disabled" do
+    flags = ::SQLite3::Constants::Open::READWRITE | SQLite3::Constants::Open::CREATE
+
+    with_connection(flags: flags) do |conn|
+      assert_not_predicate(conn, :shared_cache?)
+    end
+  end
+
+  test "raises when trying to open a transaction in a isolation level other than `read_uncommitted`" do
+    with_connection do |conn|
+      assert_raises(ActiveRecord::TransactionIsolationError) do
+        conn.transaction(requires_new: true, isolation: :something) do
+          conn.transaction_manager.materialize_transactions
+        end
+      end
+    end
+  end
+
+  test "raises when trying to open a read_uncommitted transaction but shared-cache mode is turned off" do
+    with_connection do |conn|
+      error = assert_raises(StandardError) do
+        conn.transaction(requires_new: true, isolation: :read_uncommitted) do
+          conn.transaction_manager.materialize_transactions
+        end
+      end
+
+      assert_match("You need to enable the shared-cache mode", error.message)
+    end
+  end
+
+  test "opens a `read_uncommitted` transaction" do
+    with_connection(flags: shared_cache_flags) do |conn1|
+      conn1.create_table(:zines) { |t| t.column(:title, :string) } if in_memory_db?
+      conn1.transaction do
+        conn1.transaction_manager.materialize_transactions
+        conn1.execute("INSERT INTO zines (title) VALUES ('foo')")
+
+        with_connection(flags: shared_cache_flags) do |conn2|
+          conn2.transaction(joinable: false, isolation: :read_uncommitted) do
+            assert_not_empty(conn2.execute("SELECT * FROM zines WHERE title = 'foo'"))
+          end
+        end
+
+        raise ActiveRecord::Rollback
+      end
+    end
+  end
+
+  test "reset the read_uncommitted PRAGMA when a transaction is rolled back" do
+    with_connection(flags: shared_cache_flags) do |conn|
+      conn.transaction(joinable: false, isolation: :read_uncommitted) do
+        assert_not(read_uncommitted?(conn))
+        conn.transaction_manager.materialize_transactions
+        assert(read_uncommitted?(conn))
+
+        raise ActiveRecord::Rollback
+      end
+
+      assert_not(read_uncommitted?(conn))
+    end
+  end
+
+  test "reset the read_uncommitted PRAGMA when a transaction is committed" do
+    with_connection(flags: shared_cache_flags) do |conn|
+      conn.transaction(joinable: false, isolation: :read_uncommitted) do
+        assert_not(read_uncommitted?(conn))
+        conn.transaction_manager.materialize_transactions
+        assert(read_uncommitted?(conn))
+      end
+
+      assert_not(read_uncommitted?(conn))
+    end
+  end
+
+  test "set the read_uncommitted PRAGMA to its previous value" do
+    with_connection(flags: shared_cache_flags) do |conn|
+      conn.transaction(joinable: false, isolation: :read_uncommitted) do
+        conn.instance_variable_get(:@connection).read_uncommitted = true
+        assert(read_uncommitted?(conn))
+        conn.transaction_manager.materialize_transactions
+        assert(read_uncommitted?(conn))
+      end
+
+      assert(read_uncommitted?(conn))
+    end
+  end
+
+  private
+    def read_uncommitted?(conn)
+      conn.instance_variable_get(:@connection).get_first_value("PRAGMA read_uncommitted") != 0
+    end
+
+    def shared_cache_flags
+      ::SQLite3::Constants::Open::READWRITE | SQLite3::Constants::Open::CREATE | ::SQLite3::Constants::Open::SHAREDCACHE
+    end
+
+    def with_connection(options = {})
+      options = options.dup
+      if in_memory_db?
+        options[:database] ||= "file::memory:"
+        options[:flags] = options[:flags].to_i | ::SQLite3::Constants::Open::URI | ::SQLite3::Constants::Open::READWRITE
+      else
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+        options[:database] ||= db_config.database
+      end
+      conn = ActiveRecord::Base.sqlite3_connection(options)
+
+      yield(conn)
+    ensure
+      conn.disconnect! if conn
+    end
+end

data/test/cases/aggregations_test.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'models/customer'
+require "models/customer"
 
 class AggregationsTest < ActiveRecord::TestCase
   fixtures :customers
@@ -25,7 +27,7 @@ class AggregationsTest < ActiveRecord::TestCase
 
   def test_immutable_value_objects
     customers(:david).balance = Money.new(100)
-    assert_raise(frozen_error_class) { customers(:david).balance.instance_eval { @amount = 20 } }
+    assert_raise(FrozenError) { customers(:david).balance.instance_eval { @amount = 20 } }
   end
 
   def test_inferred_mapping
@@ -51,17 +53,17 @@ class AggregationsTest < ActiveRecord::TestCase
 
     Customer.update_all("gps_location = '24x113'")
     customers(:david).reload
-    assert_equal '24x113', customers(:david)['gps_location']
+    assert_equal "24x113", customers(:david)["gps_location"]
 
-    assert_equal GpsLocation.new('24x113'), customers(:david).gps_location
+    assert_equal GpsLocation.new("24x113"), customers(:david).gps_location
   end
 
   def test_gps_equality
-    assert_equal GpsLocation.new('39x110'), GpsLocation.new('39x110')
+    assert_equal GpsLocation.new("39x110"), GpsLocation.new("39x110")
   end
 
   def test_gps_inequality
-    assert_not_equal GpsLocation.new('39x110'), GpsLocation.new('39x111')
+    assert_not_equal GpsLocation.new("39x110"), GpsLocation.new("39x111")
   end
 
   def test_allow_nil_gps_is_nil
@@ -102,7 +104,7 @@ class AggregationsTest < ActiveRecord::TestCase
   end
 
   def test_nil_assignment_results_in_nil
-    customers(:david).gps_location = GpsLocation.new('39x111')
+    customers(:david).gps_location = GpsLocation.new("39x111")
     assert_not_nil customers(:david).gps_location
     customers(:david).gps_location = nil
     assert_nil customers(:david).gps_location
@@ -129,13 +131,13 @@ class AggregationsTest < ActiveRecord::TestCase
   end
 
   def test_custom_constructor
-    assert_equal 'Barney GUMBLE', customers(:barney).fullname.to_s
+    assert_equal "Barney GUMBLE", customers(:barney).fullname.to_s
     assert_kind_of Fullname, customers(:barney).fullname
   end
 
   def test_custom_converter
-    customers(:barney).fullname = 'Barnoit Gumbleau'
-    assert_equal 'Barnoit GUMBLEAU', customers(:barney).fullname.to_s
+    customers(:barney).fullname = "Barnoit Gumbleau"
+    assert_equal "Barnoit GUMBLEAU", customers(:barney).fullname.to_s
     assert_kind_of Fullname, customers(:barney).fullname
   end
 
@@ -154,11 +156,11 @@ class OverridingAggregationsTest < ActiveRecord::TestCase
   class DifferentName; end
 
   class Person < ActiveRecord::Base
-    composed_of :composed_of, :mapping => %w(person_first_name first_name)
+    composed_of :composed_of, mapping: %w(person_first_name first_name)
   end
 
   class DifferentPerson < Person
-    composed_of :composed_of, :class_name => 'DifferentName', :mapping => %w(different_person_first_name first_name)
+    composed_of :composed_of, class_name: "DifferentName", mapping: %w(different_person_first_name first_name)
   end
 
   def test_composed_of_aggregation_redefinition_reflections_should_differ_and_not_inherited

data/test/cases/annotate_test.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+
+class AnnotateTest < ActiveRecord::TestCase
+  fixtures :posts
+
+  def test_annotate_wraps_content_in_an_inline_comment
+    quoted_posts_id, quoted_posts = regexp_escape_table_name("posts.id"), regexp_escape_table_name("posts")
+
+    assert_sql(%r{\ASELECT #{quoted_posts_id} FROM #{quoted_posts} /\* foo \*/}i) do
+      posts = Post.select(:id).annotate("foo")
+      assert posts.first
+    end
+  end
+
+  def test_annotate_is_sanitized
+    quoted_posts_id, quoted_posts = regexp_escape_table_name("posts.id"), regexp_escape_table_name("posts")
+
+    assert_sql(%r{\ASELECT #{quoted_posts_id} FROM #{quoted_posts} /\* foo \*/}i) do
+      posts = Post.select(:id).annotate("*/foo/*")
+      assert posts.first
+    end
+
+    assert_sql(%r{\ASELECT #{quoted_posts_id} FROM #{quoted_posts} /\* foo \*/}i) do
+      posts = Post.select(:id).annotate("**//foo//**")
+      assert posts.first
+    end
+
+    assert_sql(%r{\ASELECT #{quoted_posts_id} FROM #{quoted_posts} /\* foo \*/ /\* bar \*/}i) do
+      posts = Post.select(:id).annotate("*/foo/*").annotate("*/bar")
+      assert posts.first
+    end
+
+    assert_sql(%r{\ASELECT #{quoted_posts_id} FROM #{quoted_posts} /\* \+ MAX_EXECUTION_TIME\(1\) \*/}i) do
+      posts = Post.select(:id).annotate("+ MAX_EXECUTION_TIME(1)")
+      assert posts.first
+    end
+  end
+
+  private
+    def regexp_escape_table_name(name)
+      Regexp.escape(Post.connection.quote_table_name(name))
+    end
+end

data/test/cases/ar_schema_test.rb

@@ -1,126 +1,178 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
-if ActiveRecord::Base.connection.supports_migrations?
+class ActiveRecordSchemaTest < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+
+  setup do
+    @original_verbose = ActiveRecord::Migration.verbose
+    ActiveRecord::Migration.verbose = false
+    @connection = ActiveRecord::Base.connection
+    @schema_migration = @connection.schema_migration
+    @schema_migration.drop_table
+  end
+
+  teardown do
+    @connection.drop_table :fruits rescue nil
+    @connection.drop_table :nep_fruits rescue nil
+    @connection.drop_table :nep_schema_migrations rescue nil
+    @connection.drop_table :has_timestamps rescue nil
+    @connection.drop_table :multiple_indexes rescue nil
+    @schema_migration.delete_all rescue nil
+    ActiveRecord::Migration.verbose = @original_verbose
+  end
 
-  class ActiveRecordSchemaTest < ActiveRecord::TestCase
-    self.use_transactional_tests = false
+  def test_has_primary_key
+    old_primary_key_prefix_type = ActiveRecord::Base.primary_key_prefix_type
+    ActiveRecord::Base.primary_key_prefix_type = :table_name_with_underscore
+    assert_equal "version", @schema_migration.primary_key
 
-    setup do
-      @original_verbose = ActiveRecord::Migration.verbose
-      ActiveRecord::Migration.verbose = false
-      @connection = ActiveRecord::Base.connection
-      ActiveRecord::SchemaMigration.drop_table
+    @schema_migration.create_table
+    assert_difference "@schema_migration.count", 1 do
+      @schema_migration.create version: 12
     end
+  ensure
+    @schema_migration.drop_table
+    ActiveRecord::Base.primary_key_prefix_type = old_primary_key_prefix_type
+  end
 
-    teardown do
-      @connection.drop_table :fruits rescue nil
-      @connection.drop_table :nep_fruits rescue nil
-      @connection.drop_table :nep_schema_migrations rescue nil
-      @connection.drop_table :has_timestamps rescue nil
-      @connection.drop_table :multiple_indexes rescue nil
-      ActiveRecord::SchemaMigration.delete_all rescue nil
-      ActiveRecord::Migration.verbose = @original_verbose
+  def test_schema_define
+    ActiveRecord::Schema.define(version: 7) do
+      create_table :fruits do |t|
+        t.column :color, :string
+        t.column :fruit_size, :string  # NOTE: "size" is reserved in Oracle
+        t.column :texture, :string
+        t.column :flavor, :string
+      end
     end
 
-    def test_has_primary_key
-      old_primary_key_prefix_type = ActiveRecord::Base.primary_key_prefix_type
-      ActiveRecord::Base.primary_key_prefix_type = :table_name_with_underscore
-      assert_equal "version", ActiveRecord::SchemaMigration.primary_key
+    assert_nothing_raised { @connection.select_all "SELECT * FROM fruits" }
+    assert_nothing_raised { @connection.select_all "SELECT * FROM schema_migrations" }
+    assert_equal 7, @connection.migration_context.current_version
+  end
 
-      ActiveRecord::SchemaMigration.create_table
-      assert_difference "ActiveRecord::SchemaMigration.count", 1 do
-        ActiveRecord::SchemaMigration.create version: 12
+  def test_schema_define_with_table_name_prefix
+    old_table_name_prefix = ActiveRecord::Base.table_name_prefix
+    ActiveRecord::Base.table_name_prefix = "nep_"
+    @schema_migration.reset_table_name
+    ActiveRecord::InternalMetadata.reset_table_name
+    ActiveRecord::Schema.define(version: 7) do
+      create_table :fruits do |t|
+        t.column :color, :string
+        t.column :fruit_size, :string  # NOTE: "size" is reserved in Oracle
+        t.column :texture, :string
+        t.column :flavor, :string
       end
-    ensure
-      ActiveRecord::SchemaMigration.drop_table
-      ActiveRecord::Base.primary_key_prefix_type = old_primary_key_prefix_type
     end
+    assert_equal 7, @connection.migration_context.current_version
+  ensure
+    ActiveRecord::Base.table_name_prefix = old_table_name_prefix
+    @schema_migration.reset_table_name
+    ActiveRecord::InternalMetadata.reset_table_name
+  end
 
-    def test_schema_define
-      ActiveRecord::Schema.define(:version => 7) do
-        create_table :fruits do |t|
-          t.column :color, :string
-          t.column :fruit_size, :string  # NOTE: "size" is reserved in Oracle
-          t.column :texture, :string
-          t.column :flavor, :string
+  def test_schema_raises_an_error_for_invalid_column_type
+    assert_raise NoMethodError do
+      ActiveRecord::Schema.define(version: 8) do
+        create_table :vegetables do |t|
+          t.unknown :color
         end
       end
+    end
+  end
 
-      assert_nothing_raised { @connection.select_all "SELECT * FROM fruits" }
-      assert_nothing_raised { @connection.select_all "SELECT * FROM schema_migrations" }
-      assert_equal 7, ActiveRecord::Migrator::current_version
+  def test_schema_subclass
+    Class.new(ActiveRecord::Schema).define(version: 9) do
+      create_table :fruits
     end
+    assert_nothing_raised { @connection.select_all "SELECT * FROM fruits" }
+  end
 
-    def test_schema_define_w_table_name_prefix
-      table_name = ActiveRecord::SchemaMigration.table_name
-      old_table_name_prefix = ActiveRecord::Base.table_name_prefix
-      ActiveRecord::Base.table_name_prefix  = "nep_"
-      ActiveRecord::SchemaMigration.table_name = "nep_#{table_name}"
-      ActiveRecord::Schema.define(:version => 7) do
-        create_table :fruits do |t|
-          t.column :color, :string
-          t.column :fruit_size, :string  # NOTE: "size" is reserved in Oracle
-          t.column :texture, :string
-          t.column :flavor, :string
-        end
+  def test_normalize_version
+    assert_equal "118", @schema_migration.normalize_migration_number("0000118")
+    assert_equal "002", @schema_migration.normalize_migration_number("2")
+    assert_equal "017", @schema_migration.normalize_migration_number("0017")
+    assert_equal "20131219224947", @schema_migration.normalize_migration_number("20131219224947")
+  end
+
+  def test_schema_load_with_multiple_indexes_for_column_of_different_names
+    ActiveRecord::Schema.define do
+      create_table :multiple_indexes do |t|
+        t.string "foo"
+        t.index ["foo"], name: "multiple_indexes_foo_1"
+        t.index ["foo"], name: "multiple_indexes_foo_2"
       end
-      assert_equal 7, ActiveRecord::Migrator::current_version
-    ensure
-      ActiveRecord::Base.table_name_prefix  = old_table_name_prefix
-      ActiveRecord::SchemaMigration.table_name = table_name
     end
 
-    def test_schema_raises_an_error_for_invalid_column_type
-      assert_raise NoMethodError do
-        ActiveRecord::Schema.define(:version => 8) do
-          create_table :vegetables do |t|
-            t.unknown :color
-          end
-        end
+    indexes = @connection.indexes("multiple_indexes")
+
+    assert_equal 2, indexes.length
+    assert_equal ["multiple_indexes_foo_1", "multiple_indexes_foo_2"], indexes.collect(&:name).sort
+  end
+
+  def test_timestamps_without_null_set_null_to_false_on_create_table
+    ActiveRecord::Schema.define do
+      create_table :has_timestamps do |t|
+        t.timestamps
       end
     end
 
-    def test_schema_subclass
-      Class.new(ActiveRecord::Schema).define(:version => 9) do
-        create_table :fruits
+    assert @connection.column_exists?(:has_timestamps, :created_at, null: false)
+    assert @connection.column_exists?(:has_timestamps, :updated_at, null: false)
+  end
+
+  def test_timestamps_without_null_set_null_to_false_on_change_table
+    ActiveRecord::Schema.define do
+      create_table :has_timestamps
+
+      change_table :has_timestamps do |t|
+        t.timestamps default: Time.now
       end
-      assert_nothing_raised { @connection.select_all "SELECT * FROM fruits" }
     end
 
-    def test_normalize_version
-      assert_equal "118", ActiveRecord::SchemaMigration.normalize_migration_number("0000118")
-      assert_equal "002", ActiveRecord::SchemaMigration.normalize_migration_number("2")
-      assert_equal "017", ActiveRecord::SchemaMigration.normalize_migration_number("0017")
-      assert_equal "20131219224947", ActiveRecord::SchemaMigration.normalize_migration_number("20131219224947")
-    end
+    assert @connection.column_exists?(:has_timestamps, :created_at, null: false)
+    assert @connection.column_exists?(:has_timestamps, :updated_at, null: false)
+  end
 
-    def test_schema_load_with_multiple_indexes_for_column_of_different_names
+  if ActiveRecord::Base.connection.supports_bulk_alter?
+    def test_timestamps_without_null_set_null_to_false_on_change_table_with_bulk
       ActiveRecord::Schema.define do
-        create_table :multiple_indexes do |t|
-          t.string "foo"
-          t.index ["foo"], name: "multiple_indexes_foo_1"
-          t.index ["foo"], name: "multiple_indexes_foo_2"
+        create_table :has_timestamps
+
+        change_table :has_timestamps, bulk: true do |t|
+          t.timestamps default: Time.now
         end
       end
 
-      indexes = @connection.indexes("multiple_indexes")
+      assert @connection.column_exists?(:has_timestamps, :created_at, null: false)
+      assert @connection.column_exists?(:has_timestamps, :updated_at, null: false)
+    end
+  end
 
-      assert_equal 2, indexes.length
-      assert_equal ["multiple_indexes_foo_1", "multiple_indexes_foo_2"], indexes.collect(&:name).sort
+  def test_timestamps_without_null_set_null_to_false_on_add_timestamps
+    ActiveRecord::Schema.define do
+      create_table :has_timestamps
+      add_timestamps :has_timestamps, default: Time.now
     end
 
-    def test_timestamps_without_null_set_null_to_false_on_create_table
+    assert @connection.column_exists?(:has_timestamps, :created_at, null: false)
+    assert @connection.column_exists?(:has_timestamps, :updated_at, null: false)
+  end
+
+  if supports_datetime_with_precision?
+    def test_timestamps_sets_precision_on_create_table
       ActiveRecord::Schema.define do
         create_table :has_timestamps do |t|
           t.timestamps
         end
       end
 
-      assert !@connection.columns(:has_timestamps).find { |c| c.name == 'created_at' }.null
-      assert !@connection.columns(:has_timestamps).find { |c| c.name == 'updated_at' }.null
+      assert @connection.column_exists?(:has_timestamps, :created_at, precision: 6, null: false)
+      assert @connection.column_exists?(:has_timestamps, :updated_at, precision: 6, null: false)
     end
 
-    def test_timestamps_without_null_set_null_to_false_on_change_table
+    def test_timestamps_sets_precision_on_change_table
       ActiveRecord::Schema.define do
         create_table :has_timestamps
 
@@ -129,18 +181,33 @@ if ActiveRecord::Base.connection.supports_migrations?
         end
       end
 
-      assert !@connection.columns(:has_timestamps).find { |c| c.name == 'created_at' }.null
-      assert !@connection.columns(:has_timestamps).find { |c| c.name == 'updated_at' }.null
+      assert @connection.column_exists?(:has_timestamps, :created_at, precision: 6, null: false)
+      assert @connection.column_exists?(:has_timestamps, :updated_at, precision: 6, null: false)
+    end
+
+    if ActiveRecord::Base.connection.supports_bulk_alter?
+      def test_timestamps_sets_precision_on_change_table_with_bulk
+        ActiveRecord::Schema.define do
+          create_table :has_timestamps
+
+          change_table :has_timestamps, bulk: true do |t|
+            t.timestamps default: Time.now
+          end
+        end
+
+        assert @connection.column_exists?(:has_timestamps, :created_at, precision: 6, null: false)
+        assert @connection.column_exists?(:has_timestamps, :updated_at, precision: 6, null: false)
+      end
     end
 
-    def test_timestamps_without_null_set_null_to_false_on_add_timestamps
+    def test_timestamps_sets_precision_on_add_timestamps
       ActiveRecord::Schema.define do
         create_table :has_timestamps
         add_timestamps :has_timestamps, default: Time.now
       end
 
-      assert !@connection.columns(:has_timestamps).find { |c| c.name == 'created_at' }.null
-      assert !@connection.columns(:has_timestamps).find { |c| c.name == 'updated_at' }.null
+      assert @connection.column_exists?(:has_timestamps, :created_at, precision: 6, null: false)
+      assert @connection.column_exists?(:has_timestamps, :updated_at, precision: 6, null: false)
     end
   end
 end