Is there any cost advantage of Parse.Object.saveAll vs. saving individually?

Question

The Parse JS SDK provides a Parse.Object.saveAll() method to save many objects with one command.

From looking at ParseServerRESTController.js it seems that each object is saved individually:

if (path === '/batch') {
    let initialPromise = Promise.resolve();
    if (data.transaction === true) {
        initialPromise = config.database.createTransactionalSession();
    }
    return initialPromise.then(() => {
        const promises = data.requests.map(request => {
            return handleRequest(
                request.method,
                request.path,
                request.body,
                options,
                config
            ).then(
                response => {
                    return {
                        success: response
                    };
                },
                error => {
                    return {
                        error: {
                            code: error.code,
                            error: error.message
                        },
                    };
                }
            );
        });
        return Promise.all(promises).then(result => {
            if (data.transaction === true) {
                if (
                    result.find(resultItem => typeof resultItem.error === 'object')
                ) {
                    return config.database.abortTransactionalSession().then(() => {
                        return Promise.reject(result);
                    });
                } else {
                    return config.database.commitTransactionalSession().then(() => {
                        return result;
                    });
                }
            } else {
                return result;
            }
        });
    });
}

It seems that saveAll is merely a convenience wrapper around saving each object individually, so it still does seem to make n database requests for n objects.

It it correct that saveAll has no cost advantage (performance, network traffic, etc) vs. saving each object individually in Cloud Code?

Answer 1

I can tell you that the answer is that Parse.Object.saveAll and Parse.Object.destroyAll batch requests by default in batches of 20 objects. But why take my word for it? Let's test it out!

Turn verbose logging on and then run the following:

const run = async function run() {
  const objects = [...Array(10).keys()].map(i => new Parse.Object('Test').set({i}));
  await Parse.Object.saveAll(objects);

  const promises = objects.map(o => o.increment('i').save());
  return Promise.all(promises);
};

run()
  .then(console.log)
  .catch(console.error);

And here's the output from the parse-server logs (I've truncated it, but it should be enough to be apparent what is going on):

verbose: REQUEST for [POST] /parse/batch: { // <--- note the path
  "requests": [ // <--- an array of requests!!!
    {
      "method": "POST",
      "body": {
        "i": 0
      },
      "path": "/parse/classes/Test"
    },

    ... skip the next 7, you get the idea

    {
      "method": "POST",
      "body": {
        "i": 9
      },
      "path": "/parse/classes/Test"
    }
  ]
} 
.... // <-- remove some irrelevent output for brevity.
verbose: RESPONSE from [POST] /parse/batch: { 
  "response": [
    {
      "success": {
        "objectId": "szVkuqURVq",
        "createdAt": "2020-03-05T21:25:44.487Z"
      }
    },
    ...
    {
      "success": {
        "objectId": "D18WB4Nsra",
        "createdAt": "2020-03-05T21:25:44.491Z"
      }
    }
  ]
} 
...

// now we iterate through and there's a request per object.
verbose: REQUEST for [PUT] /parse/classes/Test/szVkuqURVq: {
  "i": {
    "__op": "Increment",
    "amount": 1
  }
} 
...
verbose: REQUEST for [PUT] /parse/classes/Test/HtIqDIsrX3: {
  "i": {
    "__op": "Increment",
    "amount": 1
  }
} 
// and the responses...
verbose: RESPONSE from [PUT] /parse/classes/Test/szVkuqURVq: {
  "response": {
    "i": 1,
    "updatedAt": "2020-03-05T21:25:44.714Z"
  }
}
...

In the core manager code, you do correctly identify that we are making a request for each object to the data store (i.e. MongoDB), This is necessary because an object may have relations or pointers that have to be handled and that may require additional calls to the data store.

BUT! calls between the parse server and the data store are usually over very fast networks using a binary format, whereas calls between the client and the parse server are JSON and go over longer distances with ordinarily much slower connections.

There is one other potential advantage that you can see in the core manager code which is that the batch is done in a transaction.