aws-sdk 1.1.4 → 1.2.0

data/lib/aws/s3/config.rb

@@ -20,5 +20,7 @@ AWS::Core::Configuration.module_eval do
   add_option :s3_multipart_min_part_size, 5 * 1024 * 1024
 
   add_option :s3_multipart_max_parts, 10000
-  
+
+  add_option :s3_server_side_encryption, nil
+
 end

data/lib/aws/s3/prefixed_collection.rb

@@ -65,8 +65,7 @@ module AWS
           raise ArgumentError, "invalid prefix mode `#{mode}`, it must be " +
             ":replace, :append or :prepend"
         end
-        self.class.new(bucket,
-                       :prefix => new_prefix)
+        self.class.new(bucket, :prefix => new_prefix)
       end
 
       # @private

data/lib/aws/s3/presigned_post.rb

@@ -79,6 +79,7 @@ module AWS
                         :content_encoding,
                         :expires_header,
                         :acl,
+                        :server_side_encryption,
                         :success_action_redirect,
                         :success_action_status]
 
@@ -153,6 +154,15 @@ module AWS
       #   * +:bucket_owner_read+
       #   * +:bucket_owner_full_control+
       #
+      # @option options [Symbol] :server_side_encryption (nil) If this
+      #   option is set, the object will be stored using server side
+      #   encryption.  The only valid value is +:aes256+, which
+      #   specifies that the object should be stored using the AES
+      #   encryption algorithm with 256 bit keys.  By default, this
+      #   option uses the value of the +:s3_server_side_encryption+
+      #   option in the current configuration; for more information,
+      #   see {AWS.config}.
+      #
       # @option opts [String] :success_action_redirect The URL to
       #   which the client is redirected upon successful upload.
       #
@@ -197,6 +207,12 @@ module AWS
         @expires = opts[:expires]
 
         super
+
+        @fields[:server_side_encryption] =
+          config.s3_server_side_encryption unless
+          @fields.key?(:server_side_encryption)
+        @fields.delete(:server_side_encryption) if
+          @fields[:server_side_encryption].nil?
       end
 
       # @return [Boolean] True if {#url} generates an HTTPS url.
@@ -415,13 +431,10 @@ module AWS
         fields = (SPECIAL_FIELDS &
                   @fields.keys).inject({}) do |fields, option_name|
           fields[field_name(option_name)] =
-            @fields[option_name].to_s
+            field_value(option_name)
           fields
         end
 
-        fields["acl"] = fields["acl"].tr("_", "-") if
-          fields["acl"]
-
         @metadata.each do |key, value|
           fields["x-amz-meta-#{key}"] = value.to_s
         end
@@ -435,6 +448,8 @@ module AWS
         case option_name
         when :expires_header
           "Expires"
+        when :server_side_encryption
+          "x-amz-server-side-encryption"
         when :acl, :success_action_redirect, :success_action_status
           option_name.to_s
         else
@@ -446,6 +461,24 @@ module AWS
         end
       end
 
+      # @private
+      private
+      def field_value(option_name)
+        case option_name
+        when :acl
+          @fields[:acl].to_s.tr("_", "-")
+        when :server_side_encryption
+          value = @fields[:server_side_encryption]
+          if value.kind_of?(Symbol)
+            value.to_s.upcase
+          else
+            value.to_s
+          end
+        else
+          @fields[option_name].to_s
+        end
+      end
+
       # @private
       private
       def generate_conditions

data/lib/aws/s3/s3_object.rb

@@ -82,12 +82,14 @@ module AWS
       # * content_length (integer, number of bytes)
       # * content_type (as sent to S3 when uploading the object)
       # * etag (typically the object's MD5)
+      # * server_side_encryption (the algorithm used to encrypt the
+      #   object on the server side, e.g. +:aes256+)
       # 
       # @param [Hash] options
       # @option options [String] :version_id Which version of this object
       #   to make a HEAD request against.
       # @return A head object response with metatadata, 
