Overview

With SAP_BASIS 7.54 (SAP S/4HANA 1909), SAP delivered a completely redesigned suite of client management tools based on a new, unified architecture. These new tools replace the classic client copy transactions (such as SCCL, SCC9, SCC5) and introduce a range of new capabilities.

The redesign focuses on performance optimization, process automation, and increased stability. Additionally, the client copy log has been completely overhauled: it is now far more detailed and readable, making troubleshooting significantly easier.

The toolset also includes new features to compare clients and estimate client size. Furthermore, starting with SAP_BASIS 7.55, client export and import functions have been expanded to include the option of handling client "snapshots."

In this blog post, I will introduce you to the following tools:

New Local Client Copy
New Remote Client Copy
New Client Export and Import using Transports or Snapshots
New Client Size Estimation Tool
New Client Comparison

Why a new Client Copy Tool?

The original client copy tool was developed in the 1990s. While it was continuously maintained over the years, fundamental architectural limitations eventually emerged—especially regarding modern cloud processes—which required a completely new solution.

Consequently, development of the new tool began in late 2017. It was first released to customers in 2019 with SAP_BASIS 7.54 (S/4HANA 1909). The transition to the new architecture continued in subsequent releases:

SAP_BASIS 7.55 (S/4HANA 2020): Client Export and Client Import were converted to the new architecture.
SAP_BASIS 7.55 SP1: Transaction SCC1 was finally migrated to the new framework.

The code optimization is significant: compared to the legacy tool, the number of code statements was reduced from over 25,000 to less than half, despite the addition of major new features like the comparison tool. Today, the new Client Copy Tool boasts a unit test code coverage of over 94%.

Improvements

The new tool addresses the architectural limitations of the legacy client copy and offers significantly increased stability. Key improvements include:

Execution from a third Client. It is no longer necessary to start the copy process within the target client. Instead, it can now be triggered from a neutral third client (usually client 000). This increases efficiency and ensures that no users are active in the target client during the copy. Consequently, the workaround of using the user SAP* and restarting the application server is no longer required.

HANA Optimization. The tool is natively optimized for SAP HANA. Our internal tests demonstrated that the new Local Client Copy is about 10x faster, while the new Remote Copy is up to 5x faster compared to the legacy tools. For local copies, data is no longer loaded onto the application server first. Instead, the data remains within the database layer using an INSERT FROM SELECT statement:

INSERT (Target Client) FROM SELECT (Source Client)

Client Copy Optimizer. The tool features a built-in optimizer for empty and unchanged tables. At the start of a run, it reads the HANA database statistics to identify tables that are completely empty across all clients; these are skipped entirely. Additionally, it checks if a table has been modified since the last copy. If a table remains unchanged—and the source/target clients match the previous run—it is excluded from the delete and copy phases. This is particularly useful for regular refreshes of test clients or when resuming a cancelled copy.

Handling of Very Large Tables To handle massive database tables, a new splitting algorithm has been implemented. This algorithm generates WHERE conditions to split large tables into smaller chunks, which are then processed in parallel. This prevents memory allocation limits (in HANA and ABAP) from being exceeded and significantly boosts performance through parallelization.

Table Splitting Algorithm generates WHERE-Conditions for Parallel Processing

Class-based Exit Framework Exits are now based on class interfaces and run in an isolated environment. This separation ensures that a malfunctioning exit cannot crash the entire Client Copy tool. Starting with SAP_BASIS 7.56, exits are executed in parallel processes. Note: Legacy exits are still supported via a wrapper. If you use custom exits, please check SAP Notes for migration support.

Renovated Log (SCC3) The client copy log (Transaction SCC3) has been completely redesigned. It now uses a tab-based layout offering a "Timeline View" alongside the traditional Client View. Dedicated columns for exit status, table copy status, and general messages allow you to assess the success of a copy at a glance.

New Client Copy Log Transaction (SCC3)

Tasklist Support All new copy processes support execution via task lists. These can be started from the respective transactions or directly via Transaction STC01.

Client Tools

SAP delivers a comprehensive suite of tools for client management:

Local Client Copy (SCCLN) Performs a copy within the same system.
Remote Client Copy (SCC9N) Copies data from an external source system to the local target system using an RFC connection.
Client Deletion: Permanently deletes a client and its data.
Client Export / Import: Facilitates the export and import of clients via transport requests or the new Client Snapshots feature.
Copy from Transports (SCC1N) Copies Customizing objects (transport requests) within the same system.

Client Copy

There are two primary types of client copies:

Local Client Copy (SCCLN) The local client copy moves data between clients within the same system.
Remote Client Copy (SCC9N) The remote client copy transfers data from an external source system to a specific client in the target system using an RFC connection. This process is always triggered from the target system.

Differences between Local and Remote Client Copy

While the fundamental process flow is similar for both modes, the Remote Client Copy involves specific considerations:

DDIC Consistency Check: Source and target systems often differ in their release levels or patch statuses. Before a remote copy begins, the tool compares the Data Dictionary (DDIC) table definitions. Incompatible tables are automatically excluded. For example, a table is considered incompatible if a field present in the source is missing in the target, or if a data type length in the target is shorter than in the source.
Exit Execution Location:
- Local Copy: Exits are executed in the target client (during the analysis phase).
- Remote Copy: The analysis phase exits are executed in the source client of the source system.

Client Copy Phases

The new client copy process is divided into four distinct phases:

1. Initialization Phase In this initial step, the tool prepares the environment by initializing the list of relevant tables, setting client lock objects, and loading the exit handlers.

2. Analysis Phase Here, the client copy exits are executed. These exits can modify the scope of the copy by excluding specific tables, requesting that tables be emptied, or explicitly including additional tables. Once the exits have finished, the final list of tables to be deleted and copied is persisted in the database. If the table splitting option is active, very large tables are analyzed and divided into smaller work packages for parallel processing.

3. Delete and Copy Phase This phase handles the actual data transfer. Typically, the relevant tables in the target client are deleted first, followed by the insertion of data from the source. After all tables have been successfully copied, the source clients gets unlocked and the process transitions to the final phase.

4. Post-Processing Phase In this final step, the tool executes any necessary post-copy activities. This includes running specific exits defined to adjust data in the target client after the physical copy is complete. Finally, the target-client lock is removed, the temporary environment is cleaned up, and the overall result is written to the log.

Key New Features

In addition to the architectural changes, the new Client Copy tool introduces several powerful options to enhance flexibility and robustness:

Split Large Tables: Automatically divides very large database tables into smaller packages to optimize performance and prevent memory overflows during the copy process.
Copy Individual Tables: Allows for the targeted copying of specific database tables (via the "Expert Mode" or selection options) without the need to copy an entire client.
Tolerate Failed Exits and Tables: Offers configuration options to continue the copy process even if individual tables or exits fail. This prevents the entire run from aborting due to non-critical errors.
Simultaneous Execution: As of SAP_BASIS 7.56, the system supports the simultaneous execution of multiple client copy processes within the same system, significantly reducing downtime windows during large landscape updates.

Client Deletion

The Client Deletion tool has also been migrated to the new architecture and is now executed via transaction SCC5N.

Just like the client copy tools, the deletion process benefits from the modernized framework. It utilizes parallel processing to delete table entries, which significantly reduces the runtime compared to the legacy tool (SCC5).

Key features include:

Efficient Large Table Handling: The splitter algorithm is applied here as well, ensuring that very large tables are deleted in chunks without causing database log overflows or timeouts.
Background Execution: The deletion process is designed to run robustly in the background, allowing for better resource management.
Logging: The progress and results of the deletion are fully integrated into the new logging environment (SCC3).

Client Export and Import

With SAP_BASIS 7.55 (S/4HANA 2020), the Client Export and Import tools were also migrated to the new architecture. This modernization introduces higher stability and performance, similar to the local and remote copy tools.

The new tool supports two primary modes of operation:

1. Export/Import via Transport Requests This is the modernized version of the classic approach (formerly SCC8/SCC7). The client data is exported into transport requests. While the process logic remains similar to the legacy tool, the underlying execution is now optimized for HANA and handles large tables more efficiently.

2. Export/Import via Client Snapshots (New Feature) This is a completely new capability. Instead of exporting data to the operating system's transport directory, the tool can now create a Client Snapshot directly within the database.

How it works: The snapshot saves the state of a client in a compressed format within the database tables.
Benefits:
- No OS Access Required: You do not need access to the file system (/usr/sap/trans).
- Speed: Since data remains within the database layer, creating and restoring snapshots is significantly faster than file-based exports.
- Flexibility: Ideal for creating quick backups before critical activities or for moving clients between systems that share a database connection but no file system mount.

Copy Data from Transports (SCC1N)

The classic transaction SCC1 has been succeeded by the new transaction SCC1N.

With SAP_BASIS 7.55 Service Pack 1, this tool was fully integrated into the new Client Copy architecture. While the basic functionality—importing transport requests from a source client into the current client—remains the same, the underlying execution has been modernized.

Key advantages of SCC1N:

Performance: It benefits from the same HANA optimizations and parallel processing capabilities as the client copy tools.
Logging: A major improvement is the integration into the central log. Unlike the old tool, executions of SCC1N are persistently recorded in Transaction SCC3, allowing for better traceability and auditability.
Usability: The user interface has been harmonized with the other new tools (SCCLN, SCC9N), providing a consistent user experience.

You can find further information about SCC1N in my SCC1N blog post.

New Client Comparison Tool

In addition to the new client copy architecture, SAP has fundamentally modernized the tools used for client comparison. While previous versions focused mainly on the transfer of data, the new SCC_COMP transaction provides a precise way to validate consistency between source and target clients and perform in-depth difference analyses.

Three Specialized Comparison Modes

To balance the need for detail with system performance, the tool offers three distinct modes:

Checksum Comparison: Optimized for maximum performance, this mode calculates a checksum for every table in both the source and target systems. It is the ideal "health check" to run immediately after a client copy to ensure data integrity.
- Note: This mode identifies if differences exist but does not list the specific records that differ.
Detailed Comparison: This mode performs a record-level analysis, identifying exactly which entries are inconsistent. It categorizes results into four types:
- Records existing only in the source object.
- Records existing only in the target object.
- Records with identical keys but different field values.
- Fully identical records.
Save as Template Container: Functionally identical to the Detailed Comparison, this mode allows the results to be persisted in a "Template Container." This is particularly useful for audit purposes or for tracking changes over time.

Flexible Data Selection

Users have full control over the scope of the comparison. You can define the tables to be analyzed via three entry points:

Profiles: Use predefined SAP profiles (similar to those used in Client Copy).
Individual Table List: Manually select specific tables (including cross-client tables in remote scenarios).
Run-ID: Automatically compare tables based on the logs of a specific, previously executed client copy run.

Result Analysis and Drill-Down

The evaluation process is integrated into the redesigned transaction SCC3.

The "Comparison" tab provides a high-level overview of all comparison runs.
A double-click on any table in the list triggers a Drill-Down, allowing you to visually compare field-level differences between the clients side-by-side.

Best Practices & Performance

Performance Strategy: For large-scale tables (e.g., transactional data), always start with a Checksum Comparison. Use the Detailed Comparison only for specific subsets of data to avoid excessive resource consumption.

Use Cases: This tool is highly recommended after a Remote Client Copy to verify that customizing is identical, or to detect "configuration drift" in test environments after manual interventions.

Client Size Estimation (Transaction SCC_CLIENT_SIZE)

The Client Size Estimation tool provides an efficient way to determine the storage footprint of individual tables or an entire client. To provide these estimates, the tool applies a proportional calculation logic based on the physical disk space occupied by a table on the database:

Table Size = Table Disk Size on the database / Total Number of table rows * Number of rows in the examined client

Key Characteristics and Limitations:

Approximation Logic: The tool calculates the size based on row counts and total disk usage. It does not analyze the actual data content or specific data distributions within the client.
HANA Compression: Please note that HANA-specific internal compression algorithms are not factored into this calculation.
Dynamic Fields: For tables containing fields with dynamic lengths (e.g., LOBs or strings), the tool provides an orientation value rather than an exact measurement.

Integration and Usage:

Direct Access: You can start the estimation manually at any time using transaction SCC_CLIENT_SIZE.
Automation: As of SAP_BASIS 756, the Client Size Estimation tool is integrated into the standard workflow and runs automatically with every client copy.
Reporting: The results and estimated sizes for all clients can be reviewed centrally within the renovated log transaction SCC3.

The Renovated Client Copy Log

The logging infrastructure for client operations has been completely redesigned to offer a more intuitive and structured experience. Transaction SCC3 replaces the legacy logging system with a modern, tab-based interface that significantly simplifies monitoring, troubleshooting, and auditing.

Centralized Monitoring and Navigation

The updated SCC3 interface provides a clear hierarchy of information through several specialized views:

Process Monitor (First Tab): While a client operation is active, this tab provides a real-time status summary. It tracks the progress of deletion and copy phases, identifies the source and target clients, and monitors the current sub-process.
Client Overview: In its idle state, the main tab lists all clients within the system. Double-clicking a client allows for a deep dive into all processes associated with that specific client.
Timeline View: This chronological view lists every action performed by the tool in descending order, providing a historical audit trail of all client-related activities.
Activity-Specific Tabs: For enhanced organization, dedicated tabs group logs by operation type, including Local/Remote Client Copies, Client Deletions, Exports, Imports, Transport Request Copies (SCC1N), and Client Comparisons.

Detailed Log View

Double-clicking a specific log entry opens the detailed view, which is structured into the following tabs:

Log Header: Provides a general overview of the execution mode, the selected profile, affected clients, exit status, and the overall process status.
Options: Lists all parameters and settings configured on the selection screen before the process was started.
Table Statistics: Displays the count of tables and records that were emptied, deleted, or copied. It also identifies "skipped" tables—those excluded from processing because they were empty or had not changed since the last copy (Optimization).
General Messages: Contains all system messages and logs generated by the Client Copy Tool engine.
Exit Messages: Displays specific messages issued by the Class-based Exit Framework during the analysis or execution phases.
Processed Tables: A comprehensive list of all tables handled by the tool. This tab is also used to track the progress of individual tables during an active copy.
Included/Excluded Tables: Detailed list of tables that were either explicitly included or excluded by the tool's internal logic or by specific exits.
Parallel Processes / Packages: Since large tables are split into packages for parallel processing, this tab shows the status of each package and its assignment to parallel work processes.

Log Administration

With the release of SAP_BASIS 755 SP01, SAP introduced transaction SCC3_ADMIN. While the standard SCC3 transaction is primarily designed for viewing logs, SCC3_ADMIN expands upon this by providing dedicated administrative functions to manage and delete logs, snapshots, and containers.

Deletion of old Logs

In systems where client copies are performed frequently, log tables can grow significantly, potentially impacting database performance and storage. Because the Client Copy Tool generates multiple records for every table processed, regular maintenance of these logs is highly recommended.

Evolution of the Tool: In SAP_BASIS 755, a deletion function was initially added to the "Timeline View" within transaction SCC3. However, as of SAP_BASIS 755 Service Pack 1, this functionality has been moved exclusively to SCC3_ADMIN. This change ensures that SCC3 remains a dedicated read-only tool for monitoring and analysis.
The Log Cleanup Tool: For more efficient management, it is better to use the integrated Log Cleanup Tool rather than deleting logs individually. You can access it via the menu path: SCC3_ADMIN -> Goto -> Log Cleanup. This tool allows you to automate the removal of logs older than a specific number of days, while still retaining a defined minimum number of recent logs per client to ensure traceability.
Automation: For background processing, you can use the task list SAP_CLIENT_LOG_CLEANUP via transaction STC01.

Deletion of Snapshots and Containers

Snapshots and containers can be managed manually via the "Client Table Snapshot" or "Client Template Container" tabs within the administration interface using the corresponding toolbar buttons.

To streamline the removal of obsolete objects, SAP also provides the task list SAP_CLIENT_CONTAINER_DELETE. This allows administrators to schedule regular cleanup activities through transaction STC01, ensuring that the system remains lean and performant.

Client Table Snapshots

Introduced in SAP_BASIS 755 (SAP S/4HANA 2020)

With the latest architecture, SAP introduces Client Table Snapshots and Client Template Containers. These are local objects stored within the system’s database (Delivery Class "L"), providing a modern alternative to traditional file-based exports.

1. What are Snapshots?

Snapshots leverage the high-performance algorithm of the Remote Client Copy to back up any database table. They are flexible containers that can:

Be assigned a custom name for easy identification.
Store any number of selected tables or an entire client.
Store data as serialized RAWSTRINGs across several centralized database tables.

2. Efficiency through Intelligent Storage (Deduplication)

The snapshot tool uses a checksum-based storage method to minimize the database footprint.

Data Deduplication: Every table's data is stored centrally. If the same table exists in multiple snapshots with identical data, it is only physically stored once.
Delta-Only Growth: When performing regular backups of a client, only the "delta" (changed data) consumes additional storage space. If a table hasn't changed between two snapshots, no new data is written to the database.

3. Snapshots vs. Transport Requests (SCC8N)

While the Client Export Tool previously relied solely on transport requests, snapshots offer several significant advantages:

Ease of Access: Snapshots are stored directly in the database, eliminating the need to manage files on the application server’s file system.
RFC Integration: Like a Remote Client Copy, containers can be imported into other systems directly via an RFC connection.
Superior Performance: Creating and importing a snapshot is generally twice as fast (taking less than half the time) as using traditional transport requests.
Optimized Footprint: Storage is significantly more efficient due to the deduplication mentioned above.

4. Practical Use Cases

"Freeze and Restore": Snapshots are ideal for freezing a test client at a specific state (e.g., after successful test data preparation). This allows users to restore the client to that exact state repeatedly without a full system copy.
Data Comparison: Using the Comparison Tool (SCC_COMPARE), you can compare the current "live" data in a client against a previously taken snapshot to identify exactly what has changed over time.

5. Maintenance and Cleanup

Because snapshots reside in the database, regular maintenance is required to prevent excessive growth.

