datamapper 0.1.0 → 0.1.1

data/CHANGELOG

@@ -1,2 +1,32 @@
 -- 0.1.0
-* Initial Public Release
+* Initial Public Release
+
+-- 0.1.1
+* Removed /lib/data_mapper/extensions
+* Moved ActiveRecordImpersonation into DataMapper::Support module
+* Moved CallbackHelper methods into DataMapper::Base class
+* Moved ValidationHelper into DataMapper::Validations module
+* Removed LoadedSet since it's not necessary for it to reference the Database, so it's nothing more than an array now; Replaced with Array
+* Modified data_mapper.rb to load DataMapper::Support::Enumerable
+* Modified example.rb and performance.rb to require 'lib/data_mapper' instead of modifying $LOADPATH
+* Created SqlAdapter base-class
+* Refactored MysqlAdapter to use SqlAdapter superclass
+* Refactored Sqlite3Adapter to use SqlAdapter superclass
+* Moved /lib/data_mapper/queries to /lib/data_mapper/adapters/sql/queries
+* Moved Connection, Result and Reader classes along with Coersion and Quoting modules to DataMapper::Adapters::Sql module
+* Moved DataMapper::Adapters::Sql::Queries to ::Commands
+* Moved Mappings to SqlAdapter
+* Added monolithic DeleteCommand
+* Added monolithic SaveCommand
+* Added TableExistsCommand
+* Moved save/delete logic out of Session
+* Added create-table functionality to SaveCommand
+* Cleaned up Session; #find no longer supported, use #all or #first
+* Moved object materialization into LoadCommand
+* Migrated Sqlite3Adapter::Commands
+* Added Session#query support back in
+* Removed Connection/Reader/Result classes
+* Set DataMapper::Base#key on load to avoid double-hit against Schema
+* Added DataMapper::Support::Struct for increased Session#query performance
+* Added AdvancedHasManyAssociation (preview status)
+* Added benchmarks comparing ActiveRecord::Base::find_by_sql with Session#query

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2007 Samuel Smoot
+Copyright (c) 2007 Sam Smoot
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

data/README

@@ -1 +1,9 @@
-Start out with example.rb and go from there if you want to try it out live.
+Start out with example.rb and go from there if you want to try it out live.
+
+
+== Conventions
+
+Merb's coding conventions are a fantastic start: (http://merb.devjavu.com/#ContributingtoMerb)
+
+DataMapper could use some documentation help. If you'd like to contribute, the example you'll
+find on the above link is top-notch.

data/example.rb

@@ -1,25 +1,33 @@
-$LOAD_PATH.unshift('lib')
+#!/usr/bin/env ruby
 
-require 'data_mapper'
+require 'lib/data_mapper'
 
-if ENV['ADAPTER'] == 'sqlite3'
-  DataMapper::Database.setup do
-    adapter  'sqlite3'
-    database 'data_mapper_1.db'
+ENV['ADAPTER'] ||= 'mysql'
+
+DataMapper::Database.setup do
+  adapter  ENV['ADAPTER']
+  
+  unless ENV['LOGGER'] == 'false'
     log_stream 'example.log'
     log_level Logger::DEBUG
   end
-else
-  DataMapper::Database.setup do
-    adapter  'mysql'
-    host     'localhost'
-    username 'root'
-    database 'data_mapper_1'
-    log_stream 'example.log'
-    log_level Logger::DEBUG
+  
+  database_name = 'data_mapper_1'
+  
+  case ENV['ADAPTER']
+    when 'postgresql' then
+      username 'postgres'
+    when 'mysql' then
+      username 'root'
+    when 'sqlite3' then
+      database_name << '.db'
   end
+  
+  database database_name
 end
 
 Dir[File.dirname(__FILE__) + '/spec/models/*.rb'].each do |path|
   load path
-end
+end
+
+# p Zoo.all

data/lib/data_mapper.rb

@@ -3,10 +3,15 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 
 # Require the basics...
+require 'set'
+require 'fastthread'
+require 'data_mapper/support/blank'
+require 'data_mapper/support/enumerable'
 require 'data_mapper/support/symbol'
 require 'data_mapper/support/string'
 require 'data_mapper/support/proc'
 require 'data_mapper/support/inflector'
+require 'data_mapper/support/struct'
 require 'data_mapper/database'
 require 'data_mapper/base'
 

data/lib/data_mapper/adapters/abstract_adapter.rb

