activerecord-postgis-adapter 0.6.6 → 0.7.0

data/Version

@@ -1 +0,0 @@
-0.6.6

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

@@ -1,96 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# PostGIS adapter for ActiveRecord
-#
-# -----------------------------------------------------------------------------
-# Copyright 2010-2012 Daniel Azuma
-#
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-# * Redistributions of source code must retain the above copyright notice,
-#   this list of conditions and the following disclaimer.
-# * Redistributions in binary form must reproduce the above copyright notice,
-#   this list of conditions and the following disclaimer in the documentation
-#   and/or other materials provided with the distribution.
-# * Neither the name of the copyright holder, nor the names of any other
-#   contributors to this software, may be used to endorse or promote products
-#   derived from this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-# POSSIBILITY OF SUCH DAMAGE.
-# -----------------------------------------------------------------------------
-;
-
-
-module ActiveRecord  # :nodoc:
-
-  class Base  # :nodoc:
-
-    class << self
-
-
-      if defined?(::RUBY_ENGINE) && ::RUBY_ENGINE == 'jruby'
-
-
-        require 'active_record/connection_adapters/jdbcpostgresql_adapter'
-        require 'active_record/connection_adapters/postgis_adapter/shared/jdbc_compat'
-
-
-        def postgis_connection(config_)
-          ::ActiveRecord::ConnectionAdapters::PostGISAdapter.create_jdbc_connection(self, config_)
-        end
-
-        alias_method :jdbcpostgis_connection, :postgis_connection
-
-
-      else
-
-
-        require 'pg'
-
-
-        # ActiveRecord looks for the postgis_connection factory method in
-        # this class.
-        #
-        # Based on the default <tt>postgresql_connection</tt> definition from
-        # ActiveRecord.
-
-        def postgis_connection(config_)
-          config_ = config_.symbolize_keys
-          host_ = config_[:host]
-          port_ = config_[:port] || 5432
-          username_ = config_[:username].to_s if config_[:username]
-          password_ = config_[:password].to_s if config_[:password]
-
-          if config_.key?(:database)
-            database_ = config_[:database]
-          else
-            raise ::ArgumentError, "No database specified. Missing argument: database."
-          end
-
-          # 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, [host_, port_, nil, nil, database_, username_, password_], config_)
-        end
-
-
-      end
-
-
-    end
-
-  end
-
-end

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

