code: def results(raw: false)
        if @results.nil?
          if block_given?
            max_results(raw: raw, &Proc.new)
          elsif @limit.is_a?(Numeric)
            response = fetch!( compile )
            return [] if response.error?
            items = raw ? response.results : decode(response.results)
            return items.each(&Proc.new) if block_given?
            @results = items
          else
            @results = max_results(raw: raw)
          end
        end
        @results
      end
docs: Executes the query and builds the result set of Parse::Objects that matched.
   When this method is passed a block, the block is yielded for each matching item
   in the result, and the items are not returned. This methodology is more performant
   as large quantifies of objects are fetched in batches and all of them do
   not have to be kept in memory after the query finishes executing. This is the recommended
   method of processing large result sets.
   @example
    query = Parse::Query.new("_User", :created_at.before => DateTime.now)
    users = query.results # => Array of Parse::User objects.
  
    query = Parse::Query.new("_User", limit: :max)
  
    query.results do |user|
     # recommended; more memory efficient
    end
  
   @param raw [Boolean] whether to get the raw hash results of the query instead of
     a set of Parse::Object subclasses.
   @yield a block to iterate for each object that matched the query.
   @return [Array<Hash>] if raw is set to true, a set of Parse JSON hashes.
   @return [Array<Parse::Object>] if raw is set to false, a list of matching Parse::Object subclasses.