activerecord 1.3.0 → 1.4.0

data/lib/active_record/callbacks.rb

@@ -34,18 +34,19 @@ module ActiveRecord
   #   end
   #
   #   class Subscription < ActiveRecord::Base
-  #     # Automatically assign the signup date
-  #     def before_create
-  #       self.signed_up_on = Date.today
-  #     end
+  #     before_create :record_signup
+  #
+  #     private
+  #       def record_signup
+  #         self.signed_up_on = Date.today
+  #       end
   #   end
   #
   #   class Firm < ActiveRecord::Base
   #     # Destroys the associated clients and people when the firm is destroyed
-  #     def before_destroy
-  #       Client.destroy_all "client_of = #{id}"
-  #       Person.destroy_all "firm_id = #{id}"
-  #     end
+  #     before_destroy { |record| Person.destroy_all "firm_id = #{record.id}"   }
+  #     before_destroy { |record| Client.destroy_all "client_of = #{record.id}" }
+  #   end
   #
   # == Inheritable callback queues
   #
@@ -169,9 +170,7 @@ module ActiveRecord
           alias_method :instantiate_without_callbacks, :instantiate
           alias_method :instantiate, :instantiate_with_callbacks
         end
-      end
 
-      base.class_eval do
         alias_method :initialize_without_callbacks, :initialize
         alias_method :initialize, :initialize_with_callbacks
 
@@ -191,14 +190,21 @@ module ActiveRecord
         alias_method :destroy, :destroy_with_callbacks
       end
 
