CCNA Identify considerations for relational data on Azure Questions

Azure Database Migration Service with continuous sync is the correct online method because it reads the source transaction log and continuously applies those changes to the target Azure SQL Database, all while the on-premises database remains online and fully operational. The migration can run for days to sync historical data without blocking active workloads, and only the final cutover step—stopping the source and pointing the application to the target—requires a brief downtime window measured in minutes. Unlike offline approaches, this preserves continuity for a 1 TB database and provides validation and rollback capability during the migration.

A composite nonclustered index keyed on CustomerID then ShipDate matches the query predicate exactly, enabling a seek on CustomerID and a range scan on ShipDate. The narrow key avoids scanning millions of shipment rows, unlike indexing either column alone or the clustered primary key.

Azure SQL Database is a fully managed relational database service that supports schema enforcement, primary and foreign keys, T-SQL queries, stored procedures, and ACID transactions. For an application that requires relational storage, it gives direct support for complex joins, indexed views, and fine-grained permissions out of the box.

Azure SQL Database is a fully managed relational database service built on the SQL Server engine, offering near-total compatibility with on-premises SQL Server databases via the Data Migration Assistant and Database Migration Service. It automates patching, backups, point-in-time restore, and provides built-in high availability with a 99.99% SLA, plus intelligent features like automatic performance tuning and threat detection. This makes it the most appropriate choice for a startup wanting to offload maintenance while keeping a relational SQL Server model.

Azure SQL Managed Instance provides near-full SQL Server compatibility, including cross-database queries, SQL Server Agent, and server-level logins. It is a PaaS offering that reduces administrative overhead compared to IaaS while still supporting these features. This makes it the best fit for the healthcare organization's requirements.

A composite nonclustered index on (OrderDate, CustomerID) is ideal for a query filtering on OrderDate and ordering by CustomerID. SQL Server can perform an index seek on the leading OrderDate column to isolate the matching rows, and because CustomerID is the second key column, the rows are already returned in the required sort order—eliminating the need for a separate SORT operator and reducing query cost significantly.

Azure SQL Database is a fully managed relational database engine that provides complete T-SQL support, including table joins with various join types, primary/foreign key enforcement, check constraints, and ACID transactions. This makes it the only option in the list that natively supports the referential integrity and complex relational queries expected when designing an application that stores customer data across normalized tables. It also offers built-in high availability, automated backups, and scaling options, so it aligns with both the relational data model and operational requirements.

This covering index includes all columns needed by the query (Quantity, UnitPrice) as included columns, and the key columns (ProductID, SaleDate) support efficient filtering. The query can be satisfied entirely from the index without key lookups.

This composite non-clustered index is optimal because CustomerID is the leftmost key column, enabling a seek on CustomerID and then matching the OrderDate range or equality, while TotalAmount is stored as a non-key included column. That makes the index covering for this query, meaning all required data is present in the index pages and no round-trip to the clustered base table is needed, thereby minimizing logical reads and I/O.

A nonclustered index on AppointmentDate allows the query optimizer to seek directly to the relevant date range instead of scanning the entire table. Because it is nonclustered, it is stored separately from the table data, so inserts only need to update the index structure for the new row's date value. This balances read performance for date-filtered queries with manageable overhead on inserts, making it the appropriate choice for this scenario.

A columnstore index stores each column as a separate, compressed segment and enables SQL Server to read only the columns needed for the query (e.g., amount, category, date) rather than whole rows. It uses batch-mode processing, where the engine processes data in large batches with vectorized operators, dramatically accelerating SUM and GROUP BY over large tables. For a large Azure SQL Database table used in analytical queries, a clustered columnstore index is purpose-built for this exact scenario and requires no query rewrites.

This is correct because the policy rule uses a deny effect with a condition that compares the 'zoneRedundant' property to the literal value false. When a user attempts to create a SQL Database with zoneRedundant set to false, the condition evaluates true, causing Azure Resource Manager to block the deployment before the resource provider provisions anything. The request fails with an error indicating the resource was disallowed by policy, so the database is never created. This is the intended behavior of a deny policy.

An elastic pool allocates a shared set of vCores/eDTUs to multiple Azure SQL databases that reside on the same logical server. Databases can consume extra resources as needed up to a configured per-database cap, while idle databases automatically release unused capacity back to the pool. This shared capacity model is ideal for 20 databases with unpredictable usage because you pay for the aggregate demand of the pool rather than the sum of each database's individual peak, dramatically reducing cost.

