Scheduled Recurring Script - Setting Script to Run Continuously Until Saved Search Results are Null

Question

I have built a script that looks at fields within a saved search to process, when the script processes each line of the saved search . The script has to process a lot of lines of data and I'm running into issue where I get an SSS Usage Limit exceeded message just due to the nature of the amount of information that I'm processing. Therefore I'm wondering if on each run of the script if I can limit the amount of orders processed and then consecutively run the script until there aren't any more records that need to be processed

Previously I have just restricted the number of records that the script processes at a time and then just manually trigger the script until there aren't anymore lines left to process. I see that you can trigger the script to run every 15 minutes or so but would like it to run each day and then run in a 15 minute cadence after that until the saved search has been exhausted. Then the script would be triggered to run again the following day etc for every 15 min until all records are processed. From research don't know if this type of scheduling is possible.

code itself is working the scheduling of it is what I need guidance on

Answer 1

I had this problem some time ago. The map/reduce script can be the solution if you run 2.0 scripts. In my case, I had 'legacy' scripts in versions 1.X and 2.X. And all of them throw from time to time 'SSS_TIME_LIMIT_EXCEEDED'.

My solution :) I created a script, kind of 'listener'. I removed link to the script because the rep. is not active anymore

  // *add the script listener 
  // [it can be used for both script versions 1.X and 2.X]
    
     /** you have to calculate the 'process usage' by 1 loop cycle. 
         use script.getRemainingUsage() */
    var recallValue = 200;
    var stopValue = 200;
    var recallIsRequired = true;// use false to stop the script without recall

    var script = setScriptListener(recallValue, stopValue, recallIsRequired);
    
    for (var data in data_contaniner){
      if(script.canContinue()){
        //run you processing 
        // !important : mark the data as 'processed'. 
        //otherwise you will have a lot of duplicates after script recall
      }else{
        //stop the loop 
        break;
      }
    }

Answer 2

The other alternative (and one that I've used successfully) is to exit the scheduled script whent the usage reaches a certain point, but before you exit, trigger the scheduled script again. I've used this successfully to process thousands of records (such as mass deletions).

/**
 * @NApiVersion 2.x
 * @NScriptType ScheduledScript
 * @NModuleScope SameAccount
 */
define(['N/record', 'N/runtime', 'N/search', 'N/task'],
/**
 * @param {record} record
 * @param {search} search
 */
function(record, runtime, search, task) {

    const governanceCap = 9950;

    function getAllResults(s) {
        var results = s.run();
        var searchResults = [];
        var searchid = 0;
        do {
            var resultslice = results.getRange({start:searchid,end:searchid+1000});
            resultslice.forEach(function(slice) {
                searchResults.push(slice);
                searchid++;
                }
            );
        } while (resultslice.length >=1000);
        return searchResults;
    }

    /**
     * Definition of the Scheduled script trigger point.
     *
     * @param {Object} scriptContext
     * @param {string} scriptContext.type - The context in which the script is executed. It is one of the values from the scriptContext.InvocationType enum.
     * @Since 2015.2
     */
    function execute(scriptContext) {

        function rescheduleCurrentScript() {
            var scheduledScriptTask = task.create({
                taskType: task.TaskType.SCHEDULED_SCRIPT
            });
            scheduledScriptTask.scriptId = runtime.getCurrentScript().id;
            scheduledScriptTask.deploymentId = runtime.getCurrentScript().deploymentId;
            return scheduledScriptTask.submit();
        }

        try {

            var script = runtime.getCurrentScript();

            // GET YOUR SEARCH HERE

            var mySearch = getAllResults(
                search.create({
                       type: "transaction",
                       filters:
                       [
                          ["mainline","is","T"],
                       ],
                       columns:
                       [
                           "name",
                           "tranid",
                           "type",
                           search.createColumn({
                               name:"datecreated", 
                               sort: search.Sort.DESC
                            }),
                       ]
                    })
                );
            var recCount = mySearch.length;
            for (each in mySearch) {
                try {
                    record.delete({
                        type: transSearch[each].getValue({name:'type'}),
                        id: transSearch[each].id
                    });
                } catch (err) {log.error(err.name,err.message) }

                var govPointsUsed = 10000-script.getRemainingUsage();

                script.percentComplete = (govPointsUsed/governanceCap*100).toFixed(1);

                if (govPointsUsed >= governanceCap) {
                    var taskId = rescheduleCurrentScript();
                    log.audit('Rescheduling status: ','Task ID:' + taskId);
                    return;
                }
            }
        } catch (err) { log.error(err.name,err.message + '; Stack: '+err.stack ) };    
    }

    return {
        execute: execute
    };

});

Worked like a charm!!

Answer 3

I would encourage you to use a Map/Reduce script. That is the correct script type to use when dealing with a lot of data and can handle governance issues much better.