activerecord-cockroachdb-adapter 8.0.2 → 8.1.0

data/test/cases/adapters/postgresql/serial_test.rb

@@ -0,0 +1,199 @@
+require "cases/helper_cockroachdb"
+
+# Load dependencies from ActiveRecord test suite
+require "support/schema_dumping_helper"
+
+module CockroachDB
+  class PostgresqlSerialTest < ActiveRecord::PostgreSQLTestCase
+    include SchemaDumpingHelper
+
+    class PostgresqlSerial < ActiveRecord::Base; end
+
+    setup do
+      @connection = ActiveRecord::Base.lease_connection
+      @connection.create_table "postgresql_serials", force: true do |t|
+        t.serial :seq
+
+        # Instead of creating this column with a sequence default, we'll create
+        # it with a unique_rowid() default. This better matches the behavior in
+        # CockroachDB.
+        t.integer :serials_id, default: -> { "unique_rowid()" }
+      end
+    end
+
+    teardown do
+      @connection.drop_table "postgresql_serials", if_exists: true
+    end
+
+    # This replaces the same test that's been excluded from
+    # PostgresqlSerialTest. The column's type is integer, but it's sql_type is
+    # bigint because CockroachDB's integers are bigints.
+    # See test/excludes/PostgresqlSerialTest.rb
+    def test_serial_column
+      column = PostgresqlSerial.columns_hash["seq"]
+      assert_equal :integer, column.type
+      assert_equal "bigint", column.sql_type
+      assert_predicate column, :serial?
+    end
+
+    # This replaces the same test that's been excluded from
+    # PostgresqlSerialTest. The column's type is integer, but it's sql_type is
+    # bigint because CockroachDB's integers are bigints. The column is also
+    # serial? because it uses the same default function that serial columns use.
+    # See test/excludes/PostgresqlSerialTest.rb
+    def test_not_serial_column
+      column = PostgresqlSerial.columns_hash["serials_id"]
+      assert_equal :integer, column.type
+      assert_equal "bigint", column.sql_type
+      assert_predicate column, :serial?
+    end
+
+    # This replaces the same test that's been excluded from
+    # PostgresqlSerialTest. Although the seq column was created as a serial
+    # column, the dump will include it as a bigserial column. That's because
+    # serial columns are backed by integer columns, and integer columns are
+    # bigints in CockroachDB.
+    # See test/excludes/PostgresqlSerialTest.rb
+    def test_schema_dump_with_shorthand
+      output = dump_table_schema "postgresql_serials"
+      assert_match %r{t\.bigserial\s+"seq",\s+null: false$}, output
+    end
+
+    # This replaces the same test that's been excluded from
+    # PostgresqlSerialTest. The serials_id column wasn't created as a serial
+    # column, but the dump will include it as such because it has the same
+    # default function has a serial column.
+    # See test/excludes/PostgresqlSerialTest.rb
+    def test_schema_dump_with_not_serial
+      output = dump_table_schema "postgresql_serials"
+      assert_match %r{t\.bigserial\s+"serials_id"$}, output
+    end
+  end
+
+  class PostgresqlBigSerialTest < ActiveRecord::PostgreSQLTestCase
+    include SchemaDumpingHelper
+
+    class PostgresqlBigSerial < ActiveRecord::Base; end
+
+    setup do
+      @connection = ActiveRecord::Base.lease_connection
+      @connection.create_table "postgresql_big_serials", force: true do |t|
+        t.bigserial :seq
+
+        # Instead of creating this column with a sequence default, we'll create
+        # it with a unique_rowid() default. This better matches the behavior in
+        # CockroachDB.
+        t.bigint :serials_id, default: -> { "unique_rowid()" }
+      end
+    end
+
+    teardown do
+      @connection.drop_table "postgresql_big_serials", if_exists: true
+    end
+
+    # This replaces the same test that's been excluded from
+    # PostgresqlBigSerialTest. We can run it here because the setup has been
+    # fixed.
+    # See test/excluded/PostgresqlBigSerialTest.rb
+    def test_bigserial_column
+      column = PostgresqlBigSerial.columns_hash["seq"]
+      assert_equal :integer, column.type
+      assert_equal "bigint", column.sql_type
+      assert_predicate column, :serial?
+    end
+
+    # This replaces the same test that's been excluded from
+    # PostgresqlBigSerialTest. The column is serial? because it uses the same
+    # default function that serial columns use.
+    # See test/excludes/PostgresqlBigSerialTest.rb
+    def test_not_bigserial_column
+      column = PostgresqlBigSerial.columns_hash["serials_id"]
+      assert_equal :integer, column.type
+      assert_equal "bigint", column.sql_type
+      assert_predicate column, :serial?
+    end
+
+    # This replaces the same test that's been excluded from
+    # PostgresqlBigSerialTest. We can run it here because the setup has been
+    # fixed.
+    # See test/excluded/PostgresqlBigSerialTest.rb
+    def test_schema_dump_with_shorthand
+      output = dump_table_schema "postgresql_big_serials"
+      assert_match %r{t\.bigserial\s+"seq",\s+null: false$}, output
+    end
+
+    # This replaces the same test that's been excluded from
+    # PostgresqlBigSerialTest. The serials_id column wasn't created as a serial
+    # column, but the dump will include it as such because it has the same
+    # default function has a serial column.
+    # See test/excluded/PostgresqlBigSerialTest.rb
+    def test_schema_dump_with_not_bigserial
+      output = dump_table_schema "postgresql_big_serials"
+      assert_match %r{t\.bigserial\s+"serials_id"$}, output
+    end
+  end
+
+  module SequenceNameDetectionTestCases
+    class CollidedSequenceNameTest < ActiveRecord::PostgreSQLTestCase
+      include SchemaDumpingHelper
+
+      def setup
+        @connection = ActiveRecord::Base.lease_connection
+        @connection.create_table :foo_bar, force: true do |t|
+          t.serial :baz_id
+        end
+        @connection.create_table :foo, force: true do |t|
+          t.serial :bar_id
+          t.bigserial :bar_baz_id
+        end
+      end
+
+      def teardown
+        @connection.drop_table :foo_bar, if_exists: true
+        @connection.drop_table :foo, if_exists: true
+      end
+
+      # This replaces the same test that's been excluded from
+      # SequenceNameDetectionTestCases::CollidedSequenceNameTest. Although
+      # bar_id was created as a serial column, it will get dumped as a bigserial
+      # column. Serial columns are backed by integer columns, and integer
+      # columns are bigints in CockroachDB.
+      # See test/excludes/SequenceNameDetectionTestCases/CollidedSequenceNameTest.rb
+      def test_schema_dump_with_collided_sequence_name
+        output = dump_table_schema "foo"
+        assert_match %r{t\.bigserial\s+"bar_id",\s+null: false$}, output
+        assert_match %r{t\.bigserial\s+"bar_baz_id",\s+null: false$}, output
+      end
+    end
+
+    class LongerSequenceNameDetectionTest < ActiveRecord::PostgreSQLTestCase
+      include SchemaDumpingHelper
+
+      def setup
+        @table_name = "long_table_name_to_test_sequence_name_detection_for_serial_cols"
+        @connection = ActiveRecord::Base.lease_connection
+        @connection.create_table @table_name, force: true do |t|
+          t.serial :seq
+          t.bigserial :bigseq
+        end
+      end
+
+      def teardown
+        @connection.drop_table @table_name, if_exists: true
+      end
+
+      # This replaces the same test that's been excluded from
+      # SequenceNameDetectionTestCases::LongerSequenceNameDetectionTest.
+      # Although seq was created as a serial column, it will get dumped as a bigserial
+      # column. Serial columns are backed by integer columns, and integer
+      # columns are bigints in CockroachDB.
+      # See test/excludes/SequenceNameDetectionTestCases/LongerSequenceNameDetectionTest.rb
+      def test_schema_dump_with_long_table_name
+        output = dump_table_schema @table_name
+        assert_match %r{create_table "#{@table_name}", force: :cascade}, output
+        assert_match %r{t\.bigserial\s+"seq",\s+null: false$}, output
+        assert_match %r{t\.bigserial\s+"bigseq",\s+null: false$}, output
+      end
+    end
+  end
+end

