ar-postgis 0.7.0

data/README.rdoc

@@ -0,0 +1,78 @@
+== PostGIS \ActiveRecord Adapter
+
+The activerecord-postgis-adapter is a plugin that provides access to features of the PostGIS geospatial database from \ActiveRecord. Technically, it extends the standard postgresql adapter to provide support for the spatial data types and features added by the PostGIS extension. It uses the {RGeo}[http://github.com/dazuma/rgeo] library to represent spatial data in Ruby.
+
+Original project: https://github.com/dazuma/activerecord-postgis-adapter/
+
+== About the PostGIS Adapter
+
+This is a brief summary covering how to use activerecord-postgis-adapter. For full documentation, see Documentation.rdoc.
+
+=== Features
+
+The adapter provides three basic capabilities.
+
+First, it provides *spatial migrations*. It extends the \ActiveRecord migration syntax to support creating spatially-typed columns and spatial indexes. You can control the various PostGIS-provided attributes such as srid, dimension, and geographic vs geometric math.
+
+Second, it recognizes spatial types and casts them properly to RGeo geometry objects. The adapter can configure these objects automatically based on the srid and dimension in the database table, or you can tell it to convert the data to a different form. You can also set attribute data using WKT format.
+
+Third, it lets you include simple spatial data in queries. WKT format data and RGeo objects can be embedded in where clauses. If you include the Squeel gem, the adapter also supports advanced queries utilizing the standard SQL spatial function set.
+
+=== Requirements
+
+The adapter has the following requirements.
+
+* Ruby 2.0.0 or later.
+* PostgreSQL 9.0 or later.
+* PostGIS 2.0, or later.
+* ActiveRecord 4.0.2 or later.
+* rgeo and rgeo-activerecord.
+
+=== Installation and Configuration
+
+To install this adapter in a Rails application, add it to your Gemfile:
+
+  gem 'activerecord-postgis-adapter'
+
+and run bundle install to update your bundle.
+
+Alternately, if you are not using bundler, install it separately as a gem:
+
+  gem install activerecord-postgis-adapter
+
+Please note that this adapter uses the rgeo gem, which may have additional dependencies. Please see the \README documentation for rgeo for more information.
+
+Once you have installed the adapter, you'll need to edit your config/database.yml to call for it. At minimum, this means changing the adapter name from "postgresql" to "postgis". It may also require other settings to ensure that other functions (such as rake test) continue to work as expected. We recommend reading the Configuration section in the Documentation.rdoc file carefully before starting to use this adapter.
+
+== Development and Support
+
+Original project info:
+
+\Documentation is available at http://dazuma.github.com/activerecord-postgis-adapter/rdoc
+
+Source code is hosted on Github at http://github.com/dazuma/activerecord-postgis-adapter
+
+Contributions are welcome. Fork the project on Github.
+
+Report bugs on Github issues at http://github.org/dazuma/activerecord-postgis-adapter/issues
+
+Support available on the rgeo-users google group at http://groups.google.com/group/rgeo-users
+
+Contact the author at dazuma at gmail dot com.
+
+== Acknowledgments
+
+The PostGIS Adapter and its supporting libraries (including RGeo) are
+written by Daniel Azuma (http://www.daniel-azuma.com).
+
+Development is supported by Pirq. (http://pirq.com).
+
+This adapter implementation owes some debt to the spatial_adapter plugin
+(http://github.com/fragility/spatial_adapter). Although we made some
+different design decisions for this adapter, studying the spatial_adapter
+source gave us a head start on the implementation.
+
+== License
+
+https://github.com/neighborland/activerecord-postgis-adapter/LICENSE.txt
+

data/lib/active_record/connection_adapters/postgis_adapter.rb

@@ -0,0 +1,38 @@
+# The activerecord-postgis-adapter gem installs the *postgis*
+# connection adapter into ActiveRecord.
+
+module ActiveRecord
+  # All ActiveRecord adapters go in this namespace.
+  # This adapter is installed into the PostGISAdapter submodule.
+  module ConnectionAdapters
+    # The PostGIS Adapter lives in this namespace.
+    module PostGISAdapter
+      # The name returned by the adapter_name method of this adapter.
+      ADAPTER_NAME = 'PostGIS'.freeze
+    end
+  end
+end
+
+# :stopdoc:
+
+require 'active_record'
+require 'active_record/connection_adapters/postgresql_adapter'
+require 'rgeo/active_record'
+
+require 'active_record/connection_adapters/postgis_adapter/version.rb'
+require 'active_record/connection_adapters/postgis_adapter/shared/common_adapter_methods.rb'
+require 'active_record/connection_adapters/postgis_adapter/rails4/main_adapter.rb'
+require 'active_record/connection_adapters/postgis_adapter/rails4/spatial_table_definition.rb'
+require 'active_record/connection_adapters/postgis_adapter/rails4/spatial_column.rb'
+require 'active_record/connection_adapters/postgis_adapter/shared/arel_tosql.rb'
+require 'active_record/connection_adapters/postgis_adapter/shared/setup.rb'
+require 'active_record/connection_adapters/postgis_adapter/rails4/create_connection'
+require 'active_record/connection_adapters/postgis_adapter/rails4/postgis_database_tasks.rb'
+
+::ActiveRecord::ConnectionAdapters::PostGISAdapter.initial_setup
+
+if defined?(::Rails::Railtie)
+  load ::File.expand_path('postgis_adapter/shared/railtie.rb', ::File.dirname(__FILE__))
+end
+
+# :startdoc:

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

@@ -0,0 +1,29 @@
+module ActiveRecord  # :nodoc:
+
+  module ConnectionHandling  # :nodoc:
+    require 'pg'
+
+    # Based on the default <tt>postgresql_connection</tt> definition from
+    # ActiveRecord.
+
+    def postgis_connection(config_)
+      # FULL REPLACEMENT because we need to create a different class.
+      conn_params_ = config_.symbolize_keys
+
+      conn_params_.delete_if { |_, v_| v_.nil? }
+
+      # Map ActiveRecords param names to PGs.
+      conn_params_[:user] = conn_params_.delete(:username) if conn_params_[:username]
+      conn_params_[:dbname] = conn_params_.delete(:database) if conn_params_[:database]
+
+      # Forward only valid config params to PGconn.connect.
+      conn_params_.keep_if { |k_, _| VALID_CONN_PARAMS.include?(k_) }
+
+      # 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_)
+    end
+
+  end
+
+end

data/lib/active_record/connection_adapters/postgis_adapter/rails4/databases.rake

@@ -0,0 +1,17 @@
+# :stopdoc:
+
+namespace :db do
+  namespace :gis do
+    desc "Setup PostGIS data in the database"
+    task :setup => [:load_config] do
+      environments_ = [::Rails.env]
+      environments_ << 'test' if ::Rails.env.development?
+      configs_ = ::ActiveRecord::Base.configurations.values_at(*environments_).compact.reject{ |config_| config_['database'].blank? }
+      configs_.each do |config_|
+        ::ActiveRecord::ConnectionAdapters::PostGISAdapter::PostGISDatabaseTasks.new(config_).setup_gis
+      end
+    end
+  end
+end
+
+# :startdoc:

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

@@ -0,0 +1,202 @@
+module ActiveRecord  # :nodoc:
+  module ConnectionAdapters  # :nodoc:
+    module PostGISAdapter  # :nodoc:
+      class MainAdapter < PostgreSQLAdapter  # :nodoc:
+        def initialize(*args_)
+          # Overridden to change the visitor
+          super
+          @visitor = ::Arel::Visitors::PostGIS.new(self)
+        end
+
+        include PostGISAdapter::CommonAdapterMethods
+
+        @@native_database_types = nil
+
+        def native_database_types
+          # Overridden to add the :spatial type
+          @@native_database_types ||= super.merge(
+            :spatial => {:name => 'geometry'},
+            :geography => {:name => 'geography'})
+        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
+        end
+
+        def columns(table_name_, name_=nil)
+          # FULL REPLACEMENT. RE-CHECK ON NEW VERSIONS.
+          # We needed to return a spatial column subclass.
+          table_name_ = table_name_.to_s
+          spatial_info_ = spatial_column_info(table_name_)
+          column_definitions(table_name_).collect do |col_name_, type_, default_, notnull_, oid_, fmod_|
+            oid_ = type_map.fetch(oid_.to_i, fmod_.to_i) {
+              OID::Identity.new
+            }
+            SpatialColumn.new(@rgeo_factory_settings, table_name_, col_name_, default_, oid_, type_,
+              notnull_ == 'f', type_ =~ /geometry/i ? spatial_info_[col_name_] : nil)
+          end
+        end
+
+        def indexes(table_name_, name_=nil)
+          # FULL REPLACEMENT. RE-CHECK ON NEW VERSIONS.
+          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] }
+
+            # 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]
+            spatial_ = inddef_ =~ /using\s+gist/i && columns_.size == 1 &&
+              (columns_.values.first[1] == 'geometry' || columns_.values.first[1] == 'geography')
+
+            if column_names_.empty?
+              nil
+            else
+              ::RGeo::ActiveRecord::SpatialIndexDefinition.new(table_name_, index_name_, unique_, column_names_, [], orders_, where_, spatial_ ? true : false)
+            end
+          end.compact
+        end
+
+        def create_table_definition(name_, temporary_, options_, as_=nil)
+          # Override to create a spatial table definition (post-4.0.0.beta1)
+          PostGISAdapter::TableDefinition.new(native_database_types, name_, temporary_, options_, as_, self)
+        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_|
+            type_ = col_.spatial_type.gsub('_', '').upcase
+            has_z_ = col_.has_z?
+            has_m_ = col_.has_m?
+            type_ = "#{type_}M" if has_m_ && !has_z_
+            dimensions_ = 2
+            dimensions_ += 1 if has_z_
+            dimensions_ += 1 if has_m_
+            execute("SELECT AddGeometryColumn('#{quote_string(table_name_)}', '#{quote_string(col_.name.to_s)}', #{col_.srid}, '#{quote_string(type_)}', #{dimensions_})")
+          end
+        end
+
+        def drop_table(table_name_, *options_)
+          if postgis_lib_version.to_s.split('.').first.to_i == 1
+            execute("DELETE from geometry_columns where f_table_name='#{quote_string(table_name_.to_s)}'")
+          end
+          super
+        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))
+            limit_ = options_[:limit]
+            if type_.to_s == 'geometry' &&
+              (options_[:no_constraints] || limit_.is_a?(::Hash) && limit_[:no_constraints])
+            then
+              options_.delete(:limit)
+              super
+            else
+              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] || -1).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_ = 2
+                dimensions_ += 1 if has_z_
+                dimensions_ += 1 if has_m_
+                execute("SELECT AddGeometryColumn('#{quote_string(table_name_)}', '#{quote_string(column_name_)}', #{srid_}, '#{quote_string(type_)}', #{dimensions_})")
+              end
+            end
+          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
+
+        def add_index(table_name_, column_name_, options_={})
+          # FULL REPLACEMENT. RE-CHECK ON NEW VERSIONS.
+          # We have to fully-replace because of the gist_clause.
+          options_ ||= {}
+          gist_clause_ = options_.delete(:spatial) ? ' USING GIST' : ''
+          index_name_, index_type_, index_columns_, index_options_ = add_index_options(table_name_, column_name_, options_)
+          execute "CREATE #{index_type_} INDEX #{quote_column_name(index_name_)} ON #{quote_table_name(table_name_)}#{gist_clause_} (#{index_columns_})#{index_options_}"
+        end
+
+        def spatial_column_info(table_name_)
+          info_ = query("SELECT f_geometry_column,coord_dimension,srid,type FROM geometry_columns WHERE f_table_name='#{quote_string(table_name_.to_s)}'")
+          result_ = {}
+          info_.each do |row_|
+            name_ = row_[0]
+            type_ = row_[3]
+            dimension_ = row_[1].to_i
+            has_m_ = type_ =~ /m$/i ? true : false
+            type_.sub!(/m$/, '')
+            has_z_ = dimension_ > 3 || dimension_ == 3 && !has_m_
+            result_[name_] = {
+              :name => name_,
+              :type => type_,
+              :dimension => dimension_,
+              :srid => row_[2].to_i,
+              :has_z => has_z_,
+              :has_m => has_m_,
+            }
+          end
+          result_
+        end
+
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgis_adapter/rails4/postgis_database_tasks.rb

