ServiceNow GlideRecord CRUD Operations

// SQL equivalent (NOT used in ServiceNow)
SELECT * FROM incident WHERE priority = 1 AND state = 2

// GlideRecord equivalent
var gr = new GlideRecord('incident');
gr.addQuery('priority', 1);
gr.addQuery('state', 2);
gr.query();
while (gr.next()) {
    gs.info('Incident: ' + gr.number);
}

// Create a new incident
var gr = new GlideRecord('incident');
gr.initialize();  // Initialize a new record
gr.short_description = 'Network connectivity issue';
gr.description = 'Users unable to access internal applications';
gr.priority = 2;
gr.category = 'Network';
gr.caller_id = gs.getUserID();  // Current user

var sys_id = gr.insert();  // Returns the sys_id of the new record

if (sys_id) {
    gs.info('Created incident: ' + gr.number);
} else {
    gs.error('Failed to create incident');
}

// Get a single record by sys_id
var gr = new GlideRecord('incident');
if (gr.get('a1b2c3d4e5f6g7h8i9j0')) {  // Pass sys_id directly
    gs.info('Found: ' + gr.short_description);
}

// Get a single record by field value
var gr2 = new GlideRecord('incident');
if (gr2.get('number', 'INC0001234')) {  // field, value
    gs.info('Priority: ' + gr2.priority);
}

// Query multiple records
var gr3 = new GlideRecord('incident');
gr3.addQuery('state', 1);  // New incidents
gr3.addQuery('priority', '<=', 2);  // Priority 1 or 2
gr3.query();

while (gr3.next()) {
    gs.info(gr3.number + ': ' + gr3.short_description);
}

// Update a single record
var gr = new GlideRecord('incident');
if (gr.get('number', 'INC0001234')) {
    gr.state = 2;  // In Progress
    gr.assigned_to = 'john.doe';
    gr.work_notes = 'Assigned to network team';
    gr.update();
    gs.info('Updated: ' + gr.number);
}

// Update multiple records (use with caution!)
var gr2 = new GlideRecord('incident');
gr2.addQuery('state', 1);
gr2.addQuery('assignment_group', 'empty');
gr2.query();

while (gr2.next()) {
    gr2.assignment_group = 'default_group_sys_id';
    gr2.update();
}

// updateMultiple - bypasses Business Rules!
var gr = new GlideRecord('incident');
gr.addQuery('state', 6);  // Resolved
gr.addQuery('resolved_at', '<', gs.daysAgoStart(30));  // 30+ days ago
gr.setValue('state', 7);  // Closed
gr.updateMultiple();  // Updates all matching records at once

// Delete a single record
var gr = new GlideRecord('u_test_table');
if (gr.get('sys_id_here')) {
    gr.deleteRecord();
    gs.info('Record deleted');
}

// Delete multiple records (use with EXTREME caution!)
var gr2 = new GlideRecord('u_temp_data');
gr2.addQuery('created', '<', gs.daysAgoStart(90));  // Older than 90 days
gr2.deleteMultiple();  // Deletes ALL matching records!

// Simple equality (field equals value)
gr.addQuery('priority', 1);  // WHERE priority = 1

// With operator
gr.addQuery('priority', '<=', 2);  // WHERE priority <= 2
gr.addQuery('short_description', 'CONTAINS', 'network');  // LIKE '%network%'
gr.addQuery('caller_id', '!=', 'abc123');  // WHERE caller_id != 'abc123'

// NULL checks
gr.addNullQuery('assigned_to');  // WHERE assigned_to IS NULL
gr.addNotNullQuery('resolved_at');  // WHERE resolved_at IS NOT NULL

// Date queries
gr.addQuery('opened_at', '>', gs.daysAgo(7));  // Last 7 days
gr.addQuery('opened_at', 'ON', gs.now());  // Today

// Instead of this (inefficient - two queries)
var userGr = new GlideRecord('sys_user');
userGr.addQuery('name', 'John Doe');
userGr.query();
if (userGr.next()) {
    var incGr = new GlideRecord('incident');
    incGr.addQuery('caller_id', userGr.sys_id);
    incGr.query();
    // ...
}

// Do this (efficient - single query with dot-walk)
var gr = new GlideRecord('incident');
gr.addQuery('caller_id.name', 'John Doe');  // Dot-walk to user's name
gr.query();
while (gr.next()) {
    gs.info(gr.number);
}

// Sort by single field
var gr = new GlideRecord('incident');
gr.orderBy('opened_at');  // Ascending (oldest first)
gr.query();

// Sort descending
var gr2 = new GlideRecord('incident');
gr2.orderByDesc('opened_at');  // Descending (newest first)
gr2.query();

