activerecord-postgis-adapter 2.2.2 → 3.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 76d9431bb3c7e39d5fbd758bb5a5235c5bdf2679
-  data.tar.gz: 00b2d3a6e72cd2c66b93de93a4a50f9d011fdba1
+  metadata.gz: 5da85e153ac728aed4dd05c63c31db2b8408db33
+  data.tar.gz: e1fb8123e8ac236ff5299d19f691147a510f9d22
 SHA512:
-  metadata.gz: 96a805abbd12a4d90038b7896198c12370214881fba6ddd62cee2b062720c575b4f9479e63746fa385363484161c65070be30484cf14d208616c4c1f15aac93f
-  data.tar.gz: 64f9df06696a296d146d07323b4cd6b7c11797f756447264262d68fd992f487e9ed0a0f03e4696542356da07add81ffc4d8513ec5615fc844bf72a940c628a8c
+  metadata.gz: b6af550d08c16c0eff95249fc80e08eb9aabf59e1cfac0c163edd43506ee6c6887b6acba7e7eac4f6ca3f63a6052f4479ba3337c48c4cbdfce88d21cf0874de8
+  data.tar.gz: 9bbe835d52ed5d41f91c1d22e58564775f7c200d52ea772a7818c9987456949fbffa7393e81ad20acec16edd6ccae52b1b95363f3403a920e046f810e3451ee6

data/lib/active_record/connection_adapters/postgis_adapter.rb

@@ -17,13 +17,14 @@ require 'active_record/connection_adapters/postgresql_adapter'
 require 'rgeo/active_record'
 
 require 'active_record/connection_adapters/postgis_adapter/version'
-require 'active_record/connection_adapters/postgis_adapter/common_adapter_methods'
+require 'active_record/connection_adapters/postgis_adapter/schema_statements'
 require 'active_record/connection_adapters/postgis_adapter/main_adapter'
 require 'active_record/connection_adapters/postgis_adapter/spatial_column_info'
 require 'active_record/connection_adapters/postgis_adapter/spatial_table_definition'
 require 'active_record/connection_adapters/postgis_adapter/spatial_column'
 require 'active_record/connection_adapters/postgis_adapter/arel_tosql'
 require 'active_record/connection_adapters/postgis_adapter/setup'
+require 'active_record/connection_adapters/postgis_adapter/oid/spatial'
 require 'active_record/connection_adapters/postgis_adapter/create_connection'
 require 'active_record/connection_adapters/postgis_adapter/postgis_database_tasks'
 

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

@@ -4,7 +4,7 @@ module Arel  # :nodoc:
     PostGISSuperclass = if defined?(::ArJdbc::PostgreSQL::BindSubstitution)
                           ::ArJdbc::PostgreSQL::BindSubstitution
                         else
-                          ::Arel::Visitors::PostgreSQL
+                          PostgreSQL
                         end
 
     class PostGIS < PostGISSuperclass  # :nodoc:
@@ -13,17 +13,21 @@ module Arel  # :nodoc:
         'st_wkttosql' => 'ST_GeomFromEWKT',
       }
 
-      include ::RGeo::ActiveRecord::SpatialToSql
+      include RGeo::ActiveRecord::SpatialToSql
 
       def st_func(standard_name)
         FUNC_MAP[standard_name.downcase] || standard_name
       end
 
-      alias_method :visit_in_spatial_context, :visit
+      def visit_String(node, collector)
+        collector << "#{st_func('ST_WKTToSQL')}(#{quote(node)})"
+      end
 
-    end
+      def visit_RGeo_ActiveRecord_SpatialNamedFunction(node, collector)
+        aggregate(st_func(node.name), node, collector)
+      end
 
-    VISITORS['postgis'] = ::Arel::Visitors::PostGIS
+    end
 
   end
 end

data/lib/active_record/connection_adapters/postgis_adapter/create_connection.rb

@@ -6,13 +6,18 @@ end
 
 module ActiveRecord  # :nodoc:
   module ConnectionHandling  # :nodoc:
+
     if(defined?(::RUBY_ENGINE) && ::RUBY_ENGINE == 'jruby')
+
       def postgis_connection(config)
         config[:adapter_class] = ::ActiveRecord::ConnectionAdapters::PostGISAdapter::MainAdapter
         postgresql_connection(config)
       end
+
       alias_method :jdbcpostgis_connection, :postgis_connection
+
     else