@@ -0,0 +1,204 @@
+module ActiveRecord  # :nodoc:
+
+  module ConnectionAdapters  # :nodoc:
+
+    module PostGISAdapter  # :nodoc:
+
+      class PostGISDatabaseTasks < ::ActiveRecord::Tasks::PostgreSQLDatabaseTasks  # :nodoc:
+
+
+        def initialize(config_)
+          super
+          ensure_installation_configs
+        end
+
+
+        def setup_gis
+          establish_su_connection
+          setup_gis_schemas
+          if script_dir
+            setup_gis_from_script_dir
+          elsif extension_names
+            setup_gis_from_extension
+          end
+          if has_su? && (script_dir || extension_names)
+            setup_gis_grant_privileges
+          end
+          establish_connection(configuration)
+        end
+
+
+        # Overridden to set the database owner and call setup_gis
+
+        def create(master_established_=false)
+          establish_master_connection unless master_established_
+          extra_configs_ = {'encoding' => encoding}
+          extra_configs_['owner'] = username if has_su?
+          connection.create_database(configuration['database'], configuration.merge(extra_configs_))
+          setup_gis
+        rescue ::ActiveRecord::StatementInvalid => error_
+          if /database .* already exists/ === error_.message
+            raise ::ActiveRecord::Tasks::DatabaseAlreadyExists
+          else
+            raise
+          end
+        end
+
+
+        # Overridden to remove postgis schema
+
+        def structure_dump(filename_)
+          set_psql_env
+          search_path_ = search_path.dup
+          search_path_.delete('postgis')
+          search_path_ = ['public'] if search_path_.length == 0
+          search_path_clause_ = search_path_.map{ |part_| "--schema=#{::Shellwords.escape(part_)}" }.join(' ')
+          command_ = "pg_dump -i -s -x -O -f #{::Shellwords.escape(filename_)} #{search_path_clause_} #{::Shellwords.escape(configuration['database'])}"
+          raise 'Error dumping database' unless ::Kernel.system(command_)
+          ::File.open(filename_, "a") { |f_| f_ << "SET search_path TO #{ActiveRecord::Base.connection.schema_search_path};\n\n" }
+        end
+
+
+        private
+
+
+        # Overridden to use su_username and su_password
+
+        def establish_master_connection
+          establish_connection(configuration.merge(
+            'database' => 'postgres',
+            'schema_search_path' => 'public',
+            'username' => su_username,
+            'password' => su_password))
+        end
+
+
+        def establish_su_connection
+          establish_connection(configuration.merge(
+            'schema_search_path' => 'public',
+            'username' => su_username,
+            'password' => su_password))
+        end
+
+
+        def username
+          @username ||= configuration['username']
+        end
+
+        def quoted_username
+          @quoted_username ||= ::ActiveRecord::Base.connection.quote_column_name(username)
+        end
+
+        def password
+          @password ||= configuration['password']
+        end
+
+        def su_username
+          @su_username ||= configuration['su_username'] || username
+        end
+
+        def su_password
+          @su_password ||= configuration['su_password'] || password
+        end
+
+        def has_su?
+          @has_su = configuration.include?('su_username') unless defined?(@has_su)
+          @has_su
+        end
+
+        def search_path
+          @search_path ||= configuration['schema_search_path'].to_s.strip.split(',').map(&:strip)
+        end
+
+        def postgis_schema
+          @postgis_schema ||= search_path.include?('postgis') ? 'postgis' : (search_path.last || 'public')
+        end
+
+        def script_dir
+          @script_dir = configuration['script_dir'] unless defined?(@script_dir)
+          @script_dir
+        end
+
+        def extension_names
+          @extension_names ||= begin
+            ext_ = configuration['postgis_extension']
+            case ext_
+            when ::String
+              ext_.split(',')
+            when ::Array
+              ext_
+            else
+              ['postgis']
+            end
+          end
+        end
+
+
+        def ensure_installation_configs
+          if configuration['setup'] == 'default' && !configuration['script_dir'] && !configuration['postgis_extension']
+            share_dir_ = `pg_config --sharedir`.strip rescue '/usr/share'
+            script_dir_ = ::File.expand_path('contrib/postgis-1.5', share_dir_)
+            control_file_ = ::File.expand_path('extension/postgis.control', share_dir_)
+            if ::File.readable?(control_file_)
+              configuration['postgis_extension'] = 'postgis'
+            elsif ::File.directory?(script_dir_)
+              configuration['script_dir'] = script_dir_
+            end
+          end
+        end
+
+
+        def setup_gis_schemas
+          auth_ = has_su? ? " AUTHORIZATION #{quoted_username}" : ''
+          search_path.each do |schema_|
+            if schema_.downcase != 'public' && !connection.execute("SELECT 1 FROM pg_catalog.pg_namespace WHERE nspname='#{schema_}'").try(:first)
+              connection.execute("CREATE SCHEMA #{schema_}#{auth_}")
+            end
+          end
+        end
+
+
+        def setup_gis_from_extension
+          extension_names.each do |extname_|
+            if extname_ == 'postgis_topology'
+              raise ::ArgumentError, "'topology' must be in schema_search_path for postgis_topology" unless search_path.include?('topology')
+              connection.execute("CREATE EXTENSION IF NOT EXISTS #{extname_} SCHEMA topology")
+            else
+              connection.execute("CREATE EXTENSION IF NOT EXISTS #{extname_} SCHEMA #{postgis_schema}")
+            end
+          end
+        end
+
+
+        def setup_gis_from_script_dir
+          connection.execute("SET search_path TO #{postgis_schema}")
+          connection.execute(::File.read(::File.expand_path('postgis.sql', script_dir)))
+          connection.execute(::File.read(::File.expand_path('spatial_ref_sys.sql', script_dir)))
+        end
+
+
+        def setup_gis_grant_privileges
+          connection.execute("GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA #{postgis_schema} TO #{quoted_username}")
+          connection.execute("GRANT ALL PRIVILEGES ON ALL FUNCTIONS IN SCHEMA #{postgis_schema} TO #{quoted_username}")
+          postgis_version_ = connection.execute( "SELECT #{postgis_schema}.postgis_version();" ).first['postgis_version']
+          if postgis_version_ =~ /^2/
+            connection.execute("ALTER VIEW #{postgis_schema}.geometry_columns OWNER TO #{quoted_username}")
+            connection.execute("ALTER VIEW #{postgis_schema}.geography_columns OWNER TO #{quoted_username}")
+          else
+            connection.execute("ALTER TABLE #{postgis_schema}.geometry_columns OWNER TO #{quoted_username}")
+          end
+          connection.execute("ALTER TABLE #{postgis_schema}.spatial_ref_sys OWNER TO #{quoted_username}")
+        end
+
+
+      end
+
+
+      ::ActiveRecord::Tasks::DatabaseTasks.register_task(/postgis/, PostGISDatabaseTasks)
+
+
+    end
+
+  end
+
+end