@@ -1,232 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# PostGIS adapter for ActiveRecord
-#
-# -----------------------------------------------------------------------------
-# Copyright 2010-2012 Daniel Azuma
-#
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-# * Redistributions of source code must retain the above copyright notice,
-#   this list of conditions and the following disclaimer.
-# * Redistributions in binary form must reproduce the above copyright notice,
-#   this list of conditions and the following disclaimer in the documentation
-#   and/or other materials provided with the distribution.
-# * Neither the name of the copyright holder, nor the names of any other
-#   contributors to this software, may be used to endorse or promote products
-#   derived from this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-# POSSIBILITY OF SUCH DAMAGE.
-# -----------------------------------------------------------------------------
-;
-
-
-# :stopdoc:
-
-
-require 'rgeo/active_record/task_hacker'
-
-
-class Object
-  alias_method :create_database_without_postgis, :create_database
-  alias_method :drop_database_without_postgis, :drop_database
-end
-
-
-namespace :db do
-  namespace :gis do
-    desc "Setup PostGIS data in the database"
-    task :setup => [:load_config, :rails_env] do
-      if self.respond_to?(:configs_for_environment)
-        configs_ = configs_for_environment
-      else
-        environments_ = [::Rails.env]
-        environments_ << 'test' if ::Rails.env.development?
-        configs_ = ::ActiveRecord::Base.configurations.values_at(*environments_).compact.reject{ |config_| config_['database'].blank? }
-      end
-      configs_.each { |config_| setup_gis(config_) }
-    end
-  end
-end
-
-
-# superuser name/password
-def get_su_auth(config_)
-  username_ = config_['username']
-  su_username_ = config_['su_username'] || username_
-  su_password_ = config_['su_password'] || config_['password']
-  has_su_ = config_.include?('su_username')
-
-  [username_, su_username_, su_password_, has_su_]
-end
-
-
-def get_search_path(config_)
-  config_["schema_search_path"].to_s.strip.split(',').map(&:strip)
-end
-
-
-# Install postgis definitions into the database.
-# Note: a superuser is required to run the postgis definitions.
-# If a separate superuser is provided, we need to grant privileges on
-# the postgis definitions over to the regular user afterwards.
-# We also need to set the ownership of the postgis tables (spatial_ref_sys
-# and geometry_columns) to the regular user. This is required to e.g.
-# be able to disable referential integrity on the database when using
-# a database cleaner truncation strategy during testing.
-# The schema for the postgis definitions is chosen as follows:
-# If "postgis" is present in the search path, use it.
-# Otherwise, use the last schema in the search path.
-# If no search path is given, use "public".
-def setup_gis(config_)
-  # Initial setup of the database: Add schemas from the search path.
-  # If a superuser is given, we log in as the superuser, but we make sure
-  # the schemas are owned by the regular user.
-  username_, su_username_, su_password_, has_su_ = get_su_auth(config_)
-  ::ActiveRecord::Base.establish_connection(config_.merge('schema_search_path' => 'public', 'username' => su_username_, 'password' => su_password_))
-  conn_ = ::ActiveRecord::Base.connection
-  search_path_ = get_search_path(config_)
-  quoted_username_ = ::ActiveRecord::Base.connection.quote_column_name(username_)
-  auth_ = has_su_ ? " AUTHORIZATION #{quoted_username_}" : ''
-  search_path_.each do |schema_|
-    exists = schema_.downcase == 'public' || conn_.execute("SELECT 1 FROM pg_catalog.pg_namespace WHERE nspname='#{schema_}'").try(:first)
-    conn_.execute("CREATE SCHEMA #{schema_}#{auth_}") unless exists
-  end
-
-  script_dir_ = config_['script_dir']
-  postgis_extension_ = config_['postgis_extension']
-  if script_dir_ || postgis_extension_
-    postgis_schema_ = search_path_.include?('postgis') ? 'postgis' : (search_path_.last || 'public')
-    if script_dir_
-      # Use script_dir (for postgresql < 9.1 or postgis < 2.0)
-      conn_.execute("SET search_path TO #{postgis_schema_}")
-      conn_.execute(::File.read(::File.expand_path('postgis.sql', script_dir_)))
-      conn_.execute(::File.read(::File.expand_path('spatial_ref_sys.sql', script_dir_)))
-    elsif postgis_extension_
-      # Use postgis_extension (for postgresql >= 9.1 and postgis >= 2.0)
-      postgis_extension_ = 'postgis' if postgis_extension_ == true
-      postgis_extension_ = postgis_extension_.to_s.split(',') unless postgis_extension_.is_a?(::Array)
-      postgis_extension_.each do |extname_|
-        if extname_ == 'postgis_topology'
-          raise ArgumentError, "'topology' must be in schema_search_path for postgis_topology" unless search_path_.include?('topology')
-          conn_.execute("CREATE EXTENSION IF NOT EXISTS #{extname_} SCHEMA topology")
-        else
-          conn_.execute("CREATE EXTENSION IF NOT EXISTS #{extname_} SCHEMA #{postgis_schema_}")
-        end
-      end
-    end
-    if has_su_
-      conn_.execute("GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA #{postgis_schema_} TO #{quoted_username_}")
-      conn_.execute("GRANT ALL PRIVILEGES ON ALL FUNCTIONS IN SCHEMA #{postgis_schema_} TO #{quoted_username_}")
-
-      postgis_version = conn_.execute( "SELECT #{postgis_schema_}.postgis_version();" ).first[ 'postgis_version' ]
-      if postgis_version =~ /^2/
-        conn_.execute("ALTER VIEW #{postgis_schema_}.geometry_columns OWNER TO #{quoted_username_}")
-        conn_.execute("ALTER VIEW #{postgis_schema_}.geography_columns OWNER TO #{quoted_username_}")
-      else
-        conn_.execute("ALTER TABLE #{postgis_schema_}.geometry_columns OWNER TO #{quoted_username_}")
-      end
-      conn_.execute("ALTER TABLE #{postgis_schema_}.spatial_ref_sys OWNER TO #{quoted_username_}")
-    end
-  end
-end
-
-
-def create_database(config_)
-  if config_['adapter'] == 'postgis'
-    @encoding = config_['encoding'] || ::ENV['CHARSET'] || 'utf8'
-    begin
-      username_, su_username_, su_password_, has_su_ = get_su_auth(config_)
-
-      # Create the database. Optionally do so as the given superuser.
-      # But make sure the database is owned by the regular user.
-      ::ActiveRecord::Base.establish_connection(config_.merge('database' => 'postgres', 'schema_search_path' => 'public', 'username' => su_username_, 'password' => su_password_))
-      extra_configs_ = {'encoding' => @encoding}
-      extra_configs_['owner'] = username_ if has_su_
-      ::ActiveRecord::Base.connection.create_database(config_['database'], config_.merge(extra_configs_))
-
-      setup_gis(config_)
-
-      # Done
-      ::ActiveRecord::Base.establish_connection(config_)
-    rescue ::Exception => e_
-      $stderr.puts(e_, *(e_.backtrace))
-      $stderr.puts("Couldn't create database for #{config_.inspect}")
-    end
-  else
-    create_database_without_postgis(config_)
-  end
-end
-
-
-def drop_database(config_)
-  if config_['adapter'] == 'postgis'
-    ::ActiveRecord::Base.establish_connection(config_.merge('database' => 'postgres', 'schema_search_path' => 'public', 'username' => config_['su_username'] || config_['username'], 'password' => config_['su_password'] || config_['password']))
-    ::ActiveRecord::Base.connection.drop_database(config_['database'])
-  else
-    drop_database_without_postgis(config_)
-  end
-end
-
-
-def set_psql_env(config_)
-  ::ENV['PGHOST'] = config_["host"] if config_["host"]
-  ::ENV['PGPORT'] = config_["port"].to_s if config_["port"]
-  ::ENV['PGPASSWORD'] = config_["password"].to_s if config_["password"]
-  ::ENV['PGUSER'] = config_["username"].to_s if config_["username"]
-end
-
-
-::RGeo::ActiveRecord::TaskHacker.modify('db:charset', nil, 'postgis') do |config_|
-  ::ActiveRecord::Base.establish_connection(config_)
-  puts(::ActiveRecord::Base.connection.encoding)
-end
-
-
-::RGeo::ActiveRecord::TaskHacker.modify('db:structure:dump', nil, 'postgis') do |config_|
-  set_psql_env(config_)
-  filename_ = ::File.join(::Rails.root, "db/#{::Rails.env}_structure.sql")
-  search_path_ = config_["schema_search_path"].to_s.strip
-  search_path_ = search_path_.split(",").map{ |sp_| sp_.strip }
-  search_path_.delete('postgis')
-  search_path_ = ['public'] if search_path_.length == 0
-  search_path_ = search_path_.map{ |sp_| "--schema=#{sp_}" }.join(" ")
-  `pg_dump -i -U "#{config_["username"]}" -s -x -O -f #{filename_} #{search_path_} #{config_["database"]}`
-  raise "Error dumping database" if $?.exitstatus == 1
-end
-
-
-::RGeo::ActiveRecord::TaskHacker.modify('db:structure:load', nil, 'postgis') do |config_|
-  set_psql_env(config_)
-  filename_ = ::File.join(::Rails.root, "db/#{::Rails.env}_structure.sql")
-  `psql -f #{filename_} #{config_["database"]}`
-end
-
-
-::RGeo::ActiveRecord::TaskHacker.modify('db:test:clone_structure', 'test', 'postgis') do |config_|
-  set_psql_env(config_)
-  `psql -U "#{config_["username"]}" -f #{::Rails.root}/db/#{::Rails.env}_structure.sql #{config_["database"]}`
-end
-
-
-::RGeo::ActiveRecord::TaskHacker.modify('db:test:purge', 'test', 'postgis') do |config_|
-  ::ActiveRecord::Base.clear_active_connections!
-  drop_database(config_)
-  create_database(config_)
-end
-
-
-# :startdoc:

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

