datamapper 0.1.1 → 0.2.0

data/lib/data_mapper/adapters/mysql_adapter.rb

@@ -1,194 +1,45 @@
-require 'data_mapper/adapters/sql_adapter'
-require 'data_mapper/support/connection_pool'
-
+require 'data_mapper/adapters/data_object_adapter'
 begin
-  require 'mysql'
-rescue LoadError
-  STDERR.puts <<-EOS.gsub(/^(\s+)/, '')
-    This adapter currently depends on the \"mysql\" gem.
-    If some kind soul would like to make it work with
-    a pure-ruby version that'd be super spiffy.
-  EOS
-  
-  raise
+  require 'do_mysql'
+rescue
+  STDERR.puts <<-EOS
+You must install the DataObjects::Mysql driver.
+  rake dm:install:mysql
+EOS
+  exit
 end
 
 module DataMapper
   module Adapters
     
-    class MysqlAdapter < SqlAdapter
-      
-      def initialize(configuration)
-        super
-        
-        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
-        
-        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
-              @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
-          
-            @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
-      
-      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
-      
-      def query(*args)
-        
-        execute(*args) do |reader, fields|
-          struct = Support::Struct::define(fields)
-          
-          results = []
-          
-          reader.each do |row|
-            results << struct.new(row)
-          end
-          results
-          
-        end
+    class MysqlAdapter < DataObjectAdapter
+      def create_connection
+        
+        connection_string = ""
+        builder = lambda { |k,v| connection_string << "#{k}=#{@configuration.send(v)} " unless @configuration.send(v).blank? }
+        
+        builder['host', :host]
+        builder['user', :username]
+        builder['password', :password]
+        builder['dbname', :database]
+        builder['socket', :socket]
+        
+        conn = DataObject::Mysql::Connection.new(connection_string.strip)
+        conn.open
+        cmd = conn.create_command("SET NAMES UTF8")
+        cmd.execute_non_query
+        return conn
       end
       
-      TABLE_QUOTING_CHARACTER = '`'.freeze
-      COLUMN_QUOTING_CHARACTER = '`'.freeze
-      
-      TRUE_ALIASES.unshift('1'.freeze)
-      FALSE_ALIASES.unshift('0'.freeze)
-      
-      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
-          
-          def execute_drop(sql)
-            @adapter.log.debug(sql)
-            @adapter.connection { |db| db.query(sql) }
-            true
-          end
-          
-        end
-        
-        class SaveCommand
-          
-          def execute_insert(sql)
-            @adapter.connection do |db|
-              @adapter.log.debug(sql)
-              db.query(sql)
-              db.insert_id
-            end
-          end
-          
-          def execute_update(sql)
-            @adapter.connection do |db|
-              @adapter.log.debug(sql)
-              db.query(sql)
-              db.affected_rows > 0
-            end
-          end
-          
-          def execute_create_table(sql)
-            @adapter.log.debug(sql)
-            @adapter.connection { |db| db.query(sql) }
-            true
-          end
-          
-        end
+      module Mappings
         
-        class LoadCommand
-          def eof?(reader)
-            reader.num_rows == 0
-          end
-          
-          def close_reader(reader)
-            reader.free
+        def to_create_table_sql
+          @to_create_table_sql || @to_create_table_sql = begin
+            "CREATE TABLE #{to_sql} (#{columns.map { |c| c.to_long_form }.join(', ')}) Type=MyISAM CHARACTER SET utf8"
           end
-          
-          def execute(sql)
-            @adapter.log.debug(sql)
-            @adapter.connection { |db| db.query(to_sql) }
-          end
-          
-          def fetch_one(reader)
-            fetch_all(reader).first
-          end
-             
-          def fetch_all(reader)
-            load_instances(reader.fetch_fields.map { |field| field.name }, reader)
-          end
-          
         end
         
-      end
-      
+      end # module Mappings
     end # class MysqlAdapter
     
   end # module Adapters

data/lib/data_mapper/adapters/postgresql_adapter.rb

@@ -1,242 +1,133 @@
-require 'data_mapper/adapters/sql_adapter'
-require 'data_mapper/support/connection_pool'
-
+require 'data_mapper/adapters/data_object_adapter'
 begin
-  require 'postgres'
-rescue LoadError
-  STDERR.puts <<-EOS.gsub(/^(\s+)/, '')
-    This adapter currently depends on the \"postgres\" gem.
-    If some kind soul would like to make it work with
-    a pure-ruby version that'd be super spiffy.
-  EOS
-  
-  raise
+  require 'do_postgres'
+rescue
+  STDERR.puts <<-EOS
+You must install the DataObjects::PostgreSQL driver.
+  rake dm:install:postgresql
+EOS
+  exit
 end
 
 module DataMapper
   module Adapters
     
