datamapper 0.1.0 → 0.1.1

data/lib/data_mapper/adapters/postgresql_adapter.rb

@@ -0,0 +1,242 @@
+require 'data_mapper/adapters/sql_adapter'
+require 'data_mapper/support/connection_pool'
+
+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
+end
+
+module DataMapper
+  module Adapters
+    
+    class PostgresqlAdapter < SqlAdapter
+      
+      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
+          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)
+        end
+        
+        pg_result.clear
+        return results
+      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}"
+          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 execute_update(sql)
+            @adapter.connection do |db|
+              @adapter.log.debug(sql)
+              db.exec(sql).cmdstatus.split(' ').last.to_i > 0
+            end
+          end
+          
+          def execute_create_table(sql)
+            @adapter.log.debug(sql)
+            @adapter.connection { |db| db.exec(sql) }
+            true
+          end
+          
+          def to_create_table_sql
+            table = @adapter[@instance]
+
+            sql = "CREATE TABLE " << table.to_sql
+
+            sql << " (" << table.columns.map do |column|
+              column_long_form(column)
+            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
+          end
+          
+          def execute(sql)
+            @adapter.log.debug(sql)
+            @adapter.connection { |db| db.exec(to_sql) }
+          end
+          
+          def fetch_one(pg_result)
+            load(process_row(columns(pg_result), pg_result.result[0]))
+          end
+          
+          def fetch_all(pg_result)
+            load_instances(pg_result.fields, pg_result)
+          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]
+            end
+            hash
+          end
+          
+        end
+        
+      end
+      
+    end # class PostgresqlAdapter
+    
+  end # module Adapters
+end # module DataMapper

data/lib/data_mapper/adapters/sql/coersion.rb

@@ -0,0 +1,74 @@
+module DataMapper
+  module Adapters
+    module Sql
+      # 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
+        
+        TRUE_ALIASES = ['true'.freeze, 'TRUE'.freeze]
+        FALSE_ALIASES = [nil]
+        
+        def self.included(base)
+          base.const_set('TRUE_ALIASES', TRUE_ALIASES.dup)
+          base.const_set('FALSE_ALIASES', FALSE_ALIASES.dup)
+        end
+        
+        def type_cast_boolean(raw_value)
+          case raw_value
+            when TrueClass, FalseClass then raw_value
+            when *self::class::TRUE_ALIASES then true
+            when *self::class::FALSE_ALIASES then false
+            else "Can't type-cast #{value.inspect} to a boolean"
+          end
+        end
+        
+        def type_cast_string(raw_value)
+          return nil if raw_value.blank?
+          raw_value
+        end
+        
+        def type_cast_text(raw_value)
+          return nil if raw_value.blank?
+          raw_value
+        end
+        
+        def type_cast_class(raw_value)
+          return nil if raw_value.blank?
+          Kernel::const_get(raw_value)
+        end
+        
+        def type_cast_integer(raw_value)
+          return nil if raw_value.blank?
+          raw_value.to_i # Integer(raw_value) would be "safer", but not as fast.
+        rescue ArgumentError
+          nil
+        end
+        
+        def type_cast_datetime(raw_value)
+          return nil if raw_value.blank?
+          
+          case raw_value
+            when DateTime then raw_value
+            when Date then DateTime.new(raw_value)
+            when String then DateTime::parse(raw_value)
+            else "Can't type-cast #{raw_value.inspect} to a datetime"
+          end
+        end
+        
+        def type_cast_value(type, raw_value)
+          return nil if raw_value.blank?
+          
+          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 # module Coersion
+    end
+  end  
+end

data/lib/data_mapper/adapters/sql/commands/advanced_load_command.rb