data/test/cases/adapters/postgresql/spatial_queries_test.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'cases/helper_cockroachdb'
+require 'models/building'
+
+class SpatialQueriesTest < ActiveSupport::TestCase
+  def setup
+    Building.delete_all
+  end
+
+  def test_query_point
+    obj = Building.create!(coordinates: factory.point(1, 2))
+    id = obj.id
+    assert_empty Building.where(coordinates: factory.point(2, 2))
+    obj1 = Building.find_by(coordinates: factory.point(1, 2))
+    refute_nil(obj1)
+    assert_equal id, obj1.id
+  end
+
+  def test_query_multi_point
+    obj = Building.create!(points: factory.multi_point([factory.point(1, 2)]))
+    id = obj.id
+    obj2 = Building.find_by(points: factory.multi_point([factory.point(1, 2)]))
+    refute_nil(obj2)
+    assert_equal(id, obj2.id)
+  end
+
+  def test_query_point_wkt
+    obj = Building.create!(coordinates: factory.point(1, 2))
+    id = obj.id
+    obj2 = Building.find_by(coordinates: 'SRID=3857;POINT(1 2)')
+    refute_nil(obj2)
+    assert_equal(id, obj2.id)
+    obj3 = Building.find_by(coordinates: 'SRID=3857;POINT(2 2)')
+    assert_nil(obj3)
+  end
+
+  def test_query_st_distance
+    obj = Building.create!(coordinates: factory.point(1, 2))
+    id = obj.id
+    obj2 = Building.find_by(Building.arel_table[:coordinates].st_distance('SRID=3857;POINT(2 3)').lt(2))
+    refute_nil(obj2)
+    assert_equal(id, obj2.id)
+    obj3 = Building.find_by(Building.arel_table[:coordinates].st_distance('SRID=3857;POINT(2 3)').gt(2))
+    assert_nil(obj3)
+  end
+
+  def test_query_st_distance_from_constant
+    obj = Building.create!(coordinates: factory.point(1, 2))
+    id = obj.id
+
+    query_point = parser.parse('SRID=3857;POINT(2 3)')
+    obj2 = Building.find_by(Arel.spatial(query_point).st_distance(Building.arel_table[:coordinates]).lt(2))
+    refute_nil(obj2)
+    assert_equal(id, obj2.id)
+    obj3 = Building.find_by(Arel.spatial(query_point).st_distance(Building.arel_table[:coordinates]).gt(2))
+    assert_nil(obj3)
+  end
+
+  def test_query_st_length
+    obj = Building.new
+    obj.path = factory.line(factory.point(1.0, 2.0), factory.point(3.0, 2.0))
+    obj.save!
+    id = obj.id
+    obj2 = Building.find_by(Building.arel_table[:path].st_length.eq(2))
+    refute_nil(obj2)
+    assert_equal(id, obj2.id)
+    obj3 = Building.find_by(Building.arel_table[:path].st_length.gt(3))
+    assert_nil(obj3)
+  end
+
+  def test_query_rgeo_feature_node
+    obj = Building.new
+    obj.path = factory.line_string([factory.point(1.0, 2.0),
+                                    factory.point(2.0, 2.0), factory.point(3.0, 2.0)])
+    obj.save!
+    id = obj.id
+
+    query_point = factory.point(2.0, 2.0)
+    obj2 = Building.find_by(Building.arel_table[:path].st_contains(query_point))
+    assert_equal(id, obj2.id)
+
+    query_point = factory.point(0.0, 2.0)
+    obj3 = Building.find_by(Building.arel_table[:path].st_contains(query_point))
+    assert_nil(obj3)
+  end
+
+  def test_query_rgeo_bbox_node
+    obj = Building.new
+    obj.coordinates = factory.point(1, 2)
+    obj.save!
+    id = obj.id
+
+    pt1 = factory.point(-1, -1)
+    pt2 = factory.point(4, 4)
+    bbox = RGeo::Cartesian::BoundingBox.create_from_points(pt1, pt2)
+    obj2 = Building.find_by(Building.arel_table[:coordinates].st_within(bbox))
+    assert_equal(id, obj2.id)
+  end
+
+  def test_ewkt_parser_query
+    obj = Building.create!(coordinates: factory.point(1, 2))
+    id = obj.id
+
+    query_point = parser.parse('SRID=3857;POINT(2 3)')
+    obj2 = Building.find_by(Arel.spatial(query_point).st_distance(Building.arel_table[:coordinates]).lt(2))
+    refute_nil(obj2)
+    assert_equal(id, obj2.id)
+    obj3 = Building.find_by(Arel.spatial(query_point).st_distance(Building.arel_table[:coordinates]).gt(2))
+    assert_nil(obj3)
+  end
+
+  private
+
+  def parser
+    RGeo::WKRep::WKTParser.new(nil, support_ewkt: true)
+  end
+end