-    class PostgresqlAdapter < SqlAdapter
+    class PostgresqlAdapter < DataObjectAdapter
       
-      def initialize(configuration)
-        super
-        # Initialize the connection pool.
-        @connections = Support::ConnectionPool.new do
-          # add port parameter to configuration
-          pg_conn = PGconn.connect(configuration.host, 5432, "", "", configuration.database, configuration.username, configuration.password)
-        end
-      end
-
-
-      # Returns an available connection. Flushes the connection-pool if
-      # the connection returns an error.
-      def connection
-        raise ArgumentError.new('PostgresqlAdapter#connection requires a block-parameter') unless block_given?
-        begin
-          @connections.hold { |connection| yield connection }
-        rescue PGError => me
-          
-          @configuration.log.fatal(me)
-          
-          @connections.available_connections.each do |sock|
-            begin
-              sock.close
-            rescue => se
-              @configuration.log.error(se)
-            end
+      def schema_search_path
+        @schema_search_path || @schema_search_path = begin
+          if @configuration.schema_search_path
+            @configuration.schema_search_path.split(',').map do |part|
+              part.blank? ? nil : part.strip.ensure_wrapped_with("'")
+            end.compact
+          else
+            []
           end
-          
-          @connections.available_connections.clear
-          raise me
         end
       end
       
-      def query(*args)
-        pg_result = connection { |db| db.exec(escape_sql(*args)) }
-        
-        struct = Struct.new(*pg_result.fields.map { |field| Inflector.underscore(field).to_sym })
-        results = []
-        
-        pg_result.each do |row|
-          results << struct.new(*row)
+      def create_connection
+        conn = DataObject::Postgres::Connection.new("dbname=#{@configuration.database}")
+        conn.open
+        return conn
+             
+        unless schema_search_path.empty?
+          execute("SET search_path TO #{schema_search_path}")
         end
         
-        pg_result.clear
-        return results
+        return connection
       end
-      
+            
       TABLE_QUOTING_CHARACTER = '"'.freeze
       COLUMN_QUOTING_CHARACTER = '"'.freeze
-
-      def type_cast_boolean(value)
-        case value
-          when TrueClass, FalseClass then value
-          when "t", "true", "TRUE" then true
-          when "f", 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
-      
-      def sequence_name(table)
-        quote_table_name(table.to_sql.gsub('"', '') + "_id_seq")
-      end
       
       TYPES.merge!({
         :integer => 'integer'.freeze,
-        :string => 'varchar'.freeze,
-        :text => 'text'.freeze,
-        :class => 'varchar'.freeze,
         :datetime => 'timestamp with time zone'.freeze
       })
-
-      module Commands
         
-        class TableExistsCommand
-          def to_sql
-            # TODO cache this somewhere
-            schema_list = @adapter.connection { |db| db.exec('SHOW search_path').result[0][0].split(',').collect { |s| "'#{s}'" }.join(',') }
-            "SELECT tablename FROM pg_tables WHERE schemaname IN (#{schema_list}) AND tablename = #{table_name}"
+      module Mappings
+        class Table
+          def sequence_sql
+            @sequence_sql ||= quote_table("_id_seq").freeze
           end
           
-          def call
-            sql = to_sql
-            @adapter.log.debug(sql)
-            reader = @adapter.connection { |db| db.exec(sql) }
-            result = reader.entries.size > 0
-            reader.clear
-            result
-          end
-        end
-        
-        class DeleteCommand
-          
-          def execute(sql)
-            @adapter.connection do |db|
-              @adapter.log.debug(sql)
-              db.exec(sql).status == PGresult::COMMAND_OK
-            end
-          end
-
-          def to_truncate_sql
-            table = @adapter[@klass_or_instance]
-            sequence = @adapter.sequence_name(table)
-            # truncate the table and reset the sequence value
-            "DELETE FROM " << table.to_sql << "; SELECT setval('#{sequence}', (SELECT COALESCE(MAX(id)+(SELECT increment_by FROM #{sequence}), (SELECT min_value FROM #{sequence})) FROM #{table.to_sql}), false)"
-          end
-
-          def execute_drop(sql)
-            @adapter.log.debug(sql)
-            @adapter.connection { |db| db.exec(sql) }
-            true
-          end
-          
-        end
-        
-        class SaveCommand
-          
-          def execute_insert(sql)
-            @adapter.connection do |db|
-              @adapter.log.debug(sql)
-              db.exec(sql)
-              # Current id or latest value read from sequence in this session
-              # See: http://www.postgresql.org/docs/8.1/interactive/functions-sequence.html
-              @instance.key || db.exec("SELECT last_value from #{@adapter.sequence_name(@adapter[@instance.class])}")[0][0]
-            end
-          end
+          def to_create_table_sql
+            schema_name = name.index('.') ? name.split('.').first : nil
+            schema_list = @adapter.query('SELECT nspname FROM pg_namespace').join(',')
           