-      #   content_length, content_type and etag.
+      #   content_length, content_type, etag and server_side_encryption.
       def head options = {}
         client.head_object(options.merge(
           :bucket_name => bucket.name, :key => key))
@@ -124,6 +126,19 @@ module AWS
         head.content_type
       end
 
+      # @return [Symbol, nil] Returns the algorithm used to encrypt
+      #   the object on the server side, or +nil+ if SSE was not used
+      #   when storing the object.
+      def server_side_encryption
+        head.server_side_encryption
+      end
+
+      # @return [true, false] Returns true if the object was stored
+      #   using server side encryption.
+      def server_side_encryption?
+        !server_side_encryption.nil?
+      end
+
       # Deletes the object from its S3 bucket.
       #
       # @param [Hash] options
@@ -258,6 +273,15 @@ module AWS
       # @option options :content_type A standard MIME type
       #   describing the format of the object data.
       #
+      # @option options [Symbol] :server_side_encryption (nil) If this
+      #   option is set, the object will be stored using server side
+      #   encryption.  The only valid value is +:aes256+, which
+      #   specifies that the object should be stored using the AES
+      #   encryption algorithm with 256 bit keys.  By default, this
+      #   option uses the value of the +:s3_server_side_encryption+
+      #   option in the current configuration; for more information,
+      #   see {AWS.config}.
+      #
       # @return [S3Object, ObjectVersion] If the bucket has versioning
       #   enabled, returns the {ObjectVersion} representing the
       #   version that was uploaded.  If versioning is disabled,
@@ -267,6 +291,8 @@ module AWS
         (data_options, put_options) =
           compute_put_options(options_or_data, options)
 
+        add_configured_write_options(put_options)
+
         if use_multipart?(data_options, put_options)
           put_options.delete(:multipart_threshold)
           multipart_upload(put_options) do |upload|
@@ -363,11 +389,24 @@ module AWS
       # @option options :content_type A standard MIME type
       #   describing the format of the object data.
       #
+      # @option options [Symbol] :server_side_encryption (nil) If this
+      #   option is set, the object will be stored using server side
+      #   encryption.  The only valid value is +:aes256+, which
+      #   specifies that the object should be stored using the AES
+      #   encryption algorithm with 256 bit keys.  By default, this
+      #   option uses the value of the +:s3_server_side_encryption+
+      #   option in the current configuration; for more information,
+      #   see {AWS.config}.
+      #
       # @return [S3Object, ObjectVersion] If the bucket has versioning
       #   enabled, returns the {ObjectVersion} representing the
       #   version that was uploaded.  If versioning is disabled,
       #   returns self.
       def multipart_upload(options = {})
+
+        options = options.dup
+        add_configured_write_options(options)
+
         upload = multipart_uploads.create(options)
 
         if block_given?
@@ -399,6 +438,12 @@ module AWS
       # and upload it again.  You can also change the storage class and 
       # metadata of the object when copying.
       #
+      # @note This operation does not copy the ACL, storage class
+      #   (standard vs. reduced redundancy) or server side encryption
+      #   setting from the source object.  If you don't specify any of
+      #   these options when copying, the object will have the default
+      #   values as described below.
+      #
       # @param [Mixed] source
       #
       # @param [Hash] options
@@ -430,6 +475,15 @@ module AWS
       #   * +:bucket_owner_read+
       #   * +:bucket_owner_full_control+
       #
+      # @option options [Symbol] :server_side_encryption (nil) If this
+      #   option is set, the object will be stored using server side
+      #   encryption.  The only valid value is +:aes256+, which
+      #   specifies that the object should be stored using the AES
+      #   encryption algorithm with 256 bit keys.  By default, this
+      #   option uses the value of the +:s3_server_side_encryption+
+      #   option in the current configuration; for more information,
+      #   see {AWS.config}.
+      #
       # @return [nil]
       def copy_from source, options = {}
 
@@ -458,6 +512,10 @@ module AWS
 
         copy_opts[:acl] = options[:acl] if options[:acl]
         copy_opts[:version_id] = options[:version_id] if options[:version_id]