data/test/cases/adapters/postgresql/spatial_setup_test.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'cases/helper_cockroachdb'
+
+class SpatialSetupTest < ActiveRecord::PostgreSQLTestCase
+  def test_ignore_tables
+    expect_to_ignore = %w[
+      geography_columns
+      geometry_columns
+      layer
+      raster_columns
+      raster_overviews
+      spatial_ref_sys
+      topology
+    ]
+    assert_equal expect_to_ignore, ::ActiveRecord::SchemaDumper.ignore_tables
+  end
+end

data/test/cases/adapters/postgresql/spatial_type_test.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'cases/helper_cockroachdb'
+
+class SpatialTypeTest < ActiveRecord::PostgreSQLTestCase
+  def test_parse_simple_type
+    assert_equal ['geometry', 0, false, false], spatial.parse_sql_type('geometry')
+    assert_equal ['geography', 0, false, false], spatial.parse_sql_type('geography')
+  end
+
+  def test_parse_geo_type
+    assert_equal ['Point', 0, false, false], spatial.parse_sql_type('geography(Point)')
+    assert_equal ['Point', 0, false, true], spatial.parse_sql_type('geography(PointM)')
+    assert_equal ['Point', 0, true, false], spatial.parse_sql_type('geography(PointZ)')
+    assert_equal ['Point', 0, true, true], spatial.parse_sql_type('geography(PointZM)')
+    assert_equal ['Polygon', 0, false, false], spatial.parse_sql_type('geography(Polygon)')
+    assert_equal ['Polygon', 0, true, false], spatial.parse_sql_type('geography(PolygonZ)')
+    assert_equal ['Polygon', 0, false, true], spatial.parse_sql_type('geography(PolygonM)')
+    assert_equal ['Polygon', 0, true, true], spatial.parse_sql_type('geography(PolygonZM)')
+  end
+
+  def test_parse_type_with_srid
+    assert_equal ['Point', 4326, false, false], spatial.parse_sql_type('geography(Point,4326)')
+    assert_equal ['Polygon', 4327, true, false], spatial.parse_sql_type('geography(PolygonZ,4327)')
+    assert_equal ['Point', 4328, false, true], spatial.parse_sql_type('geography(PointM,4328)')
+    assert_equal ['Point', 4329, true, true], spatial.parse_sql_type('geography(PointZM,4329)')
+    assert_equal ['MultiPolygon', 4326, false, false], spatial.parse_sql_type('geometry(MultiPolygon,4326)')
+  end
+
+  def test_parse_non_geo_types
+    assert_equal ['x', 0, false, false], spatial.parse_sql_type('x')
+    assert_equal ['foo', 0, false, false], spatial.parse_sql_type('foo')
+    assert_equal ['foo(A,1234)', 0, false, false], spatial.parse_sql_type('foo(A,1234)')
+  end
+
+  private
+
+  def spatial
+    ActiveRecord::ConnectionAdapters::CockroachDB::OID::Spatial
+  end
+end

