Class: Parse::BatchOperation

Inherits:
Object
  • Object
show all
Includes:
Enumerable
Defined in:
lib/parse/client/batch.rb

Overview

This class provides a standard way to submit, manage and process batch operations for Parse::Objects and associations.

Batch requests are supported implicitly and intelligently through an extension of array. When an array of Parse::Object subclasses is saved, Parse-Stack will batch all possible save operations for the objects in the array that have changed. It will also batch save 50 at a time until all items in the array are saved. Note: Parse does not allow batch saving Parse::User objects.

songs = Songs.first 1000 #first 1000 songs
songs.each do |song|
 # ... modify song ...
end

# will batch save 50 items at a time until all are saved.
songs.save

The objects do not have to be of the same collection in order to be supported in the batch request.

See Also:

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(reqs = nil) ⇒ BatchOperation

Returns a new instance of BatchOperation.

Parameters:



52
53
54
55
56
57
 
# File 'lib/parse/client/batch.rb', line 52

def initialize(reqs = nil)
  @requests = []
  @responses = []
  reqs = [reqs] unless reqs.is_a?(Enumerable)
  reqs.each { |r| add(r) } if reqs.is_a?(Enumerable)
end

Instance Attribute Details

#requests ⇒ Object

Returns the value of attribute requests.




# File 'lib/parse/client/batch.rb', line 39

#responses ⇒ Array

Returns the set of responses from this batch.

Returns:

  • (Array) —

    the set of responses from this batch.



44
 
# File 'lib/parse/client/batch.rb', line 44

attr_accessor :requests, :responses

Instance Method Details

#add(req) ⇒ Array<Parse::Request> #add(batch) ⇒ Array<Parse::Request>

Add an additional request to this batch.

Overloads:



66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
# File 'lib/parse/client/batch.rb', line 66

def add(req)
  if req.respond_to?(:change_requests)
    requests = req.change_requests.select { |r| r.is_a?(Parse::Request) }
    @requests += requests
  elsif req.is_a?(Array)
    requests = req.select { |r| r.is_a?(Parse::Request) }
    @requests += requests
  elsif req.is_a?(BatchOperation)
    @requests += req.requests if req.is_a?(BatchOperation)
  else
    @requests.push(req) if req.is_a?(Parse::Request)
  end
  @requests
end

#as_json(*args) ⇒ Hash

Returns a formatted payload for the batch request.

Returns:

  • (Hash) —

    a formatted payload for the batch request.



94
95
96
 
# File 'lib/parse/client/batch.rb', line 94

def as_json(*args)
  { requests: requests }.as_json
end

#change_requests ⇒ Object

This method is for interoperability with Parse::Object instances.

See Also:

  • Object#change_requests


83
84
85
 
# File 'lib/parse/client/batch.rb', line 83

def change_requests
  @requests
end

#clear! ⇒ Array

Remove all requests in this batch.

Returns:



105
106
107
 
# File 'lib/parse/client/batch.rb', line 105

def clear!
  @requests.clear
end

#client ⇒ Parse::Client

Returns the client to be used for the request.

Returns:



47
48
49
 
# File 'lib/parse/client/batch.rb', line 47

def client
  @client ||= Parse::Client.client
end

#count ⇒ Integer

Returns the number of requests in the batch.

Returns:

  • (Integer) —

    the number of requests in the batch.



99
100
101
 
# File 'lib/parse/client/batch.rb', line 99

def count
  @requests.count
end

#each ⇒ Array

Returns:



88
89
90
91
 
# File 'lib/parse/client/batch.rb', line 88

def each
  return enum_for(:each) unless block_given?
  @requests.each(&Proc.new)
end

#error? ⇒ Boolean

Returns true if the request had an error.

Returns:

  • (Boolean) —

    true if the request had an error.



116
117
118
119
 
# File 'lib/parse/client/batch.rb', line 116

def error?
  return false if @responses.empty?
  !success?
end

#submit(segment = 50) ⇒ Array<Parse::Response> Also known as: save

Submit the batch operation in chunks until they are all complete. In general, Parse limits requests in each batch to 50 and it is possible that a Parse::BatchOperation instance contains more than 50 requests. This method will slice up the array of request and send them based on the segment amount until they have all been submitted.

Parameters:

  • segment (Integer) (defaults to: 50) —

    the number of requests to send in each batch. Default 50.

Returns:



128
129
130
131
132
133
134
135
136
137
138
 
# File 'lib/parse/client/batch.rb', line 128

def submit(segment = 50)
  @responses = []
  @requests.uniq!(&:signature)
  @responses = @requests.each_slice(segment).to_a.threaded_map(2) do |slice|
    client.batch_request(BatchOperation.new(slice))
  end
  @responses.flatten!
  #puts "Requests: #{@requests.count} == Response: #{@responses.count}"
  @requests.zip(@responses).each(&Proc.new) if block_given?
  @responses
end

#success? ⇒ Boolean

Returns true if the request was successful.

Returns:

  • (Boolean) —

    true if the request was successful.



110
111
112
113
 
# File 'lib/parse/client/batch.rb', line 110

def success?
  return false if @responses.empty?
  @responses.compact.all?(&:success?)
end