sys_transform_entry Table

Table Reference/sys_transform_entry

The sys_transform_entry table stores individual field mappings within Transform Maps in the Integration module. Each record defines how a source column maps to a target field, with optional coalesce behavior and transformation scripts.

What This Table Is

The sys_transform_entry table stores individual field mapping definitions within ServiceNow Transform Maps. Each record represents a single mapping from a source data column to a target table field, defining how data flows during imports. These entries control field-level transformation logic, coalesce behavior, and data validation during the transformation process.

Owned by the Integration module, this table supports the end-to-end data import process from external systems into ServiceNow tables. Transform entries execute during Import Set processing, taking raw source data and applying business logic to populate target records. The table works in conjunction with sys_transform_map records to define complete data transformation workflows.

This table has no parent/child relationships through extension, but maintains tight coupling with Transform Maps and Import Sets. Each transform entry belongs to exactly one transform map, and multiple entries combine to define the complete field mapping strategy for a data integration.

Record volumes typically range from 10-50 entries per transform map in most implementations. Large enterprise integrations might see 100+ entries per map when dealing with complex source systems. Performance remains strong since queries usually filter by map reference, and the table includes proper indexing on key fields.

When You'll Script Against This Table

Most scripting occurs in Transform Scripts (field-level script field), Script Includes for reusable transformation logic, and Business Rules that customize transform behavior. Integration administrators and developers with import_transformer role access this table directly. System administrators can view and modify all transform entries.

Background Scripts and Import Set processors frequently query this table to understand mapping configuration and apply custom transformation logic. The table supports both programmatic creation of transform entries and runtime inspection of mapping definitions during data processing.

Common Scripting Patterns:

Query all field mappings for a specific transform map to build dynamic processing logic
Programmatically create transform entries when building integrations via API
Disable or modify field mappings based on runtime conditions or source data characteristics
Validate transform entry configuration before import processing begins
Clone existing transform entries when creating similar transform maps
Audit and report on field mapping coverage across multiple integrations
Implement conditional field mappings that vary based on source data content

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.

Table Gotchas

⚠️

The source_field value must exactly match column names in the Import Set table, including case sensitivity. Mismatched names cause silent mapping failures.

⚠️

Transform entry scripts execute in the transform map's scope context, not the global scope. Variables and functions must be properly scoped or accessed via GlideSystem methods.

The coalesce field only accepts specific values: empty, true, or false. Invalid values default to false and cause unexpected behavior.
Transform entry active field defaults to true, but inactive entries still appear in mapping lists and can confuse administrators.
Choice field mappings require exact choice value matches, not display labels. Use choice table values in source data or transform scripts.

⚠️

Queries without map reference filters scan the entire table. Always include the map field in queries for optimal performance.

Reference field mappings automatically resolve display values to sys_ids, but this fails silently if multiple records match the display value.

The sys_transform_map table serves as the parent container for transform entries. Every entry belongs to exactly one transform map, and developers frequently join these tables to understand complete integration configuration. Transform maps define the source Import Set table and target ServiceNow table, while entries define individual field mappings within that context.

Import Set tables (sys_import_set_row extensions) provide the source data that transform entries process. Developers query both tables together when troubleshooting data transformation issues or building custom import validation logic. The sys_import_set table tracks import batches and their processing status.

Target table schemas drive transform entry configuration, making sys_dictionary and sys_db_object commonly referenced during transform development. Field types, reference qualifiers, and choice lists in the target table determine valid mapping configurations and transformation requirements.

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
map	reference	Transform Map	References sys_transform_map. Always include in queries for performance. Defines which transform map owns this field mapping.
source_field	string	Source Field	Column name from Import Set table. Must exactly match source column including case. Empty value creates constant mappings using target_field value.
target_field	string	Target Field	Field name in target table. For constant mappings without source_field, this stores the literal value to insert.
script	script	Script	JavaScript transformation code. Executes in transform map scope with 'source' and 'target' variables available. Return value populates target field.
coalesce	boolean	Coalesce	Controls update behavior: true updates existing records, false only inserts new records. Empty value inherits from transform map settings.
active	boolean	Active	Enables or disables this field mapping. Defaults to true. Inactive entries remain visible in UI but don't process during transforms.
order	integer	Order	Execution sequence within transform map. Lower numbers execute first. Critical for dependent field mappings and reference resolution.
source_table	string	Source Table	Import Set table name. Usually populated automatically from parent transform map but can override for complex multi-table scenarios.
target_table	string	Target Table	ServiceNow table receiving the data. Inherited from transform map but stored here for query optimization and reporting.
use_source_script	boolean	Use Source Script	When true, ignores source_field and uses script to determine source value. Enables complex source data processing and calculations.
choice_action	choice	Choice Action	Behavior when choice values don't match: ignore, create, or reject. Only applies to choice fields in target table.
reference_action	choice	Reference Action	Behavior when reference values don't resolve: ignore, create, or reject. Controls foreign key handling during transformation.

Common Queries

Get all active field mappings for a transform map

// Most basic query - filter by map and active status
var gr = new GlideRecord('sys_transform_entry');
gr.addQuery('map', transform_map_sys_id);
gr.addQuery('active', true);
gr.orderBy('order');
gr.query();
while (gr.next()) {
    gs.info('Field mapping: ' + gr.source_field + ' -> ' + gr.target_field);
    // Process each active mapping in execution order
}

Find transform entries with scripts for a specific target table

// Filter by target table and script presence
var gr = new GlideRecord('sys_transform_entry');
gr.addQuery('target_table', 'incident');
gr.addQuery('script', '!=', '');
gr.addQuery('active', true);
gr.query();
while (gr.next()) {
    gs.info('Transform: ' + gr.map.getDisplayValue() + ' has script for ' + gr.target_field);
    // Review scripted transformations for incidents
}

Get all reference field mappings with their resolution actions

// Business scenario: audit reference field handling across integrations
var gr = new GlideRecord('sys_transform_entry');
gr.addQuery('reference_action', '!=', '');
gr.addQuery('active', true);
gr.query();
while (gr.next()) {
    var fieldType = getFieldType(gr.target_table, gr.target_field);
    if (fieldType == 'reference') {
        gs.info('Map: ' + gr.map.name + ', Field: ' + gr.target_field + ', Action: ' + gr.reference_action);
    }
}

function getFieldType(table, field) {
    var dict = new GlideRecord('sys_dictionary');
    dict.addQuery('name', table);
    dict.addQuery('element', field);
    dict.query();
    return dict.next() ? dict.internal_type : '';
}

Count active field mappings per transform map

// Aggregate query to analyze mapping coverage
var ga = new GlideAggregate('sys_transform_entry');
ga.addQuery('active', true);
ga.groupBy('map');
ga.addAggregate('COUNT');
ga.query();
while (ga.next()) {
    var mapName = ga.map.getDisplayValue();
    var mappingCount = ga.getAggregate('COUNT');
    gs.info('Transform map "' + mapName + '" has ' + mappingCount + ' active field mappings');
}

Wrong way vs right way to query transform entries

// WRONG: Query without map filter hits entire table
var wrong = new GlideRecord('sys_transform_entry');
wrong.addQuery('target_field', 'short_description');
wrong.query(); // Scans all records - poor performance

// RIGHT: Always filter by map reference first
var right = new GlideRecord('sys_transform_entry');
right.addQuery('map', map_sys_id); // Use indexed field first
right.addQuery('target_field', 'short_description');
right.query(); // Fast lookup using proper indexing
// Map reference is the primary filter - target_field is secondary

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

sys_transform_entry