datamapper 0.1.0 → 0.1.1

data/lib/data_mapper/adapters/sql_adapter.rb

@@ -0,0 +1,163 @@
+require 'data_mapper/adapters/abstract_adapter'
+require 'data_mapper/adapters/sql/commands/load_command'
+require 'data_mapper/adapters/sql/commands/advanced_load_command'
+require 'data_mapper/adapters/sql/commands/save_command'
+require 'data_mapper/adapters/sql/commands/delete_command'
+require 'data_mapper/adapters/sql/commands/table_exists_command'
+require 'data_mapper/adapters/sql/coersion'
+require 'data_mapper/adapters/sql/quoting'
+require 'data_mapper/adapters/sql/mappings/schema'
+
+module DataMapper
+  
+  # An Adapter is really a Factory for three types of object,
+  # so they can be selectively sub-classed where needed.
+  # 
+  # The first type is a Query. The Query is an object describing
+  # the database-specific operations we wish to perform, in an
+  # abstract manner. For example: While most if not all databases
+  # support a mechanism for limiting the size of results returned,
+  # some use a "LIMIT" keyword, while others use a "TOP" keyword.
+  # We can set a SelectStatement#limit field then, and allow
+  # the adapter to override the underlying SQL generated.
+  # Refer to DataMapper::Queries.
+  # 
+  # The second type provided by the Adapter is a DataMapper::Connection.
+  # This allows us to execute queries and return results in a clear and
+  # uniform manner we can use throughout the DataMapper.
+  #
+  # The final type provided is a DataMapper::Transaction.
+  # Transactions are duck-typed Connections that span multiple queries.
+  #
+  # Note: It is assumed that the Adapter implements it's own
+  # ConnectionPool if any since some libraries implement their own at
+  # a low-level, and it wouldn't make sense to pay a performance
+  # cost twice by implementing a secondary pool in the DataMapper itself.
+  # If the library being adapted does not provide such functionality,
+  # DataMapper::Support::ConnectionPool can be used.
+  module Adapters
+      
+    # You must inherit from the SqlAdapter, and implement the
+    # required methods to adapt a database library for use with the DataMapper.
+    #
+    # NOTE: By inheriting from SqlAdapter, you get a copy of all the
+    # standard sub-modules (Quoting, Coersion and Queries) in your own Adapter.
+    # You can extend and overwrite these copies without affecting the originals.
+    class SqlAdapter < AbstractAdapter
+      
+      FIND_OPTIONS = [
+        :select, :limit, :class, :include, :reload, :conditions, :order
+      ]
+      
+      def initialize(configuration)
+        super
+        @single_threaded = configuration.single_threaded
+      end
+      
+      def single_threaded?
+        @single_threaded
+      end
+           
+      def connection(&block)
+        raise NotImplementedError.new
+      end
+  
+      def transaction(&block)
+        raise NotImplementedError.new
+      end
+      
+      def query(sql)
+        raise NotImplementedError.new
+      end
+      
+      def schema
+        @schema || ( @schema = Mappings::Schema.new(self) )
+      end
+      
+      def table_exists?(name)
+        self.class::Commands::TableExistsCommand.new(self, name).call
+      end
+      
+      def delete(klass_or_instance, options = nil)
+        self.class::Commands::DeleteCommand.new(self, klass_or_instance, options).call
+      end
+      
+      def save(session, instance)
+        self.class::Commands::SaveCommand.new(self, session, instance).call
+      end
+      
+      def load(session, klass, options)
+        self.class::Commands::LoadCommand.new(self, session, klass, options).call
+      end
+      
+      def [](klass_or_table_name)
+        schema[klass_or_table_name]
+      end
+      
+      # Escape a string of SQL with a set of arguments.
+      # The first argument is assumed to be the SQL to escape,
+      # the remaining arguments (if any) are assumed to be
+      # values to escape and interpolate.
+      #
+      # ==== Examples
+      #   escape_sql("SELECT * FROM zoos")
+      #   # => "SELECT * FROM zoos"
+      # 
+      #   escape_sql("SELECT * FROM zoos WHERE name = ?", "Dallas")
+      #   # => "SELECT * FROM zoos WHERE name = `Dallas`"
+      #
+      #   escape_sql("SELECT * FROM zoos WHERE name = ? AND acreage > ?", "Dallas", 40)
+      #   # => "SELECT * FROM zoos WHERE name = `Dallas` AND acreage > 40"
+      # 
+      # ==== Warning
+      # This method is meant mostly for adapters that don't support
+      # bind-parameters.
+      def escape_sql(*args)
+        sql = args.shift
+      
+        unless args.empty?
+          sql.gsub!(/\?/) do |x|
+            quote_value(args.shift)
+          end
+        end
+        
+        sql
+      end
+      
+      # This callback copies and sub-classes modules and classes
+      # in the AbstractAdapter to the inherited class so you don't
+      # have to copy and paste large blocks of code from the
+      # SqlAdapter.
+      # 
+      # Basically, when inheriting from the AbstractAdapter, you
+      # aren't just inheriting a single class, you're inheriting
+      # a whole graph of Types. For convenience.
+      def self.inherited(base)
+        
+        queries = base.const_set('Commands', Module.new)
+
+        Sql::Commands.constants.each do |name|
+          queries.const_set(name, Class.new(Sql::Commands.const_get(name)))
+        end  
+        
+        base.const_set('TYPES', TYPES.dup)
+        base.const_set('FIND_OPTIONS', FIND_OPTIONS.dup)
+        
+        super
+      end
+      
+      TYPES = {
+        :integer => 'int'.freeze,
+        :string => 'varchar'.freeze,
+        :text => 'text'.freeze,
+        :class => 'varchar'.freeze
+      }
+
+      include Sql
+      include Quoting
+      include Coersion
+      
+    end # class SqlAdapter
+    
+  end # module Adapters
+end # module DataMapper