+
       # Based on the default <tt>postgresql_connection</tt> definition from ActiveRecord.
       # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
       def postgis_connection(config)
@@ -30,8 +35,9 @@ module ActiveRecord  # :nodoc:
 
         # The postgres drivers don't allow the creation of an unconnected PGconn object,
         # so just pass a nil connection object for the time being.
-        ::ActiveRecord::ConnectionAdapters::PostGISAdapter::MainAdapter.new(nil, logger, conn_params, config)
+        ConnectionAdapters::PostGISAdapter::MainAdapter.new(nil, logger, conn_params, config)
       end
+
     end
 
   end

data/lib/active_record/connection_adapters/postgis_adapter/main_adapter.rb

@@ -2,213 +2,72 @@ module ActiveRecord  # :nodoc:
   module ConnectionAdapters  # :nodoc:
     module PostGISAdapter  # :nodoc:
       class MainAdapter < PostgreSQLAdapter  # :nodoc:
+        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
+
         def initialize(*args)
-          # Overridden to change the visitor
           super
-          @visitor = ::Arel::Visitors::PostGIS.new(self)
+          @visitor = Arel::Visitors::PostGIS.new(self)
         end
 
-        include PostGISAdapter::CommonAdapterMethods
+        include PostGISAdapter::SchemaStatements
 
-        @@native_database_types = nil
+        # def schema_creation
+        #   PostGISAdapter::SchemaCreation.new self
+        # end
 
-        def native_database_types
-          # Overridden to add the :spatial type
-          @@native_database_types ||= super.merge(
-            geography: { name: 'geography' },
-            spatial:   { name: 'geometry' },
-          )
+        def set_rgeo_factory_settings(factory_settings)
+          @rgeo_factory_settings = factory_settings
         end
 
-        def type_cast(value, column, array_member = false)
-          if ::RGeo::Feature::Geometry.check_type(value)
-            ::RGeo::WKRep::WKBGenerator.new(hex_format: true, type_format: :ewkb, emit_ewkb_srid: true).generate(value)
-          else
-            super
-          end
+        def adapter_name
+          ADAPTER_NAME
         end
 
-        # FULL REPLACEMENT. RE-CHECK ON NEW VERSIONS
-        # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb
-        def columns(table_name, name = nil)
-          column_info = SpatialColumnInfo.new(self, quote_string(table_name.to_s))
-          # Limit, precision, and scale are all handled by the superclass.
-          column_definitions(table_name).map do |column_name, type, default, notnull, oid, fmod|
-            # JDBC gets true/false in Rails 4, where other platforms get
-            # 't'/'f' strings.
-            if(notnull.is_a?(String))
-              notnull = (notnull == 't')
-            end
-
-            oid = column_type_map.fetch(oid.to_i, fmod.to_i) { OID::Identity.new }
-            SpatialColumn.new(@rgeo_factory_settings,
-                              table_name,
-                              column_name,
-                              default,
-                              oid,
-                              type,
-                              !notnull,
-                              column_info.get(column_name, type))
-          end
+        def self.spatial_column_options(key)
+          SPATIAL_COLUMN_OPTIONS[key]
         end
 