+        copy_opts[:server_side_encryption] =
+          options[:server_side_encryption] if
+          options.key?(:server_side_encryption)
+        add_configured_write_options(copy_opts)
 
         if options[:reduced_redundancy]
           copy_opts[:storage_class] = 'REDUCED_REDUNDANCY'
@@ -477,6 +535,12 @@ module AWS
       # and upload it again.  You can also change the storage class and 
       # metadata of the object when copying.
       #
+      # @note This operation does not copy the ACL, storage class
+      #   (standard vs. reduced redundancy) or server side encryption
+      #   setting from this object to the new object.  If you don't
+      #   specify any of these options when copying, the new object
+      #   will have the default values as described below.
+      #
       # @param [S3Object,String] target An S3Object, or a string key of
       #   and object to copy to.
       #
@@ -497,6 +561,25 @@ module AWS
       #   the object is stored with reduced redundancy in S3 for a
       #   lower cost.
       #
+      # @option options [Symbol] :acl (private) A canned access
+      #   control policy.  Valid values are:
+      #
+      #   * +:private+
+      #   * +:public_read+
+      #   * +:public_read_write+
+      #   * +:authenticated_read+
+      #   * +:bucket_owner_read+
+      #   * +:bucket_owner_full_control+
+      #
+      # @option options [Symbol] :server_side_encryption (nil) If this
+      #   option is set, the object will be stored using server side
+      #   encryption.  The only valid value is +:aes256+, which
+      #   specifies that the object should be stored using the AES
+      #   encryption algorithm with 256 bit keys.  By default, this
+      #   option uses the value of the +:s3_server_side_encryption+
+      #   option in the current configuration; for more information,
+      #   see {AWS.config}.
+      #
       # @return (see #copy_from)
       def copy_to target, options = {}
 
@@ -825,6 +908,15 @@ module AWS
         end
       end
 
+      private
+      def add_configured_write_options(options)
+        options[:server_side_encryption] =
+          config.s3_server_side_encryption unless
+          options.key?(:server_side_encryption)
+        options.delete(:server_side_encryption) if
+          options[:server_side_encryption] == nil
+      end
+
       # @private
       private
       def use_multipart?(data_options, options)

data/lib/aws/simple_db/domain.rb

@@ -100,6 +100,14 @@ module AWS
         ItemCollection.new(self)
       end
 
+      # @return [Boolean] Returns true if the domains are the same.
+      def == other
+        other.is_a?(Domain) and 
+        other.name == name and
+        other.config.simple_db_endpoint == config.simple_db_endpoint 
+      end
+      alias_method :eql?, :==
+
       # An irb-friendly string representation of this object.
       #
       # @return [String]

data/lib/aws/simple_db/item.rb

@@ -49,6 +49,13 @@ module AWS
       end
 
       # Deletes the item and all of its attributes from SimpleDB.
+      # @param [Hash] options
+      # @option options [Hash] :if Pass a hash with a single key (attribute 
+      #   name) and a single value (the attribute value).  This causes the
+      #   delete to become conditional. 
+      # @option options [String,Symbol] :unless Pass an attribute name.  This
+      #   causes the delete to become conditional on that attribute not
+      #   existing.
       # @return [nil]
       def delete options = {}
         delete_opts = {}
@@ -72,6 +79,14 @@ module AWS
         ItemData.new(:name => name, :domain => domain, :response_object => r)
       end
 
+      def == other
+        other.is_a?(Item) and 
+        other.domain == domain and
+        other.name == name
+      end
+
+      alias_method :eql?, :==
+
     end
 
   end

data/lib/aws/simple_db/item_collection.rb

@@ -17,10 +17,27 @@ module AWS
     # Represents a collection of items in a SimpleDB domain.
     class ItemCollection
 