@@ -1,48 +1,6 @@
-require 'data_mapper/queries/select_statement'
-require 'data_mapper/queries/insert_statement'
-require 'data_mapper/queries/update_statement'
-require 'data_mapper/queries/delete_statement'
-require 'data_mapper/queries/truncate_table_statement'
-require 'data_mapper/queries/create_table_statement'
-require 'data_mapper/queries/drop_table_statement'
-require 'data_mapper/queries/table_exists_statement'
-require 'data_mapper/queries/connection'
-
 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 Abstract::Adapter, and implement the
-    # required methods to adapt a database library for use with the DataMapper.
-    #
-    # NOTE: By inheriting from AbstractAdapter, 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 AbstractAdapter
   
       # Instantiate an Adapter by passing it a DataMapper::Database
@@ -50,179 +8,23 @@ module DataMapper
       def initialize(configuration)
         @configuration = configuration
       end
-  
-      def connection(&block)
+      
+      def delete(instance_or_klass, options = nil)
         raise NotImplementedError.new
       end
-  
-      def transaction(&block)
+      
+      def save(session, instance)
         raise NotImplementedError.new
       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
-      # AbstractAdapter.
-      # 
-      # 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)
-        
-        quoting = base.const_set('Quoting', Module.new)
-        quoting.send(:include, Quoting)
-        
-        coersion = base.const_set('Coersion', Module.new)
-        coersion.send(:include, Coersion)
-        
-        queries = base.const_set('Queries', Module.new)
-
-        Queries.constants.each do |name|
-          queries.const_set(name, Class.new(Queries.const_get(name)))
-        end
-        
-        base.const_set('TYPES', TYPES.dup)
-        
-        base.const_set('SYNTAX', SYNTAX.dup)
+      def load(session, klass, options)
+        raise NotImplementedError.new
       end
       
-      TYPES = {
-        :integer => 'int'.freeze,
-        :string => 'varchar'.freeze,
-        :text => 'text'.freeze,
-        :class => 'varchar'.freeze
-      }
-      
-      SYNTAX = {
-        :auto_increment => 'auto_increment'.freeze
-      }
-      
-      # Quoting is a mixin that extends your DataMapper::Database singleton-class
-      # to allow for object-name and value quoting to be exposed to the queries.
-      #
-      # DESIGN: Is there any need for this outside of the query objects? Should
-      # we just include it in our query object subclasses and not rely on a Quoting
-      # mixin being part of the "standard" Adapter interface?
-      module Quoting
-
-        def quote_table_name(name)
-          name.ensure_wrapped_with('"')
-        end
-
-        def quote_column_name(name)
-          name.ensure_wrapped_with('"')
-        end
+      def log
+        @configuration.log
+      end
       
