activerecord-cockroachdb-adapter 5.2.3 → 6.0.0beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a28ccd96cddcfaf334a3a854f8312a754e11b3a610ce338e53465abc567dcd71
-  data.tar.gz: 37ea9e0cb5d202128a46fbeb97fce75a9ef6aa8ae8043fc2c1f11fc38ae01ff1
+  metadata.gz: a580dde40d074b1982c6642310513d79bbcb710032a476a64bb9fcb99bec72bb
+  data.tar.gz: 91b11b334235484e298704ae514d435a61451a02f3f759881141fd6354549ee4
 SHA512:
-  metadata.gz: 2a3a26fe9bbd9043bbbcd50b1c262cdc88bfded513b8f4d1fb2488d0a76cc9943c8201c082f6a6a5c65123801ad3fa10851ff708e771f3be9b07b53464ed4ae5
-  data.tar.gz: f5e123cce6d782b4427b4e97066cd874b9539a4a7de78d122ed46672326864bf4640aa3a9810b506f3bd307e6a1ff2fdf9447f2e215a391022350e023c41278d
+  metadata.gz: 77b98dff7d2069ba0cdcd78bccf5aedf9ac31192c0813d7893a5a6f1084537d9d0b03039be58fe83a5a0e0cd58d5d42ba567e43beee62507d8212242722fdb13
+  data.tar.gz: f1bf6e2fa1925d94133a98dcd03690a24da2631134cc6a5eb6dd860253392f398db88572942f409f13dec4d3d7aeb34f18317a5b8cd4b30c70e4d75d13599b47

data/README.md

@@ -7,7 +7,7 @@ CockroachDB adapter for ActiveRecord 4 and 5. This is a lightweight extension of
 Add this line to your project's Gemfile:
 
 ```ruby
-gem 'activerecord-cockroachdb-adapter', '~> 5.2'
+gem 'activerecord-cockroachdb-adapter', '~> 5.2.0'
 ```
 
 If you're using Rails 4.x, use the `0.1.x` versions of this gem.