-      include Core::Model
-      include Enumerable
+      # Identifies quoted regions in the string, giving access to
+      # the regions before and after each quoted region, for example:
+      #  "? ? `foo?``bar?` ? 'foo?' ?".scan(OUTSIDE_QUOTES_REGEX)
+      #  # => [["? ? ", "`foo?``bar?`", " ? "], ["", "'foo?'", " ?"]]
+      # @private
+      OUTSIDE_QUOTES_REGEX = Regexp.compile(
+        '([^\'"`]*)(`(?:[^`]*(?:``))*[^`]*`|' +
+        '\'(?:[^\']*(?:\'\'))*[^\']*\'|'      +
+        '"(?:[^"]*(?:""))*[^"]*")([^\'`"]*)'
+      )
+
       include ConsistentReadOption
 
+      include Core::Collection::Limitable
+
+      # @return [Domain] The domain the items belong to.
+      attr_reader :domain
+
+      # @private
+      attr_reader :output_list
+
       # @private
       attr_reader :conditions
 
@@ -31,17 +48,14 @@ module AWS
       # @return [ItemCollection]
       def initialize domain, options = {}
         @domain = domain
-        @conditions = []
-        @conditions += options[:conditions] if options[:conditions]
-        @sort_instructions = options[:sort_instructions] if options[:sort_instructions]
+        @output_list = options[:output_list] || 'itemName()'
+        @conditions = options[:conditions] || []
+        @sort_instructions = options[:sort_instructions]
         @not_null_attribute = options[:not_null_attribute]
-        @limit = options[:limit] if options[:limit]
+        @limit = options[:limit]
         super
       end
 
-      # @return [Domain] The domain the items belong to.
-      attr_reader :domain
-
       # Creates a new item in SimpleDB with the given attributes: 
       #
       #   domain.items.create('shirt', {
@@ -78,132 +92,85 @@ module AWS
         Item.new(domain, item_name.to_s)
       end
 
-      # Yields to the block once for each item in the domain.
+      # Yields to the block once for each item in the collection.
+      # This method can yield two type of objects:
       #
-      # @example using each to fetch every item in the domain.
+      # * AWS::SimpleDB::Item objects (only the item name is populated)
+      # * AWS::SimpleDB::ItemData objects (some or all attributes populated)
       #
+      # The defualt mode of an ItemCollection is to yield Item objects with
+      # no populated attributes.  
+      #
+      #   # only receives item names from SimpleDB
       #   domain.items.each do |item|
       #     puts item.name
+      #     puts item.class.name # => AWS::SimpleDB::Item
+      #   end
+      #
+      # You can switch a collection into yielded {ItemData} objects by
+      # specifying what attributes to request:
+      #
+      #   domain.items.select(:all).each do |item_data|
+      #     puts item_data.class.name # => AWS::SimpleDB::ItemData
+      #     puts item_data.attributes # => { 'attr-name' => 'attr-value', ... }
+      #   end
+      #
+      # You can also pass the standard scope options to #each as well:
+      #
+      #   # output the item names of the 10 most expesive items
+      #   domain.items.each(:order => [:price, :desc], :limit => 10).each do |item|
+      #     puts item.name
       #   end
       #
       # @yield [item] Yields once for every item in the {#domain}.
-      # @yieldparam [Item] item
-      # @param options (see #select)
-      # @option options (see #select)
-      # @option options [Symbol or Array] :select Causes this method
-      #   to behave like {#select} and yield {ItemData} instead of
-      #   {Item} instances.
-      # @option options :batch_size Specifies a maximum number of records
-      #   to fetch from SimpleDB in a single request.  SimpleDB may return
-      #   fewer items than :batch_size per request, but never more.
-      # @return [nil]
-      def each options = {}, &block
-
-        handle_query_options(options) do |c, opts|
-          return c.each(opts, &block)
-        end
-
-        if attributes = options.delete(:select)
-          return select(attributes, options, &block)
-        end
-
-        perform_select(options) do |response|
-          response.items.each do |item|
-            yield(self[item.name])
-          end
-        end
-
-      end
-
-      # Retrieves data from each item in the domain.
       #