-        def quote_value(value)
-          return 'NULL' if value.nil?
-
-          case value
-            when Numeric then value.to_s
-            when String then "'#{value.gsub("'", "''")}'"
-            when Class then "'#{value.name}'"
-            when Date then "'#{value.to_s}'"
-            when Time, DateTime then "'#{value.strftime("%Y-%m-%d %H:%M:%S")}'"
-            when TrueClass, FalseClass then value.to_s.upcase
-            else raise "Don't know how to quote #{value.inspect}"
-          end
-        end
-
-      end # module Quoting
-
-      # Coersion is a mixin that allows for coercing database values to Ruby Types.
-      #
-      # DESIGN: Probably should handle the opposite scenario here too. I believe that's
-      # currently in DataMapper::Database, which is obviously not a very good spot for
-      # it.
-      module Coersion
-
-        def type_cast_value(type, raw_value)
-          return nil if raw_value.nil?
-
-          case type
-          when :class then Kernel::const_get(raw_value)
-          when :string, :text then
-            return nil if raw_value.nil?
-            value_as_string = raw_value.to_s.strip
-            return nil if value_as_string.empty?
-            value_as_string
-          when :integer then
-            return nil if raw_value.nil? || (raw_value.kind_of?(String) && raw_value.empty?)
-            begin
-              Integer(raw_value)
-            rescue ArgumentError
-              nil
-            end
-          else
-            if respond_to?("type_cast_#{type}")
-              send("type_cast_#{type}", raw_value)
-            else
-              raise "Don't know how to type-cast #{{ type => raw_value }.inspect }"
-            end
-          end      
-        end
-
-      end # module Coersion
-
-      # You define your custom queries in a sub-module called Queries.
-      # If you don't need to redefine any of the default functionality/syntax,
-      # you can just create constants that point to the standard queries:
-      #
-      #   SelectStatement = DataMapper::Queries::SelectStatement
-      #
-      # It's just as easy to turn that into a sub-class however:
-      #
-      #   class SelectStatement < DataMapper::Queries::SelectStatement
-      #   end
-      #
-      # You sub-class and edit instead of overwrite because you want to
-      # make sure your changes only affect this database adapter and avoid
-      # introducing incompatibilities into other adapters.
-      module Queries
-        
-        # Your Connection class is one of two that will be almost completely custom.
-        # Refer to DataMapper::Queries::Connection for the required interface.
-        class Connection < DataMapper::Queries::Connection
-        end
-        
-        # Reader is the other Connection related class that will be almost completely custom.
-        # The idea with the Reader is to avoid creating a large Array of Hash objects to
-        # represent rows since the hashes will be discarded almost immediately. Create only
-        # what you need. So the reader creates a single Hash to associate columns with their
-        # ordinals in the result set, then indexing the Reader for each row results in looking
-        # up the column index, then the value for that index in the current row array.
-        class Reader < DataMapper::Queries::Reader
-        end
-        
-        class Result < DataMapper::Queries::Result
-        end
-        
-        class DeleteStatement < DataMapper::Queries::DeleteStatement
-        end
-
-        class InsertStatement < DataMapper::Queries::InsertStatement
-        end
-
-        class SelectStatement < DataMapper::Queries::SelectStatement
-        end
-
-        class TruncateTableStatement < DataMapper::Queries::TruncateTableStatement
-        end
-
-        class UpdateStatement < DataMapper::Queries::UpdateStatement
-        end
-        
-        class CreateTableStatement < DataMapper::Queries::CreateTableStatement
-        end
-        
-        class DropTableStatement < DataMapper::Queries::DropTableStatement
-        end
-        
-        class TableExistsStatement < DataMapper::Queries::TableExistsStatement
-        end
-
-      end # module Queries
-    
     end # class AbstractAdapter
     
   end # module Adapters

data/lib/data_mapper/adapters/mysql_adapter.rb

@@ -1,4 +1,4 @@
-require 'data_mapper/adapters/abstract_adapter'
+require 'data_mapper/adapters/sql_adapter'
 require 'data_mapper/support/connection_pool'
 
 begin
@@ -16,155 +16,179 @@ end
 module DataMapper
   module Adapters
     
-    class MysqlAdapter < AbstractAdapter
+    class MysqlAdapter < SqlAdapter
       
       def initialize(configuration)
         super
-        @connections = Support::ConnectionPool.new { Queries::Connection.new(@configuration)  }
+        
+        create_connection = lambda do
+          Mysql.new(configuration.host, configuration.username, configuration.password, configuration.database)
+        end
+        
+        # Initialize the connection pool.
+        if single_threaded?
+          @connection_factory = create_connection
+          @active_connection = create_connection[]
+        else
+          @connections = Support::ConnectionPool.new(&create_connection)
+        end
       end
       
+      # Yields an available connection. Flushes the connection-pool if
+      # the connection returns an error.
       def connection
-        raise ArgumentError.new('MysqlAdapter#connection requires a block-parameter') unless block_given?
-        begin
-          @connections.hold { |connection| yield connection }
-        rescue Mysql::Error => me
-          
-          @configuration.log.fatal(me)
-          
-          @connections.available_connections.each do |sock|
+        
+        if single_threaded?
+          begin
+            # BUG: Single_threaded mode totally breaks shit right now. No real idea why just from
+            # eyeballing this. Probably should move this into the SqlAdapter anyways and just
+            # force derived adapters to implement a #create_connection() and #close_connection(conn) methods.
+            yield(@active_connection)
+          rescue Mysql::Error => me
+            @configuration.log.fatal(me)
+            
             begin
-              sock.close
+              @active_connection.close
             rescue => se
               @configuration.log.error(se)
             end
+            
+            @active_connection = @connection_factory[]
           end
+        else
+          begin
+            @connections.hold { |dbh| yield(dbh) }
+          rescue Mysql::Error => me
           
-          @connections.available_connections.clear
-          raise me
+            @configuration.log.fatal(me)
+          
+            @connections.available_connections.each do |sock|
+              begin
+                sock.close
+              rescue => se
+                @configuration.log.error(se)
+              end
+            end
+          
+            @connections.available_connections.clear
+            raise me
+          end
         end
       end
       