// Multiple sort fields
var gr3 = new GlideRecord('incident');
gr3.orderBy('priority');  // Primary sort
gr3.orderByDesc('opened_at');  // Secondary sort
gr3.query();

// Simple encoded query
var gr = new GlideRecord('incident');
gr.addEncodedQuery('priority=1^state=2');
gr.query();
while (gr.next()) {
    gs.info(gr.number);
}

// Complex encoded query with OR conditions
var gr2 = new GlideRecord('incident');
gr2.addEncodedQuery('priority=1^ORpriority=2^caller_id=abc123^category=inquiry');
gr2.query();

// With ordering
var gr3 = new GlideRecord('incident');
gr3.addEncodedQuery('active=true^priority<=2^ORDERBYDESCopened_at');
gr3.query();

// Query: Active, P1 or P2 incidents, opened in last 7 days,
// assigned to Network team, sorted by priority then opened date
var gr = new GlideRecord('incident');
gr.addEncodedQuery('active=true^priorityIN1,2^opened_at>=javascript:gs.daysAgo(7)^assignment_group.name=Network^ORDERBYpriority^ORDERBYDESCopened_at');
gr.query();

// Dynamic date calculation
var gr = new GlideRecord('incident');
gr.addEncodedQuery('opened_at>=javascript:gs.daysAgo(7)');  // Last 7 days
gr.query();

// Current user
var gr2 = new GlideRecord('incident');
gr2.addEncodedQuery('assigned_to=javascript:gs.getUserID()');
gr2.query();

// Beginning of current month
var gr3 = new GlideRecord('incident');
gr3.addEncodedQuery('opened_at>=javascript:gs.beginningOfThisMonth()');

// Find incidents with priority 1 OR priority 2
var gr = new GlideRecord('incident');
var qc = gr.addQuery('priority', 1);
qc.addOrCondition('priority', 2);
gr.query();

// This generates: WHERE priority = 1 OR priority = 2

while (gr.next()) {
    gs.info(gr.number + ' - Priority: ' + gr.priority);
}

// Goal: (priority = 1 OR priority = 2) AND state = 1 AND active = true

var gr = new GlideRecord('incident');
var qc = gr.addQuery('priority', 1);
qc.addOrCondition('priority', 2);  // OR for priority
gr.addQuery('state', 1);  // AND
gr.addQuery('active', true);  // AND
gr.query();

// Resulting SQL: WHERE (priority = 1 OR priority = 2) AND state = 1 AND active = true

// Goal: Find all active users named 'Ben' or 'Simon',
// OR all inactive users named 'Emma' or 'Brenda'

var gr = new GlideRecord('sys_user');
gr.addEncodedQuery('active=true^first_name=Ben^ORfirst_name=Simon^NQactive=false^first_name=Emma^ORfirst_name=Brenda');
gr.query();

// Logic: (active=true AND (first_name=Ben OR first_name=Simon))
//        OR (active=false AND (first_name=Emma OR first_name=Brenda))

// Instead of multiple ORs
var gr = new GlideRecord('incident');
var qc = gr.addQuery('state', 1);
qc.addOrCondition('state', 2);
qc.addOrCondition('state', 3);

// Use IN operator (cleaner)
var gr2 = new GlideRecord('incident');
gr2.addQuery('state', 'IN', '1,2,3');
gr2.query();

// Or with encoded query
var gr3 = new GlideRecord('incident');
gr3.addEncodedQuery('stateIN1,2,3');
gr3.query();

// Without setLimit - retrieves ALL matching records into memory
var gr = new GlideRecord('incident');
gr.addQuery('active', true);
gr.query();  // Could return millions of records!

// With setLimit - much faster, only retrieves 10 records
var gr2 = new GlideRecord('incident');
gr2.addQuery('active', true);
gr2.setLimit(10);
gr2.query();  // Returns maximum 10 records

// Common indexed fields (check your specific table)
// - sys_id (always indexed)
// - number (on task tables)
// - sys_created_on
// - sys_updated_on
// - active

// Good: Filtering on indexed field
var gr = new GlideRecord('incident');
gr.addQuery('number', 'INC0001234');  // number is indexed
gr.query();

// Bad: Filtering on non-indexed field without other constraints
var gr2 = new GlideRecord('incident');
gr2.addQuery('u_custom_field', 'some_value');  // Custom field may not be indexed
gr2.query();  // Could be slow on large tables

// BAD: Counting with loop (slow, memory-intensive)
var count = 0;
var gr = new GlideRecord('incident');
gr.addQuery('priority', 1);
gr.query();
while (gr.next()) {
    count++;
}
gs.info('Count: ' + count);