-      #   domain.items.select('size', 'color')
+      # @yieldparam [Item,ItemData] item If the item collection has been
+      #   scoped by chaining +#select+ or by passing the +:select+ option
+      #   then {ItemData} objects (that contain a hash of attrbiutes) are 
+      #   yielded.  If no list of attributes has been provided, then#
+      #   {Item} objects (with no populated data) are yielded.
       #
-      # You may optionally filter by a set of conditions.  For example, 
-      # to retrieve the attributes of each of the top 100 items in order of
-      # descending popularity as an array of hashes, you could do:
+      # @param options [Hash]
       #
-      #  items.order(:popularity, :desc).limit(100).select do |data|
-      #    puts data.to_yaml
-      #  end
+      # @option options [Boolean] :consistent_read (false) Causes this
+      #   method to yield the most current data in the domain.
       #
-      # You can select specific attributes; for example, to get
-      # all the unique colors in the collection you could do:
+      # @option options [Mixed] :select If select is provided, then each
+      #   will yield {ItemData} objects instead of empty {Item}.
+      #   The +:select+ option may be:
       #
-      #  colors = Set.new
-      #  items.select(:color) {|data| colors += data.attributes["color"] }
+      #   * +:all+ - Specifies that all attributes should requested.
       #
-      # Finally, you can specify conditions, sort instructions, and
-      # a limit in the same method call:
+      #   * A single or array of attribute names (as strings or symbols).
+      #     This causes the named attribute(s) to be requested.
       #
-      #  items.select(:color,
-      #               :where => "rating > 4",
-      #               :order => [:popularity, :desc],
-      #               :limit => 100) do |data|
-      #    puts "Data for #{data.name}: #{data.attributes.inspect}"
-      #  end
+      # @option options :where Restricts the item collection using
+      #   {#where} before querying (see {#where}).
       #
-      # @overload select(*attribute_names, options = {}) &block
-      #   @param *attributes [Symbol, String, or Array]
-      #     The attributes to retrieve.  This can be:
+      # @option options :order Changes the order in which the items
+      #   will be yielded (see {#order}).
       #
-      #     * +:all+ to retrieve all attributes (the default).
-      #     * a Symbol or String to retrieve a single attribute.
-      #     * an array of Symbols or Strings to retrieve multiple attributes.
+      # @option options :limit [Integer] The maximum number of
+      #   items to fetch from SimpleDB.  
       #
-      #     For single attributes or arrays of attributes, the
-      #     attribute name may contain any characters that are valid
-      #     in a SimpleDB attribute name; this method will handle
-      #     escaping them for inclusion in the query.  Note that you
-      #     cannot use this method to select the number of items; use
-      #     {#count} instead.
+      # @option options :batch_size Specifies a maximum number of records
+      #   to fetch from SimpleDB in a single request.  SimpleDB may return
+      #   fewer items than :batch_size per request, but never more.
+      #   Generally you should not need to specify this option.
       #
-      #   @param [Hash] options Options for querying the domain.
-      #   @option options [Boolean] :consistent_read (false) Causes this
-      #     method to yield the most current data in the domain.
-      #   @option options :where Restricts the item collection using
-      #     {#where} before querying.
-      #   @option options :order Changes the order in which the items
-      #     will be yielded (see {#order}).
-      #   @option options :limit [Integer] The maximum number of
-      #     items to fetch from SimpleDB.  More than one request may be
-      #     required to satisfy the limit.
-      #   @option options :batch_size Specifies a maximum number of records
-      #     to fetch from SimpleDB in a single request.  SimpleDB may return
-      #     fewer items than :batch_size per request, but never more.
-      #   @return If no block is given, an enumerator is returned. If a block
-      #     was passed then nil is returned.
-      def select *attributes, &block
-        
-        options = attributes.last.is_a?(Hash) ? attributes.pop : {}
-
-        args = attributes + [options]
-
-        handle_query_options(*args) do |c, *clean_args|
-          return c.select(*clean_args, &block)
-        end
-
-        unless block_given?
-          return Enumerator.new(self, :select, *args)
-        end
-
-        if attributes.empty?
-          output_list = '*'
-        #elsif attributes == ['*']
-        #  output_list = '*'
-        else
-          output_list = [attributes].flatten.collect do |attr|
-            coerce_attribute(attr)
-          end.join(', ')
-        end
+      # @return [String,nil] Returns a next token that can be used with 
+      #   the exact same SimpleDB select expression to get more results.
+      #   A next token is returned ONLY if there was a limit on the
+      #   expression, otherwise all items will be enumerated and
+      #   nil is returned.
+      #
+      def each options = {}, &block
 
