Many-to-Many Relationships

Many-to-Many Relationships in ServiceNow – CAD Exam Guide

Understanding Many-to-Many Relationships in ServiceNow

Many-to-Many (M2M) relationships are a fundamental concept in ServiceNow application design and are a key topic on the Certified Application Developer (CAD) exam. Mastering this concept is essential for both real-world development and exam success.

Why Are Many-to-Many Relationships Important?

In real-world scenarios, data rarely fits into simple one-to-one or one-to-many patterns. Consider the following examples:

- A user can belong to multiple groups, and a group can contain multiple users.
- A change request can affect multiple configuration items (CIs), and a single CI can be affected by multiple change requests.
- A knowledge article can belong to multiple categories, and a category can contain multiple articles.

Without M2M relationships, you would be forced to create redundant data, use comma-separated lists, or rely on workarounds that break referential integrity. M2M relationships provide a clean, normalized, and platform-supported way to model these complex associations.

What Is a Many-to-Many Relationship?

A Many-to-Many relationship in ServiceNow is a relationship between two tables where records on both sides can be associated with multiple records on the other side. ServiceNow implements this using a relationship table (also known as an intermediary table or junction table) that sits between the two primary tables.

This intermediary table contains two reference fields — one pointing to each of the two related tables. Each record in the intermediary table represents a single link between one record from Table A and one record from Table B.

For example, the out-of-box sys_user_grmember table is the M2M table that links sys_user (Users) to sys_user_group (Groups).

How Many-to-Many Relationships Work in ServiceNow

Here is how M2M relationships are created and function on the platform:

1. Creating a Many-to-Many Relationship

There are two primary ways to create M2M relationships:

a) Using the Many-to-Many Definition Module:
- Navigate to System Definition > Many to Many Definitions (table: sys_m2m).
- Click New to create a new definition.
- Fill in the following fields:
  • From table: The first table in the relationship (e.g., Incident).
  • To table: The second table in the relationship (e.g., Configuration Item).
  • Name: A meaningful name describing the relationship.
- When you save the M2M definition, ServiceNow automatically creates an intermediary table with two reference fields pointing to the From table and To table.
- A Related List is automatically available on both tables' forms to display the associated records.

b) Manually Creating an Intermediary Table:
- You can manually create a custom table with two reference fields (one for each related table).
- This approach offers more flexibility because you can add additional fields to the intermediary table (e.g., a role field, a priority field, or date fields to track when the relationship was established).
- However, you must manually configure related lists and any UI actions needed to manage the relationships.

2. How the Intermediary Table Works

Consider a scenario where you want to link Projects and Skills in a M2M relationship:

- The intermediary table (e.g., x_app_project_skill) contains:
  • A reference field to the Project table.
  • A reference field to the Skill table.
- When you associate Skill A with Project 1, a record is created in the intermediary table with Project = Project 1 and Skill = Skill A.
- When you associate Skill A with Project 2, another record is created in the intermediary table with Project = Project 2 and Skill = Skill A.
- This allows Project 1 to have multiple skills, and Skill A to be linked to multiple projects.

3. Displaying M2M Relationships

- M2M relationships are typically displayed as Related Lists on forms.
- When a M2M definition is created via the sys_m2m module, the related lists are automatically configured.
- Users can add or remove associations directly from these related lists using the Edit or New buttons.

4. Querying M2M Relationships

- To query M2M relationships, you query the intermediary table.
- For example, to find all skills associated with a specific project, you would query the intermediary table where the project field equals the desired project's sys_id.
- You can also use GlideRecord or GlideAggregate to traverse M2M relationships in scripts.

Key Differences: M2M Definition vs. Manual Intermediary Table

Feature	M2M Definition (sys_m2m)	Manual Intermediary Table
Ease of setup	Quick and automatic	Requires manual configuration
Additional fields on relationship	Not supported (only two reference fields)	Fully supported
Related lists	Automatically created	Must be manually configured
Flexibility	Limited	High

M2M Relationships vs. Other Relationship Types