Azure SQL Database is a fully managed Platform-as-a-Service offering that provides built-in high availability, automated backups, and automatic patching, eliminating all VM and OS management. For migrating a single on-premises SQL Server database, it delivers the needed storage, indexing, and query capabilities without the overhead of maintaining infrastructure, making it the simplest, most cost-effective PaaS choice.

Point-in-time restore (PITR) is the correct solution because it recreates a database to any specific second within the automated backup retention period (default 7 days, up to 35 days for vCore) by replaying transaction logs over a full backup. This lets you roll back an accidental table drop, erroneous UPDATE, or malformed migration without affecting the current production database — the restore creates a new database at the chosen timestamp. It directly addresses the logical error scenario described.

Dynamic Data Masking (DDM) in Azure SQL Database is the correct choice because it applies masking functions to designated sensitive columns at query time, so unauthorized users see obfuscated values (for example, xxxx-xxxx-xxxx-1234) while the underlying stored data remains unchanged. DDM does not alter the database physically; instead, it transforms the result set in place, and users with the ALTER ANY MASK permission can still query the unmasked values. This precisely matches the requirement to hide sensitive data from query results while leaving the data intact.

Serverless is the correct choice because Azure SQL Database's serverless compute tier is explicitly designed for intermittent workloads like this reporting application. It automatically pauses the database after a configurable period of inactivity (default 60 minutes) and resumes instantly on the next connection, so compute is billed only on actual usage per second during active periods. Storage remains billed separately at all times, but eliminating idle compute charges makes it far cheaper than provisioned models for a reporting app that is used sporadically.

ON DELETE CASCADE is the correct choice because it declaratively tells the database to automatically delete all rows in the Orders table that reference a customer when that customer's row is deleted from the Customers table. This is a built-in referential action on the foreign key constraint, ensuring that no orphaned order rows remain and that the deletion is atomic and enforced by the database engine. Unlike procedural triggers, it cannot be bypassed accidentally and requires no custom T-SQL logic. This exactly meets the requirement for removing a customer and their associated orders.

Azure SQL Managed Instance is a fully managed PaaS deployment that provides near 100% surface-area compatibility with on-premises SQL Server, including instance-scoped features such as SQL Agent jobs, Service Broker, Database Mail, and CLR assemblies. It integrates with a customer's virtual network yet offloads patching, backups, and high availability to Azure, making it the ideal choice for a lift-and-shift migration with minimal application changes. Unlike single databases, it supports cross-database queries and the full T-SQL surface needed by legacy workloads.

Azure SQL Database is a fully managed PaaS relational database service that automatically handles scaling, high availability, and patching. It eliminates OS management and offers consumption-based pricing models. This aligns perfectly with the company's requirements for a hands-off, scalable relational database on Azure.

Active geo-replication is a built-in Azure SQL Database feature that continuously replicates committed transactions to readable secondary databases in a different Azure region. It supports up to four secondaries per primary, and you can manually initiate failover or configure read workloads to query the secondaries for load balancing. These secondaries are real database endpoints, making the feature a direct high-availability and disaster-recovery mechanism with no need to set up any external infrastructure.

Partition elimination is a query-processing optimization that allows Azure SQL Database to access only the partition(s) relevant to a query's predicate on the partition key, instead of scanning the entire table. When a WHERE clause includes the partitioning column and the values are sargable, the optimizer can read far fewer pages, reducing I/O and improving response time. This is particularly valuable for large fact tables in a data warehouse where reports typically filter by date ranges.

A DEFAULT constraint with GETDATE() supplies the current date and time automatically at insert time, so the OrderDate column is populated server-side. This satisfies the requirement to avoid any application-side logic, since the value is generated by the database engine itself.

Auto-failover groups provide a read-write listener endpoint that redirects connections to the secondary region automatically during an outage, satisfying the automatic failover requirement. They also support asynchronous replication with configurable grace periods, keeping data loss minimal across the multiple Azure regions described.

