Exploring MapReduce Script Context Objects in NetSuite

 

In this blog, I won’t dive into the script functions of a MapReduce script. Instead, I'll explain the context objects within each stage of the script, helping you understand their significance for better script performance and reliability in NetSuite. Writing a script isn’t just about making it work; it’s about making it efficient, scalable, and robust.

Knowing when and how to use each context object lets you optimize usage, handle errors gracefully, and ensure consistent execution even if interruptions occur. This approach will help you better leverage the properties and methods available at each stage - getInputData, map, reduce, and summarize—for more effective scripting in NetSuite.

 1. getInputData Context Object: (inputContext):

The `inputContext` object is utilized in the `getInputData(inputContext)` function, helping to load data for further stages. Its properties allow the script to check if it's being restarted and reference specific input data sources.

Properties:

  • inputContext.isRestarted:

  - Indicates if the current call to `getInputData` is due to an application server restart. This flag enables you to handle re-executions gracefully, ensuring no data is lost.


Example:
    function getInputData(context) {
        if (context.isRestarted) {
            log.debug('GET_INPUT isRestarted', 'YES');
        } else {
            log.debug('GET_INPUT isRestarted', 'NO');
        }
        return search.load({ id: 'customsearch35' });
    }


  • inputContext.ObjectRef: 

  - Contains details about the input data type and its identifier, such as a SuiteQL query, file path, or saved search ID.


Example:
 function getInputData(context) {
    //suiteQL query
    rerturn {
        type: 'suiteql',
        query: 'SELECT id, email FROM Employee WHERE currency = ?',
        params: [currency]
    }
    //SEARCH
    return {
        type: search,
        id: 26,
    }
 }


 2. mapContext Object:

The `mapContext` object is used within the `map(mapContext)` function. It represents each key-value pair and offers various properties and methods for handling and writing data to pass along to the reduce stage.

Properties:

  • mapContext.isRestarted:

- Indicates if `map(mapContext)` has restarted due to an interruption, which can help manage duplicate processing.


Example:
    function map(context) {
        if (context.isRestarted) {
            // Assess previously completed processing steps
        } else {
            // Process key-value pair normally
        }
    }

  • mapContext.executionNo:
  - Tracks the number of times the `map` function has been called for the current key-value pair, providing control over re-executions.

Example:
    function map(context) {
        if (context.executionNo === 1) {
            // Full processing
        } else if (context.executionNo === 2) {
            // Handle partial completion
        }
    }

  • mapContext.errors:

  - A collection of serialized errors from previous attempts, useful for debugging by logging each error entry. 


Example:
    function map(context) {
       context.errors.iterator().each((key, error, executionNo) => {
        var errorObject = JSON.parse(error);
        log.error({
            title: 'Map error for key ' + key,
            details: errorObject.name + ': ' + errorObject.message
        });
        return true;
      });
    }

  •  mapContext.key:

  - The current key for processing in the map stage, which can vary depending on the input data type.


Example:
    function map(context) {
        context.write({
            key: context.value[i], 
            value: 1 
        });
    }

  • mapContext.value:

  - The current value associated with `mapContext.key`. This is usually a JSON string derived from a search result or another data source.


Example:
    function map(context) {
       var searchResult = JSON.parse(context.value);
    }

  • mapContext.write(options):

  - Saves key-value pairs for processing in the reduce stage, essential for moving data between stages. 


Example:
    function map(context) {
        for (var i = 0; context.value && i < context.value.length; i++) {
            if (context.value[i] !== ' ' && !PUNCTUATION_REGEXP.test(context.value[i])) {
                context.write({
                    key: context.value[i],
                    value: 1 
                });
            }
        }
   }


 3. reduceContext Object :

The `reduceContext` object is central in the `reduce(reduceContext)` function, which consolidates values based on keys provided by `mapContext.write(options)`.

Properties:

  • reduceContext.isRestarted:

  - Detects whether `reduce(reduceContext)` was restarted for a specific key, allowing duplication checks.


Example:
    function reduce(context) {
        if (context.isRestarted) {
            // Check prior progress
        } else {
            // Proceed with full processing
        }
    }

  • reduceContext.executionNo:

  - Shows the number of attempts for the `reduce` function with the current key, useful for retry logic.


Example:
    function reduce(context) {
        if (context.executionNo === 1) {
            // Process fully
        } else if (context.executionNo === 2) {
            // Handle intermediate progress
        }
    }

  • reduceContext.errors:

  - Logs errors encountered in previous attempts, allowing you to understand and resolve repeated issues.


Example:
    function reduce(context) {
       context.errors.iterator().each((key, error, executionNo) => {
        var errorObject = JSON.parse(error);
        log.error({
            title: 'Reduce error for key ' + key,
            details: errorObject.name + ': ' + errorObject.message
        });
        return true;
      });

    }

  • reduceContext.key:

  - Refers to each key passed from the `mapContext` stage.


Example:
    function reduce(context) {
          context.write({
            key: context.key,
            value: context.values.length
        });
    }

  • reduceContext.values:

  - Holds an array of all values associated with a unique key, generally formatted in lexicographical order.


Example:
    function reduce(context) {
        context.write({
            key: context.key,
            value: context.values.length
        });

    }

  • reduceContext.write(options):

  - Passes key-value pairs to the summarize stage for further processing.