@@ -21,303 +21,7 @@ development:
   host: <hostname>
   user: <username>
 ```
-## Configuration
 
-In addition to the standard adapter settings, CockroachDB also supports the following:
-
-- `disable_cockroachdb_telemetry`: Determines if a telemetry call is made to the database when the connection pool is initialized. Setting this to `true` will prevent the call from being made.
-
-## Working with Spatial Data
-
-The adapter uses [RGeo](https://github.com/rgeo/rgeo) and [RGeo-ActiveRecord](https://github.com/rgeo/rgeo-activerecord) to represent geometric and geographic data as Ruby objects and easily interface them with the adapter. The following is a brief introduction to RGeo and tips to help setup your spatial application. More documentation about RGeo can be found in the [YARD Docs](https://rubydoc.info/github/rgeo/rgeo) and [wiki](https://github.com/rgeo/rgeo/wiki).
-
-### Installing RGeo
-
-RGeo can be installed with the following command:
-
-```sh
-gem install rgeo
-```
-
-The best way to use RGeo is with GEOS support. If you have a version of libgeos installed, you can check that it was properly linked with RGeo by running the following commands:
-
-```rb
-require 'rgeo'
-
-RGeo::Geos.supported?
-#=> true
-```
-
-If this is `false`, you may need to specify the GEOS directory while installing. Here's an example linking it to the CockroachDB GEOS binary.
-
-```sh
-gem install rgeo -- --with-geos-dir=/path/to/cockroach/lib/
-```
-
-### Working with RGeo
-
-RGeo uses [factories](https://en.wikipedia.org/wiki/Factory_(object-oriented_programming)) to create geometry objects and define their properties. Different factories define their own implementations for standard methods. For instance, the `RGeo::Geographic.spherical_factory` accepts latitudes and longitues as its coordinates and does computations on a spherical surface, while `RGeo::Cartesian.factory` implements geometry objects on a plane.
-
-The factory (or factories) you choose to use will depend on the requirements of your application and what you need to do with the geometries they produce. For example, if you are working with points or other simple geometries across long distances and need precise results, the spherical factory is a good choice. If you're working with polygons or multipolygons and analyzing complex relationships between them (`intersects?`, `difference`, etc.), then using a cartesian factory backed by GEOS is a much better option.
-
-Once you've selected a factory, you need to create objects. RGeo supports geometry creation through standard constructors (`point`, `line_string`, `polygon`, etc.) or by WKT and WKB.
-
-```rb
-require 'rgeo'
-factory = RGeo::Cartesian.factory(srid: 3857)
-
-# Create a line_string from points
-pt1 = factory.point(0,0)
-pt2 = factory.point(1,1)
-pt3 = factory.point(2,2)
-line_string = factory.line_string([pt1,pt2,pt3])
-
-p line_string.length
-#=> 2.8284271247461903
-
-# check line_string equality
-line_string2 = factory.parse_wkt("LINESTRING (0 0, 1 1, 2 2)")
-p line_string == line_string2
-#=> true
-
-# create polygon and test intersection with line_string
-pt4 = factory.point(0,2)
-outer_ring = factory.linear_ring([pt1,pt2,pt3,pt4,pt1])
-poly = factory.polygon(outer_ring)
-
-p line_string.intersects? poly
-#=> true
-```
-### Creating Spatial Tables
-
-To store spatial data, you must create a column with a spatial type. PostGIS
-provides a variety of spatial types, including point, linestring, polygon, and
-different kinds of collections. These types are defined in a standard produced
-by the Open Geospatial Consortium. You can specify options indicating the coordinate system and number of coordinates for the values you are storing.
-
-The adapter extends ActiveRecord's migration syntax to
-support these spatial types. The following example creates five spatial
-columns in a table:
-
-```rb
-create_table :my_spatial_table do |t|
-  t.column :shape1, :geometry
-  t.geometry :shape2
-  t.line_string :path, srid: 3857
-  t.st_point :lonlat, geographic: true
-  t.st_point :lonlatheight, geographic: true, has_z: true
-end
-```
-
-The first column, "shape1", is created with type "geometry". This is a general
-"base class" for spatial types; the column declares that it can contain values
-of _any_ spatial type.
-
-The second column, "shape2", uses a shorthand syntax for the same type as the shape1 column.
-You can create a column either by invoking `column` or invoking the name of the type directly.
-
-The third column, "path", has a specific geometric type, `line_string`. It
-also specifies an SRID (spatial reference ID) that indicates which coordinate
-system it expects the data to be in. The column now has a "constraint" on it;
-it will accept only LineString data, and only data whose SRID is 3857.
-
-The fourth column, "lonlat", has the `st_point` type, and accepts only Point
-data. Furthermore, it declares the column as "geographic", which means it
-accepts longitude/latitude data, and performs calculations such as distances
-using a spheroidal domain.
-
-The fifth column, "lonlatheight", is a geographic (longitude/latitude) point
-that also includes a third "z" coordinate that can be used to store height
-information.
-
-The following are the data types understood by PostGIS and exposed by
-the adapter:
-
-- `:geometry` -- Any geometric type
-- `:st_point` -- Point data
-- `:line_string` -- LineString data
-- `:st_polygon` -- Polygon data
-- `:geometry_collection` -- Any collection type
-- `:multi_point` -- A collection of Points
-- `:multi_line_string` -- A collection of LineStrings
-- `:multi_polygon` -- A collection of Polygons
-
-Following are the options understood by the adapter:
-
-- `:geographic` -- If set to true, create a PostGIS geography column for
-  longitude/latitude data over a spheroidal domain; otherwise create a
-  geometry column in a flat coordinate system. Default is false. Also
-  implies :srid set to 4326.
-- `:srid` -- Set a SRID constraint for the column. Default is 4326 for a
-  geography column, or 0 for a geometry column. Note that PostGIS currently
-  (as of version 2.0) requires geography columns to have SRID 4326, so this
-  constraint is of limited use for geography columns.
-- `:has_z` -- Specify that objects in this column include a Z coordinate.
-  Default is false.
-- `:has_m` -- Specify that objects in this column include an M coordinate.
-  Default is false.
-
-To create a PostGIS spatial index, add `using: :gist` to your index:
-
-```rb
-add_index :my_table, :lonlat, using: :gist
-
-# or
-
-change_table :my_table do |t|
-  t.index :lonlat, using: :gist
-end
-```
-### Configuring ActiveRecord
-
-ActiveRecord's usefulness stems from the way it automatically configures
-classes based on the database structure and schema. If a column in the
-database has an integer type, ActiveRecord automatically casts the data to a
-Ruby Integer. In the same way, the adapter automatically
-casts spatial data to a corresponding RGeo data type.
-
-RGeo offers more flexibility in its type system than can be
-interpreted solely from analyzing the database column. For example, you can
-configure RGeo objects to exhibit certain behaviors related to their
-serialization, validation, coordinate system, or computation. These settings
-are embodied in the RGeo factory associated with the object.
-
-You can configure the adapter to use a particular factory (i.e. a
-particular combination of settings) for data associated with each type in
-the database.
-
-Here's an example using a Geos default factory:
-
-```ruby
-RGeo::ActiveRecord::SpatialFactoryStore.instance.tap do |config|
-  # By default, use the GEOS implementation for spatial columns.
-  config.default = RGeo::Geos.factory_generator
-
-  # But use a geographic implementation for point columns.
-  config.register(RGeo::Geographic.spherical_factory(srid: 4326), geo_type: "point")
-end
-```
-
-The default spatial factory for geographic columns is `RGeo::Geographic.spherical_factory`.
-The default spatial factory for cartesian columns is `RGeo::Cartesian.preferred_factory`.
-You do not need to configure the `SpatialFactoryStore` if these defaults are ok.
-
-More information about configuration options for the `SpatialFactoryStore` can be found in the [rgeo-activerecord](https://github.com/rgeo/rgeo-activerecord#spatial-factories-for-columns) docs.
-
-### Reading and Writing Spatial Columns
-
-When you access a spatial attribute on your ActiveRecord model, it is given to
-you as an RGeo geometry object (or nil, for attributes that allow null
-values). You can then call the RGeo api on the object. For example, consider
-the MySpatialTable class we worked with above:
-
-```rb
-record = MySpatialTable.find(1)
-point = record.lonlat                  # Returns an RGeo::Feature::Point
-p point.x                              # displays the x coordinate
-p point.geometry_type.type_name        # displays "Point"
-```
-
-The RGeo factory for the value is determined by how you configured the
-ActiveRecord class, as described above. In this case, we explicitly set a
-spherical factory for the `:lonlat` column:
-
-```rb
-factory = point.factory                # returns a spherical factory
-```
-
-You can set a spatial attribute by providing an RGeo geometry object, or by
-providing the WKT string representation of the geometry. If a string is
-provided, the adapter will attempt to parse it as WKT and
-set the value accordingly.
-
-```rb
-record.lonlat = 'POINT(-122 47)'  # sets the value to the given point
-```
-
-If the WKT parsing fails, the value currently will be silently set to nil. In
-the future, however, this will raise an exception.
-
-```rb
-record.lonlat = 'POINT(x)'         # sets the value to nil
-```
-
-If you set the value to an RGeo object, the factory needs to match the factory
-for the attribute. If the factories do not match, the adapter
-will attempt to cast the value to the correct factory.
-
-```rb
-p2 = factory.point(-122, 47)       # p2 is a point in a spherical factory
-record.lonlat = p2                 # sets the value to the given point
-record.shape1 = p2                 # shape1 uses a flat geos factory, so it
-                                   # will cast p2 into that coordinate system
-                                   # before setting the value
-record.save
-```
-
-If you attempt to set the value to the wrong type, such as setting a linestring attribute to a point value, you will get an exception from the database when you attempt to save the record.
-
-```rb
-record.path = p2      # This will appear to work, but...
-record.save           # This will raise an exception from the database
-```
-
-### Spatial Queries
-
-You can create simple queries based on representational equality in the same
-way you would on a scalar column:
-
-```ruby
-record2 = MySpatialTable.where(:lonlat => factory.point(-122, 47)).first
-```
-
-You can also use WKT:
-
-```ruby
-record3 = MySpatialTable.where(:lonlat => 'POINT(-122 47)').first
-```
-
-Note that these queries use representational equality, meaning they return
-records where the lonlat value matches the given value exactly. A 0.00001
-degree difference would not match, nor would a different representation of the
-same geometry (like a multi_point with a single element). Equality queries
-aren't generally all that useful in real world applications. Typically, if you
-want to perform a spatial query, you'll look for, say, all the points within a
-given area. For those queries, you'll need to use the standard spatial SQL
-functions provided by PostGIS.
-
-To perform more advanced spatial queries, you can use the extended Arel interface included in the adapter. The functions accept WKT strings or RGeo features.
-
-```rb
-point = RGeo::Geos.factory(srid: 0).point(1,1)
-
-# Example Building model where geom is a column of polygons.
-buildings = Building.arel_table
-containing_buiildings = Building.where(buildings[:geom].st_contains(point))
-```
-
-See the [rgeo-activerecord YARD Docs](https://rubydoc.info/github/rgeo/rgeo-activerecord/RGeo/ActiveRecord/SpatialExpressions) for a list of available PostGIS functions.
-
-### Validation Issues
-
-If you see an `RGeo::Error::InvalidGeometry (LinearRing failed ring test)` message while loading data or creating geometries, this means that the geometry you are trying to instantiate is not topologically valid. This is usually due to self-intersections in the geometry. The default behavior of RGeo factories is to raise this error when an invalid geometry is being instansiated, but this can be ignored by setting the `uses_lenient_assertions` flag to `true` when creating your factory.
-
-```rb
-regular_fac = RGeo::Geographic.spherical_factory
-modified_fac = RGeo::Geographic.spherical_factory(uses_lenient_assertions: true)
-
-wkt = "POLYGON (0 0, 1 1, 0 1, 1 0, 0 0)" # closed ring with self intersection
-
-regular_fac.parse_wkt(wkt)
-#=> RGeo::Error::InvalidGeometry (LinearRing failed ring test)
-
-p modified_fac.parse_wkt(wkt)
-#=>  #<RGeo::Geographic::SphericalPolygonImpl>
-```
-
-Be careful when performing calculations on potentially invalid geometries, as the results might be nonsensical. For example, the area returned of an hourglass made of 2 equivalent triangles with a self-intersection in the middle is 0. 
-
-Note that when using the `spherical_factory`, there is a chance that valid geometries will be interpreted as invalid due to floating point issues with small geometries.
 
 ## Modifying the adapter?
 

data/activerecord-cockroachdb-adapter.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = "activerecord-cockroachdb-adapter"
-  spec.version       = "5.2.3"
+  spec.version       = "6.0.0beta1"
   spec.licenses      = ["Apache-2.0"]
   spec.authors       = ["Cockroach Labs"]
   spec.email         = ["cockroach-db@googlegroups.com"]
@@ -13,9 +13,8 @@ Gem::Specification.new do |spec|
   spec.description   = "Allows the use of CockroachDB as a backend for ActiveRecord and Rails apps."
   spec.homepage      = "https://github.com/cockroachdb/activerecord-cockroachdb-adapter"
 
-  spec.add_dependency "activerecord", "~> 5.2"
+  spec.add_dependency "activerecord", "~> 6.0.3"
   spec.add_dependency "pg", ">= 0.20"
-  spec.add_dependency "rgeo-activerecord", "~> 7.0.0"
 
   # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
   # to allow pushing to a single host or delete this section to allow pushing to any host.

data/build/config.teamcity.yml

@@ -11,7 +11,6 @@ connections:
       user: root
       requiressl: disable
       min_messages: warning
-      disable_cockroachdb_telemetry: true
     arunit_without_prepared_statements:
       database: activerecord_unittest
       host: localhost
@@ -20,7 +19,6 @@ connections:
       requiressl: disable
       min_messages: warning
       prepared_statements: false
-      disable_cockroachdb_telemetry: true
     arunit2:
       database: activerecord_unittest2
       host: localhost
@@ -28,4 +26,3 @@ connections:
       user: root
       requiressl: disable
       min_messages: warning
-      disable_cockroachdb_telemetry: true

data/build/teamcity-test.sh

@@ -3,7 +3,7 @@
 set -euox pipefail
 
 # Download CockroachDB
-VERSION=v20.2.3
+VERSION=v20.2.1
 wget -qO- https://binaries.cockroachdb.com/cockroach-$VERSION.linux-amd64.tgz | tar  xvz
 readonly COCKROACH=./cockroach-$VERSION.linux-amd64/cockroach
 
@@ -21,7 +21,7 @@ run_cockroach() {
   cockroach quit --insecure || true
   rm -rf cockroach-data
   # Start CockroachDB.
-  cockroach start-single-node --max-sql-memory=25% --cache=25% --insecure --host=localhost --spatial-libs=./cockroach-$VERSION.linux-amd64/lib --listening-url-file="$urlfile" >/dev/null 2>&1 &
+  cockroach start-single-node --max-sql-memory=25% --cache=25% --insecure --host=localhost --listening-url-file="$urlfile" >/dev/null 2>&1 &
   # Ensure CockroachDB is stopped on script exit.
   trap "echo 'Exit routine: Killing CockroachDB.' && kill -9 $! &> /dev/null" EXIT
   # Wait until CockroachDB has started.

data/lib/active_record/connection_adapters/cockroachdb/column.rb

@@ -2,87 +2,8 @@ module ActiveRecord
   module ConnectionAdapters
     module CockroachDB
       module PostgreSQLColumnMonkeyPatch
-        # most functions taken from activerecord-postgis-adapter spatial_column
-        # https://github.com/rgeo/activerecord-postgis-adapter/blob/master/lib/active_record/connection_adapters/postgis/spatial_column.rb
-        def initialize(name, default, sql_type_metadata = nil, null = true, table_name = nil,
-                       default_function = nil, collation = nil, comment = nil, cast_type = nil, opts = nil)
-          @sql_type_metadata = sql_type_metadata
-          @geographic = !!(sql_type_metadata.sql_type =~ /geography\(/i)
-
-          @cast_type = cast_type
-          @geographic = !!(sql_type_metadata.sql_type =~ /geography\(/i)
-          if opts
-            # This case comes from an entry in the geometry_columns table
-            set_geometric_type_from_name(opts[:type])
-            @srid = opts[:srid].to_i
-            @has_z = !!opts[:has_z]
-            @has_m = !!opts[:has_m]
-          elsif @geographic
-            # Geographic type information is embedded in the SQL type
-            @srid = 4326
-            @has_z = @has_m = false
-            build_from_sql_type(sql_type_metadata.sql_type)
-          elsif sql_type =~ /geography|geometry|point|linestring|polygon/i
-            build_from_sql_type(sql_type_metadata.sql_type)
-          elsif sql_type_metadata.sql_type =~ /geography|geometry|point|linestring|polygon/i
-            # A geometry column with no geometry_columns entry.
-            # @geometric_type = geo_type_from_sql_type(sql_type)
-            build_from_sql_type(sql_type_metadata.sql_type)
-          end
-          super(name, default, sql_type_metadata, null, table_name, default_function, collation, comment: comment)
-          if spatial?
-            if @srid
-              @limit = { srid: @srid, type: to_type_name(geometric_type) }
-              @limit[:has_z] = true if @has_z
-              @limit[:has_m] = true if @has_m
-              @limit[:geographic] = true if @geographic
-            end
-          end
-        end
-
-        attr_reader :geographic,
-                    :geometric_type,
-                    :has_m,
-                    :has_z,
-                    :srid
-
-        alias geographic? geographic
-        alias has_z? has_z
-        alias has_m? has_m
-
-        def limit
-          spatial? ? @limit : super
-        end
-
-        def spatial?
-          %i[geometry geography].include?(@sql_type_metadata.type)
-        end
-
         def serial?
-          default_function == 'unique_rowid()'
-        end
-
-        private
-
-        def set_geometric_type_from_name(name)
-          @geometric_type = RGeo::ActiveRecord.geometric_type_from_name(name) || RGeo::Feature::Geometry
-        end
-
-        def build_from_sql_type(sql_type)
-          geo_type, @srid, @has_z, @has_m = OID::Spatial.parse_sql_type(sql_type)
-          set_geometric_type_from_name(geo_type)
-        end
-
-        def to_type_name(geometric_type)
-          name = geometric_type.type_name.underscore
-          case name
-          when 'point'
-            'st_point'
-          when 'polygon'
-            'st_polygon'
-          else
-            name
-          end
+          default_function == "unique_rowid()"
         end
       end
     end

data/lib/active_record/connection_adapters/cockroachdb/quoting.rb

@@ -14,19 +14,10 @@ module ActiveRecord
         # always be strings. Then, we won't have to make any additional changes
         # to ActiveRecord to support inserting integer values into string
         # columns.
-        #
-        # For spatial types, data is stored as Well-known Binary (WKB) strings
-        # (https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry#Well-known_binary)
-        # but when creating objects, using RGeo features is more convenient than
-        # converting to WKB, so this does it automatically.
         def _quote(value)
           case value
           when Numeric
             "'#{quote_string(value.to_s)}'"
-          when RGeo::Feature::Geometry
-            "'#{RGeo::WKRep::WKBGenerator.new(hex_format: true, type_format: :ewkb, emit_ewkb_srid: true).generate(value)}'"
-          when RGeo::Cartesian::BoundingBox
-            "'#{value.min_x},#{value.min_y},#{value.max_x},#{value.max_y}'::box"
           else
             super
           end

data/lib/active_record/connection_adapters/cockroachdb/schema_statements.rb

@@ -39,52 +39,8 @@ module ActiveRecord
           nil
         end
 
-        def columns(table_name)
-          # Limit, precision, and scale are all handled by the superclass.
-          column_definitions(table_name).map do |column_name, type, default, notnull, oid, fmod, collation, comment|
-            oid = oid.to_i
-            fmod = fmod.to_i
-            type_metadata = fetch_type_metadata(column_name, type, oid, fmod)
-            cast_type = get_oid_type(oid.to_i, fmod.to_i, column_name, type)
-            default_value = extract_value_from_default(default)
-
-            default_function = extract_default_function(default_value, default)
-            new_column(table_name, column_name, default_value, cast_type, type_metadata, !notnull,
-                       default_function, collation, comment)
-          end
-        end
-
-        def new_column(table_name, column_name, default, cast_type, sql_type_metadata = nil,
-                        null = true, default_function = nil, collation = nil, comment = nil)
-          # JDBC gets true/false in Rails 4, where other platforms get 't'/'f' strings.
-          if null.is_a?(String)
-            null = (null == "t")
-          end
-
-          column_info = spatial_column_info(table_name).get(column_name, sql_type_metadata.sql_type)
-
-          PostgreSQLColumn.new(
-            column_name,
-            default,
-            sql_type_metadata,
-            null,
-            table_name,
-            default_function,
-            collation,
-            comment,
-            cast_type,
-            column_info
-          )
-        end
-
         # CockroachDB will use INT8 if the SQL type is INTEGER, so we make it use
         # INT4 explicitly when needed.
-        #
-        # For spatial columns, include the limit to properly format the column name
-        # since type alone is not enough to format the column.
-        # Ex. type_to_sql(:geography, limit: "Point,4326")
-        # => "geography(Point,4326)"
-        # 
         def type_to_sql(type, limit: nil, precision: nil, scale: nil, array: nil, **) # :nodoc:
           sql = \
             case type.to_s
@@ -96,44 +52,39 @@ module ActiveRecord
               when 5..8; "int8"
               else super
               end
-            when "geometry", "geography"
-              "#{type}(#{limit})"
             else
               super
             end
           # The call to super might have appeneded [] already.
           if array && type != :primary_key && !sql.end_with?("[]")
-            sql = "#{sql}[]" 
+            sql = "#{sql}[]"
           end
           sql
         end
 
-        # override
-        def native_database_types
-          # Add spatial types
-          super.merge(
-            geography:           { name: "geography" },
-            geometry:            { name: "geometry" },
-            geometry_collection: { name: "geometry_collection" },
-            line_string:         { name: "line_string" },
-            multi_line_string:   { name: "multi_line_string" },
-            multi_point:         { name: "multi_point" },
-            multi_polygon:       { name: "multi_polygon" },
-            spatial:             { name: "geometry" },
-            st_point:            { name: "st_point" },
-            st_polygon:          { name: "st_polygon" }
-          )
-        end
+        # This overrides the method from PostegreSQL adapter
+        # Resets the sequence of a table's primary key to the maximum value.
+        def reset_pk_sequence!(table, pk = nil, sequence = nil)
+          unless pk && sequence
+            default_pk, default_sequence = pk_and_sequence_for(table)
 
-        # override
-        def create_table_definition(*args, **kwargs)
-          CockroachDB::TableDefinition.new(*args, **kwargs)
-        end
+            pk ||= default_pk
+            sequence ||= default_sequence
+          end
+
+          if @logger && pk && !sequence
+            @logger.warn "#{table} has primary key #{pk} with no default sequence."
+          end
+
+          if pk && sequence
+            quoted_sequence = quote_table_name(sequence)
+            max_pk = query_value("SELECT MAX(#{quote_column_name pk}) FROM #{quote_table_name(table)}", "SCHEMA")
+            if max_pk.nil?
+              minvalue = query_value("SELECT seqmin FROM pg_sequence WHERE seqrelid = #{quote(quoted_sequence)}::regclass", "SCHEMA")
+            end
 
-        # memoize hash of column infos for tables
-        def spatial_column_info(table_name)
-          @spatial_column_info ||= {}
-          @spatial_column_info[table_name.to_sym] ||= SpatialColumnInfo.new(self, table_name.to_s)
+            query_value("SELECT setval(#{quote(quoted_sequence)}, #{max_pk ? max_pk : minvalue}, #{max_pk ? true : false})", "SCHEMA")
+          end
         end
       end
     end

data/lib/active_record/connection_adapters/cockroachdb_adapter.rb

@@ -1,24 +1,12 @@
-require "rgeo/active_record"
-
 require 'active_record/connection_adapters/postgresql_adapter'
-require "active_record/connection_adapters/cockroachdb/column_methods"
 require "active_record/connection_adapters/cockroachdb/schema_statements"
 require "active_record/connection_adapters/cockroachdb/referential_integrity"
 require "active_record/connection_adapters/cockroachdb/transaction_manager"
+require "active_record/connection_adapters/cockroachdb/column"
 require "active_record/connection_adapters/cockroachdb/database_statements"
-require "active_record/connection_adapters/cockroachdb/table_definition"
 require "active_record/connection_adapters/cockroachdb/quoting"
 require "active_record/connection_adapters/cockroachdb/type"
 require "active_record/connection_adapters/cockroachdb/attribute_methods"
-require "active_record/connection_adapters/cockroachdb/column"
-require "active_record/connection_adapters/cockroachdb/spatial_column_info"
-require "active_record/connection_adapters/cockroachdb/setup"
-require "active_record/connection_adapters/cockroachdb/oid/spatial"
-require "active_record/connection_adapters/cockroachdb/arel_tosql"
-
-# Run to ignore spatial tables that will break schemna dumper.
-# Defined in ./setup.rb
-ActiveRecord::ConnectionAdapters::CockroachDB.initial_setup
 
 module ActiveRecord
   module ConnectionHandling
@@ -39,14 +27,13 @@ module ActiveRecord
       # The postgres drivers don't allow the creation of an unconnected
       # PG::Connection object, so just pass a nil connection object for the
       # time being.
-      ConnectionAdapters::CockroachDBAdapter.new(nil, logger, conn_params, config)
-    # This rescue flow appears in new_client, but it is needed here as well
-    # since Cockroach will sometimes not raise until a query is made.
-    rescue ActiveRecord::StatementInvalid => error
-      if conn_params && conn_params[:dbname] && error.cause.message.include?(conn_params[:dbname])
-        raise ActiveRecord::NoDatabaseError, error.cause.message
+      conn = PG.connect(conn_params)
+      ConnectionAdapters::CockroachDBAdapter.new(conn, logger, conn_params, config)
+    rescue ::PG::Error => error
+      if error.message.include?("does not exist")
+        raise ActiveRecord::NoDatabaseError
       else
-        raise ActiveRecord::ConnectionNotEstablished, error.message
+        raise
       end
     end
   end
@@ -54,130 +41,15 @@ end
 
 module ActiveRecord
   module ConnectionAdapters
-    module CockroachDBConnectionPool
-      def initialize(pool_config)
-        super(pool_config)
-        disable_telemetry = pool_config.config[:disable_cockroachdb_telemetry]
-        adapter = pool_config.config[:adapter]
-        return if disable_telemetry || adapter != "cockroachdb"
-
-
-        begin
-          with_connection do |conn|
-            if conn.active?
-              begin
-                query = "SELECT crdb_internal.increment_feature_counter('ActiveRecord %d.%d')"
-                conn.execute(query % [ActiveRecord::VERSION::MAJOR, ActiveRecord::VERSION::MINOR])
-              rescue ActiveRecord::StatementInvalid
-                # The increment_feature_counter built-in is not supported on this
-                # CockroachDB version. Ignore.
-              rescue StandardError => e
-                conn.logger.warn "Unexpected error when incrementing feature counter: #{e}"
-              end
-            end
-          end
-        rescue StandardError
-          # Prevent failures on db creation and parallel testing.
-        end
-      end
-    end
-    ConnectionPool.prepend(CockroachDBConnectionPool)
-
     class CockroachDBAdapter < PostgreSQLAdapter
       ADAPTER_NAME = "CockroachDB".freeze
       DEFAULT_PRIMARY_KEY = "rowid"
 
-      SPATIAL_COLUMN_OPTIONS =
-        {
-          geography:           { geographic: true },
-          geometry:            {},
-          geometry_collection: {},
-          line_string:         {},
-          multi_line_string:   {},
-          multi_point:         {},
-          multi_polygon:       {},
-          spatial:             {},
-          st_point:            {},
-          st_polygon:          {},
-        }
-
-      # http://postgis.17.x6.nabble.com/Default-SRID-td5001115.html      
-      DEFAULT_SRID = 0
-
       include CockroachDB::SchemaStatements
       include CockroachDB::ReferentialIntegrity
       include CockroachDB::DatabaseStatements
       include CockroachDB::Quoting
 
-      # override
-      # This method makes a sql query to gather information about columns
-      # in a table. It returns an array of arrays (one for each col) and
-      # is mapped to columns in the SchemaStatements#columns method.
-      #
-      # The issue with the default method is that the sql_type field is
-      # retrieved with the `format_type` function, but this is implemented
-      # differently in CockroachDB than PostGIS, so geometry/geography
-      # types are missing information which makes parsing them impossible.
-      # Below is an example of what `format_type` returns for a geometry
-      # column.
-      #
-      # column_type: geometry(POINT, 4326)
-      # Expected: geometry(POINT, 4326)
-      # Actual: geometry
-      #
-      # The solution is to make the default query with super, then
-      # iterate through the columns and if it is a spatial type,
-      # access the proper column_type with the information_schema.columns
-      # table.
-      #
-      # @see: https://github.com/rails/rails/blob/8695b028261bdd244e254993255c6641bdbc17a5/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb#L829
-      def column_definitions(table_name)
-        fields = super
-        # iterate through and identify all spatial fields based on format_type
-        # being geometry or geography, then query for the information_schema.column
-        # column_type because that contains the necessary information.
-        fields.map do |field|
-          dtype = field[1]
-          if dtype == 'geometry' || dtype == 'geography'
-            col_name = field[0]
-            data_type = \
-            query(<<~SQL, "SCHEMA")
-              SELECT c.data_type
-                FROM information_schema.columns c
-              WHERE c.table_name = #{quote(table_name)}
-                AND c.column_name = #{quote(col_name)}
-            SQL
-            field[1] = data_type[0][0]
-          end
-          field
-        end
-      end
-
-      def arel_visitor
-        Arel::Visitors::CockroachDB.new(self)
-      end
-
-      def self.spatial_column_options(key)
-        SPATIAL_COLUMN_OPTIONS[key]
-      end
-
-      def postgis_lib_version
-        @postgis_lib_version ||= select_value("SELECT PostGIS_Lib_Version()")
-      end
-
-      def default_srid
-        DEFAULT_SRID
-      end
-
-      def srs_database_columns
-        {
-          auth_name_column: "auth_name",
-          auth_srid_column: "auth_srid",
-          proj4text_column: "proj4text",
-          srtext_column:    "srtext",
-        }
-      end
-
       def debugging?
         !!ENV["DEBUG_COCKROACHDB_ADAPTER"]
       end
@@ -208,11 +80,6 @@ module ActiveRecord
         false
       end
 
-      def supports_ranges?
-        # See cockroachdb/cockroach#17022
-        false
-      end
-
       def supports_materialized_views?
         false
       end
@@ -253,10 +120,6 @@ module ActiveRecord
         @crdb_version >= 202
       end
 
-      def supports_partitioned_indexes?
-        false
-      end
-
       # This is hardcoded to 63 (as previously was in ActiveRecord 5.0) to aid in
       # migration from PostgreSQL to CockroachDB. In practice, this limitation
       # is arbitrary since CockroachDB supports index name lengths and table alias
@@ -274,7 +137,6 @@ module ActiveRecord
 
       def initialize(connection, logger, conn_params, config)
         super(connection, logger, conn_params, config)
-
         crdb_version_string = query_value("SHOW crdb_version")
         if crdb_version_string.include? "v1."
           version_num = 1
@@ -291,26 +153,11 @@ module ActiveRecord
         end
         @crdb_version = version_num
       end
-        
+
       private
 
         def initialize_type_map(m = type_map)
-          %w(
-            geography
-            geometry
-            geometry_collection
-            line_string
-            multi_line_string
-            multi_point
-            multi_polygon
-            st_point
-            st_polygon
-          ).each do |geo_type|
-            m.register_type(geo_type) do |oid, _, sql_type|
-              CockroachDB::OID::Spatial.new(oid, sql_type)
-            end
-          end
-
+          super(m)
           # NOTE(joey): PostgreSQL intervals have a precision.
           # CockroachDB intervals do not, so overide the type
           # definition. Returning a ArgumentError may not be correct.
@@ -322,8 +169,6 @@ module ActiveRecord
             end
             OID::SpecializedString.new(:interval, precision: precision)
           end
-
-          super(m)
         end
 
         # Configures the encoding, verbosity, schema search path, and time zone of the connection.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-cockroachdb-adapter
 version: !ruby/object:Gem::Version
-  version: 5.2.3
+  version: 6.0.0beta1
 platform: ruby
 authors:
 - Cockroach Labs
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-06-27 00:00:00.000000000 Z
+date: 2020-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: 6.0.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: 6.0.3
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -38,20 +38,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0.20'
-- !ruby/object:Gem::Dependency
-  name: rgeo-activerecord
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 7.0.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 7.0.0
 description: Allows the use of CockroachDB as a backend for ActiveRecord and Rails
   apps.
 email:
@@ -75,19 +61,13 @@ files:
 - build/local-test.sh
 - build/teamcity-test.sh
 - docker.sh
-- lib/active_record/connection_adapters/cockroachdb/arel_tosql.rb
 - lib/active_record/connection_adapters/cockroachdb/attribute_methods.rb
 - lib/active_record/connection_adapters/cockroachdb/column.rb
-- lib/active_record/connection_adapters/cockroachdb/column_methods.rb
 - lib/active_record/connection_adapters/cockroachdb/database_statements.rb
 - lib/active_record/connection_adapters/cockroachdb/database_tasks.rb
-- lib/active_record/connection_adapters/cockroachdb/oid/spatial.rb
 - lib/active_record/connection_adapters/cockroachdb/quoting.rb
 - lib/active_record/connection_adapters/cockroachdb/referential_integrity.rb
 - lib/active_record/connection_adapters/cockroachdb/schema_statements.rb
-- lib/active_record/connection_adapters/cockroachdb/setup.rb
-- lib/active_record/connection_adapters/cockroachdb/spatial_column_info.rb
-- lib/active_record/connection_adapters/cockroachdb/table_definition.rb
 - lib/active_record/connection_adapters/cockroachdb/transaction_manager.rb
 - lib/active_record/connection_adapters/cockroachdb/type.rb
 - lib/active_record/connection_adapters/cockroachdb_adapter.rb
@@ -108,11 +88,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.2.15
+rubygems_version: 3.1.4
 signing_key:
 specification_version: 4
 summary: CockroachDB adapter for ActiveRecord.

data/lib/active_record/connection_adapters/cockroachdb/arel_tosql.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module RGeo
-  module ActiveRecord
-    ##
-    # Extend rgeo-activerecord visitors to use PostGIS specific functionality
-    module SpatialToPostGISSql
-      def visit_in_spatial_context(node, collector)
-        # Use ST_GeomFromEWKT for EWKT geometries
-        if node.is_a?(String) && node =~ /SRID=[\d+]{0,};/
-          collector << "#{st_func('ST_GeomFromEWKT')}(#{quote(node)})"
-        else
-          super(node, collector)
-        end
-      end
-    end
-  end
-end
-RGeo::ActiveRecord::SpatialToSql.prepend RGeo::ActiveRecord::SpatialToPostGISSql
-
-module Arel # :nodoc:
-  module Visitors # :nodoc:
-    class CockroachDB < PostgreSQL  # :nodoc:
-      include RGeo::ActiveRecord::SpatialToSql
-    end
-  end
-end

data/lib/active_record/connection_adapters/cockroachdb/column_methods.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-  module ConnectionAdapters
-    module CockroachDB
-      module ColumnMethods
-        def spatial(name, options = {})
-          raise "You must set a type. For example: 't.spatial type: :st_point'" unless options[:type]
-
-          column(name, options[:type], **options)
-        end
-
-        def geography(name, options = {})
-          column(name, :geography, **options)
-        end
-
-        def geometry(name, options = {})
-          column(name, :geometry, **options)
-        end
-
-        def geometry_collection(name, options = {})
-          column(name, :geometry_collection, **options)
-        end
-
-        def line_string(name, options = {})
-          column(name, :line_string, **options)
-        end
-
-        def multi_line_string(name, options = {})
-          column(name, :multi_line_string, **options)
-        end
-
-        def multi_point(name, options = {})
-          column(name, :multi_point, **options)
-        end
-
-        def multi_polygon(name, options = {})
-          column(name, :multi_polygon, **options)
-        end
-
-        def st_point(name, options = {})
-          column(name, :st_point, **options)
-        end
-
-        def st_polygon(name, options = {})
-          column(name, :st_polygon, **options)
-        end
-      end
-    end
-
-    PostgreSQL::Table.include CockroachDB::ColumnMethods
-  end
-end

data/lib/active_record/connection_adapters/cockroachdb/oid/spatial.rb

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-  module ConnectionAdapters
-    module CockroachDB
-      module OID
-        class Spatial < Type::Value
-          # sql_type is a string that comes from the database definition
-          # examples:
-          #   "geometry(Point,4326)"
-          #   "geography(Point,4326)"
-          #   "geometry(Polygon,4326) NOT NULL"
-          #   "geometry(Geography,4326)"
-          def initialize(oid, sql_type)
-            @sql_type = sql_type
-            @geo_type, @srid, @has_z, @has_m = self.class.parse_sql_type(sql_type)
-          end
-
-          # sql_type: geometry, geometry(Point), geometry(Point,4326), ...
-          #
-          # returns [geo_type, srid, has_z, has_m]
-          #   geo_type: geography, geometry, point, line_string, polygon, ...
-          #   srid:     1234
-          #   has_z:    false
-          #   has_m:    false
-          def self.parse_sql_type(sql_type)
-            geo_type = nil
-            srid = 0
-            has_z = false
-            has_m = false
-
-            if sql_type =~ /(geography|geometry)\((.*)\)$/i
-              # geometry(Point)
-              # geometry(Point,4326)
-              params = Regexp.last_match(2).split(',')
-              if params.first =~ /([a-z]+[^zm])(z?)(m?)/i
-                has_z = Regexp.last_match(2).length > 0
-                has_m = Regexp.last_match(3).length > 0
-                geo_type = Regexp.last_match(1)
-              end
-              srid = Regexp.last_match(1).to_i if params.last =~ /(\d+)/
-            else
-              geo_type = sql_type
-            end
-            [geo_type, srid, has_z, has_m]
-          end
-
-          def spatial_factory
-            @spatial_factory ||=
-              RGeo::ActiveRecord::SpatialFactoryStore.instance.factory(
-                factory_attrs
-              )
-          end
-
-          def geographic?
-            @sql_type =~ /geography/
-          end
-
-          def spatial?
-            true
-          end
-
-          def type
-            geographic? ? :geography : :geometry
-          end
-
-          # support setting an RGeo object or a WKT string
-          def serialize(value)
-            return if value.nil?
-
-            geo_value = cast_value(value)
-
-            # TODO: - only valid types should be allowed
-            # e.g. linestring is not valid for point column
-            # raise "maybe should raise" unless RGeo::Feature::Geometry.check_type(geo_value)
-
-            RGeo::WKRep::WKBGenerator.new(hex_format: true, type_format: :ewkb, emit_ewkb_srid: true)
-                                     .generate(geo_value)
-          end
-
-          private
-
-          def cast_value(value)
-            return if value.nil?
-
-            value.is_a?(String) ? parse_wkt(value) : value
-          end
-
-          # convert WKT string into RGeo object
-          def parse_wkt(string)
-            wkt_parser(string).parse(string)
-          rescue RGeo::Error::ParseError
-            nil
-          end
-
-          def binary_string?(string)
-            string[0] == "\x00" || string[0] == "\x01" || string[0, 4] =~ /[0-9a-fA-F]{4}/
-          end
-
-          def wkt_parser(string)
-            if binary_string?(string)
-              RGeo::WKRep::WKBParser.new(spatial_factory, support_ewkb: true, default_srid: @srid)
-            else
-              RGeo::WKRep::WKTParser.new(spatial_factory, support_ewkt: true, default_srid: @srid)
-            end
-          end
-
-          def factory_attrs
-            {
-              geo_type: @geo_type.underscore,
-              has_m: @has_m,
-              has_z: @has_z,
-              srid: @srid,
-              sql_type: type.to_s
-            }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_record/connection_adapters/cockroachdb/setup.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord # :nodoc:
-  module ConnectionAdapters # :nodoc:
-    module CockroachDB  # :nodoc:
-      def self.initial_setup
-        ::ActiveRecord::SchemaDumper.ignore_tables |= %w[
-          geography_columns
-          geometry_columns
-          layer
-          raster_columns
-          raster_overviews
-          spatial_ref_sys
-          topology
-        ]
-      end
-    end
-  end
-end

data/lib/active_record/connection_adapters/cockroachdb/spatial_column_info.rb

@@ -1,44 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters
-    module CockroachDB
-      class SpatialColumnInfo
-        def initialize(adapter, table_name)
-          @adapter = adapter
-          @table_name = table_name
-        end
-
-        def all
-          info = @adapter.query(
-            "SELECT f_geometry_column,coord_dimension,srid,type FROM geometry_columns WHERE f_table_name='#{@table_name}'"
-          )
-          result = {}
-          info.each do |row|
-            name = row[0]
-            type = row[3]
-            dimension = row[1].to_i
-            has_m = !!(type =~ /m$/i)
-            type.sub!(/m$/, '')
-            has_z = dimension > 3 || dimension == 3 && !has_m
-            result[name] = {
-              dimension: dimension,
-              has_m: has_m,
-              has_z: has_z,
-              name: name,
-              srid: row[2].to_i,
-              type: type
-            }
-          end
-          result
-        end
-
-        # do not query the database for non-spatial columns/tables
-        def get(column_name, type)
-          return unless CockroachDBAdapter.spatial_column_options(type.to_sym)
-
-          @spatial_column_info ||= all
-          @spatial_column_info[column_name]
-        end
-      end
-    end
-  end
-end

data/lib/active_record/connection_adapters/cockroachdb/table_definition.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord # :nodoc:
-  module ConnectionAdapters # :nodoc:
-    module CockroachDB # :nodoc:
-      class TableDefinition < PostgreSQL::TableDefinition # :nodoc:
-        include ColumnMethods
-
-        # Support for spatial columns in tables
-        # super: https://github.com/rails/rails/blob/master/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
-        def new_column_definition(name, type, **options)
-          if (info = CockroachDBAdapter.spatial_column_options(type.to_sym))
-            if (limit = options.delete(:limit)) && limit.is_a?(::Hash)
-              options.merge!(limit)
-            end
-
-            geo_type = ColumnDefinitionUtils.geo_type(options[:type] || type || info[:type])
-            base_type = info[:type] || (options[:geographic] ? :geography : :geometry)
-
-            options[:limit] = ColumnDefinitionUtils.limit_from_options(geo_type, options)
-            options[:spatial_type] = geo_type
-            column = super(name, base_type, **options)
-          else
-            column = super(name, type, **options)
-          end
-
-          column
-        end
-      end
-
-      module ColumnDefinitionUtils
-        class << self
-          def geo_type(type = 'GEOMETRY')
-            g_type = type.to_s.delete('_').upcase
-            return 'POINT' if g_type == 'STPOINT'
-            return 'POLYGON' if g_type == 'STPOLYGON'
-
-            g_type
-          end
-
-          def limit_from_options(type, options = {})
-            spatial_type = geo_type(type)
-            spatial_type << 'Z' if options[:has_z]
-            spatial_type << 'M' if options[:has_m]
-            spatial_type << ",#{options[:srid] || default_srid(options)}"
-            spatial_type
-          end
-
-          def default_srid(options)
-            options[:geographic] ? 4326 : CockroachDBAdapter::DEFAULT_SRID
-          end
-        end
-      end
-    end
-  end
-end