-        perform_select(options.merge(:output_list => output_list)) do |response|
-          response.items.each do |item|
-            yield(ItemData.new(:domain => domain, :response_object => item))
-          end
+        handle_query_options(options) do |collection, opts|
+          return collection.each(opts, &block)
         end
 
-        nil
+        super
 
       end
 
@@ -211,31 +178,32 @@ module AWS
       #
       #   domain.items.count
       #
-      # You can use this method to get the total number of items in
-      # the domain, or you can use it with {#where} to count a subset
-      # of items.  For example, to count the items where the "color"
-      # attribute is "red":
+      # You can specify what items to count with {#where}:
       #
-      #   domain.items.where("color" => "red").count
+      #   domain.items.where(:color => "red").count
       #
-      # You can also limit the number of items searched using the
-      # {#limit} method.  For example, to count the number of items up
-      # to 500:
+      # You can also limit the number of items to count:
       #
+      #   # count up to 500 items and then stop
       #   domain.items.limit(500).count
       #
       # @param [Hash] options Options for counting items.
       #
       # @option options [Boolean] :consistent_read (false) Causes this
-      #   method to yield the most current data in the domain.
+      #   method to yield the most current data in the domain when +true+.
+      #
       # @option options :where Restricts the item collection using
       #   {#where} before querying.
+      #
       # @option options :limit [Integer] The maximum number of
-      #   items to fetch from SimpleDB.  More than one request may be
-      #   required to satisfy the limit.
+      #   items to count in SimpleDB.
+      #
+      # @return [Integer] The number of items counted.
+      #
       def count options = {}, &block
-        handle_query_options(options) do |c, opts|
-          return c.count(opts, &block)
+
+        handle_query_options(options) do |collection, opts|
+          return collection.count(opts, &block)
         end
 
         options = options.merge(:output_list => "count(*)")
@@ -243,30 +211,107 @@ module AWS
         count = 0
         next_token = nil
 
-        while limit.nil? || count < limit and
-            response = select_request(options, next_token)
+        begin
 
-          if domain_item = response.items.first and
-              count_attribute = domain_item.attributes.first
+          response = select_request(options, next_token)
+
+          if 
+            domain_item = response.items.first and
+            count_attribute = domain_item.attributes.first
+          then
             count += count_attribute.value.to_i
           end
 
-          next_token = response.next_token
-          break unless next_token
+          break unless next_token = response.next_token
 
-        end
+        end while limit.nil? || count < limit
 
         count
+
       end
       alias_method :size, :count
 
