postgis_adapter 0.1.8

data/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + "/rails/init"

data/lib/postgis_adapter.rb

@@ -0,0 +1,388 @@
+# #
+# PostGIS Adapter
+#
+# Spatial Adapter PostGIS Adapter for ActiveRecord
+#
+#
+#require 'active_record'
+require 'geo_ruby'
+require 'postgis_adapter/common_spatial_adapter'
+require 'postgis_functions'
+require 'postgis_functions/common'
+require 'postgis_functions/class'
+require 'postgis_functions/point'
+require 'postgis_functions/linestring'
+require 'postgis_functions/polygon'
+require 'postgis_functions/bbox'
+require 'postgis_adapter/acts_as_geom'
+
+include GeoRuby::SimpleFeatures
+include SpatialAdapter
+
+module PostgisAdapter
+  VERSION = '0.1.8'
+end
+
+#tables to ignore in migration : relative to PostGIS management of geometric columns
+ActiveRecord::SchemaDumper.ignore_tables << "spatial_ref_sys" << "geometry_columns"
+
+
+#add a method to_yaml to the Geometry class which will transform a geometry in a form suitable to be used in a YAML file (such as in a fixture)
+GeoRuby::SimpleFeatures::Geometry.class_eval do
+  def to_fixture_format
+    as_hex_ewkb
+  end
+end
+
+
+ActiveRecord::Base.class_eval do
+  require 'active_record/version'
+
+    #Vit Ondruch & Tilmann Singer 's patch
+    def self.get_conditions(attrs)
+      attrs.map do |attr, value|
+        attr = attr.to_s
+        if columns_hash[attr].is_a?(SpatialColumn)
+          if value.is_a?(Array)
+            attrs[attr.to_sym]= "BOX3D(" + value[0].join(" ") + "," + value[1].join(" ") + ")"
+            "#{table_name}.#{connection.quote_column_name(attr)} && SetSRID(?::box3d, #{value[2] || DEFAULT_SRID} ) "
+          elsif value.is_a?(Envelope)
+            attrs[attr.to_sym]= "BOX3D(" + value.lower_corner.text_representation + "," + value.upper_corner.text_representation + ")"
+            "#{table_name}.#{connection.quote_column_name(attr)} && SetSRID(?::box3d, #{value.srid} ) "
+          else
+            "#{table_name}.#{connection.quote_column_name(attr)} && ? "
+          end
+        else
+          "#{table_name}.#{connection.quote_column_name(attr)} #{attribute_condition(value)}"
+        end
+      end.join(' AND ')
+    end
+
+    #For Rails >= 2
+    def self.sanitize_sql_hash_for_conditions(attrs)
+      conditions = get_conditions(attrs)
+      replace_bind_variables(conditions, expand_range_bind_variables(attrs.values))
+    end
+
+end
+
+ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
+
+  include SpatialAdapter
+
+  alias :original_native_database_types :native_database_types
+  def native_database_types
+    original_native_database_types.update(geometry_data_types)
+  end
+
+  alias :original_quote :quote
+  #Redefines the quote method to add behaviour for when a Geometry is encountered
+  def quote(value, column = nil)
+    if value.kind_of?(GeoRuby::SimpleFeatures::Geometry)
+      "'#{value.as_hex_ewkb}'"
+    else
+      original_quote(value,column)
+    end
+  end
+
+  alias :original_tables :tables
+  def tables(name = nil) #:nodoc:
+    schemas = schema_search_path.split(/,/).map { |p| quote(p.strip) }.join(',')
+    original_tables(name) + query(<<-SQL, name).map { |row| row[0] }
+      SELECT viewname
+        FROM pg_views
+        WHERE schemaname IN (#{schemas})
+    SQL
+  end
+
+  def create_table(name, options = {})
+    table_definition = ActiveRecord::ConnectionAdapters::PostgreSQLTableDefinition.new(self)
+    table_definition.primary_key(options[:primary_key] || "id") unless options[:id] == false
+
+    yield table_definition
+
+    if options[:force]
+      drop_table(name) rescue nil
+    end
+
+    create_sql = "CREATE#{' TEMPORARY' if options[:temporary]} TABLE "
+    create_sql << "#{name} ("
+    create_sql << table_definition.to_sql
+    create_sql << ") #{options[:options]}"
+    execute create_sql
+
+    #added to create the geometric columns identified during the table definition
+    unless table_definition.geom_columns.nil?
+      table_definition.geom_columns.each do |geom_column|
+        execute geom_column.to_sql(name)
+      end
+    end
+  end
+
+  alias :original_remove_column :remove_column
+  def remove_column(table_name,column_name, options = {})
+    columns(table_name).each do |col|
+      if col.name == column_name.to_s
+        #check if the column is geometric
+        unless geometry_data_types[col.type].nil? or
+               (options[:remove_using_dropgeometrycolumn] == false)
+          execute "SELECT DropGeometryColumn('#{table_name}','#{column_name}')"
+        else
+          original_remove_column(table_name,column_name)
+        end
+      end
+    end
+  end
+
+  alias :original_add_column :add_column
+  def add_column(table_name, column_name, type, options = {})
+    unless geometry_data_types[type].nil? or (options[:create_using_addgeometrycolumn] == false)
+      geom_column = ActiveRecord::ConnectionAdapters::PostgreSQLColumnDefinition.
+        new(self,column_name, type, nil,nil,options[:null],options[:srid] || -1 ,
+        options[:with_z] || false , options[:with_m] || false)
+
+      execute geom_column.to_sql(table_name)
+    else
+      original_add_column(table_name,column_name,type,options)
+    end
+  end
+
+  # Adds a GIST spatial index to a column. Its name will be
+  # <table_name>_<column_name>_spatial_index unless
+  # the key :name is present in the options hash, in which case its
+  # value is taken as the name of the index.
+  def add_index(table_name,column_name,options = {})
+    index_name = options[:name] || index_name(table_name,:column => Array(column_name))
+    if options[:spatial]
+      execute "CREATE INDEX #{index_name} ON #{table_name} USING GIST (#{Array(column_name).join(", ")} GIST_GEOMETRY_OPS)"
+    else
+      index_type = options[:unique] ? "UNIQUE" : ""
+      #all together
+      execute "CREATE #{index_type} INDEX #{index_name} ON #{table_name} (#{Array(column_name).join(", ")})"
+    end
+  end
+
+  def indexes(table_name, name = nil) #:nodoc:
+    result = query(<<-SQL, name)
+          SELECT i.relname, d.indisunique, a.attname , am.amname
+            FROM pg_class t, pg_class i, pg_index d, pg_attribute a, pg_am am
+           WHERE i.relkind = 'i'
+             AND d.indexrelid = i.oid
+             AND d.indisprimary = 'f'
+             AND t.oid = d.indrelid
+             AND i.relam = am.oid
+             AND t.relname = '#{table_name}'
+             AND a.attrelid = t.oid
+             AND ( d.indkey[0]=a.attnum OR d.indkey[1]=a.attnum
+                OR d.indkey[2]=a.attnum OR d.indkey[3]=a.attnum
+                OR d.indkey[4]=a.attnum OR d.indkey[5]=a.attnum
+                OR d.indkey[6]=a.attnum OR d.indkey[7]=a.attnum
+                OR d.indkey[8]=a.attnum OR d.indkey[9]=a.attnum )
+          ORDER BY i.relname
+        SQL
+
+    current_index = nil
+    indexes = []
+
+    result.each do |row|
+      if current_index != row[0]
+        #index type gist indicates a spatial index (probably not totally true but let's simplify!)
+        indexes << ActiveRecord::ConnectionAdapters::IndexDefinition.
+          new(table_name, row[0], row[1] == "t", row[3] == "gist" ,[])
+
+        current_index = row[0]
+      end
+      indexes.last.columns << row[2]
+    end
+    indexes
+  end
+
+  def columns(table_name, name = nil) #:nodoc:
+    raw_geom_infos = column_spatial_info(table_name)
+
+    column_definitions(table_name).collect do |name, type, default, notnull|
+      if type =~ /geometry/i
+        raw_geom_info = raw_geom_infos[name]
+        if raw_geom_info.nil?
+          ActiveRecord::ConnectionAdapters::SpatialPostgreSQLColumn.create_simplified(name,default,notnull == "f")
+        else
+          ActiveRecord::ConnectionAdapters::SpatialPostgreSQLColumn.new(name, default,raw_geom_info.type, notnull == "f", raw_geom_info.srid, raw_geom_info.with_z, raw_geom_info.with_m)
+        end
+      else
+        ActiveRecord::ConnectionAdapters::Column.new(name, ActiveRecord::ConnectionAdapters::PostgreSQLColumn.extract_value_from_default( default), type,notnull == "f")
+      end
+    end
+  end
+
+#  # For version of Rails where exists disable_referential_integrity
+#  if self.instance_methods.include? "disable_referential_integrity"
+#    #Pete Deffendol's patch
+#    alias :original_disable_referential_integrity :disable_referential_integrity
+#    def disable_referential_integrity(&block) #:nodoc:
+#      ignore_tables = %w{ geometry_columns spatial_ref_sys }
+#      execute(tables.select { |name| !ignore_tables.include?(name) }.collect { |name| "ALTER TABLE #{quote_table_name(name)} DISABLE TRIGGER ALL" }.join(";"))
+#      yield
+#    ensure
+#      execute(tables.select { |name| !ignore_tables.include?(name)}.collect { |name| "ALTER TABLE #{quote_table_name(name)} ENABLE TRIGGER ALL" }.join(";"))
+#    end
+#  end
+
+  private
+
+  def column_spatial_info(table_name)
+    constr = query <<-end_sql
+SELECT * FROM geometry_columns WHERE f_table_name = '#{table_name}'
+    end_sql
+
+    raw_geom_infos = {}
+    constr.each do |constr_def_a|
+      raw_geom_infos[constr_def_a[3]] ||= ActiveRecord::ConnectionAdapters::RawGeomInfo.new
+      raw_geom_infos[constr_def_a[3]].type = constr_def_a[6]
+      raw_geom_infos[constr_def_a[3]].dimension = constr_def_a[4].to_i
+      raw_geom_infos[constr_def_a[3]].srid = constr_def_a[5].to_i
+
+      if raw_geom_infos[constr_def_a[3]].type[-1] == ?M
+        raw_geom_infos[constr_def_a[3]].with_m = true
+        raw_geom_infos[constr_def_a[3]].type.chop!
+      else
+        raw_geom_infos[constr_def_a[3]].with_m = false
+      end
+    end
+
+    raw_geom_infos.each_value do |raw_geom_info|
+      #check the presence of z and m
+      raw_geom_info.convert!
+    end
+
+    raw_geom_infos
+
+  end
+
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+    class RawGeomInfo < Struct.new(:type,:srid,:dimension,:with_z,:with_m) #:nodoc:
+      def convert!
+        self.type = "geometry" if self.type.nil? #if geometry the geometrytype constraint is not present : need to set the type here then
+
+        if dimension == 4
+          self.with_m = true
+          self.with_z = true
+        elsif dimension == 3
+          if with_m
+            self.with_z = false
+            self.with_m = true
+          else
+            self.with_z = true
+            self.with_m = false
+          end
+        else
+          self.with_z = false
+          self.with_m = false
+        end
+      end
+    end
+  end
+end
+
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLTableDefinition < TableDefinition
+      attr_reader :geom_columns
+
+      def column(name, type, options = {})
+        unless (@base.geometry_data_types[type.to_sym].nil? or
+                (options[:create_using_addgeometrycolumn] == false))
+
+          geom_column = PostgreSQLColumnDefinition.new(@base,name, type)
+          geom_column.null = options[:null]
+          geom_column.srid = options[:srid] || -1
+          geom_column.with_z = options[:with_z] || false
+          geom_column.with_m = options[:with_m] || false
+
+          @geom_columns = [] if @geom_columns.nil?
+          @geom_columns << geom_column
+        else
+          super(name,type,options)
+        end
+      end
+
+      SpatialAdapter.geometry_data_types.keys.each do |column_type|
+        class_eval <<-EOV
+          def #{column_type}(*args)
+            options = args.extract_options!
+            column_names = args
+
+            column_names.each { |name| column(name, '#{column_type}', options) }
+          end
+        EOV
+      end
+    end
+
+    class PostgreSQLColumnDefinition < ColumnDefinition
+      attr_accessor :srid, :with_z,:with_m
+      attr_reader :spatial
+
+      def initialize(base = nil, name = nil, type=nil, limit=nil, default=nil,null=nil,srid=-1,with_z=false,with_m=false)
+        super(base, name, type, limit, default,null)
+        @spatial=true
+        @srid=srid
+        @with_z=with_z
+        @with_m=with_m
+      end
+
+      def to_sql(table_name)
+        if @spatial
+          type_sql = type_to_sql(type.to_sym)
+          type_sql += "M" if with_m and !with_z
+          if with_m and with_z
+            dimension = 4
+          elsif with_m or with_z
+            dimension = 3
+          else
+            dimension = 2
+          end
+
+          column_sql = "SELECT AddGeometryColumn('#{table_name}','#{name}',#{srid},'#{type_sql}',#{dimension})"
+          column_sql += ";ALTER TABLE #{table_name} ALTER #{name} SET NOT NULL" if null == false
+          column_sql
+        else
+          super
+        end
+      end
+
+
+      private
+      def type_to_sql(name, limit=nil)
+        base.type_to_sql(name, limit) rescue name
+      end
+
+    end
+
+  end
+end
+
+#Would prefer creation of a PostgreSQLColumn type instead but I would
+# need to reimplement methods where Column objects are instantiated so
+# I leave it like this
+module ActiveRecord
+  module ConnectionAdapters
+    class SpatialPostgreSQLColumn < Column
+
+      include SpatialColumn
+
+      #Transforms a string to a geometry. PostGIS returns a HewEWKB string.
+      def self.string_to_geometry(string)
+        return string unless string.is_a?(String)
+        GeoRuby::SimpleFeatures::Geometry.from_hex_ewkb(string) rescue nil
+      end
+
+      def self.create_simplified(name,default,null = true)
+        new(name,default,"geometry",null,nil,nil,nil)
+      end
+
+    end
+  end
+end

data/lib/postgis_adapter/acts_as_geom.rb

@@ -0,0 +1,39 @@
+# #
+# PostGIS Adapter
+#
+#
+# http://github.com/nofxx/postgis_adapter
+#
+module PostgisFunctions
+  def self.included(base)
+    base.send :extend, ClassMethods
+  end
+
+  module ClassMethods
+
+    # acts_as_geom :geom
+    def acts_as_geom(*columns)
+      cattr_accessor :postgis_geoms
+
+      geoms = columns.map do |g|
+        geom_type = get_geom_type(g)
+        case geom_type
+        when :point
+          send :include, PointFunctions
+        when :polygon
+          send :include, PolygonFunctions
+        when :line_string
+          send :include, LineStringFunctions
+        end
+        {g => geom_type}
+      end
+      self.postgis_geoms = {:geoms => geoms}#, :opts => options}
+    end
+
+    def get_geom_type(column)
+      self.columns.select { |c| c.name == column.to_s}.first.geometry_type
+    end
+  end
+end
+
+ActiveRecord::Base.send :include, PostgisFunctions

data/lib/postgis_adapter/common_spatial_adapter.rb

@@ -0,0 +1,179 @@
+# #
+# PostGIS Adapter
+#
+# Common Spatial Adapter for ActiveRecord
+#
+#
+#Addition of a flag indicating if the index is spatial
+ActiveRecord::ConnectionAdapters::IndexDefinition.class_eval do
+  attr_accessor :spatial
+
+  def initialize(table, name, unique, spatial,columns)
+    super(table,name,unique,columns)
+    @spatial = spatial
+  end
+
+end
+
+ActiveRecord::SchemaDumper.class_eval do
+  def table(table, stream)
+
+    columns = @connection.columns(table)
+    begin
+      tbl = StringIO.new
+
+      if @connection.respond_to?(:pk_and_sequence_for)
+        pk, pk_seq = @connection.pk_and_sequence_for(table)
+      end
+      pk ||= 'id'
+
+      tbl.print "  create_table #{table.inspect}"
+      if columns.detect { |c| c.name == pk }
+        if pk != 'id'
+          tbl.print %Q(, :primary_key => "#{pk}")
+        end
+      else
+        tbl.print ", :id => false"
+      end
+
+      if @connection.respond_to?(:options_for)
+        res = @connection.options_for(table)
+        tbl.print ", :options=>'#{res}'" if res
+      end
+
+      tbl.print ", :force => true"
+      tbl.puts " do |t|"
+
+      columns.each do |column|
+
+        raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" if @types[column.type].nil?
+        next if column.name == pk
+        #need to use less_simplified_type  here or have each specific geometry type be simplified to a specific simplified type in Column and each one treated separately in the Column methods
+        if column.is_a?(SpatialColumn)
+          tbl.print "    t.column #{column.name.inspect}, #{column.geometry_type.inspect}"
+          tbl.print ", :srid => #{column.srid.inspect}" if column.srid != -1
+          tbl.print ", :with_z => #{column.with_z.inspect}" if column.with_z
+          tbl.print ", :with_m => #{column.with_m.inspect}" if column.with_m
+        else
+          tbl.print "    t.column #{column.name.inspect}, #{column.type.inspect}"
+        end
+        tbl.print ", :limit => #{column.limit.inspect}" if column.limit != @types[column.type][:limit]
+        tbl.print ", :default => #{column.default.inspect}" if !column.default.nil?
+        tbl.print ", :null => false" if !column.null
+        tbl.puts
+      end
+
+      tbl.puts "  end"
+      tbl.puts
+      indexes(table, tbl)
+      tbl.rewind
+      stream.print tbl.read
+    rescue => e
+      stream.puts "# Could not dump table #{table.inspect} because of following #{e.class}"
+      stream.puts "#   #{e.message} #{e.backtrace}"
+      stream.puts
+    end
+
+    stream  end
+
+  def indexes(table, stream)
+    indexes = @connection.indexes(table)
+    indexes.each do |index|
+      stream.print "  add_index #{index.table.inspect}, #{index.columns.inspect}, :name => #{index.name.inspect}"
+      stream.print ", :unique => true" if index.unique
+      stream.print ", :spatial=> true " if index.spatial
+      stream.puts
+    end
+
+    stream.puts unless indexes.empty?
+  end
+end
+
+
+
+
+module SpatialAdapter
+  #Translation of geometric data types
+  def geometry_data_types
+    {
+      :point => { :name => "POINT" },
+      :line_string => { :name => "LINESTRING" },
+      :polygon => { :name => "POLYGON" },
+      :geometry_collection => { :name => "GEOMETRYCOLLECTION" },
+      :multi_point => { :name => "MULTIPOINT" },
+      :multi_line_string => { :name => "MULTILINESTRING" },
+      :multi_polygon => { :name => "MULTIPOLYGON" },
+      :geometry => { :name => "GEOMETRY"}
+    }
+  end
+
+end
+
+
+#using a mixin instead of subclassing Column since each adapter can have a specific subclass of Column
+module SpatialColumn
+  attr_reader  :geometry_type, :srid, :with_z, :with_m
+
+  def initialize(name, default, sql_type = nil, null = true,srid=-1,with_z=false,with_m=false)
+    super(name,default,sql_type,null)
+    @geometry_type = geometry_simplified_type(@sql_type)
+    @srid = srid
+    @with_z = with_z
+    @with_m = with_m
+  end
+
+
+  #Redefines type_cast to add support for geometries
+  def type_cast(value)
+    return nil if value.nil?
+    case type
+    when :geometry then self.class.string_to_geometry(value)
+    else super
+    end
+  end
+
+  #Redefines type_cast_code to add support for geometries.
+  #
+  #WARNING : Since ActiveRecord keeps only the string values directly returned from the database, it translates from these to the correct types everytime an attribute is read (using the code returned by this method), which is probably ok for simple types, but might be less than efficient for geometries. Also you cannot modify the geometry object returned directly or your change will not be saved.
+  def type_cast_code(var_name)
+    case type
+    when :geometry then "#{self.class.name}.string_to_geometry(#{var_name})"
+    else super
+    end
+  end
+
+
+  #Redefines klass to add support for geometries
+  def klass
+    case type
+    when :geometry then GeoRuby::SimpleFeatures::Geometry
+    else super
+    end
+  end
+
+  private
+
+  #Redefines the simplified_type method to add behaviour for when a column is of type geometry
+  def simplified_type(field_type)
+    case field_type
+    when /geometry|point|linestring|polygon|multipoint|multilinestring|multipolygon|geometrycollection/i then :geometry
+    else super
+    end
+  end
+
+  #less simlpified geometric type to be use in migrations
+  def geometry_simplified_type(field_type)
+    case field_type
+    when /^point$/i then :point
+    when /^linestring$/i then :line_string
+    when /^polygon$/i then :polygon
+    when /^geometry$/i then :geometry
+    when /multipoint/i then :multi_point
+    when /multilinestring/i then :multi_line_string
+    when /multipolygon/i then :multi_polygon
+    when /geometrycollection/i then :geometry_collection
+    end
+  end
+
+
+end