module ETL #:nodoc:
  module Control #:nodoc:
    # Destination which writes directly to a database. This is useful when you are dealing with
    # a small amount of data. For larger amounts of data you should probably use the bulk
    # loader if it is supported with your target database as it will use a much faster load
    # method.
    class DatabaseDestination < Destination
      # Specify the order from the source
      attr_reader :order
      
      # Set to true to truncate the destination table first
      attr_reader :truncate
      
      # Initialize the database destination
      # 
      # * <tt>control</tt>: The ETL::Control::Control instance
      # * <tt>configuration</tt>: The configuration Hash
      # * <tt>mapping</tt>: The mapping
      #
      # Configuration options:
      # * <tt>:database</tt>: The database name (REQUIRED)
      # * <tt>:table<tt>: The table to write to (REQUIRED)
      # * <tt>:truncate</tt>: Set to true to truncate before writing (defaults to false)
      # * <tt>:unique</tt>: Set to true to only insert unique records (defaults to false)
      # * <tt>:adapter</tt>: The adapter to use (defaults to :mysql)
      # * <tt>:username</tt>: The database username (defaults to 'root')
      # * <tt>:password</tt>: The password to the database (defaults to nothing)
      # * <tt>:host<tt>: The host for the database (defaults to 'localhost')
      #
      # Mapping options:
      # * <tt>:order</tt>: The order of fields to write (REQUIRED)
      def initialize(control, configuration, mapping)
        super
        @truncate = configuration[:truncate] ||= false
        @unique = configuration[:unique]
        @order = mapping[:order] || order_from_source
        raise ControlError, "Order required in mapping" unless @order
        connect
      end
      
      # Flush the currently buffered data
      def flush
        conn = ETL::ActiveRecord::Base.connection
        conn.transaction do
          conn.truncate(configuration[:table]) if truncate
          
          buffer.each do |row|
            # check to see if this row's compound key constraint already exists
            # note that the compound key constraint may not utilize virtual fields
            next unless row_allowed?(row)

            # add any virtual fields
            add_virtuals!(row)
            
            names = []
            values = []
            order.each do |name|
              names << name
              values << "'#{row[name]}'" # TODO: this is probably not database agnostic
            end
            q = "INSERT INTO #{configuration[:table]} (#{names.join(',')}) VALUES (#{values.join(',')})"
            # ETL::Engine.logger.debug("Query: #{q}")
            conn.insert(q, "Insert row #{current_row}")
            @current_row += 1
          end
          buffer.clear
        end
      end
      
      # Close the connection
      def close
        flush
        ETL::ActiveRecord::Base.connection.disconnect!
      end
      
      private
      # Connect to the database. 
      #
      # Required options:
      # * <tt>:database</tt>: The database name
      # 
      # Options:
      # * <tt>:adapter</tt>: The adapter to use (defaults to :mysql)
      # * <tt>:username</tt>: The database username (defaults to 'root')
      # * <tt>:password</tt>: The password to the database (defaults to nothing)
      # * <tt>:host<tt>: The host for the database (defaults to 'localhost')
      def connect
        ETL::ActiveRecord::Base.establish_connection(
            :adapter  => (configuration[:adapter] || :mysql),
            :username => (configuration[:username] || 'root'),
            :host     => (configuration[:host] || 'localhost'),
            :password => configuration[:password],
            :database => configuration[:database] 
        )
      end
    end
  end
end