// GOOD: Counting with GlideAggregate (fast, efficient)
var ga = new GlideAggregate('incident');
ga.addQuery('priority', 1);
ga.addAggregate('COUNT');
ga.query();
if (ga.next()) {
    var count = ga.getAggregate('COUNT');
    gs.info('Count: ' + count);
}

// Get records 51-100 (for page 2 with 50 per page)
var gr = new GlideRecord('incident');
gr.addQuery('active', true);
gr.orderByDesc('opened_at');
gr.chooseWindow(50, 100);  // (start, end) - 0-indexed
gr.query();

while (gr.next()) {
    gs.info(gr.number);
}

// Note: For large offsets, performance degrades
// Avoid chooseWindow(10000, 10050) - will be slow

// BUG: Using gr.sys_id in a loop
var sysIds = [];
var gr = new GlideRecord('incident');
gr.addQuery('priority', 1);
gr.query();
while (gr.next()) {
    sysIds.push(gr.sys_id);  // WRONG! Pointer, not value
}
// Result: Array contains the SAME sys_id repeated (last record's ID)

// FIX: Use getValue() to get a snapshot
var sysIds = [];
var gr = new GlideRecord('incident');
gr.addQuery('priority', 1);
gr.query();
while (gr.next()) {
    sysIds.push(gr.getValue('sys_id'));  // CORRECT! Value snapshot
}
// Result: Array contains unique sys_ids

// BUG: Missing query() call
var gr = new GlideRecord('incident');
gr.addQuery('priority', 1);
// gr.query();  // MISSING!
while (gr.next()) {  // Never executes - no results
    gs.info(gr.number);
}

// FIX: Always call query() before next()
var gr = new GlideRecord('incident');
gr.addQuery('priority', 1);
gr.query();  // Execute the query
while (gr.next()) {
    gs.info(gr.number);
}

// BUG: No existence check before update
var gr = new GlideRecord('incident');
gr.get('non_existent_sys_id');  // Returns false, but creates new object
gr.short_description = 'Updated description';
gr.update();  // INSERTS a new record with that sys_id!

// FIX: Always check the return value
var gr = new GlideRecord('incident');
if (gr.get('possibly_non_existent_sys_id')) {  // Returns true if found
    gr.short_description = 'Updated description';
    gr.update();
} else {
    gs.warn('Record not found');
}

// BUG: Typo in field name
var gr = new GlideRecord('incident');
gr.addQuery('prioritty', 1);  // Typo: 'prioritty' instead of 'priority'
gr.query();
// Query runs without error but returns ALL records (no WHERE clause)

// FIX: Validate table and field names
var gr = new GlideRecord('incident');
if (gr.isValidField('priority')) {
    gr.addQuery('priority', 1);
    gr.query();
} else {
    gs.error('Invalid field name');
}

// Script Include in custom scope 'x_myapp'
// May not have access to global tables

var gr = new GlideRecord('sys_user');  // Global table
gr.addQuery('user_name', 'admin');
gr.query();
if (gr.next()) {
    gs.info('Found: ' + gr.name);  // May return empty results
}

// Solution: Check scope access settings in Application Registry
// Or use GlideRecordSecure for tables with cross-scope access enabled

// BAD: Generic variable names
var gr = new GlideRecord('incident');
var gr2 = new GlideRecord('sys_user');
var gr3 = new GlideRecord('cmdb_ci');

// GOOD: Descriptive variable names with table hints
var grIncident = new GlideRecord('incident');
var grUser = new GlideRecord('sys_user');
var grCI = new GlideRecord('cmdb_ci');

// ALTERNATIVE: Prefix with table abbreviation
var gr_INC = new GlideRecord('incident');
var gr_USER = new GlideRecord('sys_user');

// When comparing or storing reference values
var incidentData = {
    number: gr.getValue('number'),
    caller: gr.getValue('caller_id'),
    assignedTo: gr.getValue('assigned_to'),
    sysId: gr.getValue('sys_id')
};

// When getting display values from references
var callerName = gr.getDisplayValue('caller_id');  // Returns user's name
var groupName = gr.getDisplayValue('assignment_group');

// Robust error handling pattern
function updateIncident(sysId, newState) {
    var gr = new GlideRecord('incident');

    if (!gr.get(sysId)) {
        gs.error('Incident not found: ' + sysId);
        return { success: false, error: 'Record not found' };
    }

    gr.state = newState;

    if (gr.update()) {
        gs.info('Updated incident: ' + gr.number);
        return { success: true, number: gr.getValue('number') };
    } else {
        var errorMsg = gr.getLastErrorMessage();
        gs.error('Failed to update: ' + errorMsg);
        return { success: false, error: errorMsg };
    }
}