data/lib/data_mapper/adapters/sqlite3_adapter.rb

@@ -1,4 +1,4 @@
-require 'data_mapper/adapters/abstract_adapter'
+require 'data_mapper/adapters/sql_adapter'
 require 'data_mapper/support/connection_pool'
 
 require 'sqlite3'
@@ -6,11 +6,15 @@ require 'sqlite3'
 module DataMapper
   module Adapters
     
-    class Sqlite3Adapter < AbstractAdapter
+    class Sqlite3Adapter < SqlAdapter
       
       def initialize(configuration)
         super
-        @connections = Support::ConnectionPool.new { Queries::Connection.new(@configuration)  }
+        @connections = Support::ConnectionPool.new do
+          dbh = SQLite3::Database.new(configuration.database)
+          dbh.results_as_hash = true
+          dbh
+        end
       end
       
       def connection
@@ -34,126 +38,76 @@ module DataMapper
         end
       end
       
+      def query(*args)
+        reader = connection { |db| db.query(escape_sql(*args)) }
+        
+        fields = nil
+        rows = []
+        
+        until reader.eof?
+          hash = reader.next
+          break if hash.nil?
+          
+          fields = hash.keys.select { |field| field.is_a?(String) } unless fields
+          
+          rows << fields.map { |field| hash[field] }
+        end
+        
+        reader.close
+        
+        struct = Support::Struct::define(fields)
+        
+        rows.map do |row|
+          struct.new(row)
+        end
+      end
+      
       TYPES.merge!({
         :integer => 'INTEGER'.freeze,
         :string => 'TEXT'.freeze,
         :text => 'TEXT'.freeze,
         :class => 'TEXT'.freeze
       })
-      
-      module Coersion
 
-        def type_cast_boolean(value)
-          case value
-            when TrueClass, FalseClass then value
-            when "1", "true", "TRUE" then true
-            when "0", nil then false
-            else "Can't type-cast #{value.inspect} to a boolean"
-          end
+      TABLE_QUOTING_CHARACTER = '"'.freeze
+      COLUMN_QUOTING_CHARACTER = '"'.freeze
+      
+      def type_cast_boolean(value)
+        case value
+          when TrueClass, FalseClass then value
+          when "1", "true", "TRUE" then true
+          when "0", nil then false
+          else "Can't type-cast #{value.inspect} to a boolean"
         end
+      end
 
-        def type_cast_datetime(value)
-          case value
-            when DateTime then value
-            when Date then DateTime.new(value)
-            when String then DateTime::parse(value)
-            else "Can't type-cast #{value.inspect} to a datetime"
-          end
+      def type_cast_datetime(value)
+        case value
+          when DateTime then value
+          when Date then DateTime.new(value)
+          when String then DateTime::parse(value)
+          else "Can't type-cast #{value.inspect} to a datetime"
         end
-
-      end # module Coersion
-      
-      module Queries
-        
-        class Connection
-      
-          def initialize(database)
-            @database = database
-            @dbh = SQLite3::Database.new(database.database)
-            database.log.debug("Initializing Connection for Database[#{database.name}]")
-            super(database.log)
-          end
-          
-          def execute(statement)
-            send_query(statement)
-            Result.new(@dbh.total_changes, @dbh.last_insert_row_id)
-          end
-      
-          def query(statement)
-            Reader.new(send_query(statement))
-          end
-      
-          def close
-            @dbh.close
-          end
-          
-          private
-          def send_query(statement)
-            sql = statement.respond_to?(:to_sql) ? statement.to_sql : statement
-            log.debug("Database[#{@database.name}] => #{sql}")
-            @dbh.query(sql)
-          end
-          
-        end # class Connection
+      end
+    
+      module Commands
         