-      module Quoting
-
-        def quote_table_name(name)
-          name.ensure_wrapped_with('`')
-        end
-
-        def quote_column_name(name)
-          name.ensure_wrapped_with('`')
+      def execute(*args)
+        connection do |db|
+          reader = db.query(escape_sql(*args))
+          result = yield(reader, reader.fetch_fields.map { |field| field.name })
+          reader.free
+          result
         end
-
-      end # module Quoting
-
-      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
-        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
-
-      end # module Coersion
+      end
       
-      module Queries
+      def query(*args)
         
-        class Connection
-      
-          def initialize(database)
-            @database = database
-            @dbh = Mysql.new(database.host, database.username, database.password, database.database)
-            database.log.debug("Initializing Connection for Database[#{database.name}]")
-            super(database.log)
-          end
+        execute(*args) do |reader, fields|
+          struct = Support::Struct::define(fields)
+          
+          results = []
           
-          def execute(statement)
-            send_query(statement)
-            Result.new(@dbh.affected_rows, @dbh.insert_id)
+          reader.each do |row|
+            results << struct.new(row)
           end
+          results
+          
+        end
+      end
       
-          def query(statement)
-            Reader.new(send_query(statement))
-          end
+      TABLE_QUOTING_CHARACTER = '`'.freeze
+      COLUMN_QUOTING_CHARACTER = '`'.freeze
+      
+      TRUE_ALIASES.unshift('1'.freeze)
+      FALSE_ALIASES.unshift('0'.freeze)
       
-          def close
-            @dbh.close
+      module Commands
+        
+        class TableExistsCommand
+          def call
+            sql = to_sql
+            @adapter.log.debug(sql)
+            reader = @adapter.connection { |db| db.query(sql) }
+            result = reader.num_rows > 0
+            reader.free
+            result
+          end
+        end
+        
+        class DeleteCommand
+          
+          def execute(sql)
+            @adapter.connection do |db|
+              @adapter.log.debug(sql)
+              db.query(sql)
+              db.affected_rows > 0
+            end
           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)
+          def execute_drop(sql)
+            @adapter.log.debug(sql)
+            @adapter.connection { |db| db.query(sql) }
+            true
           end
           
-        end # class Connection
+        end
         
-        class Reader
-      
-          include Enumerable
+        class SaveCommand
           
-          def initialize(results)
-            @results = results
-            @columns = {}
-            results.fetch_fields.each_with_index do |field, index|
-              @columns[field.name] = index
+          def execute_insert(sql)
+            @adapter.connection do |db|
+              @adapter.log.debug(sql)
+              db.query(sql)
+              db.insert_id
             end
-            @current_row_index = 0
           end
           
-          def eof?
-            records_affected <= @current_row_index
+          def execute_update(sql)
+            @adapter.connection do |db|
+              @adapter.log.debug(sql)
+              db.query(sql)
+              db.affected_rows > 0
+            end
           end
           
-          def records_affected
-            @results.num_rows
+          def execute_create_table(sql)
+            @adapter.log.debug(sql)
+            @adapter.connection { |db| db.query(sql) }
+            true
           end
           
-          def next
-            @current_row_index += 1
-            @current_row = @results.fetch_row
-            self
-          end
-      
-          def each
-            @results.each do |row|
-              @current_row = row
-              yield self
-            end
+        end
+        
+        class LoadCommand
+          def eof?(reader)
+            reader.num_rows == 0
           end
-      
-          def [](column)
-            index = @columns[column]
-            return nil if index.nil?
-            @current_row[index]
+          
+          def close_reader(reader)
+            reader.free
           end
           
-          def each_pair
-            @columns.each_pair do |column_name, index|
-              yield(column_name, @current_row[index])
-            end
+          def execute(sql)
+            @adapter.log.debug(sql)
+            @adapter.connection { |db| db.query(to_sql) }
           end
           
-          def close
-            @results.free
+          def fetch_one(reader)
+            fetch_all(reader).first
           end
-      
-        end # class Reader
-        
-      end # module Queries
+             
+          def fetch_all(reader)
+            load_instances(reader.fetch_fields.map { |field| field.name }, reader)
+          end
+          
+        end
         
+      end
+      
     end # class MysqlAdapter
     
   end # module Adapters