Azure SQL Managed Instance is the correct choice because it is a PaaS offering that provides near-100% compatibility with on-premises SQL Server, including instance-level features such as cross-database queries using three-part names, SQL Server Agent, linked servers, and CLR. You get the administrative benefits of Azure (automated backups, patching, and high availability) without sacrificing the instance-scoped functionality these 15 databases likely rely on. This makes it ideal for lift-and-shift migrations where you need reduced overhead but full SQL Server instance behavior.

The ARM template snippet is a match for an Azure SQL Database logical server. The `Microsoft.Sql/servers` resource type uses exactly the properties shown: a server name, `administratorLogin`, `administratorLoginPassword`, and a location. A logical server is a management container for SQL databases and elastic pools, and this template is the standard way to provision that container before adding databases, firewall rules, or other child resources.

An elastic pool allows multiple databases to share a pool of resources. Databases automatically use resources as needed, maximizing utilization and lowering cost while providing predictable performance per database via settings like min and max vCores.

Transparent data encryption (TDE) encrypts the actual database files (data and log files) at rest by performing real-time I/O encryption and decryption of pages as they are written to and read from disk. The encryption uses a database encryption key that is protected by a certificate or asymmetric key stored either in Azure Key Vault or managed by the service. This operation is transparent to applications, requiring no changes to application code or queries, and explicitly provides the data-at-rest encryption that the question is asking about.

Active geo-replication continuously replicates committed transactions from the primary Azure SQL database to a secondary database in a different Azure region using asynchronous Always On technology. It is the intended disaster-recovery feature because it maintains a readable warm standby that can be promoted during an outage, and when paired with an auto-failover group it can switch customer traffic automatically. This directly addresses the requirement for cross-region availability in a multinational e-commerce deployment.

Azure SQL Database elastic pools share a set of eDTUs or vCores across multiple databases, letting a SaaS provider assign per-database minimum and maximum performance limits. This design absorbs unpredictable usage spikes from different tenants without over-provisioning each database, making it the most cost-efficient and operationally simple choice for a large multi-tenant workload.

A failover group on Azure SQL Database wraps the underlying geo-replication into an automatic, policy-driven failover mechanism, with a read-write listener and a separate read-only listener for reporting workloads. The readable secondary in a different region gives the corporation both a hot standby and a queryable copy for analytics, while automatic failover handles a regional outage without manual intervention. Failover groups are the intended PaaS database-native pattern for exactly this mission-critical, multi-region scenario.

An integer IDENTITY column provides sequential values that reduce fragmentation and page splits, improving insert performance. The nonclustered index on TransactionID supports efficient point lookups. This is a recommended pattern when the natural key is not ideal for clustering.

Reorganizing the clustered columnstore index invokes the tuple mover to force closed rowgroups into compressed segments, merge small compressed segments, and eliminate logically deleted rows. This compacts the physical storage, improves segment density and min/max statistics, and accelerates scan pruning and predicate evaluation. It is the correct, online operation for resolving columnstore fragmentation in Azure Synapse Analytics while avoiding a full rebuild.

Atomicity is the ACID property that treats a transaction as an indivisible unit: all statements inside it must succeed, or the entire transaction is aborted and any already-applied changes are rolled back to the original state. In Azure SQL Database, atomicity is implemented via the transaction log and rollback operations—if the second UPDATE of the patient record fails, the first UPDATE is undone, ensuring that the two rows are always updated together. This directly fulfills the hospital's requirement that both rows be updated or neither, regardless of where the failure occurs.

Azure SQL Managed Instance is the correct choice because it provides near 100% surface area compatibility with on-premises SQL Server, including SQL Server Agent, linked servers, and cross-database queries within the same instance. As a Platform-as-a-Service (PaaS) offering, it handles patching, backups, and high availability automatically, which directly satisfies the requirement to minimize management overhead during migration. This makes it ideal for a 500 GB database with dependency on SQL Server-specific features.

Azure SQL Managed Instance offers high compatibility with on-premises SQL Server, including SQL Agent, Service Broker, and cross-database queries. It is a PaaS solution that requires minimal to no application code changes, making it the best fit for this scenario.

Normalization is the systematic process of structuring a relational database into separate, related tables to eliminate data redundancy, reduce update anomalies, and enforce data integrity. It progresses through normal forms—starting with 1NF for atomic values, then 2NF and 3NF for partial and transitive dependencies—which collectively guide table decomposition. For many-to-many relationships, normalization specifically calls for a junction (associative) table containing foreign keys from both parent tables, making this the correct answer for the designer's goal.

