datamapper 0.3.2 → 0.9.3

data/lib/data_mapper/adapters/sql/mappings/associations_set.rb

@@ -1,34 +0,0 @@
-module DataMapper
-  module Adapters
-    module Sql
-      module Mappings
-        
-        class AssociationsSet
-          
-          include Enumerable
-          
-          def initialize
-            @set = {}
-          end
-          
-          def <<(association)
-            @set[association.name] = association            
-          end
-          
-          def [](name)
-            @set[name]
-          end
-          
-          def each
-            @set.each { |name, association| yield(association) }
-          end
-          
-          def empty?
-            @set.empty?
-          end
-        end
-        
-      end # module Mappings
-    end # module Sql
-  end # module Adapters
-end # module DataMapper

data/lib/data_mapper/adapters/sql/mappings/column.rb

@@ -1,279 +0,0 @@
-module DataMapper
-  module Adapters
-    module Sql
-      module Mappings
-    
-        # TODO: There are of course many more options to add here.
-        # Ordinal, Length/Size, Nullability are just a few.
-        class Column
-          attr_reader :type, :name, :ordinal, :size, :default, :check
-          attr_writer :lazy, :index, :unique
-          attr_accessor :table, :options
-          
-          def initialize(adapter, table, name, type, ordinal, options = {})
-            @adapter = adapter
-            @table = table
-            @name, self.type, @options = name.to_sym, type, options
-            @ordinal = ordinal
-            parse_options!
-          end
-          
-          def parse_options!
-            @key = @options[:key] == true || @options[:serial] == true
-            @nullable = @options.has_key?(:nullable) ? @options[:nullable] : !@key
-            @lazy = @options.has_key?(:lazy) ? @options[:lazy] : (@type == :text && !@key)
-            @serial = @options[:serial] == true
-            @default = @options[:default]
-            
-            @unique = if @options[:index] == :unique then @options.delete(:index); true else false end
-            @index = @options[:index]
-            @check = @options[:check] # only for postgresql
-            
-            @size = if @options.has_key?(:size)
-              @options[:size]
-            elsif @options.has_key?(:length)
-              @options[:length]
-            else
-              case type
-                when :integer then 11
-                when :string, :class then 50
-                else nil
-              end
-            end
-            @size = @size.last if @size.is_a?(Range)
-          end
-          
-          def defaulted?() instance_variables.include?("@default") end
-          
-          def type=(value)
-            self.flush_sql_caches!
-            @type = value
-            (class << self; self end).class_eval <<-EOS
-              def type_cast_value(value)
-                @adapter.type_cast_#{@type}(value)
-              end
-            EOS
-            @type
-          end
-          
-          def name=(value)
-            flush_sql_caches!
-            @name = value
-          end
-
-          # Determines if the field should be lazy loaded.
-          # You can set this explicitly, or accept the default,
-          # which is false for all but text fields.
-          def lazy?
-            @lazy
-          end
-      
-          def nullable?
-            @nullable
-          end
-      
-          def key?
-            @key
-          end
-          
-          def serial?
-            @serial
-          end
-          
-          def unique?
-          	@unique
-          end
-          
-          def index?
-          	@index
-          end
-
-          def default=(value)
-            self.flush_sql_caches!
-            @default = value
-          end
-          
-          def to_sym
-            @name
-          end
-      
-          def instance_variable_name
-            @instance_variable_name || (@instance_variable_name = "@#{@name.to_s.gsub(/\?$/, '')}".freeze)
-          end
-      
-          def to_s
-            @name.to_s
-          end
-      
-          def column_name
-            @column_name || (@column_name = (@options.has_key?(:column) ? @options[:column].to_s : name.to_s.gsub(/\?$/, '')).freeze)
-          end
-      
-          def to_sql(include_table_name = false)
-            if include_table_name
-              @to_sql_with_table_name || @to_sql_with_table_name = begin
-                (@table.to_sql + '.' + @adapter.quote_column_name(column_name)).freeze
-              end
-            else
-              @to_sql || (@to_sql = @adapter.quote_column_name(column_name).freeze)
-            end
-          end
-
-          def size=(val)
-            self.flush_sql_caches!
-            @size = val
-          end
-      
-          def inspect
-            "#<%s:0x%x @name=%s, @type=%s, @options=%s>" % [self.class.name, (object_id * 2), to_sql, type.inspect, options.inspect]
-          end
-          
-          def to_create_sql            
-            "ALTER TABLE " <<  table.to_sql << " ADD " << to_long_form
-          end
-          
-          def to_alter_sql
-            "ALTER TABLE " <<  table.to_sql << " MODIFY COLUMN " << to_long_form
-          end
-          
-          def to_drop_sql
-            "ALTER TABLE " <<  table.to_sql << " DROP COLUMN " << to_sql
-          end
-                  
-          def create!
-            @table.columns << self
-            flush_sql_caches!
-            
-            @adapter.connection do |db|
-              command = db.create_command(to_create_sql)
-              command.execute_non_query
-            end
-            true
-          end
-          
-          def drop!
-            @table.columns.delete(self)
-            flush_sql_caches!
-            
-            @adapter.connection do |db|
-              command = db.create_command(to_drop_sql)
-              command.execute_non_query
-            end
-            true
-          end
-          
-          def alter!
-            flush_sql_caches!
-            @adapter.connection do |db|
-              command = db.create_command(to_alter_sql)
-              command.execute_non_query
-            end
-            true
-          end
-          
-          def rename!(new_name)
-            old_name = name # Store the old_name
-            
-            new_column = @table.add_column(new_name, self.type, self.options.merge(:ordinal => self.ordinal))
-            
-            # Create the new column
-            new_column.create!
-            
-            # Copy the data from one column to the other.
-            @adapter.connection do |db|
-              command = db.create_command <<-EOS.compress_lines
-                UPDATE #{@table.to_sql} SET
-                #{new_column.to_sql} = #{to_sql}
-              EOS
-              command.execute_non_query
-            end
-            
-            self.drop!
-            new_column
-          end
-          
-          def to_long_form
-            @to_long_form || begin
-              @to_long_form = "#{to_sql} #{type_declaration}"
-              
-              unless nullable? || not_null_declaration.blank?
-                @to_long_form << " #{not_null_declaration}"
-              end
-              
-              # NOTE: We only do inline PRIMARY KEY declarations
-              # if the column is also serial since we know
-              # "there can be only one".
-              if key? && serial? && !primary_key_declaration.blank?
-                @to_long_form << " #{primary_key_declaration}"
-              end
-              
-              if serial? && !serial_declaration.blank?
-                @to_long_form << " #{serial_declaration}"
-              end
-              
-              unless default.nil? || (value = default_declaration).blank?
-                @to_long_form << " #{value}"
-              end
-              
-              if unique? && !unique_declaration.blank?
-                @to_long_form << " #{unique_declaration}"
-              end
-              
-              @to_long_form
-            end
-          end
-          
-          def <=>(other)
-            ordinal <=> other.ordinal
-          end
-          
-          def hash
-            @hash || @hash = to_sql(true).hash
-          end
-          
-          def eql?(other)
-            name == other.name
-          end
-          
-          protected
-          
-          def primary_key_declaration
-            "PRIMARY KEY"
-          end
-          
-          def type_declaration
-            sql = "#{@adapter.class::TYPES[type] || type}"
-            sql << "(#{size})" unless size.nil?
-            sql
-          end
-          
-          def not_null_declaration
-            "NOT NULL"
-          end
-          
-          def serial_declaration
-            "AUTO_INCREMENT"
-          end
-          
-          def unique_declaration
-          	"UNIQUE"
-          end
-          
-          def default_declaration
-            @adapter.connection { |db| db.create_command("DEFAULT ?").escape_sql([default]) }
-          end
-          
-          def flush_sql_caches!
-            @to_long_form = nil
-            @to_sql = nil
-            @to_sql_with_table_name = nil
-            @column_name = nil
-            @table.flush_sql_caches!(false)
-          end
-      
-        end
-    
-      end
-    end
-  end
-end

