activerecord-postgresql-extensions 0.0.12 → 0.1.0

data/lib/{postgresql_extensions/postgresql_extensions.rb → active_record/postgresql_extensions/extensions.rb}

@@ -3,7 +3,7 @@ require 'active_record/connection_adapters/postgresql_adapter'
 
 module ActiveRecord
   module ConnectionAdapters
-    class PostgreSQLAdapter < AbstractAdapter
+    class PostgreSQLAdapter
       # Creates a new PostgreSQL text search configuration. You must provide
       # either a parser_name or a source_config option as per the PostgreSQL
       # text search docs.

data/lib/{postgresql_extensions → active_record/postgresql_extensions}/foreign_key_associations.rb

@@ -1,5 +1,5 @@
 
-module PostgreSQLExtensions::ActiveRecord
+module ActiveRecord::PostgreSQLExtensions
   # The ForeignKeyAssociations module attempts to automatically create
   # associations based on your database schema by looking at foreign key
   # relationships. It can be enabled by setting the
@@ -365,3 +365,11 @@ ActiveRecord::Base.class_eval do
   # convention of "FirstModelSecondModel".
   cattr_accessor :strict_foreign_key_has_many_throughs
 end
+
+# for backwards compatibility with the older module name.
+module PostgreSQLExtensions
+  module ActiveRecord
+    ForeignKeyAssociations = ::ActiveRecord::PostgreSQLExtensions::ForeignKeyAssociations
+  end
+end
+

data/lib/{postgresql_extensions/postgresql_functions.rb → active_record/postgresql_extensions/functions.rb}

@@ -27,7 +27,7 @@ module ActiveRecord
   end
 
   module ConnectionAdapters
-    class PostgreSQLAdapter < AbstractAdapter
+    class PostgreSQLAdapter
       # Creates a PostgreSQL function/stored procedure.
       #
       # +args+ is a simple String that you can use to represent the
@@ -306,10 +306,16 @@ module ActiveRecord
 
       private
         def build_statement(k, v) #:nodoc:
-          sql = "ALTER FUNCTION #{base.quote_function(@new_name || name)}(#{args}) "
+          new_name = if defined?(@new_name) && @new_name
+            @new_name
+          else
+            self.name
+          end
+
+          sql = "ALTER FUNCTION #{base.quote_function(new_name)}(#{args}) "
           sql << case k
             when :rename_to
-              "RENAME TO #{base.quote_generic_ignore_schema(v)}".tap { @new_name = v }
+              "RENAME TO #{base.quote_generic_ignore_scoped_schema(v)}".tap { @new_name = v }
             when :owner_to
               "OWNER TO #{base.quote_role(v)}"
             when :set_schema

data/lib/{postgresql_extensions/postgresql_geometry.rb → active_record/postgresql_extensions/geometry.rb}

@@ -1,5 +1,6 @@
 
 require 'active_record/connection_adapters/postgresql_adapter'
+require 'active_record/postgresql_extensions/postgis'
 
 module ActiveRecord
   class InvalidGeometryType < ActiveRecordError #:nodoc:
@@ -8,46 +9,71 @@ module ActiveRecord
     end
   end
 
+  class InvalidSpatialColumnType < ActiveRecordError #:nodoc:
+    def initialize(type)
+      super("Invalid PostGIS spatial column type - #{type}")
+    end
+  end
+
   class InvalidGeometryDimensions < ActiveRecordError #:nodoc:
   end
 
   module ConnectionAdapters