-      # Identifies quoted regions in the string, giving access to
-      # the regions before and after each quoted region, for example:
-      #  "? ? `foo?``bar?` ? 'foo?' ?".scan(OUTSIDE_QUOTES_REGEX)
-      #  # => [["? ? ", "`foo?``bar?`", " ? "], ["", "'foo?'", " ?"]]
-      OUTSIDE_QUOTES_REGEX = Regexp.compile('([^\'"`]*)(`(?:[^`]*(?:``))*[^`]*`|'+
-                                            '\'(?:[^\']*(?:\'\'))*[^\']*\'|'+
-                                            '"(?:[^"]*(?:""))*[^"]*")([^\'`"]*)')
+#       # @return [PageResult] Returns an array-based object with results.
+#       #   Results are either {Item} or {ItemData} objects depending on
+#       #   the selection mode (item names only or with attributes).
+#       #
+#       def page options = {}
+# 
+#         handle_query_options(options) do |collection, opts|
+#           return collection.page(opts)
+#         end
+# 
+#         super(options)
+# 
+#       end
+
+      # Specifies a list of attributes select from SimpleDB.
+      #
+      #   domain.items.select('size', 'color').each do |item_data|
+      #     puts item_data.attributes # => { 'size' => ..., :color => ... }
+      #   end
+      #
+      # You can select all attributes by passing +:all+ or '*':
+      #
+      #   domain.items.select('*').each {|item_data| ... }
+      #
+      #   domain.items.select(:all).each {|item_data| ... }
+      #
+      # Calling #select causes #each to yield {ItemData} objects
+      # with #attribute hashes, instead of {Item} objects with 
+      # an item name.
+      #
+      # @param *attributes [Symbol, String, or Array] The attributes to
+      #   retrieve.  This can be:
+      #  
+      #   * +:all+ or '*' to request all attributes for each item
+      #  
+      #   * A list or array of attribute names as strinsg or symbols
+      #
+      #     Attribute names may contain any characters that are valid
+      #     in a SimpleDB attribute name; this method will handle
+      #     escaping them for inclusion in the query.  Note that you
+      #     cannot use this method to select the number of items; use
+      #     {#count} instead.
+      #
+      # @return [ItemCollection] Returns a new item collection with the
+      #   specified list of attributes to select.
+      #
+      def select *attributes, &block
+
+        # Before select was morphed into a chainable method, it accepted
+        # a hash of options (e.g. :where, :order, :limit) that no longer
+        # make sense, but to maintain backwards compatability we still
+        # consume those.
+        #
+        # TODO : it would be a good idea to add a deprecation warning for
+        #        passing options to #select
+        #
+        handle_query_options(*attributes) do |collection, *args|
+          return collection.select(*args, &block)
+        end
+
+        options = attributes.last.is_a?(Hash) ? attributes.pop : {}
+
+        output_list = case attributes.flatten
+        when []     then '*'
+        when ['*']  then '*'
+        when [:all] then '*'
+        else attributes.flatten.map{|attr| coerce_attribute(attr) }.join(', ')
+        end
+
+        collection = collection_with(:output_list => output_list)
+
+        if block_given?
+          # previously select accepted a block and it would enumerate items
+          # this is for backwards compatability
+          collection.each(options, &block)
+          nil
+        else
+          collection
+        end
+
+      end
 
       # Returns an item collection defined by the given conditions
       # in addition to any conditions defined on this collection.
@@ -333,7 +378,8 @@ module AWS
       #
       # @return [ItemCollection] Returns a new item collection with the
       #   additional conditions.
-      def where(conditions, *substitutions)
+      #
+      def where conditions, *substitutions
         case conditions
         when String
           conditions = [replace_placeholders(conditions, *substitutions)]
@@ -391,64 +437,72 @@ module AWS
       #
       # @overload limit
       #   @return [Integer] Returns the current limit for the collection.
+      #
       # @overload limit(value)
       #   @return [ItemCollection] Returns a collection with the given limit.
-      def limit(*args)
+      #
+      def limit *args
         return @limit if args.empty?
         collection_with(:limit => Integer(args.first))
       end
+      alias_method :_limit, :limit # for Collection::Limitable
 
-      # turns e.g. each(:where => 'foo', ...) into where('foo').each(...)
+      # Applies standard scope options (e.g. :where => 'foo') and removes them from
+      # the options hash by calling their method (e.g. by calling #where('foo')).
+      # Yields only if there were scope options to apply.  
       # @private
       protected
       def handle_query_options(*args)
-        options = args.pop if args.last.kind_of?(Hash)
-        if query_options = options.keys & [:where, :order, :limit] and
-            !query_options.empty?
-          c = self
+
+        options = args.last.is_a?(Hash) ? args.pop : {}
+
+        if 
+          query_options = options.keys & [:select, :where, :order, :limit] and
+          !query_options.empty?
+        then
+          collection = self
           query_options.each do |query_option|
             option_args = options[query_option]
             option_args = [option_args] unless option_args.kind_of?(Array)
             options.delete(query_option)