data/lib/data_mapper/adapters/sql/mappings/conditions.rb

@@ -1,172 +0,0 @@
-module DataMapper
-  module Adapters
-    module Sql
-      module Mappings
-        
-        class Conditions
-          def initialize(table, adapter, qualify_columns=false, options={})
-            @table = table
-            @qualify_columns = qualify_columns
-            
-            # BEGIN: Partion out the options hash into general options,
-            # and conditions.
-            standard_find_options = adapter.class::FIND_OPTIONS
-            conditions_hash = {}
-            
-            options.each do |key,value|
-              unless standard_find_options.include?(key) && key != :conditions
-                conditions_hash[key] = value
-              end
-            end
-            # END
-            
-            @conditions = parse_conditions(conditions_hash)
-          end
-        
-          # Generate a statement after 'WHERE' based on the initialization
-          # arguments.
-          def to_params_sql
-            parameters = []
-            sql = ""
-          
-            unless @conditions.empty?
-              sql << ' WHERE ('
-            
-              last_index = @conditions.size
-              current_index = 0
-
-              @conditions.each do |condition|
-                case condition
-                when String then sql << condition
-                when Array then
-                    sql << condition.shift
-                    parameters += condition
-                else
-                  raise "Unable to parse condition: #{condition.inspect}" if condition
-                end
-              
-                if (current_index += 1) == last_index
-                  sql << ')'
-                else
-                  sql << ') AND ('
-                end
-              end
-            end
-            
-            parameters.unshift(sql)
-          end
-        
-          def parse_conditions(conditions_hash)
-            collection = []
-
-            case x = conditions_hash.delete(:conditions)
-            when Array then
-              # DO NOT mutate incoming Array values!!!
-              # Otherwise the mutated version may impact all the
-              # way up to the options passed to the finders,
-              # and have unintended side-effects.
-              array_copy = x.dup
-              clause = array_copy.shift
-              expression_to_sql(clause, array_copy, collection)
-            when Hash then
-              x.each_pair do |key,value|
-                expression_to_sql(key, value, collection)
-              end
-            else
-              raise "Unable to parse conditions: #{x.inspect}" if x
-            end
-            
-            if @table.paranoid?
-              conditions_hash[@table.paranoid_column.name] = nil
-            end
-            
-            conditions_hash.each_pair do |key,value|
-              expression_to_sql(key, value, collection)
-            end
-
-            collection              
-          end
-        
-          # expression_to_sql takes a set of arguments, and turns them into a an
-          # Array of generated SQL, followed by optional Values to interpolate as SQL-Parameters.
-          #
-          # Parameters:
-          # +clause+ The name of the column as a Symbol, a raw-SQL String, a Mappings::Column
-          # instance, or a Symbol::Operator.
-          # +value+ The Value for the condition.
-          # +collector+ An Array representing all conditions that is appended to by expression_to_sql
-          #
-          # Returns: Undefined Output. The work performed is added to the +collector+ argument.
-          # Example:
-          #   conditions = []
-          #   expression_to_sql(:name, 'Bob', conditions)
-          #   => +undefined return value+
-          #   conditions.inspect
-          #   => ["name = ?", 'Bob']
-          def expression_to_sql(clause, value, collector)
-            case clause
-            when Symbol::Operator then
-              operator = case clause.type
-              when :gt then '>'
-              when :gte then '>='
-              when :lt then '<'
-              when :lte then '<='
-              when :not then inequality_operator(value)
-              when :eql then equality_operator(value)
-              when :like then equality_operator(value, 'LIKE')
-              when :in then equality_operator(value)
-              else raise ArgumentError.new('Operator type not supported')
-              end
-              #Table[column name] is column.to_sql(true/false based on associations or not)
-              collector << ["#{@table[clause].to_sql(@qualify_columns)} #{operator} ?", value]
-            when Symbol then
-              collector << ["#{@table[clause].to_sql(@qualify_columns)} #{equality_operator(value)} ?", value]
-            when String then
-              collector << [clause, *value]
-            when Mappings::Column then
-              collector << ["#{clause.to_sql(@qualify_columns)} #{equality_operator(value)} ?", value]
-            else raise "CAN HAS CRASH? #{clause.inspect}"
-            end
-          rescue => e
-            raise ConditionsError.new(clause, value, e)
-          end
-        
-          def equality_operator(value, default = '=')
-            case value
-            when NilClass then 'IS'
-            when Array then 'IN'
-            else default
-            end
-          end
-
-          def inequality_operator(value, default = '<>')
-            case value
-            when NilClass then 'IS NOT'
-            when Array then 'NOT IN'
-            else default
-            end
-          end
-          
-          class ConditionsError < StandardError
-
-            attr_reader :inner_error
-
-            def initialize(clause, value, inner_error)
-              @clause, @value, @inner_error = clause, value, inner_error
-            end
-
-            def message
-              "Conditions (:clause => #{@clause.inspect}, :value => #{@value.inspect}) failed: #{@inner_error}"
-            end
-
-            def backtrace
-              @inner_error.backtrace
-            end              
-
-          end
-                  
-        end
-      end
-    end
-  end
-end