-        # FULL REPLACEMENT. RE-CHECK ON NEW VERSIONS
-        # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb
-        def indexes(table_name, name = nil)
-          result = query(<<-SQL, 'SCHEMA')
-            SELECT distinct i.relname, d.indisunique, d.indkey, pg_get_indexdef(d.indexrelid), t.oid
-            FROM pg_class t
-            INNER JOIN pg_index d ON t.oid = d.indrelid
-            INNER JOIN pg_class i ON d.indexrelid = i.oid
-            WHERE i.relkind = 'i'
-              AND d.indisprimary = 'f'
-              AND t.relname = '#{table_name}'
-              AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY (current_schemas(false)) )
-            ORDER BY i.relname
-          SQL
-
-          result.map do |row|
-            index_name = row[0]
-            unique = row[1] == 't'
-            indkey = row[2].split(" ")
-            inddef = row[3]
-            oid = row[4]
-
-            columns = query(<<-SQL, "SCHEMA")
-              SELECT a.attnum, a.attname, t.typname
-                FROM pg_attribute a, pg_type t
-              WHERE a.attrelid = #{oid}
-                AND a.attnum IN (#{indkey.join(",")})
-                AND a.atttypid = t.oid
-            SQL
-            columns = columns.inject({}){ |h, r| h[r[0].to_s] = [r[1], r[2]]; h }
-            column_names = columns.values_at(*indkey).compact.map{ |a| a[0] }
-
-            unless column_names.empty?
-              # add info on sort order for columns (only desc order is explicitly specified, asc is the default)
-              desc_order_columns = inddef.scan(/(\w+) DESC/).flatten
-              orders = desc_order_columns.any? ? Hash[desc_order_columns.map {|order_column| [order_column, :desc]}] : {}
-              where = inddef.scan(/WHERE (.+)$/).flatten[0]
-              # using = inddef.scan(/USING (.+?) /).flatten[0].to_sym
-
-              spatial = inddef =~ /using\s+gist/i &&
-                        columns.size == 1 &&
-                        %w[geometry geography].include?(columns.values.first[1])
-
-              # IndexDefinition.new(table_name, index_name, unique, column_names, [], orders, where, nil, using)
-              ::RGeo::ActiveRecord::SpatialIndexDefinition.new(table_name, index_name, unique, column_names, [], orders, where, !!spatial)
-            end
-          end.compact
+        def postgis_lib_version
+          @postgis_lib_version ||= select_value("SELECT PostGIS_Lib_Version()")
         end
 
-        def create_table_definition(name, temporary, options, as = nil)
-          # Override to create a spatial table definition
-          if ActiveRecord::VERSION::STRING > '4.1'
-            PostGISAdapter::TableDefinition.new(native_database_types, name, temporary, options, as, self)
-          else
-            PostGISAdapter::TableDefinition.new(native_database_types, name, temporary, options, self)
-          end
+        def default_srid
+          DEFAULT_SRID
         end
 
-        def create_table(table_name, options = {}, &block)
-          table_name = table_name.to_s
-          # Call super and snag the table definition
-          table_definition = nil
-          super(table_name, options) do |td|
-            block.call(td) if block
-            table_definition = td
-          end
-          table_definition.non_geographic_spatial_columns.each do |col|
-            options = {
-              default: col.default,
-              has_m: col.has_m?,
-              has_z: col.has_z?,
-              null: col.null,
-              srid:  col.srid,
-              type:  col.spatial_type,
-            }
-            column_name = col.name.to_s
-            type = col.spatial_type
-
-            add_spatial_column(table_name, column_name, type, options)
-          end
+        def srs_database_columns
+          {
+            auth_name_column: 'auth_name',
+            auth_srid_column: 'auth_srid',
+            proj4text_column: 'proj4text',
+            srtext_column:    'srtext',
+          }
         end
 
-        def add_column(table_name, column_name, type, options = {})
-          table_name = table_name.to_s
-          column_name = column_name.to_s
-          if (info = spatial_column_constructor(type.to_sym))
-            options[:info] = info
-            add_spatial_column(table_name, column_name, type, options)
+        def quote(value, column = nil)
+          if RGeo::Feature::Geometry.check_type(value)
+            "'#{ RGeo::WKRep::WKBGenerator.new(hex_format: true, type_format: :ewkb, emit_ewkb_srid: true).generate(value) }'"
+          elsif value.is_a?(RGeo::Cartesian::BoundingBox)
+            "'#{ value.min_x },#{ value.min_y },#{ value.max_x },#{ value.max_y }'::box"
           else
             super
           end
         end
-
-        def remove_column(table_name, column_name, type = nil, options = {})
-          table_name = table_name.to_s
-          column_name = column_name.to_s
-          spatial_info = spatial_column_info(table_name)
-          if spatial_info.include?(column_name)
-            execute("SELECT DropGeometryColumn('#{quote_string(table_name)}','#{quote_string(column_name)}')")
-          else
-            super
-          end
-        end
-
-        # FULL REPLACEMENT. RE-CHECK ON NEW VERSIONS
-        # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb
-        def add_index(table_name, column_name, options = {})
-          # We have to fully replace to add the gist clause.
-          options ||= {} # in case nil explicitly passed
-          gist = options.delete(:spatial)
-          index_name, index_type, index_columns, index_options, index_algorithm, index_using = add_index_options(table_name, column_name, options)
-          index_using = 'USING GIST' if gist
-          execute "CREATE #{index_type} INDEX #{index_algorithm} #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} #{index_using} (#{index_columns})#{index_options}"
-        end
-
-        def spatial_column_info(table_name)
-          SpatialColumnInfo.new(self, quote_string(table_name.to_s)).all
-        end
-
-        private
-
-        def add_spatial_column(table_name, column_name, type, options)
-          limit = options[:limit]
-          info = options[:info] || {}
-          options.merge!(limit) if limit.is_a?(::Hash)
-          type = (options[:type] || info[:type] || type).to_s.gsub('_', '').upcase
-          has_z = options[:has_z]
-          has_m = options[:has_m]
-          srid = (options[:srid] || PostGISAdapter::DEFAULT_SRID).to_i
-          if options[:geographic]
-            type << 'Z' if has_z
-            type << 'M' if has_m
-            execute("ALTER TABLE #{quote_table_name(table_name)} ADD COLUMN #{quote_column_name(column_name)} GEOGRAPHY(#{type},#{srid})")
-            change_column_default(table_name, column_name, options[:default]) if options_include_default?(options)
-            change_column_null(table_name, column_name, false, options[:default]) if options[:null] == false
-          else
-            type = "#{type}M" if has_m && !has_z
-            dimensions = set_dimensions(has_m, has_z)
-            execute("SELECT AddGeometryColumn('#{quote_string(table_name)}', '#{quote_string(column_name)}', #{srid}, '#{quote_string(type)}', #{dimensions})")
-            change_column_null(table_name, column_name, false, options[:default]) if options[:null] == false
-          end
-        end
-
-        def column_type_map
-          if defined?(type_map) # ActiveRecord 4.1+
-            type_map
-          else # ActiveRecord 4.0.x
-            OID::TYPE_MAP
-          end
-        end
-
-        def set_dimensions(has_m, has_z)
-          dimensions = 2
-          dimensions += 1 if has_z
-          dimensions += 1 if has_m
-          dimensions
-        end
       end
     end
   end

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

@@ -0,0 +1,119 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostGISAdapter
+      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)
+            @geo_type, @srid, @has_z, @has_m = self.class.parse_sql_type(sql_type)
+            @factory_generator = RGeo::Geographic.spherical_factory(srid: 4326) if oid =~ /geography/
+          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, srid, has_z, has_m = nil, 0, false, false
+
+            if (sql_type =~ /[geography,geography]\((.*)\)$/i)
+              # geometry(Point,4326)
+              params = $1.split(',')
+              if params.size > 1
+                if params.first =~ /([a-z]+[^zm])(z?)(m?)/i
+                  has_z = $2.length > 0
+                  has_m = $3.length > 0
+                  geo_type = $1
+                end
+                if params.last =~ /(\d+)/
+                  srid = $1.to_i
+                end
+              else
+                # geometry(Point)
+                geo_type = params[0]
+              end
+            else
+              # geometry
+              geo_type = sql_type
+            end
+            [geo_type, srid, has_z, has_m]
+          end
+
+          def factory_generator
+            @factory_generator
+          end
+
+          def geographic?
+            !!factory_generator
+          end
+
+          def spatial?
+            true
+          end
+
+          def type
+            geographic? ? :geography : :geometry
+          end
+
+          # support setting an RGeo object or a WKT string
+          def type_cast_for_database(value)
+            return if value.nil?
+            geo_value = type_cast(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 type_cast(value)
+            return if value.nil?
+            String === value ? parse_wkt(value) : value
+          end
+
+          def cast_value(value)
+            return if value.nil?
+            RGeo::WKRep::WKBParser.new(@factory_generator, support_ewkb: true).parse(value)
+          rescue RGeo::Error::ParseError
+            puts "\ncast failed!!\n\n"
+            nil
+          end
+
+          # convert WKT string into RGeo object
+          def parse_wkt(string)
+            # factory = factory_settings.get_column_factory(table_name, column, constraints)
+            factory = @factory_generator || RGeo::ActiveRecord::RGeoFactorySettings.new
+            wkt_parser(factory, string).parse(string)
+          rescue RGeo::Error::ParseError
+            nil
+          end
+
+          def binary?(string)
+            string[0] == "\x00" || string[0] == "\x01" || string[0, 4] =~ /[0-9a-fA-F]{4}/
+          end
+
+          def wkt_parser(factory, string)
+            if binary?(string)
+              RGeo::WKRep::WKBParser.new(factory, support_ewkb: true, default_srid: @srid)
+            else
+              RGeo::WKRep::WKTParser.new(factory, support_ewkt: true, default_srid: @srid)
+            end
+          end
+
+        end
+      end
+    end
+  end
+end