activerecord-spatialite-adapter 0.2.3 → 0.3.0

data/History.rdoc

@@ -1,3 +1,11 @@
+=== 0.3.0 / 2011-01-26
+
+* Reworked type and constraint handling, which should result in a large number of bug fixes, especially related to schema dumps.
+* Experimental support for complex spatial queries. (Requires Arel 2.1, which is expected to be released with Rails 3.1.)
+* API CHANGE: The indexes method now returns all indexes including spatial indexes; removed the separate spatial_indexes method.
+* The path to the Railtie is now different (see the README), though a compatibility wrapper has been left in the old location.
+* Reorganized the code a bit for better clarity.
+
 === 0.2.3 / 2011-01-06
 
 * Many of ActiveRecord's rake tasks weren't working because they need to know about every adapter explicitly. I hesitate to call this "fixed" since I see it as a problem in ActiveRecord, but we now at least have a workaround so the rake tasks will run properly. (Reported by Tad Thorley.)

data/README.rdoc

@@ -7,7 +7,9 @@ the {RGeo}[http://github.com/dazuma/rgeo] library to represent spatial
 data in Ruby. Like the standard sqlite3 adapter, this adapter requires
 the sqlite3-ruby gem.
 
-=== What This Adapter Provides
+== What This Adapter Provides
+
+=== Spatial Migrations
 
 First, this adapter extends the migration syntax to support creating 
 spatial columns and indexes. To create a spatial column, use the
@@ -17,24 +19,29 @@ the <tt>:spatial</tt> option to true.
 
 Examples:
 
- create_table :spatial_table do |t|
-   t.column :latlon, :point  # or t.point :latlon
-   t.line_string :path
-   t.geometry :shape
- end
- change_table :spatial_table do |t|
-   t.index :latlon, :spatial => true
- end
+  create_table :my_spatial_table do |t|
+    t.column :latlon, :point  # or t.point :latlon
+    t.line_string :path
+    t.geometry :shape
+  end
+  change_table :my_spatial_table do |t|
+    t.index :latlon, :spatial => true
+  end
+
+=== Spatial Attributes
 
 When this adapter is in use, spatial attributes in your \ActiveRecord
 objects will have RGeo geometry values. You can set spatial attributes
 either to RGeo geometry objects, or to strings in WKT (well-known text)
 format, which the adapter will automatically convert to geometry objects.
 
-To specify the RGeo geometry factory, you can either set an explicit
-factory for a column, or provide a factory generator that will yield the
-appropriate factory for the table's spatial columns based on the value.
-For the former, call the set_rgeo_factory_for_column class method on your
+Spatial objects in RGeo are tied to a factory that specifies the
+coordinate system as well as other behaviors of the object. You must
+therefore specify a factory for each spatial column (attribute) in your
+ActiveRecord class. You can either set an explicit factory for a specific
+column, or provide a factory generator that will yield the appropriate
+factory for the table's spatial columns based on their types. For the
+former, call the <tt>set_rgeo_factory_for_column</tt> class method on your
 \ActiveRecord class. For the latter, set the rgeo_factory_generator class
 attribute. This generator should understand at least the <tt>:srid</tt>
 option, which will be provided based on the column's specified SRID. Note
@@ -45,39 +52,45 @@ actually implemented and documented in the "rgeo-activerecord" gem.
 
 Examples, given the spatial table defined above:
 
- class SpatialTable < ActiveRecord::Base
-   
-   # By default, use the GEOS implementation for spatial columns.
-   self.rgeo_factory_generator = RGeo::Geos.method(:factory)
-   
-   # But use a geographic implementation for the :latlon column.
-   set_rgeo_factory_for_column(:latlon, RGeo::Geographic.spherical_factory)
-   
- end
+  class MySpatialTable < ActiveRecord::Base
+    
+    # By default, use the GEOS implementation for spatial columns.
+    self.rgeo_factory_generator = RGeo::Geos.method(:factory)
+    
+    # But use a geographic implementation for the :latlon column.
+    set_rgeo_factory_for_column(:latlon, RGeo::Geographic.spherical_factory)
+    
+  end
 
 Now you can interact with the data using the RGeo types:
 
- rec = SpatialTable.new
- rec.latlon = 'POINT(-122 47)'   # You can set by feature object or WKT.
- loc = rec.latlon                # Accessing always returns a feature object, in
-                                 # this case, a geographic that understands latitude.
- loc.latitude                    # => 47
- rec.shape = loc                 # the factory for the :shape column is GEOS, so the
-                                 # value will be cast from geographic to GEOS.
- RGeo::Geos.is_geos?(rec.shape)  # => true
+  rec = MySpatialTable.new
+  rec.latlon = 'POINT(-122 47)'   # You can set by feature object or WKT.
+  loc = rec.latlon                # Accessing always returns a feature object, in
+                                  # this case, a geographic that understands latitude.
+  loc.latitude                    # => 47
+  rec.shape = loc                 # the factory for the :shape column is GEOS, so the
+                                  # value will be cast from geographic to GEOS.
+  RGeo::Geos.is_geos?(rec.shape)  # => true
+
+=== Spatial Queries
 
 You can create simple queries based on spatial equality in the same way
 you would on a scalar column:
 
- rec = SpatialTable.where(:latlon => RGeo::Geos.factory.point(-122, 47)).first
+  rec = MySpatialTable.where(:latlon => RGeo::Geos.factory.point(-122, 47)).first
 
 You can also use WKT:
 
- rec = SpatialTable.where(:latlon => 'POINT(-122 47)').first
+  rec = MySpatialTable.where(:latlon => 'POINT(-122 47)').first
+
+The adapter also provides experimental support for more complex queries
+such as radius searches. However, these extensions require Arel 2.1
+(which is scheduled for release with Rails 3.1). We do not have these
+documented yet, and the syntax is subject to change. For now, you should
+write more complex queries in SQL.
 
-Other types of queries currently must be written in SQL. However, we are
-investigating writing a set of Arel extensions for constructing arbitrary
-spatial queries.
+== Installation And Configuration
 
 === Installing The Adapter Gem
 
@@ -87,12 +100,12 @@ This adapter has the following requirements:
 * SpatiaLite 2.3 or later (2.4 recommended).
 * \ActiveRecord 3.0.3 or later. Earlier versions will not work.
 * rgeo gem 0.2.4 or later.
-* rgeo-activerecord gem 0.2.2 or later.
-* sqlite3 gem 1.3 or later.
+* rgeo-activerecord gem 0.3.0 or later.
+* sqlite3 gem 1.3.3 or later.
 
 Install this adapter as a gem:
 
- gem install activerecord-spatialite-adapter
+  gem install activerecord-spatialite-adapter
 
 See the README for the "rgeo" gem, a required dependency, for further
 installation information.
@@ -109,16 +122,55 @@ which should be set to the full path to the libspatialite shared library,
 if it is not installed in a standard place (such as /usr/local or
 /opt/local).
 
-Furthermore, the SpatiaLite adapter includes a special railtie that
-provides support for SpatiaLite databases in ActiveRecord's rake tasks.
-This railtie is required in order to run, e.g., rake test. To install 
-this railtie, you should add this line to your config/application.rb:
+Generally, you can create a new Rails application using:
 
- require 'rgeo/active_record/spatialite_adapter/railtie'
+  rails new my_app --database=sqlite3
+
+...and then change the adapter names to "<tt>spatialite</tt>" and add an
+appropriate <tt>libspatialite</tt> setting.
+
+Next, the SpatiaLite adapter includes a special railtie that provides
+support for SpatiaLite databases in ActiveRecord's rake tasks. This
+railtie is required in order to run, e.g., rake test. To install this
+railtie, you should add this line to your config/application.rb:
+
+  require 'active_record/connection_adapters/spatialite_adapter/railtie'
 
 Note that this railtie must load after the ActiveRecord railtie. That is,
 the above require command should appear after <tt>require 'rails/all'</tt>.
 
+=== Dealing with SpatiaLite Definitions
+
+SpatiaLite adds many objects (meta-information tables, functions,
+triggers, etc.) to a Sqlite3 database. These objects are required to
+maintain the spatial elements of the database, but they can be a hassle
+when managing the database with Rails. Following are some tips and
+gotchas that you may encounter.
+
+Make sure you include the correct <tt>libspatialite</tt> setting in your
+database.yml config file, especially for your production environments.
+
+SpatiaLite databases need to be initialized by executing the SpatiaLite
+initialization script or by calling the InitSpatialMetaData() function.
+The rake db:create task will do this for you when it creates a database.
+Thus, when setting up a new application, you should make sure you call
+rake db:create or otherwise cause the SpatiaLite initialization to
+occur, before you attempt to run your first migration. Failure to do so
+will result in errors during the migration.
+
+Dumping a SpatiaLite database as SQL will cause a bunch of internal tables
+and triggers to be included in your dump. These are the actual SpatiaLite
+implementation objects used to enforce spatial constraints and implement
+spatial indexes. Unfortunately, not only is this a bit unsightly, but not
+everything is dumped here: for example, for each spatial column, there
+should be a row in the geometry_columns table, and those will be missing
+in the SQL structure dump. As a result, loading from the SQL structure
+dump will not properly reproduce your database schema. Because of this, we
+highly recommend that you leave config.active_record.schema_format set to
+<tt>:ruby</tt> for now, so that schema dumps are done in the Ruby format.
+
+== Additional Information
+
 === Known bugs and limitations
 
 The spatialite adapter works in principle, but there are a few known holes
@@ -145,7 +197,8 @@ Contact the author at dazuma at gmail dot com.
 
 === Acknowledgments
 
-RGeo is written by Daniel Azuma (http://www.daniel-azuma.com).
+The SpatiaLite Adapter and its supporting libraries (including RGeo) are
+written by Daniel Azuma (http://www.daniel-azuma.com).
 
 Development of RGeo is sponsored by GeoPage, Inc. (http://www.geopage.com).
 

data/Version

@@ -1 +1 @@
-0.2.3
+0.3.0

data/lib/active_record/connection_adapters/spatialite_adapter.rb

@@ -38,33 +38,6 @@ require 'rgeo/active_record'
 require 'active_record/connection_adapters/sqlite3_adapter'
 
 
-# :stopdoc:
-
-module Arel
-  module Visitors
-    
-    class SpatiaLite < SQLite
-      
-      FUNC_MAP = {
-        'ST_WKTToSQL' => 'GeomFromText',
-      }
-      
-      include ::RGeo::ActiveRecord::SpatialToSql
-      
-      def st_func(standard_name_)
-        FUNC_MAP[standard_name_] || standard_name_
-      end
-      
-    end
-    
-    VISITORS['spatialite'] = ::Arel::Visitors::SpatiaLite
-    
-  end
-end
-
-# :startdoc:
-
-
 # The activerecord-spatialite-adapter gem installs the *spatialite*
 # connection adapter into ActiveRecord.
 
@@ -122,418 +95,42 @@ module ActiveRecord
       db_.enable_load_extension(1)
       db_.load_extension(path_)
       
-      ConnectionAdapters::SpatiaLiteAdapter.new(db_, logger, config_)
+      ::ActiveRecord::ConnectionAdapters::SpatiaLiteAdapter::MainAdapter.new(db_, logger, config_)
     end
     
     
   end
   
   
-  module ConnectionAdapters  # :nodoc:
-    
+  # All ActiveRecord adapters go in this namespace.
+  module ConnectionAdapters
     
-    class SpatiaLiteAdapter < SQLite3Adapter  # :nodoc:
-      
+    # The SpatiaLite Adapter
+    module SpatiaLiteAdapter
       
+      # The name returned by the adapter_name method of this adapter.
       ADAPTER_NAME = 'SpatiaLite'.freeze
       
-      @@native_database_types = nil
-      
-      
-      def native_database_types
-        unless @@native_database_types
-          @@native_database_types = super.dup
-          @@native_database_types.merge!(:geometry => {:name => "geometry"}, :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"})
-        end
-        @@native_database_types
-      end
-      
-      
-      def adapter_name
-        ADAPTER_NAME
-      end
-      
-      
-      def spatialite_version
-        @spatialite_version ||= SQLiteAdapter::Version.new(select_value('SELECT spatialite_version()'))
-      end
-      
-      
-      def srs_database_columns
-        {:name_column => 'ref_sys_name', :proj4text_column => 'proj4text', :auth_name_column => 'auth_name', :auth_srid_column => 'auth_srid'}
-      end
-      
-      
-      def quote(value_, column_=nil)
-        if ::RGeo::Feature::Geometry.check_type(value_)
-          "GeomFromWKB(X'#{::RGeo::WKRep::WKBGenerator.new(:hex_format => true).generate(value_)}', #{value_.srid})"
-        else
-          super
-        end
-      end
-      
-      
-      def columns(table_name_, name_=nil)  #:nodoc:
-        spatial_info_ = spatial_column_info(table_name_)
-        table_structure(table_name_).map do |field_|
-          col_ = SpatialColumn.new(field_['name'], field_['dflt_value'], field_['type'], field_['notnull'].to_i == 0)
-          info_ = spatial_info_[field_['name']]
-          if info_
-            col_.set_srid(info_[:srid])
-          end
-          col_
-        end
-      end
-      
-      
-      def spatial_indexes(table_name_, name_=nil)
-        table_name_ = table_name_.to_s
-        names_ = select_values("SELECT name FROM sqlite_master WHERE type='table' AND name LIKE 'idx_#{quote_string(table_name_)}_%' AND rootpage=0") || []
-        names_.map do |name_|
-          col_name_ = name_.sub("idx_#{table_name_}_", '')
-          ::RGeo::ActiveRecord::SpatialIndexDefinition.new(table_name_, name_, false, [col_name_], [], true)
-        end
-      end
-      
-      
-      def create_table(table_name_, options_={})
-        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_.spatial_columns.each do |col_|
-          execute("SELECT AddGeometryColumn('#{quote_string(table_name_)}', '#{quote_string(col_.name.to_s)}', #{col_.srid}, '#{quote_string(col_.type.to_s.gsub('_','').upcase)}', 'XY', #{col_.null ? 0 : 1})")
-        end
-      end
-      
-      
-      def drop_table(table_name_, options_={})
-        spatial_indexes(table_name_).each do |index_|
-          remove_index(table_name_, :spatial => true, :column => index_.columns[0])
-        end
-        execute("DELETE from geometry_columns where f_table_name='#{quote_string(table_name_.to_s)}'")
-        super
-      end
-      
-      
-      def add_column(table_name_, column_name_, type_, options_={})
-        if ::RGeo::ActiveRecord::GEOMETRY_TYPES.include?(type_.to_sym)
-          execute("SELECT AddGeometryColumn('#{quote_string(table_name_.to_s)}', '#{quote_string(column_name_.to_s)}', #{options_[:srid].to_i}, '#{quote_string(type_.to_s)}', 'XY', #{options_[:null] == false ? 0 : 1})")
-        else
-          super
-        end
-      end
-      
-      
-      def add_index(table_name_, column_name_, options_={})
-        if options_[:spatial]
-          column_name_ = column_name_.first if column_name_.kind_of?(::Array) && column_name_.size == 1
-          table_name_ = table_name_.to_s
-          column_name_ = column_name_.to_s
-          spatial_info_ = spatial_column_info(table_name_)
-          unless spatial_info_[column_name_]
-            raise ::ArgumentError, "Can't create spatial index because column '#{column_name_}' in table '#{table_name_}' is not a geometry column"
-          end
-          result_ = select_value("SELECT CreateSpatialIndex('#{quote_string(table_name_)}', '#{quote_string(column_name_)}')").to_i
-          if result_ == 0
-            raise ::ArgumentError, "Spatial index already exists on table '#{table_name_}', column '#{column_name_}'"
-          end
-          result_
-        else
-          super
-        end
-      end
-      
-      
-      def remove_index(table_name_, options_={})
-        if options_[:spatial]
-          table_name_ = table_name_.to_s
-          column_ = options_[:column]
-          if column_
-            column_ = column_[0] if column_.kind_of?(::Array)
-            column_ = column_.to_s
-          else
-            index_name_ = options_[:name]
-            unless index_name_
-              raise ::ArgumentError, "You need to specify a column or index name to remove a spatial index."
-            end
-            if index_name_ =~ /^idx_#{table_name_}_(\w+)$/
-              column_ = $1
-            else
-              raise ::ArgumentError, "Unknown spatial index name: #{index_name_.inspect}."
-            end
-          end
-          spatial_info_ = spatial_column_info(table_name_)
-          unless spatial_info_[column_]
-            raise ::ArgumentError, "Can't remove spatial index because column '#{column_}' in table '#{table_name_}' is not a geometry column"
-          end
-          index_name_ = "idx_#{table_name_}_#{column_}"
-          has_index_ = select_value("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='#{quote_string(index_name_)}'").to_i > 0
-          unless has_index_
-            raise ::ArgumentError, "Spatial index not present on table '#{table_name_}', column '#{column_}'"
-          end
-          execute("SELECT DisableSpatialIndex('#{quote_string(table_name_)}', '#{quote_string(column_)}')")
-          execute("DROP TABLE #{quote_table_name(index_name_)}")
-        else
-          super
-        end
-      end
-      
-      
-      def spatial_column_info(table_name_)
-        info_ = execute("SELECT * FROM geometry_columns WHERE f_table_name='#{quote_string(table_name_.to_s)}'")
-        result_ = {}
-        info_.each do |row_|
-          result_[row_['f_geometry_column']] = {
-            :name => row_['f_geometry_column'],
-            :type => row_['type'],
-            :dimension => row_['coord_dimension'],
-            :srid => row_['srid'],
-            :has_index => row_['spatial_index_enabled'],
-          }
-        end
-        result_
-      end
-      
-      
-      class SpatialTableDefinition < ConnectionAdapters::TableDefinition  # :nodoc:
-        
-        attr_reader :spatial_columns
-        
-        def initialize(base_)
-          super
-        end
-        
-        def column(name_, type_, options_={})
-          super
-          col_ = self[name_]
-          if ::RGeo::ActiveRecord::GEOMETRY_TYPES.include?(col_.type.to_sym)
-            col_.extend(GeometricColumnDefinitionMethods) unless col_.respond_to?(:srid)
-            col_.set_srid(options_[:srid].to_i)
-          end
-          self
-        end
-        
-        def to_sql
-          @columns.find_all{ |c_| !c_.respond_to?(:srid) }.map{ |c_| c_.to_sql } * ', '
-        end
-        
-        def spatial_columns
-          @columns.find_all{ |c_| c_.respond_to?(:srid) }
-        end
-        
-      end
-      
-      
-      module GeometricColumnDefinitionMethods  # :nodoc:
-        
-        def srid
-          defined?(@srid) ? @srid : 4326
-        end
-        
-        def set_srid(value_)
-          @srid = value_
-        end
-        
-      end
-      
-      
-      class SpatialColumn < ConnectionAdapters::SQLiteColumn  # :nodoc:
-        
-        
-        def initialize(name_, default_, sql_type_=nil, null_=true)
-          super(name_, default_, sql_type_, null_)
-          @geometric_type = ::RGeo::ActiveRecord.geometric_type_from_name(sql_type_)
-          @ar_class = ::ActiveRecord::Base
-          @srid = 0
-        end
-        
-        
-        def set_ar_class(val_)
-          @ar_class = val_
-        end
-        
-        def set_srid(val_)
-          @srid = val_
-        end
-        
-        
-        attr_reader :srid
-        attr_reader :geometric_type
-        
-        
-        def spatial?
-          type == :geometry
-        end
-        
-        
-        def klass
-          type == :geometry ? ::RGeo::Feature::Geometry : super
-        end
-        
-        
-        def type_cast(value_)
-          type == :geometry ? SpatialColumn.convert_to_geometry(value_, @ar_class, name, @srid) : super
-        end
-        
-        
-        def type_cast_code(var_name_)
-          type == :geometry ? "::ActiveRecord::ConnectionAdapters::SpatiaLiteAdapter::SpatialColumn.convert_to_geometry(#{var_name_}, self.class, #{name.inspect}, #{@srid})" : super
-        end
-        
-        
-        private
-        
-        
-        def simplified_type(sql_type_)
-          sql_type_ =~ /geometry|point|linestring|polygon/i ? :geometry : super
-        end
-        
-        
-        def self.convert_to_geometry(input_, ar_class_, column_name_, column_srid_)
-          case input_
-          when ::RGeo::Feature::Geometry
-            factory_ = ar_class_.rgeo_factory_for_column(column_name_, :srid => column_srid_)
-            ::RGeo::Feature.cast(input_, factory_)
-          when ::String
-            if input_.length == 0
-              nil
-            else
-              factory_ = ar_class_.rgeo_factory_for_column(column_name_, :srid => column_srid_)
-              if input_[0,1] == "\x00"
-                NativeFormatParser.new(factory_).parse(input_) rescue nil
-              else
-                ::RGeo::WKRep::WKTParser.new(factory_, :support_ewkt => true).parse(input_)
-              end
-            end
-          else
-            nil
-          end
-        end
-        
-        
-      end
-      
-      
-      class NativeFormatParser  # :nodoc:
-        
-        
-        def initialize(factory_)
-          @factory = factory_
-        end
-        
-        
-        def parse(data_)
-          @little_endian = data_[1,1] == "\x01"
-          srid_ = data_[2,4].unpack(@little_endian ? 'V' : 'N').first
-          begin
-            _start_scanner(data_)
-            obj_ = _parse_object(false)
-            _get_byte(0xfe)
-          ensure
-            _clean_scanner
-          end
-          obj_
-        end
-        
-        
-        def _parse_object(contained_)
-          _get_byte(contained_ ? 0x69 : 0x7c)
-          type_code_ = _get_integer
-          case type_code_
-          when 1
-            coords_ = _get_doubles(2)
-            @factory.point(*coords_)
-          when 2
-            _parse_line_string
-          when 3
-            interior_rings_ = (1.._get_integer).map{ _parse_line_string }
-            exterior_ring_ = interior_rings_.shift || @factory.linear_ring([])
-            @factory.polygon(exterior_ring_, interior_rings_)
-          when 4
-            @factory.multi_point((1.._get_integer).map{ _parse_object(1) })
-          when 5
-            @factory.multi_line_string((1.._get_integer).map{ _parse_object(2) })
-          when 6
-            @factory.multi_polygon((1.._get_integer).map{ _parse_object(3) })
-          when 7
-            @factory.collection((1.._get_integer).map{ _parse_object(true) })
-          else
-            raise ::RGeo::Error::ParseError, "Unknown type value: #{type_code_}."
-          end
-        end
-        
-        
-        def _parse_line_string
-          count_ = _get_integer
-          coords_ = _get_doubles(2 * count_)
-          @factory.line_string((0...count_).map{ |i_| @factory.point(*coords_[2*i_,2]) })
-        end
-        
-        
-        def _start_scanner(data_)
-          @_data = data_
-          @_len = data_.length
-          @_pos = 38
-        end
-        
-        
-        def _clean_scanner
-          @_data = nil
-        end
-        
-        
-        def _get_byte(expect_=nil)
-          if @_pos + 1 > @_len
-            raise ::RGeo::Error::ParseError, "Not enough bytes left to fulfill 1 byte"
-          end
-          str_ = @_data[@_pos, 1]
-          @_pos += 1
-          val_ = str_.unpack("C").first
-          if expect_ && expect_ != val_
-            raise ::RGeo::Error::ParseError, "Expected byte 0x#{expect_.to_s(16)} but got 0x#{val_.to_s(16)}"
-          end
-          val_
-        end
-        
-        
-        def _get_integer
-          if @_pos + 4 > @_len
-            raise ::RGeo::Error::ParseError, "Not enough bytes left to fulfill 1 integer"
-          end
-          str_ = @_data[@_pos, 4]
-          @_pos += 4
-          str_.unpack("#{@little_endian ? 'V' : 'N'}").first
-        end
-        
-        
-        def _get_doubles(count_)
-          len_ = 8 * count_
-          if @_pos + len_ > @_len
-            raise ::RGeo::Error::ParseError, "Not enough bytes left to fulfill #{count_} doubles"
-          end
-          str_ = @_data[@_pos, len_]
-          @_pos += len_
-          str_.unpack("#{@little_endian ? 'E' : 'G'}*")
-        end
-        
-        
-      end
-      
-      
     end
     
   end
   
   
 end
+
+
+require 'active_record/connection_adapters/spatialite_adapter/version.rb'
+require 'active_record/connection_adapters/spatialite_adapter/native_format_parser.rb'
+require 'active_record/connection_adapters/spatialite_adapter/main_adapter.rb'
+require 'active_record/connection_adapters/spatialite_adapter/spatial_table_definition.rb'
+require 'active_record/connection_adapters/spatialite_adapter/spatial_column.rb'
+require 'active_record/connection_adapters/spatialite_adapter/arel_tosql.rb'
+
+
+ignore_tables_ = ::ActiveRecord::SchemaDumper.ignore_tables
+ignore_tables_ << 'geometry_columns' unless ignore_tables_.include?('geometry_columns')
+ignore_tables_ << 'geometry_columns_auth' unless ignore_tables_.include?('geometry_columns_auth')
+ignore_tables_ << 'views_geometry_columns' unless ignore_tables_.include?('views_geometry_columns')
+ignore_tables_ << 'virts_geometry_columns' unless ignore_tables_.include?('virts_geometry_columns')
+ignore_tables_ << 'spatial_ref_sys' unless ignore_tables_.include?('spatial_ref_sys')
+ignore_tables_ << /^idx_\w+_\w+$/ unless ignore_tables_.include?(/^idx_\w+_\w+$/)