data/test/cases/adapters/postgresql/timestamp_test.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "cases/helper_cockroachdb"
+require "models/developer"
+require "models/topic"
+
+module CockroachDB
+  class PostgresqlTimestampMigrationTest < ActiveRecord::PostgreSQLTestCase
+    self.use_transactional_tests = false
+
+    class PostgresqlTimestampWithZone < ActiveRecord::Base; end
+
+    def test_adds_column_as_timestamp
+      original, $stdout = $stdout, StringIO.new
+
+      ActiveRecord::Migration.new.add_column :postgresql_timestamp_with_zones, :times, :datetime
+
+      assert_equal({ "data_type" => "timestamp without time zone" },
+                  PostgresqlTimestampWithZone.lease_connection.execute("select data_type from information_schema.columns where column_name = 'times'").to_a.first)
+    ensure
+      ActiveRecord::Migration.new.remove_column :postgresql_timestamp_with_zones, :times, if_exists: true
+      $stdout = original
+    end
+
+    def test_adds_column_as_timestamptz_if_datetime_type_changed
+      original, $stdout = $stdout, StringIO.new
+
+      with_cockroachdb_datetime_type(:timestamptz) do
+        ActiveRecord::Migration.new.add_column :postgresql_timestamp_with_zones, :times, :datetime
+
+        assert_equal({ "data_type" => "timestamp with time zone" },
+                    PostgresqlTimestampWithZone.lease_connection.execute("select data_type from information_schema.columns where column_name = 'times'").to_a.first)
+      end
+    ensure
+      ActiveRecord::Migration.new.remove_column :postgresql_timestamp_with_zones, :times, if_exists: true
+      $stdout = original
+    end
+
+    def test_adds_column_as_custom_type
+      original, $stdout = $stdout, StringIO.new
+
+      PostgresqlTimestampWithZone.lease_connection.execute("CREATE TYPE custom_time_format AS ENUM ('past', 'present', 'future');")
+
+      ActiveRecord::ConnectionAdapters::CockroachDBAdapter::NATIVE_DATABASE_TYPES[:datetimes_as_enum] = { name: "custom_time_format" }
+      with_cockroachdb_datetime_type(:datetimes_as_enum) do
+        ActiveRecord::Migration.new.add_column :postgresql_timestamp_with_zones, :times, :datetime, precision: nil
+
+        assert_equal({ "data_type" => "USER-DEFINED", "udt_name" => "custom_time_format" },
+                    PostgresqlTimestampWithZone.lease_connection.execute("select data_type, udt_name from information_schema.columns where column_name = 'times'").to_a.first)
+      end
+    ensure
+      ActiveRecord::ConnectionAdapters::CockroachDBAdapter::NATIVE_DATABASE_TYPES.delete(:datetimes_as_enum)
+      ActiveRecord::Migration.new.remove_column :postgresql_timestamp_with_zones, :times, if_exists: true
+      ActiveRecord::Base.lease_connection.execute("DROP TYPE IF EXISTS custom_time_format")
+      $stdout = original
+    end
+  end
+end