-    class PostgreSQLAdapter < AbstractAdapter
-      def native_database_types_with_geometry #:nodoc:
-        native_database_types_without_geometry.merge({
-          :geometry => { :name => 'geometry' }
+    class PostgreSQLAdapter
+      def native_database_types_with_spatial_types #:nodoc:
+        native_database_types_without_spatial_types.merge({
+          :geometry => { :name => 'geometry' },
+          :geography => { :name => 'geography' }
         })
       end
-      alias_method_chain :native_database_types, :geometry
+      alias_method_chain :native_database_types, :spatial_types
     end
 
-    class PostgreSQLTableDefinition < TableDefinition
-      attr_reader :geometry_columns
+    class PostgreSQLGeometryColumnDefinition
+    end
 
-      # This is a special geometry type for the PostGIS extension's
-      # geometry data type. It is used in a table definition to define
-      # a geometry column.
+    class PostgreSQLTableDefinition < TableDefinition
+      # This is a special spatial type for the PostGIS extension's
+      # data types. It is used in a table definition to define
+      # a spatial column.
+      #
+      # Depending on the version of PostGIS being used, we'll try to create
+      # geometry columns in a post-2.0-ish, typmod-based way or a pre-2.0-ish
+      # AddGeometryColumn-based way. We can also add CHECK constraints and
+      # create a GiST index on the column all in one go.
       #
-      # Essentially this method works like a wrapper around the PostGIS
-      # AddGeometryColumn function. It can create the geometry column,
-      # add CHECK constraints and create a GiST index on the column
-      # all in one go.
+      # In versions of PostGIS prior to 2.0, geometry columns are created using
+      # the AddGeometryColumn and will created with CHECK constraints where
+      # appropriate and entries to the <tt>geometry_columns</tt> will be
+      # updated accordingly.
+      #
+      # In versions of PostGIS after 2.0, geometry columns are creating using
+      # typmod specifiers. CHECK constraints can still be created, but their
+      # creation must be forced using the <tt>:force_constraints</tt> option.
+      #
+      # The <tt>geometry</tt> and <tt>geography</tt> methods are shortcuts to
+      # calling the <tt>spatial</tt> method with the <tt>:spatial_column_type</tt>
+      # option set accordingly.
       #
       # ==== Options
       #
+      # * <tt>:spatial_column_type</tt> - the column type. This value can
+      #   be one of <tt>:geometry</tt> or <tt>:geography</tt>. This value
+      #   doesn't refer to the spatial type used by the column, but rather
+      #   by the actual column type itself.
       # * <tt>:geometry_type</tt> - set the geometry type. The actual
-      #   data type is always "geometry"; this option is used in the
-      #   <tt>geometry_columns</tt> table and on the CHECK constraints
-      #   to enforce the geometry type allowed in the field. The default
-      #   is "GEOMETRY". See the PostGIS documentation for valid types,
-      #   or check out the GEOMETRY_TYPES constant in this extension.
+      #   data type is either "geometry" or "geography"; this option refers to
+      #   the spatial type being used.
       # * <tt>:add_constraints</tt> - automatically creates the CHECK
       #   constraints used to enforce ndims, srid and geometry type.
       #   The default is true.
+      # * <tt>:force_constraints</tt> - forces the creation of CHECK
+      #   constraints in versions of PostGIS post-2.0.
       # * <tt>:add_geometry_columns_entry</tt> - automatically adds
       #   an entry to the <tt>geometry_columns</tt> table. We will
       #   try to delete any existing match in <tt>geometry_columns</tt>
-      #   before inserting. The default is true.
+      #   before inserting. The default is true. This value is ignored in
+      #   versions of PostGIS post-2.0.
       # * <tt>:create_gist_index</tt> - automatically creates a GiST
       #   index for the new geometry column. This option accepts either
       #   a true/false expression or a String. If the value is a String,
@@ -58,15 +84,20 @@ module ActiveRecord
       #   <tt>:geometry_type</tt> ends in an "m" (for "measured
       #   geometries" the default is 3); for everything else, it is 2.
       # * <tt>:srid</tt> - the SRID, a.k.a. the Spatial Reference
-      #   Identifier. The default is -1, which is a special SRID
-      #   PostGIS in lieu of a real SRID.
-      def geometry(column_name, opts = {})
+      #   Identifier. The default depends on the version of PostGIS being used
+      #   and the spatial column type being used. Refer to the PostGIS docs
+      #   for the specifics, but generally this means either a value of -1
+      #   for versions of PostGIS prior to 2.0 for geometry columns and a value
+      #   of 0 for versions post-2.0 and for all geography columns.
+      def spatial(column_name, opts = {})
         opts = {
+          :spatial_column_type => :geometry,
           :geometry_type => :geometry,
           :add_constraints => true,
+          :force_constraints => false,
           :add_geometry_columns_entry => true,
           :create_gist_index => true,
-          :srid => -1
+          :srid => ActiveRecord::PostgreSQLExtensions::PostGIS.UNKNOWN_SRID
         }.merge(opts)
 
         if opts[:ndims].blank?
@@ -77,25 +108,41 @@ module ActiveRecord
           end
         end
 
+        assert_valid_spatial_column_type(opts[:spatial_column_type])
         assert_valid_geometry_type(opts[:geometry_type])
         assert_valid_ndims(opts[:ndims], opts[:geometry_type])
 
-        column = self[column_name] || ColumnDefinition.new(base, column_name, :geometry)
+        column_type = if ActiveRecord::PostgreSQLExtensions::PostGIS.VERSION[:lib] < '2.0'
+          opts[:spatial_column_type]
+        else
+          column_args = [ opts[:geometry_type].to_s.upcase ]
+
+          if ![ 0, -1 ].include?(opts[:srid])
+            column_args << opts[:srid]
+          end
+
+          "#{opts[:spatial_column_type]}(#{column_args.join(', ')})"
+        end
+
+        column = self[column_name] || ColumnDefinition.new(base, column_name, column_type)
         column.default = opts[:default]
         column.null = opts[:null]
 
         unless @columns.include?(column)
           @columns << column
-          if opts[:add_constraints]
+          if opts[:add_constraints] && (
+            ActiveRecord::PostgreSQLExtensions::PostGIS.VERSION[:lib] < '2.0' ||
+            opts[:force_constraints]
+          )
             @table_constraints << PostgreSQLCheckConstraint.new(
               base,
-              "srid(#{base.quote_column_name(column_name)}) = (#{opts[:srid].to_i})",
+              "ST_srid(#{base.quote_column_name(column_name)}) = (#{opts[:srid].to_i})",
               :name => "enforce_srid_#{column_name}"
             )
 
             @table_constraints << PostgreSQLCheckConstraint.new(
               base,
-              "ndims(#{base.quote_column_name(column_name)}) = #{opts[:ndims].to_i}",
+              "ST_ndims(#{base.quote_column_name(column_name)}) = #{opts[:ndims].to_i}",
               :name => "enforce_dims_#{column_name}"
             )
 
@@ -111,10 +158,10 @@ module ActiveRecord
 
         # We want to split up the schema and the table name for the
         # upcoming geometry_columns rows and GiST index.
-        current_schema, current_table_name = if self.table_name.is_a?(Hash)
+        current_scoped_schema, current_table_name = if self.table_name.is_a?(Hash)
           [ self.table_name.keys.first, self.table_name.values.first ]
-        elsif base.current_schema
-          [ base.current_schema, self.table_name ]
+        elsif base.current_scoped_schema
+          [ base.current_scoped_schema, self.table_name ]
         else
           schema, table_name = base.extract_schema_and_table_names(self.table_name)
           [ schema || 'public', table_name ]
@@ -122,20 +169,23 @@ module ActiveRecord
 
         @post_processing ||= Array.new
 
-        if opts[:add_geometry_columns_entry]
+        if opts[:add_geometry_columns_entry] &&
+          opts[:spatial_column_type].to_s != 'geography' &&
+          ActiveRecord::PostgreSQLExtensions::PostGIS.VERSION[:lib] < '2.0'
+
           @post_processing << sprintf(
             "DELETE FROM \"geometry_columns\" WHERE f_table_catalog = '' AND " +
             "f_table_schema = %s AND " +
             "f_table_name = %s AND " +
             "f_geometry_column = %s;",
-            base.quote(current_schema.to_s),
+            base.quote(current_scoped_schema.to_s),
             base.quote(current_table_name.to_s),
             base.quote(column_name.to_s)
           )
 
           @post_processing << sprintf(
             "INSERT INTO \"geometry_columns\" VALUES ('', %s, %s, %s, %d, %d, %s);",
-            base.quote(current_schema.to_s),
+            base.quote(current_scoped_schema.to_s),
             base.quote(current_table_name.to_s),
             base.quote(column_name.to_s),
             opts[:ndims].to_i,
@@ -154,7 +204,7 @@ module ActiveRecord
           @post_processing << PostgreSQLIndexDefinition.new(
             base,
             index_name,
-            current_table_name,
+            { current_scoped_schema => current_table_name },
             column_name,
             :using => :gist
           ).to_s
@@ -163,6 +213,20 @@ module ActiveRecord
         self
       end
 
+      def geometry(column_name, opts = {})
+        self.spatial(column_name, opts)
+      end
+
+      def geography(column_name, opts = {})
+        opts = {
+          :srid => ActiveRecord::PostgreSQLExtensions::PostGIS.UNKNOWN_SRIDS[:geography]
+        }.merge(opts)
+
+        self.spatial(column_name, opts.merge(
+          :spatial_column_type => :geography
+        ))
+      end
+
       private
         GEOMETRY_TYPES = [
           'GEOMETRY',
@@ -173,6 +237,7 @@ module ActiveRecord
           'MULTIPOLYGON',
           'LINESTRING',
           'MULTILINESTRING',
+          'GEOMETRYM',
           'GEOMETRYCOLLECTIONM',
           'POINTM',
           'MULTIPOINTM',
@@ -192,12 +257,23 @@ module ActiveRecord
           'MULTISURFACEM'
         ].freeze
 
+        SPATIAL_COLUMN_TYPES = [
+          'geometry',
+          'geography'
+        ].freeze
+
         def assert_valid_geometry_type(type)
           if !GEOMETRY_TYPES.include?(type.to_s.upcase)
             raise ActiveRecord::InvalidGeometryType.new(type)
           end unless type.nil?
         end
 
+        def assert_valid_spatial_column_type(type)
+          if !SPATIAL_COLUMN_TYPES.include?(type.to_s)
+            raise ActiveRecord::InvalidSpatialColumnType.new(type)
+          end unless type.nil?
+        end
+
         def assert_valid_ndims(ndims, type)
           if !ndims.blank?
             if type.to_s.upcase =~ /([A-Z]+M)$/ && ndims != 3

data/lib/{postgresql_extensions/postgresql_indexes.rb → active_record/postgresql_extensions/indexes.rb}

@@ -1,4 +1,6 @@
 
+require 'active_record/connection_adapters/postgresql_adapter'
+
 module ActiveRecord
   class InvalidIndexColumnDefinition < ActiveRecordError #:nodoc:
     def initialize(msg, column)
@@ -13,7 +15,7 @@ module ActiveRecord
   end
 
   module ConnectionAdapters
-    class PostgreSQLAdapter < AbstractAdapter
+    class PostgreSQLAdapter
       # Creates an index. This method is an alternative to the standard
       # ActiveRecord add_index method and includes PostgreSQL-specific
       # options.
@@ -179,7 +181,7 @@ module ActiveRecord
         sql << ')'
         sql << " WITH (FILLFACTOR = #{options[:fill_factor].to_i})" if options[:fill_factor]
         sql << " TABLESPACE #{base.quote_tablespace(options[:tablespace])}" if options[:tablespace]
-        sql << " WHERE #{options[:conditions] || options[:where]}" if options[:conditions] || options[:where]
+        sql << " WHERE (#{options[:conditions] || options[:where]})" if options[:conditions] || options[:where]
         "#{sql};"
       end
       alias :to_s :to_sql

data/lib/{postgresql_extensions/postgresql_languages.rb → active_record/postgresql_extensions/languages.rb}

@@ -3,7 +3,7 @@ require 'active_record/connection_adapters/postgresql_adapter'
 
 module ActiveRecord
   module ConnectionAdapters
-    class PostgreSQLAdapter < AbstractAdapter
+    class PostgreSQLAdapter
       # Creates a PostgreSQL procedural language.
       #
       # Note that you can grant privileges on languages using the

data/lib/{postgresql_extensions/postgresql_permissions.rb → active_record/postgresql_extensions/permissions.rb}

@@ -9,7 +9,7 @@ module ActiveRecord
   end
 
   module ConnectionAdapters
-    class PostgreSQLAdapter < AbstractAdapter
+    class PostgreSQLAdapter
       # Grants privileges on tables. You can specify multiple tables,
       # roles and privileges all at once using Arrays for each of the
       # desired parameters. See PostgreSQLGrantPrivilege for
@@ -224,7 +224,7 @@ module ActiveRecord
         sql << Array(objects).collect do |t|
           if my_query_options[:quote_objects]
             if my_query_options[:ignore_schema]
-              base.quote_generic_ignore_schema(t)
+              base.quote_generic_ignore_scoped_schema(t)
             else
               base.quote_table_name(t)
             end
@@ -293,7 +293,7 @@ module ActiveRecord
         sql << Array(objects).collect do |t|
           if my_query_options[:quote_objects]
             if my_query_options[:ignore_schema]
-              base.quote_generic_ignore_schema(t)
+              base.quote_generic_ignore_scoped_schema(t)
             else
               base.quote_table_name(t)
             end

data/lib/active_record/postgresql_extensions/postgis.rb

@@ -0,0 +1,53 @@
+
+module ActiveRecord
+  module PostgreSQLExtensions
+    module PostGIS
+      class << self
+        def VERSION
+          return @VERSION if defined?(@VERSION)
+
+          @VERSION = if (version_string = ::ActiveRecord::Base.connection.select_rows("SELECT postgis_full_version()").flatten.first).present?
+            hash = {
+              :use_stats => version_string =~ /USE_STATS/
+            }
+
+            {
+              :lib => /POSTGIS="([^"]+)"/,
+              :geos => /GEOS="([^"]+)"/,
+              :proj => /PROJ="([^"]+)"/,
+              :libxml => /LIBXML="([^"]+)"/
+            }.each do |k, v|
+              hash[k] = version_string.scan(v).flatten.first
+            end
+
+            hash.freeze
+          else
+            nil
+          end
+        end
+
+        def UNKNOWN_SRIDS
+          return @UNKNOWN_SRIDS if defined?(@UNKNOWN_SRIDS)
+
+          @UNKNOWN_SRIDS = if self.VERSION[:lib] >= '2.0'
+            {
+              :geography => 0,
+              :geometry  => 0
+            }.freeze
+          else
+            {
+              :geography =>  0,
+              :geometry  => -1
+            }.freeze
+          end
+        end
+
+        def UNKNOWN_SRID
+          return @UNKNOWN_SRID if defined?(@UNKNOWN_SRID)
+
+          @UNKNOWN_SRID = self.UNKNOWN_SRIDS[:geometry]
+        end
+      end
+    end
+  end
+end

data/lib/{postgresql_extensions/postgresql_roles.rb → active_record/postgresql_extensions/roles.rb}

@@ -9,7 +9,7 @@ module ActiveRecord
   end
 
   module ConnectionAdapters
-    class PostgreSQLAdapter < AbstractAdapter
+    class PostgreSQLAdapter
       def create_role(name, options = {})
         execute PostgreSQLRole.new(self, :create, name, options).to_sql
       end