-        class Reader
-      
-          include Enumerable
-          
-          def initialize(results)
-            @results = results
-            @columns = {}
-            @results.columns.each_with_index do |name, index|
-              @columns[name] = index
-            end
-          end
-          
-          def eof?
-            @results.eof?
-          end
-          
-          def records_affected
-            @results.entries.size
-          end
-          
-          def next
-            @current_row = @results.next
-            self
-          end
-      
-          def each
-            until self.next.eof?
-              yield(self)
-            end
-          end
-      
-          def [](column)
-            index = @columns[column]
-            return nil if index.nil? || @current_row.nil?
-            @current_row[index]
-          end
-          
-          def each_pair            
-            @columns.each_pair do |column_name, index|
-              yield(column_name, @current_row.nil? ? nil : @current_row[index])
-            end
+        class TableExistsCommand
+          def to_sql
+            "SELECT name FROM sqlite_master WHERE type = \"table\" AND name = #{table_name}"
           end
           
-          def close
-            @results.close
-          end
-      
-        end # class Reader
-        
-        class TableExistsStatement
-          def to_sql
-            "SELECT name FROM sqlite_master WHERE type = \"table\" AND name = #{@database.quote_value(@database[@klass].name)}"
+          def call
+            reader = @adapter.connection { |db| db.query(to_sql) }
+            result = reader.entries.size > 0
+            reader.close
+            result
           end
-        end # class TableExistsStatement
+        end # class TableExistsCommand
          
-        class CreateTableStatement
-          def to_sql
-            table = @database[@klass]
+        class SaveCommand
+          def to_create_table_sql
+            table = @adapter[@instance]
 
             sql = "CREATE TABLE " << table.to_sql
 
@@ -165,7 +119,7 @@ module DataMapper
           end
 
           def column_long_form(column)
-            long_form = "#{column.to_sql} #{@database.adapter.class::TYPES[column.type] || column.type}"
+            long_form = "#{column.to_sql} #{@adapter.class::TYPES[column.type] || column.type}"
 
             long_form << " NOT NULL" unless column.nullable?
             long_form << " PRIMARY KEY" if column.key?
@@ -173,16 +127,101 @@ module DataMapper
 
             return long_form
           end
-        end # class CreateTableStatement
-        
-        class TruncateTableStatement
-          def to_sql
-            "DELETE FROM " << @database[@klass].to_sql
+          
+          def execute_insert(sql)
+            @adapter.connection do |db|
+              db.query(sql)
+              db.last_insert_row_id
+            end
           end
-        end # class TruncateTableStatement
+          
+          def execute_update(sql)
+            @adapter.connection do |db|
+              db.query(sql)
+              db.total_changes > 0
+            end
+          end
+          
+          def execute_create_table(sql)
+            @adapter.connection { |db| db.query(sql) }
+            true
+          end
+        end # class SaveCommand
         
-      end # module Queries
+        class DeleteCommand
+          def to_truncate_sql
+            "DELETE FROM " << @adapter[@klass_or_instance].to_sql
+          end
+          
+          def execute(sql)
+            @adapter.connection do |db|
+              db.query(sql)
+              db.total_changes > 0
+            end
+          end
+          
+          def execute_drop(sql)
+            @adapter.connection { |db| db.query(sql) }
+            true
+          end
+        end # class DeleteCommand
+         
+        class LoadCommand
+          def eof?(reader)
+            reader.eof?
+          end
+          
+          def close_reader(reader)
+            reader.close
+          end
+          
+          def execute(sql)
+            @adapter.connection { |db| db.query(to_sql) }
+          end
+          
+          def fetch_one(reader)
+            load(reader.next)
+          end
+          
+          def fetch_all(reader)
+            fields = nil
+            rows = []
+            
+            until reader.eof?
+              hash = reader.next
+              break if hash.nil?
+              
+              fields = hash.keys.select { |field| field.is_a?(String) } unless fields
+              
+              rows << fields.map { |name| hash[name] }
+            end
+            
+            load_instances(fields, rows)
+          end
+          
+          def fetch_structs(reader)
+            fields = nil
+            rows = []
+            
+            until reader.eof?
+              hash = reader.next
+              break if hash.nil?
+              
+              fields = hash.keys.select { |field| field.is_a?(String) } unless fields
+              
+              rows << fields.map { |name| hash[name] }
+            end
+            
+            fields = fields.inject({}) do |h,f|
+              h[f] = fields.index(f); h
+            end
+            
+            load_structs(fields, rows)
+          end
+        end
         
+      end # module Commands
+      
     end # class Sqlite3Adapter
     
   end # module Adapters