datamapper 0.1.0 → 0.1.1

data/lib/data_mapper/queries/conditions.rb

@@ -1,141 +0,0 @@
-module DataMapper
-  module Queries
-    
-    class Conditions
-      
-      def initialize(database, options)
-        @database, @options = database, options
-        @has_id = false
-      end
-      
-      class NormalizationError < StandardError
-        
-        attr_reader :inner_error
-        
-        def initialize(clause, inner_error = nil)
-          @clause = clause
-          @inner_error = inner_error
-          
-          message = "Failed to normalize clause: #{clause.inspect}"
-          message << ", Error: #{inner_error.inspect}" unless inner_error.nil?
-          
-          super(message)
-        end
-        
-      end
-      
-      def normalize(clause, collector)
-        case clause
-          when Hash then
-            clause.each_pair do |k,v|
-              if k.kind_of?(Symbol::Operator)
-                if k.type == :select
-                  k.options[:class] ||= @options[:class]
-                  
-                  k.options[:select] ||= if k.value.to_s == @database[k.options[:class]].default_foreign_key
-                    @database[k.options[:class]].key.column_name
-                  else
-                    k.value
-                  end
-                  
-                  sub_select = @database.select_statement(k.options.merge(v))
-                  normalize(["#{@database[@options[:class]][k.value.to_sym].to_sql} IN ?", sub_select], collector)
-                else                
-                  @has_id = true if k.value == :id
-                  op = case k.type
-                    when :gt then '>'
-                    when :gte then '>='
-                    when :lt then '<'
-                    when :lte then '<='
-                    when :not then v.nil? ? 'IS NOT' : (v.kind_of?(Array) ? 'NOT IN' : '<>')
-                    when :eql then v.nil? ? 'IS' : (v.kind_of?(Array) ? 'IN' : '=')
-                    when :like then 'LIKE'
-                    when :in then 'IN'
-                    else raise ArgumentError.new('Operator type not supported')
-                  end
-                  normalize(["#{@database[@options[:class]][k.value.to_sym].to_sql} #{op} ?", v], collector)
-                end
-              else
-                @has_id = true if k == :id
-                case v
-                when Array then
-                  normalize(["#{@database[@options[:class]][k.to_sym].to_sql} IN ?", v], collector)
-                when SelectStatement then
-                  normalize(["#{@database[@options[:class]][k.to_sym].to_sql} IN ?", v], collector)
-                else
-                  normalize(["#{@database[@options[:class]][k.to_sym].to_sql} = ?", v], collector)
-                end
-              end
-            end
-          when Array then
-            return collector if clause.empty?
-            @has_id = true if clause.first =~ /(^|\s|\`)id(\`|\s|\=|\<)/ && !clause[1].kind_of?(SelectStatement)
-            collector << escape(clause)
-          when String then
-            @has_id = true if clause =~ /(^|\s|\`)id(\`|\s|\=|\<)/
-            collector << clause
-          else raise NormalizationError.new(clause)              
-        end
-        
-        return collector
-      end
-      
-      def escape(conditions)
-        clause = conditions.shift
-
-        clause.gsub(/\?/) do |x|
-          # Check if the condition is an in, clause.
-          case conditions.first
-          when Array then
-            '(' << conditions.shift.map { |c| @database.quote_value(c) }.join(', ') << ')'
-          when SelectStatement then
-            '(' << conditions.shift.to_sql << ')'
-          else
-            @database.quote_value(conditions.shift)
-          end
-        end
-      end
-      
-      def has_id?
-        normalized_conditions
-        @has_id
-      end
-      
-      def normalized_conditions
-        
-        if @normalized_conditions.nil?
-          @normalized_conditions = []
-          
-          table = @database[@options[:class]]
-          invalid_keys = nil
-          
-          implicits = @options.reject do |k,v|            
-            standard_key = DataMapper::Session::FIND_OPTIONS.include?(k)
-            (invalid_keys ||= []) << k if !standard_key && table[k.to_sym].nil?
-            standard_key
-          end
-          
-          raise "Invalid options: #{invalid_keys.inspect}" unless invalid_keys.nil?
-          
-          normalize(implicits, @normalized_conditions)
-          
-          if @options.has_key?(:conditions)
-            normalize(@options[:conditions], @normalized_conditions)
-          end
-          
-        end
-        
-        return @normalized_conditions          
-      end
-      
-      def empty?
-        normalized_conditions.empty?
-      end
-      
-      def to_a
-        normalized_conditions
-      end
-    end
-    
-  end
-end

data/lib/data_mapper/queries/connection.rb

@@ -1,34 +0,0 @@
-require File.dirname(__FILE__) + '/result'
-require File.dirname(__FILE__) + '/reader'
-
-module DataMapper
-  module Queries
-  
-    class Connection
-      
-      def initialize(logger)
-        @logger = logger
-      end
-      
-      def log
-        @logger
-      end
-      
-      def execute(sql)
-        raise NotImplementedError.new
-        Results.new
-      end
-      
-      def query(sql)
-        raise NotImplementedError.new
-        Reader.new
-      end
-      
-      def close
-        raise NotImplementedError.new
-      end
-      
-    end
-  
-  end # module Queries
-end # module DataMapper

data/lib/data_mapper/queries/create_table_statement.rb

@@ -1,38 +0,0 @@
-module DataMapper
-  module Queries
-    
-    class CreateTableStatement
-      
-      def initialize(database, klass)
-        @database, @klass = database, klass
-      end
-      
-      def to_sql
-        table = @database[@klass]
-        
-        sql = "CREATE TABLE " << table.to_sql << " ("
-        
-        sql << table.columns.map do |column|
-          column_long_form(column)
-        end.join(', ')
-        
-        sql << ", PRIMARY KEY (#{table.key.to_sql}))"
-        
-        return sql
-      end
-      
-      def column_long_form(column)
-        long_form = "#{column.to_sql} #{@database.adapter.class::TYPES[column.type] || column.type}"
-        
-        long_form << "(#{column.size})" unless column.size.nil?
-        long_form << " NOT NULL" unless column.nullable?
-        long_form << " " << @database.syntax(:auto_increment) if column.key?
-        long_form << " default #{column.options[:default]}" if column.options.has_key?(:default)
-        
-        return long_form
-      end
-      
-    end
-    
-  end
-end

data/lib/data_mapper/queries/delete_statement.rb

@@ -1,17 +0,0 @@
-module DataMapper
-  module Queries
-    
-    class DeleteStatement
-      
-      def initialize(database, instance)
-        @database, @instance = database, instance
-      end
-      
-      def to_sql
-        "DELETE FROM " << @database[@instance.class].to_sql << " WHERE id = " << @database.quote_value(@instance.key)
-      end
-      
-    end
-    
-  end
-end

data/lib/data_mapper/queries/drop_table_statement.rb

@@ -1,17 +0,0 @@
-module DataMapper
-  module Queries
-    
-    class DropTableStatement
-      
-      def initialize(database, klass)
-        @database, @klass = database, klass
-      end
-      
-      def to_sql
-        "DROP TABLE #{@database[@klass].to_sql}"
-      end
-      
-    end
-    
-  end
-end

data/lib/data_mapper/queries/insert_statement.rb

@@ -1,29 +0,0 @@
-module DataMapper
-  module Queries
-    
-    class InsertStatement
-      
-      def initialize(database, instance)
-        @database, @instance = database, instance
-      end
-      
-      # The only thing this method is responsible for is generating the insert statement.
-      # It is the database adapters responsibility to get the last inserted id
-      def to_sql
-        
-        table = @database[@instance.class]
-        
-        keys = []
-        values = []
-        
-        @instance.dirty_attributes.each_pair { |k,v| keys << table[k].to_sql; values << v }
-        
-        # Formatting is a bit off here, but it looks nicer in the log this way.
-        sql = "INSERT INTO #{table.to_sql} (#{keys.join(', ')}) \
-VALUES (#{values.map { |v| @database.quote_value(v) }.join(', ')})"
-      end
-      
-    end
-    
-  end
-end

data/lib/data_mapper/queries/reader.rb

@@ -1,42 +0,0 @@
-module DataMapper
-  module Queries
-  
-    class Reader
-      
-      attr_reader :columns
-      
-      def initialize(database_result_set)
-      end
-      
-      def eof?
-        raise NotImplementedError.new
-      end
-      
-      def records_affected
-        raise NotImplementedError.new
-      end
-      
-      def each
-        raise NotImplementedError.new
-      end
-      
-      def entries
-        raise NotImplementedError.new
-      end
-      
-      def [](column)
-        raise NotImplementedError.new
-      end
-      
-      def each_pair
-        raise NotImplementedError.new
-      end
-      
-      def close
-        raise NotImplementedError.new
-      end
-      
-    end
-  
-  end # module Queries
-end # module DataMapper

data/lib/data_mapper/queries/result.rb

@@ -1,19 +0,0 @@
-module DataMapper
-  module Queries
-  
-    class Result
-      
-      attr_accessor :size, :last_inserted_id
-      
-      def initialize(size, last_inserted_id = nil)
-        @size, @last_inserted_id = size, last_inserted_id
-      end
-      
-      def success?
-        size > 0
-      end
-      
-    end # class Result
-  
-  end # module Queries
-end # module DataMapper

data/lib/data_mapper/queries/select_statement.rb

@@ -1,103 +0,0 @@
-require 'data_mapper/queries/conditions'
-
-module DataMapper
-  module Queries
-    
-    class SelectStatement
-      
-      def initialize(database, options)
-        @database, @options = database, options
-      end
-      
-      def limit
-        @options[:limit]
-      end
-      
-      def order
-        @options[:order]
-      end
-
-      def klass
-        @options[:class]
-      end
-
-      def has_id?
-        conditions.has_id?
-      end
-
-      def escape(conditions)
-        @database.escape(conditions)
-      end
-      
-      def inspect
-        @options.inspect
-      end
-      
-      def include?(association_name)
-        return false if includes.empty?
-        includes.include?(association_name)
-      end
-      
-      def includes
-        list = @options[:include] ||= []
-        list.kind_of?(Array) ? list : [list]
-      end
-      
-      def reload?
-        @options[:reload]
-      end
-      
-      def select
-        select_columns = @options[:select]
-        unless select_columns.nil?
-          select_columns = select_columns.kind_of?(Array) ? select_columns : (@options[:select] = [select_columns])
-          select_columns.map { |column| @database.quote_column_name(column.to_s) }
-        else
-          @options[:select] = @database[klass].columns.select do |column|
-            include?(column.name) || !column.lazy?
-          end.map { |column| column.to_sql }
-        end
-      end
-      
-      def instance_id
-        @options[:id]
-      end
-        
-      def conditions
-        @conditions ||= Conditions.new(@database, @options)
-      end
-      
-      def table
-        @table_name || @table_name = if @options.has_key?(:table)
-          @database.quote_table_name(@options[:table])
-        else
-          @database[klass].to_sql
-        end
-      end
-
-      def to_sql
-        sql = 'SELECT ' << select.join(', ') << ' FROM ' << table
-        
-        where = []
-        
-        where += conditions.to_a unless conditions.empty?
-        
-        unless where.empty?
-          sql << ' WHERE (' << where.join(') AND (') << ')'
-        end
-        
-        unless order.nil?
-          sql << ' ORDER BY ' << order.to_s
-        end
-        
-        unless limit.nil?
-          sql << ' LIMIT ' << limit.to_s
-        end
-        
-        return sql
-      end
-      
-    end
-    
-  end
-end