@@ -1,298 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# PostGIS adapter for ActiveRecord
-#
-# -----------------------------------------------------------------------------
-# Copyright 2010-2012 Daniel Azuma
-#
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-# * Redistributions of source code must retain the above copyright notice,
-#   this list of conditions and the following disclaimer.
-# * Redistributions in binary form must reproduce the above copyright notice,
-#   this list of conditions and the following disclaimer in the documentation
-#   and/or other materials provided with the distribution.
-# * Neither the name of the copyright holder, nor the names of any other
-#   contributors to this software, may be used to endorse or promote products
-#   derived from this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-# POSSIBILITY OF SUCH DAMAGE.
-# -----------------------------------------------------------------------------
-;
-
-
-module ActiveRecord  # :nodoc:
-
-  module ConnectionAdapters  # :nodoc:
-
-    module PostGISAdapter  # :nodoc:
-
-
-      class MainAdapter < PostgreSQLAdapter  # :nodoc:
-
-
-        def initialize(*args_)
-          super
-          # Rails 3.2 way of defining the visitor: do so in the constructor
-          if defined?(@visitor) && @visitor
-            @visitor = ::Arel::Visitors::PostGIS.new(self)
-          end
-        end
-
-
-        include PostGISAdapter::CommonAdapterMethods
-
-
-        @@native_database_types = nil
-
-        def native_database_types
-          @@native_database_types ||= super.merge(:spatial => {:name => 'geometry'})
-        end
-
-
-        def type_cast(value_, column_)
-          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_|
-            # JDBC support: JDBC adapter returns a hash for column definitions,
-            # instead of an array of values.
-            if col_name_.kind_of?(::Hash)
-              notnull_ = col_name_["column_not_null"]
-              default_ = col_name_["column_default"]
-              type_ = col_name_["column_type"]
-              col_name_ = col_name_["column_name"]
-            end
-
-            SpatialColumn.new(col_name_, default_, type_, notnull_ == 'f',
-              ((type_ =~ /geometry/i ? spatial_info_[col_name_] : nil) || {}).merge({
-                  :table_name => table_name_,
-                  :factory_settings => @rgeo_factory_settings
-                }))
-          end
-        end
-
-
-        def indexes(table_name_, name_=nil)
-          # FULL REPLACEMENT. RE-CHECK ON NEW VERSIONS.
-          # We needed to modify the catalog queries to pull the index type info.
-
-          # Remove postgis from schemas
-          schemas_ = schema_search_path.split(/,/)
-          schemas_.delete('postgis')
-          schemas_ = schemas_.map{ |p_| quote(p_) }.join(',')
-
-          # Get index type by joining with pg_am.
-          result_ = query(<<-SQL, name_)
-            SELECT DISTINCT i.relname, d.indisunique, d.indkey, t.oid, am.amname
-              FROM pg_class t, pg_class i, pg_index d, pg_am am
-            WHERE i.relkind = 'i'
-              AND d.indexrelid = i.oid
-              AND d.indisprimary = 'f'
-              AND t.oid = d.indrelid
-              AND t.relname = '#{table_name_}'
-              AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname IN (#{schemas_}) )
-              AND i.relam = am.oid
-            ORDER BY i.relname
-          SQL
-
-          result_.map do |row_|
-            index_name_ = row_[0]
-            unique_ = row_[1] == 't'
-            indkey_ = row_[2].split(" ")
-            oid_ = row_[3]
-            indtype_ = row_[4]
-
-            columns_ = query(<<-SQL, "Columns for index #{row_[0]} on #{table_name_}").inject({}){ |h_, r_| h_[r_[0].to_s] = [r_[1], r_[2]]; h_ }
-              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
-
-            spatial_ = indtype_ == 'gist' && columns_.size == 1 && (columns_.values.first[1] == 'geometry' || columns_.values.first[1] == 'geography')
-            column_names_ = columns_.values_at(*indkey_).compact.map{ |a_| a_[0] }
-            if column_names_.empty?
-              nil
-            else
-              ::RGeo::ActiveRecord::SpatialIndexDefinition.new(table_name_, index_name_, unique_, column_names_, nil, nil, nil, spatial_ ? true : false)
-            end
-          end.compact
-        end
-
-
-        def create_table(table_name_, options_={})
-          # FULL REPLACEMENT. RE-CHECK ON NEW VERSIONS.
-          # Note: we have to do a full replacement for Rails 3.0 because
-          # there is no way to override the creation of the table
-          # definition object. In Rails 3.1, this has been factored out
-          # into the table_definition method, so we could rewrite this
-          # to call super if we're willing to go 3.1 only.
-          table_name_ = table_name_.to_s
-          table_definition_ = SpatialTableDefinition.new(self)
-          table_definition_.primary_key(options_[:primary_key] || ::ActiveRecord::Base.get_primary_key(table_name_.singularize)) unless options_[:id] == false
-          yield table_definition_ if block_given?
-          if options_[:force] && table_exists?(table_name_)
-            drop_table(table_name_, options_)
-          end
-
-          create_sql_ = "CREATE#{' TEMPORARY' if options_[:temporary]} TABLE "
-          create_sql_ << "#{quote_table_name(table_name_)} ("
-          create_sql_ << table_definition_.to_sql
-          create_sql_ << ") #{options_[:options]}"
-          execute create_sql_
-
-          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
-          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_.to_s)}', #{srid_}, '#{quote_string(type_)}', #{dimensions_})")
-              end
-            end
-          else
-            super
-          end
-        end
-
-
-        def remove_column(table_name_, *column_names_)
-          column_names_ = column_names_.flatten.map{ |n_| n_.to_s }
-          spatial_info_ = spatial_column_info(table_name_)
-          remaining_column_names_ = []
-          column_names_.each do |name_|
-            if spatial_info_.include?(name_)
-              execute("SELECT DropGeometryColumn('#{quote_string(table_name_.to_s)}','#{quote_string(name_)}')")
-            else
-              remaining_column_names_ << name_.to_sym
-            end
-          end
-          if remaining_column_names_.size > 0
-            super(table_name_, *remaining_column_names_)
-          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.
-          table_name_ = table_name_.to_s
-          column_names_ = ::Array.wrap(column_name_)
-          index_name_ = index_name(table_name_, :column => column_names_)
-          gist_clause_ = ''
-          index_type_ = ''
-          if ::Hash === options_  # legacy support, since this param was a string
-            index_type_ = 'UNIQUE' if options_[:unique]
-            index_name_ = options_[:name].to_s if options_.key?(:name)
-            gist_clause_ = 'USING GIST' if options_[:spatial]
-          else
-            index_type_ = options_
-          end
-          if index_name_.length > index_name_length
-            raise ::ArgumentError, "Index name '#{index_name_}' on table '#{table_name_}' is too long; the limit is #{index_name_length} characters"
-          end
-          if index_name_exists?(table_name_, index_name_, false)
-            raise ::ArgumentError, "Index name '#{index_name_}' on table '#{table_name_}' already exists"
-          end
-          quoted_column_names_ = quoted_columns_for_index(column_names_, options_).join(", ")
-          execute "CREATE #{index_type_} INDEX #{quote_column_name(index_name_)} ON #{quote_table_name(table_name_)} #{gist_clause_} (#{quoted_column_names_})"
-        end
-
-
-        def spatial_column_info(table_name_)
-          info_ = query("SELECT * FROM geometry_columns WHERE f_table_name='#{quote_string(table_name_.to_s)}'")
-          result_ = {}
-          info_.each do |row_|
-            name_ = row_[3]
-            type_ = row_[6]
-            dimension_ = row_[4].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_[5].to_i,
-              :has_z => has_z_,
-              :has_m => has_m_,
-            }
-          end
-          result_
-        end
-
-
-      end
-
-
-    end
-
-  end
-
-end