GlideRecord.getTableName() — ServiceNow API

getTableName()→ string

beginnerTested on Xanadu

What It Does

The getTableName() method returns the string table name that was passed to the GlideRecord constructor when the object was created. This is a simple getter that accesses the internal table reference stored in the GlideRecord instance.

ServiceNow stores the table name as an immutable property when you instantiate the GlideRecord. The method performs no database queries or table validation—it simply returns the string that was originally provided, whether that table exists or not.

The method always returns a string, never null or undefined. Even if you instantiate a GlideRecord with an invalid table name, getTableName() will faithfully return whatever string you provided.

⚠️

For task-extended tables (incident, change_request, sc_req_item), getTableName() returns the table you queried against, not where individual records actually reside. An incident query returns 'incident', even though records might live in tables like incident or problem.

This method differs from getRecordClassName() which returns the actual table where a specific record resides. Both methods serve different purposes: getTableName() tells you what you queried, getRecordClassName() tells you what you found.

When to Use This

Use getTableName() when you need to know which table a GlideRecord object is configured to query against. This is essential for debugging, logging, and generic functions that work with multiple table types. Common scenarios include building dynamic queries, constructing URLs, or validating that you're working with the expected table type.

Do not use this method when you need to determine the actual table where a record is stored—use getRecordClassName() instead. Avoid using getTableName() for record-specific operations on task-extended tables where you need to route logic based on the actual record type.

A common misuse is calling this method unnecessarily in loops or repeated operations. Since the table name never changes for a GlideRecord instance, cache the result in a variable if you need it multiple times within the same scope.

Return Value

Returns a string containing the exact table name used in the GlideRecord constructor. The string is returned as-is with no validation, normalization, or case conversion. If you created the GlideRecord with 'INCIDENT', it returns 'INCIDENT', not 'incident'.

The method cannot fail or return null. Even with invalid table names, empty strings, or malformed input, it returns whatever string was provided to the constructor. You can safely use the return value in string operations without null checks, though you should validate that the table actually exists if that matters for your use case.

Free Newsletter

Enjoying this? Get one deep-dive per week.

Join 1,000+ ServiceNow pros — scripts, GlideRecord patterns, Flow Designer techniques, and career moves. Free.

Platform Behavior & Side Effects

No database queries are executed—this is a pure getter method accessing cached metadata
No Business Rules, ACLs, or other platform mechanisms are triggered
Performance is instantaneous—the table name is stored as a simple string property
No audit trail or logging occurs when this method is called
Behavior is identical across all server-side contexts (Business Rules, Script Includes, Scheduled Jobs)
Safe to call on empty GlideRecord instances before any queries are executed
Return value remains consistent throughout the GlideRecord object's lifecycle

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

Code Examples

Basic usage — identifying table in generic functionsbasic

// Generic function that needs to know which table it's working with
function processRecord(gr) {
    var tableName = gr.getTableName();
    gs.info('Processing record from table: ' + tableName);
    
    // Route logic based on table type
    if (tableName == 'incident') {
        // Incident-specific processing
        gr.impact = 2;
    } else if (tableName == 'sc_req_item') {
        // Request item-specific processing
        gr.stage = 'fulfillment';
    }
    
    gr.update();
}

// Usage with different tables
var inc = new GlideRecord('incident');
processRecord(inc); // Logs: Processing record from table: incident

This example shows how to use `getTableName()` in generic functions that need to behave differently based on the table type. The method helps route logic without hardcoding table assumptions.

Intermediate — debugging and URL constructionintermediate

// Building dynamic navigation URLs based on table
function buildRecordURL(gr, sysId) {
    var tableName = gr.getTableName();
    var baseURL = gs.getProperty('glide.servlet.uri');
    
    // Construct the URL using the queried table name
    var recordURL = baseURL + tableName + '.do?sys_id=' + sysId;
    
    gs.info('Table: ' + tableName + ', URL: ' + recordURL);
    return recordURL;
}

// Cache table name to avoid repeated calls in loops
var taskGR = new GlideRecord('sc_task');
var cachedTableName = taskGR.getTableName(); // Cache the result

while (taskGR.next()) {
    // Use cached value instead of calling getTableName() repeatedly
    gs.info('Processing ' + cachedTableName + ' record: ' + taskGR.number);
}

This demonstrates caching the table name for performance in loops and using it for dynamic URL construction. The table name from the query is used, not where individual records might actually reside.

Advanced — understanding getTableName vs getRecordClassNameadvanced

// Query the task table to see all task-extended records
var taskGR = new GlideRecord('task');
taskGR.addQuery('active', true);
taskGR.query();

while (taskGR.next()) {
    var queryTable = taskGR.getTableName();      // Always returns 'task'
    var actualTable = taskGR.getRecordClassName(); // Returns actual record type
    
    gs.info('Query table: ' + queryTable);
    gs.info('Actual record table: ' + actualTable);
    gs.info('Record number: ' + taskGR.getValue('number'));
    gs.info('---');
}

// Output might be:
// Query table: task, Actual record table: incident
// Query table: task, Actual record table: change_request  
// Query table: task, Actual record table: sc_req_item
// All show queryTable as 'task' but actualTable varies

This example highlights the critical difference between the two methods. `getTableName()` returns what you queried against, while `getRecordClassName()` tells you where each record actually lives in the inheritance hierarchy.

Gotchas

The method returns the exact string from the constructor, including any case variations or typos—no validation occurs.

For task-extended tables, `getTableName()` returns the queried table (like 'task'), not the actual record table (like 'incident').

The table name never changes during a GlideRecord's lifecycle, even if you modify queries or filters.

Calling this method on GlideRecord instances with invalid table names still returns the invalid name string.

The return value includes no indication of whether the table actually exists or is accessible to the current user.

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