sys_import_set Table — ServiceNow Reference

Table Reference/sys_import_set

The sys_import_set table tracks import operations from external systems into ServiceNow. Part of the Integration module, it creates a record for each import session while actual imported data goes into dynamically generated import set tables. Critical for monitoring data loads and debugging failed imports.

What This Table Is

The sys_import_set table serves as the control record for data import operations. When you import data through scheduled imports, web services, or file uploads, ServiceNow creates one record here to track that import session. The actual imported data lands in dynamically created tables named with the pattern u_import_set_[sys_id] where the sys_id comes from this table.

This table belongs to the Integration module and supports the entire import-transform-load process. It doesn't extend any other table and serves as the parent for tracking import set rows through the sys_import_set_row table. Each import set row references back to its parent import set, creating the hierarchy needed to track individual record processing within larger data loads.

Import sets follow a strict lifecycle: Loading while data arrives, Loaded when complete, then Processing during transformation, and finally Processed when transform maps have run. Understanding this state progression is essential because you can't transform data from a set that's still in Loading state.

In large enterprises, this table grows rapidly—major integrations can create thousands of import sets daily. The platform automatically cleans up old import sets based on retention policies, but the constant creation and deletion means frequent table maintenance. Performance degrades when querying across date ranges without proper indexing on sys_created_on or state.

When You'll Script Against This Table

You'll primarily script against sys_import_set in Scheduled Jobs for automated import processing, Transform Scripts to modify data during processing, and Business Rules that fire on import set state changes. Import Set Business Rules commonly trigger on after insert and after update to send notifications when imports complete or fail.

Access requires the import_set_loader role for basic operations, while import_admin provides full control over import sets and transform maps. REST API access follows standard table ACLs but requires explicit permission for automated external systems posting data.

Common scripting patterns:

Query for failed imports to trigger retry logic or administrator alerts
Monitor import set state changes to orchestrate downstream processing
Archive completed import sets by copying data to long-term storage tables
Generate import statistics and success metrics for integration dashboards
Clean up orphaned import set tables when their control records are deleted
Programmatically trigger transform map execution on completed import sets
Validate import set data before processing by checking row counts and field patterns

Table Gotchas

⚠️

The table_name field contains the actual import set table name but without the u_ prefix. When querying the dynamically created table, you must prepend u_ to the stored value.

⚠️

Import sets in 'Loading' state cannot be transformed even if they contain data. Always check state equals 'loaded' before triggering transform maps programmatically.

The run_time field stores duration in milliseconds but displays in human-readable format. Scripts must parse the raw integer value for calculations.
Deleting an import set record doesn't automatically drop its associated table. This creates orphaned tables that consume database space until manually cleaned.
The row_count field updates asynchronously during loading. Don't rely on it for real-time monitoring—query the actual import set table instead.

⚠️

Large import sets (>10,000 rows) can cause transform timeouts. The platform may need batch processing or background scheduling for transforms on oversized imports.

Business Rules on this table fire during system import operations. Poorly written rules can cascade and impact all data loading performance across the instance.

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.

The sys_import_set_row table tracks individual record processing within each import set. Every row in the dynamically created import table gets a corresponding entry in sys_import_set_row that references back via the import_set field. This relationship enables tracking transform success and failure at the individual record level.

Transform maps (sys_transform_map) and data sources (sys_data_source) connect to import sets through the source configuration. The sys_transform_history table logs each transform execution, linking import sets to their processing results. Import set audit logs in sys_audit capture state changes and provide compliance trails for data loading operations.

Scheduled imports create relationships with sys_trigger records that store execution schedules and next run times. When troubleshooting import failures, you often need to cross-reference between import sets, their data sources, transform maps, and the target tables where processed data ultimately lands.

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

Key Fields