-      CALLBACKS.each { |cb| base.class_eval("def self.#{cb}(*methods) write_inheritable_array(\"#{cb}\", methods) end") }
+      CALLBACKS.each do |method|
+        base.class_eval <<-"end_eval"
+          def self.#{method}(*callbacks, &block)
+            callbacks << block if block_given?
+            write_inheritable_array(#{method.to_sym.inspect}, callbacks)
+          end
+        end_eval
+      end
     end
 
     module ClassMethods #:nodoc:
       def instantiate_with_callbacks(record)
         object = instantiate_without_callbacks(record)
-        object.callback(:after_find) if object.respond_to_without_attributes?(:after_find)
-        object.callback(:after_initialize) if object.respond_to_without_attributes?(:after_initialize)
+        object.send(:invoke_and_notify, :after_find)
+        object.send(:invoke_and_notify, :after_initialize)
         object
       end
     end
@@ -211,7 +217,7 @@ module ActiveRecord
     def initialize_with_callbacks(attributes = nil) #:nodoc:
       initialize_without_callbacks(attributes)
       result = yield self if block_given?
-      after_initialize if respond_to_without_attributes?(:after_initialize)
+      invoke_and_notify(:after_initialize)
       result
     end
 
@@ -298,45 +304,40 @@ module ActiveRecord
       result
     end
 
-    def callback(callback_method) #:nodoc:
-      run_callbacks(callback_method)
-      send(callback_method)
-      notify(callback_method)
-    end
-
-    def run_callbacks(callback_method)
-      filters = self.class.read_inheritable_attribute(callback_method.to_s)
-      if filters.nil? then return end
-      filters.each do |filter|
-        if Symbol === filter
-          self.send(filter)
-        elsif String === filter
-          eval(filter, binding)
-        elsif filter_block?(filter)
-          filter.call(self)
-        elsif filter_class?(filter, callback_method)
-          filter.send(callback_method, self)
-        else
-          raise(
-            ActiveRecordError,
-            "Filters need to be either a symbol, string (to be eval'ed), proc/method, or " +
-            "class implementing a static filter method"
-          )
+    private
+      def callback(method)
+        callbacks_for(method).each do |callback|
+          case callback
+            when Symbol
+              self.send(callback)
+            when String
+              eval(callback, binding)
+            when Proc, Method
+              callback.call(self)
+            else
+              if callback.respond_to?(method)
+                callback.send(method, self)
+              else
+                raise ActiveRecordError, "Callbacks must be a symbol denoting the method to call, a string to be evaluated, a block to be invoked, or an object responding to the callback method."
+              end
+          end
         end
+
+        invoke_and_notify(method)
       end
-    end
 
-    def filter_block?(filter)
-      filter.respond_to?("call") && (filter.arity == 1 || filter.arity == -1)
-    end
+      def callbacks_for(method)
+        self.class.read_inheritable_attribute(method.to_sym) or []
+      end
 
-    def filter_class?(filter, callback_method)
-      filter.respond_to?(callback_method)
-    end
+      def invoke_and_notify(method)
+        send(method) if respond_to_without_attributes?(method)
+        notify(method)
+      end
 
-    def notify(callback_method) #:nodoc:
-      self.class.changed
-      self.class.notify_observers(callback_method, self)
-    end
+      def notify(method) #:nodoc:
+        self.class.changed
+        self.class.notify_observers(method, self)
+      end
   end
-end
+end

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -184,6 +184,7 @@ module ActiveRecord
           when :timestamp     then Time
           when :time          then Time
           when :text, :string then String
+          when :binary        then String
           when :boolean       then Object
         end
       end
@@ -199,6 +200,7 @@ module ActiveRecord
           when :timestamp then string_to_time(value)
           when :time      then string_to_dummy_time(value)
           when :date      then string_to_date(value)
+          when :binary    then binary_to_string(value)
           when :boolean   then (value == "t" or value == true ? true : false)
           else value
         end
@@ -207,6 +209,14 @@ module ActiveRecord
       def human_name
         Base.human_attribute_name(@name)
       end
+      
+      def string_to_binary(value)
+        value
+      end     
+
+      def binary_to_string(value)
+        value
+      end     
 
       private
         def string_to_date(string)
@@ -220,21 +230,21 @@ module ActiveRecord
           return string if Time === string
           time_array = ParseDate.parsedate(string).compact
           # treat 0000-00-00 00:00:00 as nil
-          Time.local(*time_array) rescue nil
+          Time.send(Base.default_timezone, *time_array) rescue nil
         end
 
-       def string_to_dummy_time(string)
-         return string if Time === string
-         time_array = ParseDate.parsedate(string)
-         # pad the resulting array with dummy date information
-         time_array[0] = 2000; time_array[1] = 1; time_array[2] = 1;
-         Time.local(*time_array) rescue nil
-       end
-
+        def string_to_dummy_time(string)
+          return string if Time === string
+          time_array = ParseDate.parsedate(string)
+          # pad the resulting array with dummy date information
+          time_array[0] = 2000; time_array[1] = 1; time_array[2] = 1;
+          Time.send(Base.default_timezone, *time_array) rescue nil
+        end 
+        
         def extract_limit(sql_type)
           $1.to_i if sql_type =~ /\((.*)\)/
         end
-
+        
         def simplified_type(field_type)
           case field_type
             when /int/i
@@ -249,8 +259,10 @@ module ActiveRecord
               :time
             when /date/i
               :date
-            when /(c|b)lob/i, /text/i
+            when /clob/i, /text/i
               :text
+            when /blob/i, /binary/i
+              :binary
             when /char/i, /string/i
               :string
             when /boolean/i
@@ -323,7 +335,12 @@ module ActiveRecord
 
       def quote(value, column = nil)
         case value
-          when String                then "'#{quote_string(value)}'" # ' (for ruby-mode)
+          when String                
+            if column && column.type == :binary
+              "'#{quote_string(column.string_to_binary(value))}'" # ' (for ruby-mode)
+            else
+              "'#{quote_string(value)}'" # ' (for ruby-mode)
+            end
           when NilClass              then "NULL"
           when TrueClass             then (column && column.type == :boolean ? "'t'" : "1")
           when FalseClass            then (column && column.type == :boolean ? "'f'" : "0")
@@ -345,6 +362,10 @@ module ActiveRecord
       # Returns a string of the CREATE TABLE SQL statements for recreating the entire structure of the database.
       def structure_dump() end
 
+      def add_limit!(sql, limit)
+        sql << " LIMIT #{limit}"
+      end
+
       protected
         def log(sql, name, connection, &action)
           begin

data/lib/active_record/connection_adapters/db2_adapter.rb

@@ -0,0 +1,129 @@
+# db2_adapter.rb
+# author: Maik Schmidt <contact@maik-schmidt.de>
+
+require 'active_record/connection_adapters/abstract_adapter'
+
+begin
+  require 'db2/db2cli' unless self.class.const_defined?(:DB2CLI)
+  require 'active_record/vendor/db2'
+
+  module ActiveRecord
+    class Base
+      # Establishes a connection to the database that's used by
+      # all Active Record objects
+      def self.db2_connection(config) # :nodoc:
+        symbolize_strings_in_hash(config)
+        usr = config[:username]
+        pwd = config[:password]
+
+        if config.has_key?(:database)
+          database = config[:database]
+        else
+          raise ArgumentError, "No database specified. Missing argument: database."
+        end
+
+        connection = DB2::Connection.new(DB2::Environment.new)
+        connection.connect(database, usr, pwd)
+        ConnectionAdapters::DB2Adapter.new(connection)
+      end
+    end
+
+    module ConnectionAdapters
+      class DB2Adapter < AbstractAdapter # :nodoc:
+        def select_all(sql, name = nil)
+          select(sql, name)
+        end
+
+        def select_one(sql, name = nil)
+          select(sql, name).first
+        end
+
+        def insert(sql, name = nil, pk = nil, id_value = nil)
+          execute(sql, name = nil)
+          id_value || last_insert_id
+        end
+
+        def execute(sql, name = nil)
+          rows_affected = 0
+
+          log(sql, name, @connection) do |connection| 
+            stmt = DB2::Statement.new(connection)
+            stmt.exec_direct(sql)
+            rows_affected = stmt.row_count
+            stmt.free
+          end
+
+          rows_affected
+        end
+
+        alias_method :update, :execute
+        alias_method :delete, :execute
+
+        def begin_db_transaction
+          @connection.set_auto_commit_off
+        end
+
+        def commit_db_transaction
+          @connection.commit
+          @connection.set_auto_commit_on
+        end
+        
+        def rollback_db_transaction
+          @connection.rollback
+          @connection.set_auto_commit_on
+        end
+
+        def quote_column_name(name) name; end
+
+        def quote_string(s)
+          s.gsub(/'/, "''") # ' (for ruby-mode)
+        end
+
+        def add_limit!(sql, limit)
+          sql << " FETCH FIRST #{limit} ROWS ONLY"
+        end
+
+        def columns(table_name, name = nil)
+          stmt = DB2::Statement.new(@connection)
+          result = []
+
+          stmt.columns(table_name.upcase).each do |c| 
+            c_name = c[3].downcase
+            c_default = c[12] == 'NULL' ? nil : c[12]
+            c_type = c[5].downcase
+            c_type += "(#{c[6]})" if !c[6].nil? && c[6] != ''
+            result << Column.new(c_name, c_default, c_type)
+          end 
+
+          stmt.free
+          result
+        end
+
+        private
+          def last_insert_id
+            row = select_one(<<-GETID.strip)
+            with temp(id) as (values (identity_val_local())) select * from temp
+            GETID
+            row['id'].to_i
+          end
+
+          def select(sql, name = nil)
+            stmt = nil
+            log(sql, name, @connection) do |connection|
+              stmt = DB2::Statement.new(connection)
+              stmt.exec_direct(sql + " with ur")
+            end
+
+            rows = []
+            while row = stmt.fetch_as_hash
+              rows << row
+            end
+            stmt.free
+            rows
+          end
+      end
+    end
+  end
+rescue LoadError
+  # DB2 driver is unavailable.
+end

data/lib/active_record/connection_adapters/sqlite_adapter.rb

@@ -25,6 +25,28 @@ module ActiveRecord
   end
 
   module ConnectionAdapters
+    
+    class SQLiteColumn < Column
+      
+      def string_to_binary(value)
+        value.gsub(/(\0|\%)/) do
+          case $1
+            when "\0" then "%00"
+            when "%" then "%25"
+          end
+        end                
+      end
+      
+      def binary_to_string(value)
+        value.gsub(/(%00|%25)/) do
+          case $1
+            when "%00" then "\0"
+            when "%25" then "%"
+          end
+        end                
+      end
+      
+    end
     class SQLiteAdapter < AbstractAdapter # :nodoc:
       def select_all(sql, name = nil)
         select(sql, name)
@@ -37,7 +59,7 @@ module ActiveRecord
 
       def columns(table_name, name = nil)
         table_structure(table_name).inject([]) do |columns, field| 
-          columns << Column.new(field['name'], field['dflt_value'], field['type'])
+          columns << SQLiteColumn.new(field['name'], field['dflt_value'], field['type'])
           columns
         end
       end

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -30,67 +30,26 @@ module ActiveRecord
   class Base
     def self.sqlserver_connection(config)
       require_library_or_gem 'dbi' unless self.class.const_defined?(:DBI)
-      class_eval { include ActiveRecord::SQLServerBaseExtensions }
       
       symbolize_strings_in_hash(config)
 
-      if config.has_key? :dsn
-        dsn = config[:dsn]
+      host     = config[:host]
+      username = config[:username] ? config[:username].to_s : 'sa'
+      password = config[:password].to_s
+
+      if config.has_key? :database
+        database = config[:database]
       else
-        raise ArgumentError, "No DSN specified"
+        raise ArgumentError, "No database specified. Missing argument: database."
       end
 
-      conn = DBI.connect(dsn)
+      conn = DBI.connect("DBI:ADO:Provider=SQLOLEDB;Data Source=#{host};Initial Catalog=#{database};User Id=#{username};Password=#{password};")
       conn["AutoCommit"] = true
 
       ConnectionAdapters::SQLServerAdapter.new(conn, logger)
     end
   end
 
-  module SQLServerBaseExtensions #:nodoc:
-    def self.append_features(base)
-      super
-      base.extend(ClassMethods)
-    end
-
-    module ClassMethods #:nodoc:
-      def find_first(conditions = nil, orderings = nil)
-        sql  = "SELECT TOP 1 * FROM #{table_name} "
-        add_conditions!(sql, conditions)
-        sql << "ORDER BY #{orderings} " unless orderings.nil?
-
-        record = connection.select_one(sql, "#{name} Load First")
-        instantiate(record) unless record.nil?
-      end
-
-      def find_all(conditions = nil, orderings = nil, limit = nil, joins = nil)
-        sql  = "SELECT "
-        sql << "TOP #{limit} " unless limit.nil?
-        sql << " * FROM #{table_name} " 
-        sql << "#{joins} " if joins
-        add_conditions!(sql, conditions)
-        sql << "ORDER BY #{orderings} " unless orderings.nil?
-
-        find_by_sql(sql)
-      end
-    end
-
-    def attributes_with_quotes
-      columns_hash = self.class.columns_hash
-
-      attrs = @attributes.dup
-
-      attrs = attrs.reject do |name, value|
-        columns_hash[name].identity
-      end
-
-      attrs.inject({}) do |attrs_quoted, pair|
-        attrs_quoted[pair.first] = quote(pair.last, columns_hash[pair.first])
-        attrs_quoted
-      end
-    end
-  end
-
   module ConnectionAdapters
     class ColumnWithIdentity < Column# :nodoc:
       attr_reader :identity
@@ -104,7 +63,7 @@ module ActiveRecord
 
     class SQLServerAdapter < AbstractAdapter # :nodoc:
       def quote_column_name(name)
-        " [#{name}] "
+        "[#{name}]"
       end
 
       def select_all(sql, name = nil)
@@ -127,7 +86,6 @@ JOIN sysobjects AS s ON (c.id = s.id)
 LEFT OUTER JOIN syscomments AS com ON (c.cdefault = com.id)
 WHERE s.name = '#{table_name}'
 EOL
-
         columns = []
 
         log(sql, name, @connection) do |conn|
@@ -196,8 +154,12 @@ EOL
         end
       end
 
-      alias_method :update, :execute
-      alias_method :delete, :execute
+      def update(sql, name = nil)
+        execute(sql, name)
+        affected_rows(name)
+      end
+
+      alias_method :delete, :update
 
       def begin_db_transaction
         begin
@@ -236,63 +198,91 @@ EOL
         execute "CREATE DATABASE #{name}"
       end
 
+      def add_limit!(sql, limit)
+        limit_amount = limit.to_s.include?("OFFSET") ? get_offset_amount(limit) : Array.new([limit])
+        order_by = sql.include?("ORDER BY") ? get_order_by(sql.sub(/.*ORDER\sBY./, "")) : nil
+        if limit_amount.size == 2
+          sql.gsub!(/SELECT/i, "SELECT * FROM ( SELECT TOP #{limit_amount[0]} * FROM ( SELECT TOP #{limit_amount[1]}")<<" ) AS tmp1 ORDER BY #{order_by[1]} ) AS tmp2 ORDER BY #{order_by[0]}"
+        else
+          sql.gsub!(/SELECT/i, "SELECT TOP #{limit_amount[0]}")
+        end     
+      end
+
       private
-      def select(sql, name = nil)
-        rows = []
+        def select(sql, name = nil)
+          rows = []
 
-        log(sql, name, @connection) do |conn|
-          conn.select_all(sql) do |row|
-            record = {}
+          log(sql, name, @connection) do |conn|
+            conn.select_all(sql) do |row|
+              record = {}
 
-            row.column_names.each do |col|
-              record[col] = row[col]
-            end
+              row.column_names.each do |col|
+                record[col] = row[col]
+              end
 
-            rows << record
+              rows << record
+            end
           end
+
+          rows
         end
 
-        rows
-      end
+        def enable_identity_insert(table_name, enable = true)
+          if has_identity_column(table_name)
+            "SET IDENTITY_INSERT #{table_name} #{enable ? 'ON' : 'OFF'}"
+          end
+        end
 
-      def enable_identity_insert(table_name, enable = true)
-        if has_identity_column(table_name)
-          "SET IDENTITY_INSERT #{table_name} #{enable ? 'ON' : 'OFF'}"
+        def get_table_name(sql)
+          if sql =~ /into\s*([^\s]+)\s*/i or
+              sql =~ /update\s*([^\s]+)\s*/i
+            $1
+          else
+            nil
+          end
         end
-      end
 
-      def get_table_name(sql)
-        if sql =~ /into\s*([^\s]+)\s*/i or
-            sql =~ /update\s*([^\s]+)\s*/i
-          $1
-        else
-          nil
+        def has_identity_column(table_name)
+          return get_identity_column(table_name) != nil
         end
-      end
 
-      def has_identity_column(table_name)
-        return get_identity_column(table_name) != nil
-      end
+        def get_identity_column(table_name)
+          if not @table_columns
+            @table_columns = {}
+          end
+
+          if @table_columns[table_name] == nil
+            @table_columns[table_name] = columns(table_name)
+          end
 
-      def get_identity_column(table_name)
-        if not @table_columns
-          @table_columns = {}
+          @table_columns[table_name].each do |col|
+            return col.name if col.identity
+          end
+
+          return nil
         end
 
-        if @table_columns[table_name] == nil
-          @table_columns[table_name] = columns(table_name)
+        def query_contains_identity_column(sql, col)
+          return sql =~ /[\(\.\,]\s*#{col}/
         end
 
-        @table_columns[table_name].each do |col|
-          return col.name if col.identity
+        def get_order_by(sql)
+          return sql, sql.gsub(/\s*DESC\s*/, "").gsub(/\s*ASC\s*/, " DESC")
         end
 
-        return nil
-      end
+        def get_offset_amount(limit)
+          limit = limit.gsub!(/.OFFSET./i, ",").split(',')
+          return limit[0].to_i, limit[0].to_i+limit[1].to_i
+        end
 
-      def query_contains_identity_column(sql, col)
-        return sql =~ /[\(\.\,]\s*#{col}/
-      end
+        def affected_rows(name = nil)
+          sql = "SELECT @@ROWCOUNT AS AffectedRows"
+          log(sql, name, @connection) do |conn|
+            conn.select_all(sql) do |row|
+              return row[:AffectedRows].to_i
+            end
+          end
+        end
     end
   end
 end