Manual Deletion: Use transaction SCC3_ADMIN (on the "Client Table Snapshot" tab) to delete old snapshots.
Automation: The task list SAP_CLIENT_CONTAINER_DELETE can be scheduled in transaction STC01 to automate the cleanup of expired snapshots and containers.

With SAP_BASIS 755, SAP delivers client table snapshots and client template containers for the first time. Client table snapshots are local objects that are stored in tables of delivery class "L" (temporary data).

Processing Options

The Client Copy tool includes several configuration settings designed to optimize database performance, ensure data consistency, and manage error handling.

1. General Performance & Safety

These settings determine how the system handles user access and database resources during the copy.

Test Mode
- Function: Simulates the entire client copy process without writing to or deleting from the database.
- Benefit: Allows you to identify potential issues before execution. A complete log is generated and can be viewed via transaction SCC3.
Lock Source Client
- Function: Prevents new user logins to the source client during the process.
- Recommendation: Always Enable. Existing users aren't kicked out, but preventing new logins ensures data consistency by stopping mid-process changes.
Use Exclusive Locks
- Function: Sets an exclusive database lock on each table being copied.
- Benefit: Reduces the database memory footprint and increases speed.
- Caution: Other tools cannot update the table while it is locked. Disable this if the system must remain active for other users.
Split Large Tables
- Function: Breaks large tables into smaller units to be processed in parallel.
- Note: This prevents "out of memory" errors.
- Status: As of SAP_BASIS 756, this is permanently activated and no longer appears on the selection screen.

2. Error Handling

These options prevent a single failure from halting the entire long-running process.

Tolerate Failed Exits If a Client Copy Application Exit fails, the process continues instead of canceling.
Tolerate Failed Tables If a specific table fails to delete or copy, the tool skips it and moves to the next table. It ensures that the majority of the client is copied even if specific data clusters are corrupted.

3. Remote Copy (RFC) Compatibility

These rules apply when copying tables between systems where the structures might not be identical.

Copy Incompatible Tables (RFC) When enabled, tables are copied even if structures differ, potentially leading to data loss (e.g., if the source has a column the target lacks).

Rule:

Rule Category	Standard Requirement (Option Disabled)	RFC Compatibility Mode (Option Enabled)
Existence	Must exist in both source and target.	Must exist in both source and target.
Key Fields	Must be identical.	Must be identical.
Field List	Must be identical (positions may vary).	Differences allowed. Missing fields are ignored; matches are copied.
Data Types	All fields must match.	Only matching fields must have the same type.
Field Length	Target must be $\ge$ Source.	Target must be $\ge$ Source.

4. Client Export Options

These settings are specific to Client Export to a Transport Request.

Automated Import Postprocessing: Automatically triggers transaction SCC7N immediately after the export is imported into the target system. This removes the need for manual intervention.
Release Transport Requests on Client Export: Automatically releases the transport requests as soon as the export process finishes.
Use Mode Vector / All Languages: Utilizes "LSM-Mode = Vector" and ensures all language headers are exported upon transport release.

Overview of Transaction Codes and Tasklists

Process/Tasks Old Transaction New Transaction Tasklist Released with

Local Client Copy	SCCL	SCCLN	SAP_CLIENT_COPY_LOCAL	SAP_BASIS 754 SP00
Remote Client Copy	SCC9	SCC9N	SAP_CLIENT_COPY_REMOTE	SAP_BASIS 754 SP01
Client Deletion	SCC5	SCC5N	SAP_CLIENT_DELETION	SAP_BASIS 754 SP00
Client Export	SCC8	SCC8N	SAP_CLIENT_EXPORT	SAP_BASIS 754 SP02
Client Import	SCC7	SCC7N	SAP_CLIENT_IMPORT_POSTPROCESSING	SAP_BASIS 754 SP02
Client Copy Log	SCC3	SCC3	n/a	SAP_BASIS 754 SP01
Client Copy - Special Selection	SCC1	SCC1N	SAP_CLIENT_COPY_BY_TRANSPORT	SAP_BASIS 755 SP01
Comparison Tool	N/A	SCC_COMPARE	SAP_CLIENT_COMPARISON	SAP_BASIS 754 SP03
Client Size Determination	N/A	SCC_CLIENT_SIZE	-	SAP_BASIS 754 SP00

New Authorization Checks

Please note that with the new Client Copy Tool, new authorization objects have also been introduced. See the main note 2962811 for more information.

Related Information

SCC1N Blog Post

Client Copy Main Note: 2962811

SAP Help Portal: Client Copy and Transport

New Client Copy Tool