@@ -0,0 +1,140 @@
+module DataMapper
+  module Adapters
+    module Sql
+      module Commands
+    
+        class AdvancedLoadCommand
+      
+          attr_reader :conditions, :options
+          
+          def initialize(adapter, session, primary_class, options = {})
+            @adapter, @session, @primary_class, @options = adapter, session, primary_class, options
+            
+            @order = @options[:order]
+            @limit = @options[:limit]
+            @offset = @options[:offset]
+            @reload = @options[:reload]
+            @include = @options[:include]
+            @instance_id = @options[:id]
+            @conditions = @options[:conditions]
+            @join_fetch = false
+            @joins = []
+          end
+          
+          # If +true+ then force the command to reload any objects
+          # already existing in the IdentityMap when executing.
+          def reload?
+            @reload
+          end
+          
+          # Determine if there is a limitation on the number of
+          # instances returned in the results. If +nil+, no limit
+          # is set. Can be used in conjunction with #offset for
+          # paging through a set of results.
+          def limit
+            @limit
+          end
+          
+          # Used in conjunction with #limit to page through a set
+          # of results.
+          def offset
+            @offset
+          end
+          
+          # Generate a select statement based on the initialization
+          # arguments.
+          def to_sql            
+            sql = 'SELECT ' << columns_for_select.join(', ')
+            sql << ' FROM ' << from_table_name            
+            
+            if @join_fetch
+              @joins.each do |entry|
+                primary_table, association_table, association = entry
+                sql << ' JOIN ' << association_table.to_sql << ' ON '
+                sql << association_table.to_sql << '.'
+                sql << @adapter.quote_column_name(association.foreign_key)
+                sql << ' = ' << primary_table.key.to_sql(true)
+              end
+            end
+            
+            return sql
+          end
+          
+          private
+          
+            # Return the Sql-escaped columns names to be selected in the results.
+            def columns_for_select
+              @columns_for_select || @columns_for_select = begin
+                columns.map { |column| column.to_sql(@join_fetch) }
+              end
+            end
+            
+            # Returns the DataMapper::Adapters::Sql::Mappings::Column instances to
+            # be selected in the results.
+            def columns
+              @columns || begin
+                @columns = if @options.has_key?(:select)
+                  primary_class_table.columns.select do |column|
+                    @options[:select].include?(column.name)
+                  end
+                else
+                  primary_class_table.columns.select do |column|
+                    include_column?(column.name) || !column.lazy?
+                  end
+                end
+                
+                # Return if there is no +:include+ option to evaluate.
+                return @columns if @include.nil?
+                
+                if @include.kind_of?(Array)
+                  # Return if all +:include+ parameters are columns in
+                  # the primary_class_table.
+                  return @columns if @include.all? do |name|
+                    !primary_class_table[name].nil?
+                  end
+                elsif @include.kind_of?(Symbol)
+                  # Return if the include is a column in the primary_class_table.
+                  return @columns if primary_class_table[@include]
+                  
+                  primary_class_table.associations.each do |association|
+                    next unless association.name == @include
+                    association_table = @adapter[association.constant]
+                    @columns += association_table.columns
+                    @joins << [ primary_class_table, association_table, association ]
+                  end
+                  
+                  @join_fetch = true
+                else
+                  raise ':include option must be a Symbol or Array of Symbols'
+                end
+                
+                @columns
+              end
+            end
+            
+            # Determine if a Column should be included based on the
+            # value of the +:include+ option.
+            def include_column?(name)
+              case @include
+                when nil then false
+                when Symbol then @include == name
+                when Array then @include.includes?(name)
+                else raise ':include option must be a Symbol or Array of Symbols'
+              end
+            end
+
+            # Return the Sql-escaped table name of the +primary_class+.
+            def from_table_name
+              @from_table_name || (@from_table_name = @adapter[@primary_class].to_sql)
+            end
+            
+            # Returns the DataMapper::Adapters::Sql::Mappings::Table for the +primary_class+.
+            def primary_class_table
+              @primary_class_table || (@primary_class_table = @adapter[@primary_class])
+            end
+          
+        end # class LoadCommand
+      end # module Commands
+    end # module Sql
+  end # module Adapters
+end # module DataMapper