// Query: Active P1/P2 incidents, opened in last 7 days,
//        assigned to Network team, excluding resolved/closed,
//        sorted by priority (asc) then opened date (desc)
var QUERY = 'active=true' +
    '^priorityIN1,2' +
    '^opened_at>=javascript:gs.daysAgo(7)' +
    '^assignment_group.name=Network' +
    '^stateNOT IN6,7,8' +
    '^ORDERBYpriority' +
    '^ORDERBYDESCopened_at';

var gr = new GlideRecord('incident');
gr.addEncodedQuery(QUERY);
gr.query();

// During development/testing, limit results to avoid long waits
var gr = new GlideRecord('incident');
gr.addQuery('active', true);
gr.setLimit(5);  // Remove or increase in production
gr.query();

while (gr.next()) {
    gs.info(gr.number + ': ' + gr.short_description);
}

// CLIENT SIDE - Use GlideAjax
var ga = new GlideAjax('MyScriptInclude');
ga.addParam('sysparm_name', 'getIncidentDetails');
ga.addParam('sysparm_incident_id', 'abc123');
ga.getXML(function(response) {
    var answer = response.responseXML.documentElement.getAttribute('answer');
    console.log('Result: ' + answer);
});

// SERVER SIDE (Script Include) - Use GlideRecord
var MyScriptInclude = Class.create();
MyScriptInclude.prototype = Object.extendsObject(AbstractAjaxProcessor, {
    getIncidentDetails: function() {
        var incId = this.getParameter('sysparm_incident_id');
        var gr = new GlideRecord('incident');
        if (gr.get(incId)) {
            return gr.getValue('short_description');
        }
        return '';
    },
    type: 'MyScriptInclude'
});

// GlideRecordSecure - Automatically enforces ACLs
var grs = new GlideRecordSecure('incident');
grs.addQuery('active', true);
grs.query();

while (grs.next()) {
    // Only returns records the current user can read
    // Fields user can't access return NULL
    gs.info(grs.number + ': ' + grs.short_description);
}

// No need for manual canRead() checks!

// GlideRecord with manual ACL checks
var gr = new GlideRecord('incident');
gr.addQuery('active', true);
gr.query();

while (gr.next()) {
    // CRITICAL: Check if user can read this record
    if (!gr.canRead()) {
        continue;  // Skip records user can't access
    }

    // Check field-level access before displaying
    if (gr.canRead('caller_id')) {
        gs.info('Caller: ' + gr.getDisplayValue('caller_id'));
    }

    gs.info(gr.number);
}

// Check record-level permissions
gr.canRead()      // Can current user read this record?
gr.canWrite()     // Can current user update this record?
gr.canDelete()    // Can current user delete this record?
gr.canCreate()    // Can current user create records in this table?

// Check field-level permissions
gr.canRead('field_name')   // Can user read this field?
gr.canWrite('field_name')  // Can user write to this field?

// Check user roles
gs.hasRole('admin')              // Does user have admin role?
gs.hasRole('itil')               // Does user have ITIL role?
gs.getUser().isMemberOf('group_sys_id')  // Is user in group?

// Example: Role-based query restriction
var gr = new GlideRecord('incident');
if (!gs.hasRole('admin')) {
    // Non-admins only see their own incidents
    gr.addQuery('caller_id', gs.getUserID());
}
gr.query();

// Bypass Business Rules (not security, but related)
gr.setWorkflow(false);  // Disables Business Rules
gr.autoSysFields(false);  // Disables sys_updated_on, sys_updated_by updates

// Run as system (bypasses ACLs in certain contexts)
// Only works in specific contexts like Scheduled Jobs
var gr = new GlideRecord('sys_user');
gr.addQuery('user_name', 'admin');
gr.query();  // In Scheduled Job context, runs with elevated privileges

// setAbortAction() - Cancel current Business Rule action
// Does NOT bypass security, but controls workflow
current.setAbortAction(true);

// Scoped apps have restricted table access by default
// Check Application Registry > Tables for cross-scope access

// To access global tables from a scoped app:
// 1. Table must have "Accessible from" set to "All application scopes"
// 2. OR create an Application Cross-Scope Access record

// Example: Checking scope access programmatically
var scopeCheck = new GlideRecord('sys_scope_privilege');
scopeCheck.addQuery('source_scope', gs.getCurrentScopeSysId());
scopeCheck.addQuery('target_scope', 'global');
scopeCheck.query();
if (scopeCheck.next()) {
    gs.info('Cross-scope access configured');
}