data/test/cases/adapters/postgresql/virtual_column_test.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+module CockroachDB
+  if ActiveRecord::Base.lease_connection.supports_virtual_columns?
+    class PostgresqlVirtualColumnTest < ActiveRecord::PostgreSQLTestCase
+      include SchemaDumpingHelper
+
+      self.use_transactional_tests = false
+
+      class VirtualColumn < ActiveRecord::Base
+      end
+
+      def setup
+        @connection = ActiveRecord::Base.lease_connection
+        @connection.create_table :virtual_columns, force: true do |t|
+          t.string  :name
+          t.virtual :upper_name,  type: :string,  as: "UPPER(name)", stored: true
+          t.virtual :name_length, type: :integer, as: "LENGTH(name)", stored: true
+          t.virtual :name_octet_length, type: :integer, as: "OCTET_LENGTH(name)", stored: true
+          t.integer :column1
+          t.virtual :column2, type: :integer, as: "column1 + 1", stored: true
+        end
+        VirtualColumn.create(name: "Rails")
+      end
+
+      # TODO: is this test result acceptable?
+      def test_schema_dumping
+        output = dump_table_schema("virtual_columns")
+        assert_match(/t\.virtual\s+"upper_name",\s+type: :string,\s+as: "upper\(name\)", stored: true$/i, output)
+        assert_match(/t\.virtual\s+"name_length",\s+type: :bigint,\s+as: "length\(name\)", stored: true$/i, output)
+        assert_match(/t\.virtual\s+"name_octet_length",\s+type: :bigint,\s+as: "octet_length\(name\)", stored: true$/i, output)
+        assert_match(/t\.virtual\s+"column2",\s+type: :bigint,\s+as: "column1 \+ 1", stored: true$/i, output)
+      end
+    end
+  end
+end

data/test/cases/associations/eager_load_nested_include_test.rb

