GlideSystem.tableExists() — ServiceNow API

gs.tableExists(name)→ boolean

intermediateTested on Xanadu

What It Does

The tableExists() method queries the sys_db_object table to determine if a specified table exists in the current instance. This is a direct database dictionary lookup that checks whether the table name is registered in ServiceNow's metadata.

Internally, ServiceNow performs a query equivalent to new GlideRecord('sys_db_object').get('name', tableName). The method leverages ServiceNow's table dictionary cache, making it relatively fast for repeated calls within the same transaction.

The method returns true for any table that has a dictionary entry, including base tables, extended tables, and tables from scoped applications. It returns false for non-existent tables, misspelled table names, or tables that have been deleted but may still be referenced in code.

The method respects table-level ACLs and will return false if the current user lacks read access to the table, even if the table physically exists. This security feature prevents information disclosure about restricted tables but can create unexpected behavior in system-level scripts.

Related methods include gs.getProperty() for checking if plugins are active, and GlideTableHierarchy.getAllExtensions() for discovering table inheritance relationships. Unlike those methods, tableExists() provides a simple boolean answer about table existence.

When to Use This

Use tableExists() when building dynamic queries or reports that might reference tables from optional plugins like ITOM, SecOps, or HRSD. Script Includes that work across multiple instances should check table existence before attempting operations. This prevents runtime errors when code runs on instances without required plugins activated.

Avoid using this method for standard platform tables like incident, sys_user, or task that exist in all ServiceNow instances. For plugin detection, use gs.getProperty('glide.plugin_name.active') instead of checking individual plugin tables. Common misuse includes checking table existence in tight loops where caching the result would be more efficient.

Never use this method as a substitute for proper error handling around GlideRecord operations. A table might exist but be inaccessible due to ACLs, or become unavailable between the check and the actual query. Always combine existence checks with try-catch blocks for robust error handling.

Return Value

Returns a JavaScript boolean value: true if the table exists and is accessible to the current user, false otherwise. The method never returns null or undefined, making it safe to use directly in conditional statements without additional null checks.

The return value is immediately usable in boolean contexts. When the method returns false, it could indicate either a non-existent table or an access control restriction. The method provides no mechanism to distinguish between these scenarios, so additional logging or error handling may be necessary for debugging purposes.

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 Business Rules, ACLs, or notifications fire during the table existence check
Nothing is written to the database; this is a read-only metadata operation
Performance is generally fast due to dictionary caching, but first calls may be slower
Respects table-level ACLs, potentially returning false for tables that exist but are restricted
Works identically in Business Rules, Script Includes, and Scheduled Jobs
Does not trigger any audit logging or session tracking
Results may be cached within the same transaction but not across different requests

Parameters

Name	Type	Required	Description
name	string	Yes	The table name to check for existence. Can be a standard table like 'incident' or an extended table like 'u_custom_table'. Case-sensitive and must match the exact table name in the dictionary.

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 plugin table validationbasic

// Check if ITOM Discovery table exists before querying
if (gs.tableExists('cmdb_ci_server')) {
    var server = new GlideRecord('cmdb_ci_server');
    server.addQuery('install_status', 1);
    server.query();
    
    gs.info('Found ' + server.getRowCount() + ' active servers');
} else {
    gs.warn('ITOM Discovery plugin not available - skipping server check');
}

// Safe approach for optional functionality
function processServers() {
    // Graceful degradation when plugin tables unavailable
    return gs.tableExists('cmdb_ci_server');
}

This pattern prevents runtime errors when accessing plugin-specific tables that may not exist in all instances. Always provide fallback behavior when the table doesn't exist.

Dynamic table selection with cachingintermediate

var TableChecker = Class.create();
TableChecker.prototype = {
    initialize: function() {
        this.tableCache = {};
    },
    
    safeTableExists: function(tableName) {
        // Cache results to avoid repeated dictionary lookups
        if (this.tableCache[tableName] === undefined) {
            this.tableCache[tableName] = gs.tableExists(tableName);
        }
        return this.tableCache[tableName];
    },
    
    getPreferredTaskTable: function() {
        var tables = ['sc_req_item', 'sc_request', 'incident', 'task'];
        for (var i = 0; i < tables.length; i++) {
            if (this.safeTableExists(tables[i])) {
                return tables[i];
            }
        }
        return 'task'; // Fallback to base table
    }
};

Caching table existence results improves performance when checking multiple tables repeatedly. This pattern is useful for dynamic table selection based on available plugins.

The classic mistake - timing and securityadvanced

// WRONG: Race condition between check and use
if (gs.tableExists('u_sensitive_data')) {
    // Table could become inaccessible here due to ACL changes
    var gr = new GlideRecord('u_sensitive_data');
    gr.query(); // Might fail even though table exists
}

// BETTER: Combine existence check with error handling
function safeTableOperation(tableName, callback) {
    if (!gs.tableExists(tableName)) {
        gs.warn('Table ' + tableName + ' not available');
        return false;
    }
    
    try {
        var gr = new GlideRecord(tableName);
        return callback(gr);
    } catch (e) {
        gs.error('Failed to access ' + tableName + ': ' + e.message);
        return false;
    }
}

Table existence doesn't guarantee accessibility due to ACLs or timing issues. Always combine existence checks with proper error handling for robust code.

Gotchas

The method returns false if the table exists but the current user lacks read access due to ACLs, making it impossible to distinguish between non-existent and restricted tables.

Table names are case-sensitive - 'Incident' will return false while 'incident' returns true, even though ServiceNow generally treats table names as case-insensitive.

Extended tables like 'u_custom_incident' require the full table name, not just the base table name, and the method won't automatically check inheritance relationships.

Results may be cached within a single transaction but not across requests, so table availability changes during instance updates might not be immediately reflected.

The method works on system tables like 'sys_user' and 'sys_db_object' but may return false for some internal platform tables that exist but are restricted from script access.

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