Recursive GlideRecord Avoidance Pattern

intermediateTested on Xanadu

The Recursive GlideRecord Avoidance Pattern transforms recursive database traversals into iterative loops using data structures like stacks or queues. This prevents JavaScript call stack overflow errors that occur when traversing deep hierarchies like organizational structures, category trees, or approval chains with many levels.

Recursive GlideRecord queries become problematic when hierarchies exceed the JavaScript engine's stack limit (typically around 1000 levels in ServiceNow). Each recursive function call consumes stack memory, and deep traversals can crash with 'Maximum call stack size exceeded' errors. This pattern replaces recursive function calls with a manual stack data structure, allowing unlimited traversal depth while maintaining the same logical flow.

The iterative approach processes nodes level-by-level using a stack to track pending work. Instead of calling functions recursively, nodes are pushed onto the stack and processed in a loop until the stack is empty. This transforms O(depth) stack memory usage into O(1) stack usage with O(width) heap memory for the manual stack.

Chrome Extension

Sourdough: ServiceNow Monitoring and Analytics

A Chrome extension for ServiceNow Admins and Developers with essential tools, analytics, graphs and monitoring features.

Instance HealthGraphs & ChartsAPI HealthDeveloper ToolsQuick SearchInstance Switcher

Add to Chrome

Free to install. Pro $5/month after a 14-day no-card trial.
Pro requires the ServiceNow admin role. Upgrade inside the extension.

Overview

Tasks

CMDB

API

Metrics

Monitor

Internals

Instance:sourdoughdev·Version:Yokohama

Instance StateONLINE

System StatusFully Operational

Session Timeout90 minutes

Logged-In Sessions2 (20 active)

Build Nameyokohama-12-18-2024_p1

IP Address10.159.128.43

Instance HealthHealth Score: 90%

🔥 5dSourdough (Chrome Plugin)Dark Mode

Use This When

Use this pattern when traversing hierarchical data structures that could exceed 500-1000 levels deep, such as deeply nested organizational charts, product categories, or approval workflows. It's essential when working with user-generated hierarchies where depth cannot be controlled or predicted.

Avoid When

Avoid this pattern for shallow hierarchies under 100 levels where recursive code is simpler and more readable. Don't use it when the hierarchy structure is guaranteed to be flat or when performance isn't critical and code maintainability is more important than preventing theoretical stack overflows.

Implementation

Server-side

// Script Include: HierarchyTraversal
var HierarchyTraversal = Class.create();
HierarchyTraversal.prototype = {
    initialize: function() {
    },

    // Iterative traversal using stack - avoids recursion
    getDescendantsIterative: function(tableName, parentField, startingId) {
        var descendants = [];
        var stack = []; // Manual stack replaces call stack
        
        // Initialize stack with starting node
        stack.push(startingId);
        
        while (stack.length > 0) {
            // Pop next item to process - LIFO order
            var currentId = stack.pop();
            
            // Query for direct children of current node
            var gr = new GlideRecord(tableName);
            gr.addQuery(parentField, currentId);
            gr.query();
            
            while (gr.next()) {
                var childId = gr.getValue('sys_id');
                descendants.push({
                    sys_id: childId,
                    name: gr.getValue('name') || gr.getDisplayValue(),
                    parent: currentId
                });
                
                // Push child onto stack for processing its children
                stack.push(childId);
            }
        }
        
        return descendants;
    },

    // Breadth-first traversal using queue for level-order processing
    getDescendantsByLevel: function(tableName, parentField, startingId) {
        var descendants = [];
        var queue = []; // FIFO queue for breadth-first
        var level = 0;
        
        queue.push({id: startingId, level: level});
        
        while (queue.length > 0) {
            // Shift removes from front - FIFO order
            var current = queue.shift();
            
            var gr = new GlideRecord(tableName);
            gr.addQuery(parentField, current.id);
            gr.query();
            
            while (gr.next()) {
                var childData = {
                    sys_id: gr.getValue('sys_id'),
                    name: gr.getValue('name') || gr.getDisplayValue(),
                    parent: current.id,
                    level: current.level + 1
                };
                
                descendants.push(childData);
                
                // Add to queue with incremented level
                queue.push({id: childData.sys_id, level: current.level + 1});
            }
        }
        
        return descendants;
    },

    // Example: Get all descendants of a company in org chart
    getAllCompanyEmployees: function(companyId) {
        return this.getDescendantsIterative('sys_user', 'manager', companyId);
    },

    type: 'HierarchyTraversal'
};

The code replaces recursive function calls with manual stack management using JavaScript arrays. The stack.push() and stack.pop() operations simulate the call stack behavior while keeping memory usage in the heap instead of the call stack. The breadth-first variant uses shift() instead of pop() to process nodes level-by-level, which can be useful for limiting traversal depth or processing by hierarchy levels.

Alternatives

Recursive with depth limiting

Keeps code simple and readable while preventing infinite loops by adding a maximum depth parameter. Use when hierarchies are reasonably shallow and you want cleaner code, but accept that very deep structures will be truncated.

Database-level hierarchical queries

Uses database features like WITH RECURSIVE (if available) or hierarchical query operators to traverse in SQL. More efficient for large datasets but less portable and harder to add custom processing logic during traversal.

Batch processing with scheduled jobs

Breaks large hierarchy traversals into smaller chunks processed by scheduled jobs. Ideal for massive hierarchies that would timeout in a single request, but adds complexity and latency to get complete results.

Test Your Knowledge

Quick 3-question quiz — see how your ServiceNow skills stack up.

Question 1 of 3Performance

A list view on a table with millions of records is slow. Best fix?

Select an answer to continue