Column	Type	Label	Notes
state	choice	State	Current processing state: loading, loaded, processing, processed, or cancelled. Transforms can only run when state equals 'loaded'.
table_name	string	Table name	Name of the dynamically created import table without the u_ prefix. Must prepend u_ when querying the actual import data table.
name	string	Name	Display name for the import set. Defaults to the data source name but can be customized for manual imports.
data_source	reference	Data Source	References sys_data_source that defines the import configuration. Null for one-time manual imports via UI or web service.
row_count	integer	Row count	Number of records imported. Updates asynchronously during loading—don't rely on it for real-time counts.
run_time	integer	Run time	Import duration in milliseconds. Displays in human-readable format but stores as integer for calculations.
started_on	glide_date_time	Started on	Timestamp when import began loading data. Critical for performance monitoring and timeout troubleshooting.
completed_on	glide_date_time	Completed on	Timestamp when import reached final state. Used to calculate total processing time including transforms.
source_table	string	Source table	Name of the target table where transformed data will be inserted or updated. Empty for staging-only imports.
total_rows_processed	integer	Total rows processed	Count of rows that completed transform processing. May differ from row_count if transforms skip or reject records.
total_rows_ignored	integer	Total rows ignored	Count of rows skipped during transform due to conditions or errors. Essential for data quality monitoring.
total_rows_inserted	integer	Total rows inserted	Count of new records created in target table. Combined with updated count shows total impact.
total_rows_updated	integer	Total rows updated	Count of existing records modified in target table. Zero for insert-only transforms.
schedule_id	reference	Schedule	References sys_trigger for scheduled imports. Null for manual imports or one-time loads.
description	string	Description	Optional description of the import purpose. Helpful for distinguishing similar data sources in monitoring.
active	boolean	Active	Whether the import set is available for processing. Inactive sets cannot be transformed or queried normally.
delete_after_processing	boolean	Delete after processing	When true, import set and its table are automatically cleaned up after successful transform completion.

Common Queries

Get all import sets that are ready for transformation

// Query for loaded import sets that haven't been processed
var gr = new GlideRecord('sys_import_set');
gr.addQuery('state', 'loaded');
gr.addQuery('active', true);
gr.orderByDesc('sys_created_on');
gr.query();

while (gr.next()) {
    gs.info('Ready to process: ' + gr.getDisplayValue('name'));
    gs.info('Table: u_' + gr.getValue('table_name'));
    gs.info('Row count: ' + gr.getValue('row_count'));
}

Find failed imports from a specific data source in the last 24 hours

// Identify problematic imports for troubleshooting
var gr = new GlideRecord('sys_import_set');
gr.addQuery('state', 'cancelled');
gr.addQuery('data_source.name', 'HR Employee Feed'); // specific data source
gr.addQuery('sys_created_on', '>=', gs.hoursAgoStart(24));
gr.orderByDesc('sys_created_on');
gr.query();

gs.info('Failed imports in last 24 hours: ' + gr.getRowCount());
while (gr.next()) {
    gs.error('Failed import: ' + gr.getValue('name') + ' at ' + gr.getValue('started_on'));
}

Get import sets with high error rates for data quality monitoring

// Business scenario: identify data sources with quality issues
var gr = new GlideRecord('sys_import_set');
gr.addQuery('state', 'processed');
gr.addQuery('total_rows_ignored', '>', 0);
gr.addQuery('sys_created_on', '>=', gs.daysAgoStart(7));
gr.query();

while (gr.next()) {
    var errorRate = (gr.getValue('total_rows_ignored') / gr.getValue('row_count')) * 100;
    if (errorRate > 10) { // More than 10% errors
        gs.warn('High error rate: ' + gr.getDisplayValue('name') + ' (' + errorRate.toFixed(1) + '%)');
    }
}

Count import sets by state for dashboard metrics

// Aggregate counts for operational dashboard
var ga = new GlideAggregate('sys_import_set');
ga.addQuery('sys_created_on', '>=', gs.daysAgoStart(1)); // last 24 hours
ga.groupBy('state');
ga.addAggregate('COUNT');
ga.query();

var counts = {};
while (ga.next()) {
    var state = ga.getValue('state');
    var count = ga.getAggregate('COUNT');
    counts[state] = count;
    gs.info('Import sets in ' + state + ' state: ' + count);
}
return counts;

Wrong way vs right way: querying import set data

// WRONG: Trying to query with stored table name directly
// var wrong = new GlideRecord(gr.getValue('table_name')); // Fails!

// RIGHT: Prepend u_ prefix to stored table name
var importSet = new GlideRecord('sys_import_set');
importSet.get('name', 'Employee Import 2024-01');

if (importSet.isValidRecord()) {
    var tableName = 'u_' + importSet.getValue('table_name'); // Add u_ prefix
    var importData = new GlideRecord(tableName);
    importData.query();
    gs.info('Found ' + importData.getRowCount() + ' rows in ' + tableName);
}

Related Tables

sys_transform_map sys_trigger

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