- One-to-Many (1:M): A single reference field on the child table pointing to the parent table (e.g., an Incident references a single Caller). No intermediary table is needed.
- Many-to-Many (M2M): Requires an intermediary table because neither side can store multiple references in a single field in a normalized fashion.
- List Fields: ServiceNow does support List type fields (glide_list), which store multiple sys_ids in a comma-separated format. However, these are not the recommended approach for true M2M relationships because they do not support referential integrity, are harder to query efficiently, and can cause performance issues.

Common Out-of-Box M2M Relationships

- sys_user_grmember: Links Users to Groups.
- task_ci: Links Tasks (Incidents, Changes, etc.) to Configuration Items.
- sc_cat_item_category: Links Catalog Items to Categories.

Best Practices for M2M Relationships

- Use the sys_m2m module for simple M2M relationships where no additional attributes are needed on the relationship itself.
- Use a manual intermediary table when you need to store additional metadata about the relationship (e.g., a role, weight, or effective date).
- Avoid using List fields (glide_list) as a substitute for proper M2M relationships in application design.
- Always consider ACLs (Access Control Lists) on the intermediary table to ensure proper security.
- Add unique constraints to the intermediary table to prevent duplicate relationships if applicable.
- Use business rules or UI policies on the intermediary table to enforce validation logic.

Exam Tips: Answering Questions on Many-to-Many Relationships

The CAD exam frequently tests your understanding of M2M relationships. Here are targeted tips to help you answer these questions confidently:

1. Know the Module: Remember that M2M definitions are managed under System Definition > Many to Many Definitions and stored in the sys_m2m table. If an exam question asks where to create a M2M relationship, this is the answer.

2. Understand the Intermediary Table: The most commonly tested concept is that M2M relationships require an intermediary table (junction table). If a question describes two tables that need to reference each other in a many-to-many fashion, the correct answer will involve creating an intermediary table — either via the sys_m2m module or manually.

3. Distinguish from List Fields: Exam questions may present a glide_list (List) field as a possible answer for modeling M2M relationships. While technically functional, this is not the recommended or best practice approach. The correct answer for proper M2M modeling is an intermediary table.

4. Know When to Use Manual Tables: If the exam question specifies that additional attributes need to be tracked on the relationship (e.g., a priority or role associated with the link between two records), the answer is to use a manually created intermediary table, not a sys_m2m definition.

5. Related Lists Are Automatic: When a M2M definition is created through the sys_m2m module, related lists on both tables are generated automatically. You do not need to manually configure them.

6. Scenario-Based Questions: The exam often presents scenarios like: "A company needs to track which employees are assigned to which projects, and each employee can be on multiple projects while each project can have multiple employees." Recognize this as a classic M2M scenario. The correct answer will involve creating a M2M relationship (not a simple reference field).

7. Watch for Distractors: Common wrong answers in exam questions include:
  • Using a single reference field (this only handles one-to-many).
  • Using a document ID field (this is for polymorphic references, not M2M).
  • Using a comma-separated string field (not a valid relational approach).

8. Remember Key Terminology: The exam may use terms like junction table, cross table, association table, or intermediary table — these all refer to the same concept: the table that sits between two tables in a M2M relationship.

9. Think About Data Integrity: If a question asks about the best way to maintain data integrity in a M2M scenario, the answer is always the intermediary table approach rather than list fields or string-based workarounds.

10. Practice with Examples: Before the exam, practice creating M2M relationships in a ServiceNow Personal Developer Instance (PDI). Create both a sys_m2m definition and a manual intermediary table so you understand the differences firsthand.

Summary

Many-to-Many relationships are a critical aspect of ServiceNow application design. They allow you to model complex, real-world associations between records across different tables. ServiceNow provides two approaches: the quick sys_m2m definition for simple relationships and manual intermediary tables for relationships requiring additional attributes. For the CAD exam, always remember that the intermediary table is the correct mechanism for M2M relationships, distinguish this approach from list fields, and be prepared to identify M2M scenarios in question stems. With a solid understanding of these concepts, you will be well-prepared to tackle any M2M-related question on the exam.