This composite nonclustered index places CustomerID as the leading key, enabling the query optimizer to perform an efficient index seek on the equality predicate CustomerID = @Customer. Because OrderDate is the second column, all rows for a given customer are stored in ascending OrderDate order, so the storage engine can return the results in the required sorted order without a separate SORT operator. If the SELECT list is limited to CustomerID, OrderDate, and perhaps other included columns, the index can also be covering, further eliminating base-table lookups. This design directly matches the WHERE and ORDER BY patterns and is the recommended approach for this query.

Azure SQL Managed Instance is a fully managed PaaS service that provides near-total compatibility with on-premises SQL Server. It supports CLR assemblies, stored procedures, SQL Server Agent, linked servers, and other instance-level features, making it the ideal target for a seamless migration. Because Microsoft handles patching, backups, and high availability, it combines the benefits of a managed service with the compatibility requirements of the existing database.

Azure SQL Database stores relational data in tables with enforced schemas, primary and foreign keys, and full T-SQL querying, satisfying the stem's requirement for a relational store. As a fully managed platform service, it handles patching, backups and high availability, letting you deploy a relational database without managing underlying infrastructure.

This composite index supports the exact filter (CustomerID and OrderDate), the sort order (OrderDate DESC is included in the key), and the included TotalAmount column eliminates key lookups, making it a covering index for the query.

Transparent Data Encryption encrypts Azure SQL Database data and backups at rest at the page level, using a database encryption key protected by a key vault. This satisfies the regulatory requirement for encryption at rest without application changes.

Read scale-out is correct because Azure SQL Database automatically provisions a read-only replica in the Premium, Business Critical, or Hyperscale service tiers, and you can route reporting queries to that replica by adding `ApplicationIntent=ReadOnly` to the connection string. This offloads read-only workloads from the primary replica, preserving its performance for OLTP traffic, and it operates within the same region as the primary. This is the simplest architectural solution because it requires no separate database, manual copying, or cross-region setup—just a connection string change to enable read-only routing.

Azure SQL Managed Instance is a fully managed PaaS service that provides near-total compatibility with the on-premises SQL Server engine, including support for SQL Server Agent jobs and cross-database queries using three-part names. It also offers automatic backups, patching, and high availability, so the 2 TB database can be migrated with only minimal application and code changes. For a financial company looking to move off an on-premises SQL Server while preserving existing features, Managed Instance is the correct choice.

This index directly supports both the filter and the sort requirements because the index key columns are listed as (CategoryID, Price), and the Price column is explicitly designated as descending. For a given CategoryID, the index entries are stored in descending Price order, so the query optimizer can perform a seek to the first matching row and then scan forward to retrieve rows already sorted exactly as requested, eliminating the need for a sort operator. Additionally, if the query only references these two columns, the index is covering and avoids lookups, making it the optimal choice for this predicate and ordering.

A nonclustered index with CustomerID as the leading key and SaleDate as the second key lets the query engine perform an index seek on CustomerID (equality) and then efficiently navigate the ordered SaleDate values within that customer's rows for range filtering. Because the index entries are sorted by CustomerID first and SaleDate second, the engine can stop scanning as soon as the date condition is met for that customer. This index also covers queries that only return CustomerID and SaleDate, avoiding costly key lookups to the clustered index or heap.

This composite index is correctly ordered for the query filter because DoctorID is used with an equality predicate, so SQL Server can perform a seek directly to that doctor's rows. The subsequent key column, AppointmentDate, is used with a range predicate, and once the seek lands on the doctor, scanning the date range is a narrow, contiguous index scan. This maximizes selectivity and minimizes the number of index rows touched compared to the reversed column order.

Azure SQL Managed Instance is a Platform-as-a-Service deployment that provides the broadest SQL Server engine compatibility among managed offerings, including support for instance-scoped features like SQL Server Agent, CLR integration, database mail, Service Broker, and cross-database queries. This makes it the appropriate migration target for an existing SQL Server instance that depends on instance-level objects or features. Unlike single databases, it exposes a full SQL Server instance boundary, so logins, server roles, and instance-level permissions are preserved.

A composite nonclustered index keyed on CustomerID then OrderDate DESC satisfies the equality predicate, supports the descending range scan without a sort, and covering TotalAmount via INCLUDE avoids key lookups back to the clustered index, eliminating the residual lookup per row.