@@ -0,0 +1,111 @@
+# This test has been copied to fix a bug in the test setup. It can be removed
+# once the bug has been fixed and released in Rails.
+# See test/excludes/EagerLoadPolyAssocsTest.rb
+
+require "cases/helper_cockroachdb"
+
+# Load dependencies from ActiveRecord test suite
+require "models/post"
+require "models/tag"
+require "models/author"
+require "models/comment"
+require "models/category"
+require "models/categorization"
+require "models/tagging"
+
+module CockroachDB
+  module Remembered
+    extend ActiveSupport::Concern
+
+    included do
+      after_create :remember
+    private
+      def remember; self.class.remembered << self; end
+    end
+
+    module ClassMethods
+      # The test setup bug is fixed here. @@remembered was being shared by every
+      # class that included the Remembered module. Instead, we can use
+      # @remembered which will be unique to each included class.
+      def remembered; @remembered ||= []; end
+      def sample; remembered.sample; end
+    end
+  end
+
+  class ShapeExpression < ActiveRecord::Base
+    belongs_to :shape, polymorphic: true
+    belongs_to :paint, polymorphic: true
+  end
+
+  class Circle < ActiveRecord::Base
+    has_many :shape_expressions, as: :shape
+    include Remembered
+  end
+  class Square < ActiveRecord::Base
+    has_many :shape_expressions, as: :shape
+    include Remembered
+  end
+  class Triangle < ActiveRecord::Base
+    has_many :shape_expressions, as: :shape
+    include Remembered
+  end
+  class PaintColor < ActiveRecord::Base
+    has_many   :shape_expressions, as: :paint
+    belongs_to :non_poly, foreign_key: "non_poly_one_id", class_name: "NonPolyOne"
+    include Remembered
+  end
+  class PaintTexture < ActiveRecord::Base
+    has_many   :shape_expressions, as: :paint
+    belongs_to :non_poly, foreign_key: "non_poly_two_id", class_name: "NonPolyTwo"
+    include Remembered
+  end
+  class NonPolyOne < ActiveRecord::Base
+    has_many :paint_colors
+    include Remembered
+  end
+  class NonPolyTwo < ActiveRecord::Base
+    has_many :paint_textures
+    include Remembered
+  end
+
+  class EagerLoadPolyAssocsTest < ActiveRecord::TestCase
+    NUM_SIMPLE_OBJS = 50
+    NUM_SHAPE_EXPRESSIONS = 100
+
+    def setup
+      generate_test_object_graphs
+    end
+
+    teardown do
+      [Circle, Square, Triangle, PaintColor, PaintTexture,
+       ShapeExpression, NonPolyOne, NonPolyTwo].each(&:delete_all)
+    end
+
+    def generate_test_object_graphs
+      1.upto(NUM_SIMPLE_OBJS) do
+        [Circle, Square, Triangle, NonPolyOne, NonPolyTwo].map(&:create!)
+      end
+      1.upto(NUM_SIMPLE_OBJS) do
+        PaintColor.create!(non_poly_one_id: NonPolyOne.sample.id)
+        PaintTexture.create!(non_poly_two_id: NonPolyTwo.sample.id)
+      end
+      1.upto(NUM_SHAPE_EXPRESSIONS) do
+        shape_type = [Circle, Square, Triangle].sample
+        paint_type = [PaintColor, PaintTexture].sample
+        ShapeExpression.create!(shape_type: shape_type.to_s, shape_id: shape_type.sample.id,
+                                paint_type: paint_type.to_s, paint_id: paint_type.sample.id)
+      end
+    end
+
+    def test_include_query
+      res = ShapeExpression.all.merge!(includes: [ :shape, { paint: :non_poly } ]).to_a
+      assert_equal NUM_SHAPE_EXPRESSIONS, res.size
+      assert_queries_count(0) do
+        res.each do |se|
+          assert_not_nil se.paint.non_poly, "this is the association that was loading incorrectly before the change"
+          assert_not_nil se.shape, "just making sure other associations still work"
+        end
+      end
+    end
+  end
+end

data/test/cases/associations/left_outer_join_association_test.rb

@@ -0,0 +1,30 @@
+require "cases/helper_cockroachdb"
+
+# Load dependencies from ActiveRecord test suite
+require "models/post"
+require "models/author"
+
+module CockroachDB
+  class LeftOuterJoinAssociationTest < ActiveRecord::TestCase
+    fixtures :author_addresses, :authors, :posts
+
+    # This replaces the same test that's been excluded from
+    # LeftOuterJoinAssociationTest. The query has been updated to guarantee the
+    # result order.
+    # See test/excludes/LeftOuterJoinAssociationTest.rb
+    def test_construct_finder_sql_applies_aliases_tables_on_association_conditions
+      result = Author.left_outer_joins(:thinking_posts, :welcome_posts).order(:id).to_a
+      assert_equal authors(:david), result.first
+    end
+
+    # This replaces the same test that's been excluded from
+    # LeftOuterJoinAssociationTest. The select query has been updated so the
+    # integer columns are casted to strings for concatenation.
+    # See test/excludes/LeftOuterJoinAssociationTest.rb
+    def test_does_not_override_select
+      authors = Author.select("authors.name, #{%{(authors.author_address_id::STRING || ' ' || authors.author_address_extra_id::STRING) as addr_id}}").left_outer_joins(:posts)
+      assert_predicate authors, :any?
+      assert_respond_to authors.first, :addr_id
+    end
+  end
+end