-          def execute_update(sql)
-            @adapter.connection do |db|
-              @adapter.log.debug(sql)
-              db.exec(sql).cmdstatus.split(' ').last.to_i > 0
+            sql = if schema_name and !schema_list.include?(schema_name)
+                "CREATE SCHEMA #{@adapter.quote_table_name(schema_name)}; " 
+            else
+              ''
             end
-          end
-          
-          def execute_create_table(sql)
-            @adapter.log.debug(sql)
-            @adapter.connection { |db| db.exec(sql) }
-            true
-          end
+            
+            sql << "CREATE TABLE " << to_sql
           
-          def to_create_table_sql
-            table = @adapter[@instance]
-
-            sql = "CREATE TABLE " << table.to_sql
-
-            sql << " (" << table.columns.map do |column|
-              column_long_form(column)
+            sql << " (" << columns.map do |column|
+              column.to_long_form
             end.join(', ') << ")"
-
-            return sql
-          end
-
-          def column_long_form(column)
-            
-            long_form = if column.key? 
-              "#{column.to_sql} serial primary key"
-            else
-              "#{column.to_sql} #{@adapter.class::TYPES[column.type] || column.type}"
-            end  
-            long_form << " NOT NULL" unless column.nullable?
-            long_form << " default #{column.options[:default]}" if column.options.has_key?(:default)
-
-            return long_form
-          end
-        end
-        
-        class LoadCommand
-          def eof?(pg_result)
-            pg_result.result.entries.empty?
-          end
           
-          def close_reader(pg_result)
-            pg_result.clear
+            return sql
           end
           
-          def execute(sql)
-            @adapter.log.debug(sql)
-            @adapter.connection { |db| db.exec(to_sql) }
+          def to_exists_sql
+            @to_exists_sql || @to_exists_sql = <<-EOS.compress_lines
+              SELECT TABLE_NAME
+              FROM INFORMATION_SCHEMA.TABLES
+              WHERE TABLE_NAME = #{@adapter.quote_value(name)}
+                AND TABLE_CATALOG = #{@adapter.quote_value(@adapter.schema.name)}
+            EOS
           end
           
-          def fetch_one(pg_result)
-            load(process_row(columns(pg_result), pg_result.result[0]))
-          end
+          private 
           
-          def fetch_all(pg_result)
-            load_instances(pg_result.fields, pg_result)
+          def quote_table(table_suffix = nil)
+            parts = name.split('.')
+            parts.last << table_suffix if table_suffix
+            parts.map { |part|
+              @adapter.quote_table_name(part) }.join('.')
           end
+        end # class Table
+        
+        class Column
+          def serial_declaration
+            "SERIAL"
+          end
+          
+          def to_long_form
+            @to_long_form || begin
+              @to_long_form = "#{to_sql}"
+              
+              if serial? && !serial_declaration.blank?
+                @to_long_form << " #{serial_declaration}"
+              else
+                @to_long_form << " #{type_declaration}"
+                
+                unless nullable? || not_null_declaration.blank?
+                  @to_long_form << " #{not_null_declaration}"
+                end
+                
+                if key? && !primary_key_declaration.blank?
+                  @to_long_form << " #{primary_key_declaration}"
+                end
 
-          private
-          
-          def columns(pg_result)
-            columns = {}
-            pg_result.fields.each_with_index do |name, index|
-              columns[name] = index
-            end
-            columns
-          end
-         
-          def process_row(columns, row)
-            hash = {}
-            columns.each_pair do |name,index|
-              hash[name] = row[index]
+                if default && !default_declaration.blank?
+                  @to_long_form << " #{default_declaration}"
+                end
+              end
+                      
+              @to_long_form
             end
-            hash
           end
           
-        end
-        
-      end
+          def size
+            nil
+          end
+        end # class Column
+      end # module Mappings
       
     end # class PostgresqlAdapter
     
   end # module Adapters
-end # module DataMapper
+end # module DataMapper