Long-term retention (LTR) enables you to retain full database backups for up to 10 years (or a custom period) in a separate storage container, independent of the automated point-in-time restore (PITR) backups. LTR policies are defined at the database or server level and can specify weekly, monthly, or yearly backup schedules. Because LTR stores these full backups in a dedicated vault and allows restores to any specific point within the retention window, it directly satisfies the 7-year compliance requirement for financial data.

Active geo-replication allows you to create up to four readable secondary databases in the same or different regions. Application read queries can be directed to these secondaries, distributing the read load and improving performance without modifying application logic.

Elastic pool is correct because it aggregates compute and storage resources across the 15 databases, letting each database automatically consume up to the pool's configured limit during demand spikes. Under the vCore or DTU purchasing models, you pay for the pool's total resource ceiling, not per-database provisioning, which is ideal for workloads like these that are unpredictable but whose peaks do not align across all databases. This shared-resource model keeps costs lower while still guaranteeing a minimum performance level for every database through per-database min/max settings.

This composite nonclustered index is precisely tuned for queries that filter by a specific CustomerID and a range of OrderDate values. The leftmost key column CustomerID enables an equality seek, immediately narrowing the scan to that customer's rows, while OrderDate as the second key column lets SQL Server traverse a contiguous, ordered subset of the B-tree for the date range instead of scanning the entire table. Because the index stores both filter keys together, it also reduces the number of key lookups needed to retrieve the row data, making it the most efficient choice for the described e-commerce workload.

A composite index on (DeviceID, Timestamp) directly matches the query's equality predicate on DeviceID and range predicate on Timestamp. The leftmost prefix rule lets the optimizer seek to the exact DeviceID value and then use the Timestamp column to efficiently navigate the range, retrieving only the relevant rows in sorted order. This minimizes both the number of index pages read and the associated key lookups, making it the ideal choice for high-volume IoT data where per-device temporal queries are frequent.

Auto-failover groups provide automatic failover to a secondary region, include a readable secondary, and meet the RPO of 5 seconds and RTO of 30 minutes.

Rebuilding the nonclustered index on OrderDate with a FILLFACTOR of 80 is correct because it compacts the index while reserving 20 percent free space in each leaf-level page. This free space accommodates the page splits that frequently occur when new orders are inserted with OrderDate values that fall between existing rows. By reducing page splits, you also reduce logical and extent fragmentation, which lowers I/O for range scans and keeps index performance predictable as new orders accumulate.

Azure SQL Database elastic pools are designed specifically for multi-tenant SaaS: you purchase a shared pool of eDTUs or vCores and place each tenant in its own database inside that pool. Each database is assigned a minimum and maximum resource limit, allowing idle tenants to contribute unused capacity to busy tenants while still guaranteeing a base level of performance. This automatically balances cost and performance across thousands of small, intermittently active tenant workloads, making it the ideal choice for this scenario.

Azure SQL Managed Instance provides near-full SQL Server surface area, supporting SQL Server Agent jobs and linked servers, so the existing database migrates with minimal application changes. It also delivers built-in automated backups and patching, satisfying both stated requirements.

This composite nonclustered index uses AccountID as the leading key, allowing the query optimizer to seek directly to the index entries for the requested account. Within that account, TransactionDate is the second key column, so the index can perform an ordered range scan to retrieve only the rows whose transaction date falls within the specified window. Because the index contains both columns in its key, it can cover this query without returning to the clustered index, minimizing logical reads and making it the most efficient choice for the described filter.

Query Store is the SQL Server and Azure SQL Database feature that captures runtime query metrics such as CPU, duration, and execution counts. The QueryStoreRuntimeStatistics table is populated only when Query Store has been enabled for the database; if it has never been turned on, no rows are written to that table and the KQL query correctly returns an empty result set. Enable Query Store with ALTER DATABASE ... SET QUERY_STORE = ON to begin collecting this telemetry.

Rebuilding the index online is the best approach because it eliminates fragmentation caused by page splits and logical ordering issues without locking the underlying table for the entire operation. Azure SQL Database supports the ONLINE option for both clustered and nonclustered index rebuilds, allowing concurrent user queries to continue during the rebuild. This minimizes downtime for the order management system while restoring the index's B-tree structure to a defragmented state.