Example:
    function reduce(context) {
        context.write({
            key: context.key,
            value: context.values.length
        });

    }


 4. summaryContext Object: 

Finally, the `summaryContext` object in the `summarize(summaryContext)` function provides performance metrics and error logs for all stages of the MapReduce script.

Properties:

  • summaryContext.isRestarted:

  - Shows if the summarize function is being rerun due to a restart.


Example:
    function summarize(summary) {
        if (summary.isRestarted) {
            log.debug('SUMMARY isRestarted', 'YES');
        } else {
            log.debug('SUMMARY isRestarted', 'NO');
        }
    }

  • summaryContext.concurrency:

  - Indicates the concurrency level used in parallel processing for the script. 


Example:
    function summarize(summary) {
      log.audit('Concurrency Number', summary.concurrency);
    }

  • summaryContext.dateCreated:

  - The timestamp of when the script started.


Example:
    function summarize(summary) {
        log.audit('Creation Date', summary.dateCreated);
    }

  • summaryContext.seconds:

  - Total seconds elapsed during the script's execution.


Example:
    function summarize(summary) {
       log.audit('Total seconds elapsed', summary.seconds);
    }

  • summaryContext.usage:

  - Tracks the total usage units consumed by the script.


Example:
    function summarize(summary) {
       log.audit('Usage Consumed', summary.usage);
    }

  • summaryContext.yields:

  - Shows the number of times the script yielded to other processes.


Example:
    function summarize(summary) {
       log.audit('Number of Yields', summary.yields);
    }

  • summaryContext.output:

  - Provides key-value pairs created in the reduce stage.


Example:
    function summarize(summary) {
      var totalRecordsUpdated = 0;
        summary.output.iterator().each((key, value) => {
            log.audit({
                title: 'Summary Output Iterator',
                details: 'key: ' + key + ' / value: ' + value
            });
            totalRecordsUpdated++;
            return true;
        });
        log.debug('Total records updated', totalRecordsUpdated);

    }
  • inputSummary
    1. dateCreated
    2. seconds
    3. usage
    4. error
  • mapSummary
    1. concurrency
    2. dateCreated
    3. keys
    4. seconds
    5. usage
    6. yields
    7. errors
  • reduceSummary
    1. concurrency
    2. dateCreated
    3. keys
    4. seconds
    5. usage
    6. yields
    7. errors

For additional details on summarize properties not covered here, refer to the NetSuite documentation.

This overview of each context object’s properties and example usage gives you a thorough understanding of how to navigate and utilize the data at each stage of a MapReduce script in NetSuite.

Comments

Post a Comment

Popular posts from this blog

Exploring the LLM Module in SuiteScript 2.1 with a Chatbot Example

Image
  Introduction: As AI continues to transform industries, integrating natural language processing into business applications has become increasingly valuable. NetSuite’s SuiteScript 2.1 now offers the `N/llm` module, enabling developers to harness the power of large language models directly in NetSuite. In this blog, we'll dive into the basics of the `llm` module and walk through a practical example of using it to create a chatbot Suitelet for seamless user interactions.   What is the `N/llm` Module? The `N/llm` module in SuiteScript 2.1 brings AI-driven language generation into NetSuite scripts. This module allows for generating text responses based on user prompts, making it an excellent tool for applications like customer service chatbots, content generation, and automated responses in workflows.   Key Components of the `llm` Module: generateText: The primary method used to create responses. It takes a user prompt and, optionally, the chat history to gene...
Read more

OAuth 2.0 Authentication with SuiteCloud CLI for Node.js(M2M)

Image
  Introduction:   In the ever-evolving world of NetSuite development, ensuring secure authentication for your integrations is crucial. SuiteCloud CLI for Node.js provides developers with robust tools to streamline customizations, and with the introduction of OAuth 2.0 authentication, managing these integrations securely has become easier. In this post, we’ll explore how to set up and use OAuth 2.0 authentication for SuiteCloud CLI, including machine-to-machine (M2M) authentication for CI environments.   Prerequisites: To follow along with this guide, you need the following software installed: - Node.js version 20 LTS   - Oracle JDK version 17 For a full list of prerequisites, refer to the SuiteCloud CLI for Node.js Installation Prerequisites .   Supported Versions: Ensure you are using the latest version of SuiteCloud CLI available in NPM. Here’s a quick reference: | Version in NPM | NetSuite Version | |----------------   ...
Read more

Integrating AngularJS with NetSuite Suitelets for Dynamic Web Pages

When working with NetSuite’s Suitelets, you may find yourself wanting a more dynamic and interactive user experience for your users. By integrating AngularJS with Suitelets, you can achieve exactly that! AngularJS enhances the front-end experience while Suitelets power the backend within NetSuite, creating a highly modular and scalable architecture. In this blog, I'll walk you through how to use AngularJS to create dynamic web pages with Suitelets and load HTML from the NetSuite File Cabinet.   1. Why Combine AngularJS and Suitelets? AngularJS, a popular front-end framework, offers powerful two-way data binding and modular architecture, making it ideal for building responsive and dynamic interfaces. Suitelets, on the other hand, allow you to create custom backend logic that can be exposed as webpages in NetSuite. Combining the two provides: Ø   Separation of concerns: Cleanly separate your front-end from your back-end code. Ø   Reusable UI components: Leverage AngularJS...
Read more