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:

Constant Summary collapse

DEFAULT_PARALLELISM =

Default number of threads used to dispatch batch segments concurrently. Raise via ‘Parse::BatchOperation.parallelism = N` (or pass `parallelism:` to `#submit`) for higher throughput on bulk writes; 2 is intentionally conservative to avoid overwhelming smaller Parse Server deployments.

2

Class Attribute Summary collapse

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(reqs = nil, transaction: false) ⇒ BatchOperation

Returns a new instance of BatchOperation.

Parameters:

  • reqs (Array<Parse::Request>) (defaults to: nil) —

    an array of requests.

  • transaction (Boolean) (defaults to: false) —

    whether to execute as a transaction.



70
71
72
73
74
75
76
 
# File 'lib/parse/client/batch.rb', line 70

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

Class Attribute Details

.parallelism ⇒ Object 



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

def parallelism
  @parallelism || DEFAULT_PARALLELISM
end

Instance Attribute Details

#requests ⇒ Object

Returns the value of attribute requests.




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

#responses ⇒ Object

Returns the value of attribute responses.




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

#transaction ⇒ Boolean

Returns whether this batch should be executed as a transaction.

Returns:

  • (Boolean) —

    whether this batch should be executed as a transaction.



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

attr_accessor :requests, :responses, :transaction

Instance Method Details

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

Add an additional request to this batch.

Overloads:



85
86
87
88
89
90
91
92
93
94
95
96
97
98
 
# File 'lib/parse/client/batch.rb', line 85

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.



113
114
115
116
117
 
# File 'lib/parse/client/batch.rb', line 113

def as_json(*args)
  payload = { requests: requests }
  payload[:transaction] = true if @transaction
  payload.as_json
end

#change_requests ⇒ Object

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

See Also:

  • Object#change_requests


102
103
104
 
# File 'lib/parse/client/batch.rb', line 102

def change_requests
  @requests
end

#clear! ⇒ Array

Remove all requests in this batch.

Returns:



126
127
128
 
# File 'lib/parse/client/batch.rb', line 126

def clear!
  @requests.clear
end

#client ⇒ Parse::Client

Returns the client to be used for the request.

Returns:



64
65
66
 
# File 'lib/parse/client/batch.rb', line 64

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.



120
121
122
 
# File 'lib/parse/client/batch.rb', line 120

def count
  @requests.count
end

#each(&block) ⇒ Array

Returns:



107
108
109
110
 
# File 'lib/parse/client/batch.rb', line 107

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

#error? ⇒ Boolean

Returns true if the request had an error.

Returns:

  • (Boolean) —

    true if the request had an error.



137
138
139
140
 
# File 'lib/parse/client/batch.rb', line 137

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

#submit(segment = 50, parallelism: self.class.parallelism, &block) ⇒ 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.

  • parallelism (Integer) (defaults to: self.class.parallelism) —

    the number of segments dispatched in parallel. Defaults to ‘Parse::BatchOperation.parallelism` (2).

Returns:



151
152
153
154
155
156
157
158
159
160
161
 
# File 'lib/parse/client/batch.rb', line 151

def submit(segment = 50, parallelism: self.class.parallelism, &block)
  @responses = []
  @requests.uniq!(&:signature)
  parallelism = 1 if parallelism.nil? || parallelism < 1
  @responses = @requests.each_slice(segment).to_a.threaded_map(parallelism) do |slice|
    client.batch_request(BatchOperation.new(slice))
  end
  @responses.flatten!
  @requests.zip(@responses).each(&block) if block_given?
  @responses
end

#success? ⇒ Boolean

Returns true if the request was successful.

Returns:

  • (Boolean) —

    true if the request was successful.



131
132
133
134
 
# File 'lib/parse/client/batch.rb', line 131

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