This index creates a composite key with Department as the leading column, allowing precise seeks for the equality filter, while HireDate as the second key column ensures rows are read in the exact sort order required by ORDER BY, eliminating a separate sort operator. By adding all other columns referenced in the query (such as employee details and salary) as included columns, the index becomes a covering index; the storage engine can return every required column directly from the index pages without performing expensive key lookups to the clustered index, drastically reducing I/O and providing optimal performance for this selective, sorted retrieval pattern.

The location string 'https://mystorageaccount.blob.core.windows.net/container' uses the blob.core.windows.net service endpoint, which is the unique DNS suffix for Azure Blob Storage. When you create an external table in Azure SQL Database or Azure Synapse Analytics, you define an external data source with a LOCATION that points to a Blob Storage path. Because the exhibit clearly shows this endpoint, the underlying service must be Azure Blob Storage.

The vCore-based serverless compute tier is the right fit because it provisions compute capacity for Azure SQL Database that autonomously scales between a configurable minimum and maximum number of vCores based on demand. During periods of low or no activity—such as nights and weekends—the service can scale down to the minimum vCores or fully pause the database, after which billing for compute stops entirely while storage and backups continue to be charged at their own rates. When traffic returns, it resumes automatically, enabling peak-load handling without paying for idle capacity. This directly minimizes costs over a variable workload while preserving compatibility with the vCore architecture.

Always Encrypted encrypts individual columns such as SSNs at rest and keeps the keys outside the database engine, so only clients holding the column master key can decrypt them. This satisfies HIPAA's requirement that only authorised users access sensitive data.

The Serverless compute tier for Azure SQL Database dynamically scales compute resources between a minimum and maximum vCore range and automatically pauses an idle database—typically after one hour of inactivity—while billing only for the vCores consumed per second. This model is ideal for intermittent, variable workloads where demand fluctuates unpredictably, as it eliminates the cost of maintaining idle capacity. Unlike the other provisioned tiers, it does not charge for compute when paused, only for storage.

This is the correct design because it creates a covering, composite index whose leftmost key column matches the equality filter on CustomerID, while the second key column OrderDate is flagged DESC to match the ORDER BY direction. The query optimizer can perform an index seek on CustomerID and then read rows from the index in exactly the required sort order, eliminating the sort operator entirely. By including any additional columns referenced in the SELECT list, the index becomes covering, avoiding expensive lookups back to the clustered index.

Azure Database Migration Service (DMS) is the correct choice because it provides online migration capabilities with minimal downtime for on-premises SQL Server databases. DMS performs an initial data and schema copy, then continuously replicates ongoing changes using transaction log shipping, allowing you to cut over only when you are ready. This near-zero downtime approach satisfies the requirement for migrating a large database without an extended outage.

This composite index covers the query predicate perfectly. CustomerID is the equality column, and OrderDate is the range column. The index allows the database engine to efficiently locate rows for a specific customer and then scan a small range of dates.

Azure SQL Database is a PaaS service that handles patching, supports elastic query for cross-database queries, and allows collation settings on a per-database level. It does not include SQL Agent or linked servers, which are not required here.

Azure SQL Database auditing tracks database events and writes them to an audit log in Azure Storage, Azure Monitor, or Log Analytics, capturing actions like INSERT, UPDATE, and DELETE along with user, time, and affected data. This feature retains the logs for a configurable period, which can be years, enabling the company to prove and review exactly what data was modified and by whom. It directly meets the need to audit all data modifications.

Normalization is the formal process of decomposing large tables into smaller, related tables based on functional dependencies, with the goal of eliminating duplicate data and ensuring each fact is stored only once. By applying normal forms such as 1NF, 2NF, and 3NF, the designer removes update anomalies and ensures consistency, directly satisfying the requirement to reduce data redundancy.

In-Memory OLTP creates memory-optimized tables and can use natively compiled stored procedures, which avoid the latch and lock overhead typical of disk-based tables by using optimistic concurrency and row-versioning. For a high-volume order processing system, this directly attacks the primary bottlenecks—latch contention and blocking on hot b-tree pages—so more transactions can commit concurrently with fewer retries and lower wait times. This makes it the appropriate choice from the listed options for improving write performance under heavy concurrent transaction load.