-            c = send(query_option, *option_args)
+            collection = collection.send(query_option, *option_args)
           end
-          yield(c, *(args + [options]))
-        end
-      end
 
-      # @private
-      protected
-      def perform_select(options = {})
+          args << options
 
-        next_token = options[:next_token]
-        batch_size = options[:batch_size] ? Integer(options[:batch_size]) : nil
-        total = 0
-        
-        begin
+          yield(collection, *args)
 
-          # if the user provided a batch size we need to rewrite the
-          # select expression's LIMIT clause.  
-          if batch_size
-            max = limit ? [limit - total, batch_size].min : batch_size
-          else
-            max = nil
-          end
+        end
+      end
 
-          response = select_request(options, next_token, max)
+      protected
+      def _each_item next_token, max, options = {}, &block
 
-          yield(response)
+        handle_query_options(options) do |collection, opts|
+          return collection._each_item(next_token, max, opts, &block)
+        end
 
-          next_token = response.next_token
+        response = select_request(options, next_token, max)
 
-          total += response.items.size
+        if output_list == 'itemName()'  
+          response.items.each do |item|
+            yield(self[item.name])
+          end
+        else
+          response.items.each do |item|
+            yield(ItemData.new(:domain => domain, :response_object => item))
+          end
+        end
 
-        end while next_token && (limit.nil? || total < limit)
+        response.next_token
+        
       end
 
       protected
       def select_request(options, next_token = nil, limit = nil)
+
         opts = {}
-        opts[:select_expression] = select_expression(options[:output_list])
+        opts[:select_expression] = select_expression(options)
         opts[:consistent_read] = consistent_read(options)
         opts[:next_token] = next_token if next_token
 
@@ -459,57 +513,57 @@ module AWS
         end
 
         client.select(opts)
-      end
 
-      # @private
-      protected
-      def select_expression(output_list = nil)
-        output_list ||= "itemName()"
-        "SELECT #{output_list} FROM `#{domain.name}`" +
-          where_clause + order_by_clause + limit_clause
       end
 
       # @private
       protected
-      def limit_clause
-        if limit
-          " LIMIT #{limit}"
-        else
-          ""
-        end
+      def select_expression options = {}
+        expression = []
+        expression << "SELECT #{options[:output_list] || self.output_list}"
+        expression << "FROM `#{domain.name}`"
+        expression << where_clause
+        expression << order_by_clause
+        expression << limit_clause
+        expression.compact.join(' ')
       end
 
       # @private
       protected
       def where_clause
-        all_conditions = conditions.dup
+
+        conditions = self.conditions.dup
+
         if @not_null_attribute
-          all_conditions << coerce_attribute(@not_null_attribute) + " IS NOT NULL"
-        end
-        if all_conditions.empty?
-          ""
-        else
-          " WHERE " + all_conditions.join(" AND ")
+          conditions << coerce_attribute(@not_null_attribute) + " IS NOT NULL"
         end
+
+        conditions.empty? ? nil : "WHERE #{conditions.join(" AND ")}"
+
       end
 
       # @private
       protected
       def order_by_clause
-        if sort_instructions
-          " ORDER BY " + sort_instructions
-        else
-          ""
-        end
+        sort_instructions ? "ORDER BY #{sort_instructions}" : nil
       end
 
       # @private
       protected
-      def collection_with(opts)
+      def limit_clause
+        limit ? "LIMIT #{limit}" : nil
+      end
+
+      # @private
+      protected
+      def collection_with options
         ItemCollection.new(domain, { 
-          :limit => limit,
+          :output_list => output_list,
           :conditions => conditions,
-          :sort_instructions => sort_instructions }.merge(opts))
+          :sort_instructions => sort_instructions,
+          :not_null_attribute => @not_null_attribute,
+          :limit => limit,
+        }.merge(options))
       end
 
       # @private