---
sourceDocument: Brazil ServiceNow AI Platform Administration
sourceDocumentLink: https://www.servicenow.com/docs/r/platform-administration

 Release :

    - brazil

ft:locale :

    - en-US

ft:publication_title :

    - Brazil ServiceNow AI Platform Administration

ft:clusterId :

    - platadm

bundleId :

    - platadm

workflow :

    - Platform


---

# Table extension and classes

# Table extension and classes {#ariaid-title1}

Release version: Brazil  
Updated September 10, 2026  
![](https://www.servicenow.com/docs/portal-asset/ico-clock) 5 minutes to read
Summarize  
![AI sparkle icon](https://servicenow.com/docs/portal-asset/ai-sparkle-icon) Summarized using AI  
This content was generated using new OpenAI-powered functionality. Results are provided on an as is basis and are not guaranteed to be accurate or complete.  

## Summary of Table extension and classes

In ServiceNow, table extension enables administrators and application developers to create child tables that share fields and records with a parent table.
This feature is used to organize related records efficiently by extending existing tables during their creation.
A table extending another is called achild class, and the extended table is theparent class.
Tables can act as both parent and child classes.
A parent class without extensions is known as abase class.
Tools like the schema map, system dictionary, and Tables module help visualize these relationships.
Show full answer Show less  

## Extension Models

ServiceNow offers three extension models that determine how tables and their data are structured and managed:

* **Table per class**
* **Table per hierarchy**
* **Table per partition**

These models affect the number of database tables created, the derivation of fields from parent classes, and record replication behavior.

## Table per class

* Creates separate database tables for parent and each child class.
* Child classes inherit fields from parent classes.
* Parent class has Dictionary records defining the collection and fields; child classes have Dictionary entries only for their unique fields.
* Records are replicated: each child record is mirrored in the parent table with the same Sys ID, and updates to child records replicate to the parent.
* Example: **Contract** table replicates records from **Lease** and **Warranty** child tables.

## Table per hierarchy

* Creates a single database table for the parent class, storing all records for parent and child classes.
* Child classes derive fields from the parent class.
* Parent class defines Dictionary records for collection and fields, including a `sysclassname` column to differentiate child class records.
* Child classes have Dictionary entries only for unique fields.
* No record replication is needed as all records reside in the parent table.
* Example: **Task** table stores records for child classes such as **Incident** , **Change** , and **Problem**.

## Table per partition

* Creates one database table for the parent class and dynamically adds storage partitions (tables) as storage limits are reached.
* Child classes do not derive fields from the parent; each defines its own fields.
* Parent class Dictionary records exist for its collection and relevant fields, with changes replicated to child class Dictionary entries.
* Dictionary records include columns `sysclassname` and `sysclasspath` to identify child class records.
* Storage partitions are managed as a single logical unit using additional Dictionary entries for storage columns.
* No record replication is needed; all records are stored within the parent and its partitions.
* Example: **Base Configuration Item \[cmdb\]** stores records for child classes like **Application** , **Computer** , and **Hardware**.

## Practical Implications for ServiceNow Customers

Choosing the appropriate extension model impacts database structure, performance, and data management:

* **Table per class** supports strict separation of child tables but requires record replication to parent tables.
* **Table per hierarchy** consolidates records into one table with class differentiation, simplifying queries but increasing table size.
* **Table per partition** manages very large datasets by partitioning storage dynamically, allowing each child class to maintain independent field sets.

Understanding these models helps customers design scalable and maintainable data architectures that fit their application needs.  
Enable one or more child tables to share fields and records with a parent table.
Administrators and application developers can only extend tables during table
creation.  
Administrators and application developers typically extend tables to create a set of related records that share information. For example, in the base system, the Task and the Configuration Item tables have multiple extensions:{#table-extension-and-classes__table_v34_p1d_ty__entry__2}

| Original table | Related tables extended from original table |
|-|-|
| Task \[task\] | * Incident \[incident\] * Problem \[problem\] * Change Request \[change_request\] {#table-extension-and-classes__ul_s4j_w1d_ty} |
| Configuration Item \[cmdb_ci\] | * Application \[cmdb_ci_appl\] * Computer \[cmdb_ci_computer\] * Database \[cmdb_ci_database\] {#table-extension-and-classes__ul_mnz_bbd_ty} |
[Table 1. Sample extended tables in the base system]

{#table-extension-and-classes__table_v34_p1d_ty}

A table that extends another table is called a child class, and the table it
extends is the parent class. A table can be both a parent and child class both
extending and providing extensions for other tables. A parent class that is not an extension of
another table is called a base class.  
Administrators can use these tools to see the relationships between classes.

* Schema map
* System dictionary
* Tables module
{#table-extension-and-classes__ul_mll_w3d_ty}  
Extending a table:

* Links the new table to the extending table.
* Creates system fields in the new table.
* Creates one or more database tables to store the parent and child classes. The number of tables the system creates depends upon the extension model selected during table creation.
{#table-extension-and-classes__ul_sp1_zzc_ty}

## Extension models {#table-extension-and-classes__section_mlg_jzj_fbb}

The ServiceNow AI Platform offers these extension models.

* Table per class
* Table per hierarchy
* Table per partition
{#table-extension-and-classes__ul_k11_431_l2b}  
The extension model determines these attributes.

* The number of database tables created
* The derivation of fields from parent classes
* The replication of records from child classes
{#table-extension-and-classes__ul_myg_531_l2b}

## Table per class {#table-extension-and-classes__section_wpy_km1_l2b}

Tables created
:   Creates a separate database table for the parent class and each child class.

Fields derived from parent class
:   Child classes derive fields from parent classes.

Dictionary records created for parent class
:   A parent class has a Dictionary record for the collection and for each field that can be
    derived from it. For example, the Contract \[ast_contract\] table has 59 Dictionary records,
    which define the table and its fields.

Dictionary records created for child classes
:   Each child class only has Dictionary entries for fields unique to the class.

Records replicated
:   The parent class replicates each record stored in its child classes. Each child class only
    stores records unique to the class. Replicated records have the same Sys ID value in each
    table. The system replicates any change you make to a child record to the matching record in
    the parent table. For example, Contract \[ast_contract\] table replicates records from the
    Lease \[ast_lease\] and Warranty \[ast_warranty\] tables.

## Table per hierarchy {#table-extension-and-classes__section_s41_pq1_l2b}

Tables created
:   Creates one database table for the parent class, which stores all records for the parent
    and child classes. Child classes do not have separate database tables.

Fields derived from parent class
:   Child classes derive fields from parent classes. For example, the Incident table derives
    fields from the Task table.

Dictionary records created for parent class

:   A parent class has a Dictionary record for the collection and for each field that can be
    derived from it. For example, the Task table is a parent class that has 66 Dictionary
    records, which define the table and its fields.

    The Dictionary entry for the parent class contains a sys_class_name column whose value
    indicates which child class each record belongs to. For example, Incident records have a
    sys_class_name value of incident, and change records have a sys_class_name value of
    change.

Dictionary records created for child classes
:   Each child class only has Dictionary entries for fields unique to the class. For example,
    the Incident table only has 22 Dictionary records, which are not already defined in the Task
    table.

Records replicated
:   Record replication is not needed, because the parent class stores all records that belong
    to the hierarchy. For example, the Task table contains all records from its
    child classes such as the Change, Incident, and Problem tables.

## Table per partition {#table-extension-and-classes__section_wwx_vr1_l2b}

Tables created
:   Creates one database table for the parent class, which stores all records for the parent
    and child classes. Child classes do not have separate database tables. As the database table
    reaches a storage limit, the system dynamically adds storage tables (partitions)
    to store additional records.

Fields derived from parent class
:   Child classes do not derive fields from parent classes. Instead each child class has its
    own list of fields. For example, the Base Configuration Item \[cmdb\], Configuration Item
    \[cmdb_ci\], and Hardware \[cmdb_ci_hardware\] tables all have their own field definitions.

Dictionary records created for parent class

:   A parent class has a Dictionary record for the collection and for each field relevant to
    it. For example, the Base Configuration Item \[cmdb\] table is a parent class that has 48
    Dictionary records.

    The system replicates changes made to parent class Dictionary entries to child class
    Dictionary entries. For example, when you change the name column in the parent class Base
    Configuration Item \[cmdb\] table, the system replicates it to child class Dictionary entries
    such as the Configuration Item \[cmdb_ci\] and Hardware \[cmdb_ci_hardware\] tables.

    The Dictionary entry for the parent class contains columns for sys_class_name and
    sys_class_path whose values indicate which child class each record belongs to. For example,
    Hardware records have a sys_class_name value of cmdb_ci_hardware, and computer records have
    a sys_class_name value of cmdb_ci_computer.

    When the database table reaches a storage limit, the system updates the Dictionary entry
    for the parent class to include columns for sys_storage_alias and storage_table_name. These
    storage column Dictionary entries allow administrators to manage the parent class and its
    storage tables as a single logical unit.

Dictionary records created for child classes
:   Each child class has a Dictionary record for the collection and for each field relevant to
    it. For example, the Hardware table has 73 Dictionary records with some records duplicating
    columns in the parent class.

Records replicated
:   Record replication is not needed, because the parent class stores all records that belong
    to the hierarchy. For example, the Base Configuration Item \[cmdb\] table contains
    all records from its child classes such as the Application \[cmdb_ci_appl\], Computer
    \[cmdb_ci_computer\], and Hardware \[cmdb_ci_hardware\] tables.