Sign in
Home/CompTIA/CompTIA DataSys+ (DS0-001)/Free questions

CompTIA DataSys+ (DS0-001) — Free Practice Questions

10 free sample questions from a bank of 10, with the correct answers and explanations. No signup required — start practising right now.

1Over the weekend, a company’s transaction database was moved to an upgraded server. All validations performed after the migration indicated that the database was functioning as expected. However, on Monday morning, multiple users reported that the corporate reporting application was not working. Which of the following are the most likely causes? (Choose two.)
  • The access permissions for the service account used by the reporting application were not changed.
  • The new database server has its own reporting system, so the old one is not needed.
  • The reporting jobs that could not process during the database migration have locked the application.
  • The reporting application’s mapping to the database location was not updated.
  • The database server is not permitted to fulfill requests from a reporting application.
  • The reporting application cannot keep up with the new, faster response from the database.
Answer: A, D

The short version

A and D — the reporting app's service account permissions and its database connection mapping were not carried to the new server.

Everything the app does depends on those two things being correct, and neither is exercised by a database-side validation run.

Key concepts

  • Service account: a dedicated database login created for an application rather than for a person, granted only the permissions that application needs.
  • Grant / permission scope: privileges granted to a login on the target objects. A new server means new grants; permissions do not migrate with the data.
  • Connection mapping: the client-side alias or descriptor (for example an Oracle TNS network service name, or a SQL Server data source / ODBC DSN) that tells the reporting app which host and service to connect to.
  • Post-migration validation: tests run immediately after a move that verify the database itself; they do not necessarily exercise every application login or client configuration.
  • Regression: a change that is correct in isolation but breaks dependent systems that were not part of the test.

Why A and D are correct

The pattern — a clean migration, working server, then a dependent reporting application failing the next business morning — points at the two things that live outside the database files.

  • A. Service account permissions: object privileges live in the database's data dictionary and are not part of the moved data or the new server's configuration. When the database was relocated to an upgraded server, the reporting application's login either was never created there or was created without the specific SELECT rights on the reporting objects. Post-migration validations passed because they were run as a different, more privileged principal, so the failure only appears when the reporting job connects as its own service account on Monday.
  • D. Connection mapping: the reporting application's connection information is client-side configuration, not database content. It still points at the old server's network alias or descriptor, so on Monday the application cannot locate the database at all. That is a configuration artefact that survives the data move untouched, which is exactly why nothing in the migration appeared to fail.

Why the others are wrong

  • B. Whether the new server ships with its own reporting facility is irrelevant to why an existing application stopped working; an application that is still calling the database needs working access regardless of what administrative tooling is installed.
  • C. Jobs that could not run during the migration would be visible in the database's own diagnostic views as active blocking sessions, and the failure would start during the migration window rather than on Monday. The scenario also reports the database functioning as expected afterwards.
  • E. The premise says all validations passed on the new server, which would not be the case if the server refused the reporting application entirely; and "not permitted" describes the missing-grant situation already covered by A rather than a distinct cause.
  • F. A faster server makes responses arrive sooner; it cannot make an application fail. A client that could not keep up with fast responses would fail in a different way, and would not appear only after a migration that left the database functionally identical.

DS0-001 exam tip

Database moved, data fine, dependent application broken on Monday → check the two things outside the data: the application's service account grants and its connection string/TNS mapping.

2Given the following customer table: Which of the following ORM snippets would return the ID, state, and country of all customers with the newest customers appearing first?
CompTIA DataSys+ (DS0-001) question 2CompTIA DataSys+ (DS0-001) question 2CompTIA DataSys+ (DS0-001) question 2CompTIA DataSys+ (DS0-001) question 2CompTIA DataSys+ (DS0-001) question 2
Answer: B

The short version

B — it projects only ID, state and country and adds an ORDER BY on the customer date descending.

Two requirements, two clauses: a restricted projection and a newest-first sort.

Key concepts

  • Projection: selecting a specific subset of columns instead of *, which cuts the columns returned over the wire and expresses the intent in the query.
  • ORDER BY ... DESC: sorts the result set from the largest value of the sort column to the smallest; applied to the customer's date-added column it puts the newest customers first.
  • ORM (object-relational mapper): a layer such as Entity Framework, LINQ to SQL or Hibernate that turns a query expression or lambda into SQL and materialises rows as objects.
  • Select projection into a new shape: the ORM idiom for returning fewer columns than the entity, for example an anonymous-type projection selecting only the fields needed.
  • Materialisation cost: fetching every column of a wide customer table when only three are needed increases I/O, memory use and object-mapping work.

Why B is correct

The requirement has two independent parts and the correct snippet satisfies both. First, only ID, state and country should come back, so the query projects those three columns explicitly rather than returning the whole customer entity; that both matches the question and avoids the cost of shipping and mapping unused fields. Second, "newest customers appearing first" is an ordering requirement, so the query applies a descending sort on the column that records when the customer was created, for example ordering by the date-added field descending. A snippet that omits either half is wrong: one that returns the right columns in arbitrary order does not answer the question, and one that sorts but returns every column does not return what was asked for.

Why the others are wrong

  • A. It fails one of the two stated requirements — it either returns the full customer record rather than only ID, state and country, or it lacks a descending sort on the customer date so the newest customers do not appear first.
  • C. It sorts ascending, so the oldest customers lead the result set, which is the exact opposite of "newest first". Ordering descending is the decisive detail in this question.
  • D. It does not produce the ordered, three-column result the question asks for — either the ordering clause on the customer date is missing (leaving the row order undefined) or the projection includes other columns instead of just ID, state and country.

DS0-001 exam tip

"Return these columns, newest first" always means projection + ORDER BY <date column> DESC. If a snippet forgets the ORDER BY, the row order is whatever the engine happens to produce — never rely on it.

3A DBA is reviewing the following logs to determine the current data backup plan for a primary data server: Which of the following best describes this backup plan?
CompTIA DataSys+ (DS0-001) question 3
  • Monthly full, daily differential
  • Daily differential
  • Daily full
  • Weekly full, daily incremental
Answer: D

The short version

D — Weekly full backups with daily incremental backups.

The logs show fulls taken on a weekly cadence and incrementals taken every day, which is the classic full-plus-incremental plan.

Key concepts

  • Full backup: copies all pages, making it self-contained and the anchor point for any later restore.
  • Incremental backup: records only the pages changed since the previous backup of either type, so each one depends on the full and on all preceding incrementals in the chain.
  • Differential backup: records changes since the last full backup only; each differential is independent of earlier differentials but grows longer as the next full recedes.
  • Backup schedule evidence: in the transaction-log records, full and incremental/differential entries carry different log identifiers, which is what reveals the real plan.
  • Restore chain: incremental restores must replay the chain in order from the full; a missing or wrong-order member makes the whole restore fail.

Why D is correct

Reading the logs, the backup entries alternate between a full-type backup taken on a regular weekly cadence and incremental-type backups recorded every day. That is the signature of a weekly full with daily incrementals. Incrementals only capture changes since the last backup, so the plan is only restorable because the weekly full periodically resets the baseline: a restore replays the most recent full, then each daily incremental in order back to the recovery point. The weekly anchor also bounds the worst-case restore work, because the incremental chain never grows longer than a week.

Why the others are wrong

  • A. Monthly fulls with daily differentials would show fulls roughly four weeks apart and differential entries in between. The logs show fulls far more often than monthly, and a monthly anchor is a poor design because the differential set would have to be retained and replayed for a very long window.
  • B. A differential-only plan is incomplete. Differentials accumulate against the last full, so without frequent fulls there is no baseline to restore from within a reasonable time, and the missing full-type entries in the logs would be visible.
  • C. Daily fulls would mean every log entry is a full backup. The presence of incremental entries immediately after fulls shows that not every backup is capturing the entire database, which rules out a pure daily-full schedule.

DS0-001 exam tip

Tell them apart in the logs: differentials accumulate since the last full, incrementals accumulate since the last backup of any kind. Alternating full + small frequent entries = weekly full, daily incremental.

4A database administrator needs to ensure that a newly installed corporate business intelligence application can access the company’s transactional data. Which of the following tasks should the administrator perform first?
  • Create a new service account exclusively for the business intelligence application.
  • Build a separate data warehouse customized to the business intelligence application's specifications.
  • Set up a nightly FTP data transfer from the database server to the business intelligence application server.
  • Send the business intelligence administrator the approved TNS names file to configure the data mapping.
  • Open a new port on the database server exclusively for the business intelligence application.
Answer: A

The short version

A — Create a dedicated service account for the business intelligence application.

Authentication requires an identity the database recognises, and least privilege says that identity must be separate from human accounts.

Key concepts

  • Service account: an application-specific database login, distinct from any individual user account, so that its grants and audit trail are isolated.
  • Least privilege: grant an account only the permissions its workload needs, rather than reusing an administrator or human login with broad rights.
  • Authentication vs authorisation: a connection is first authenticated (who are you) and then authorised (what may you read); creating the account is the authentication prerequisite.
  • Network listener / TNS names.ora: client-side configuration that maps a logical service name to a host and port; it configures how to reach the server, not who may connect.
  • Data warehouse / ETL: an architectural consolidation project that moves reporting workloads off transactional systems; a long-term design decision, not a first step.

Why A is correct

A newly installed BI application that must read transactional data needs something to log in as. That identity does not exist yet on a corporate database server, and the correct administrative practice is to create a dedicated account for it rather than lending an existing human or administrator login — that keeps the audit trail attributable to the application, allows its permissions to be tuned independently, and enforces least privilege. Creating the service account (and then granting the specific read permissions it requires) is the task that unblocks everything else: no amount of connectivity configuration will let an application query data if it has no valid login.

Why the others are wrong

  • B. Building a separate data warehouse is a large architectural programme that would normally follow from a decision to offload reporting, not the first step to give an existing BI tool access. It does not answer the immediate requirement of letting the installed application read the transactional data.
  • C. A nightly FTP file transfer is a workaround that sidesteps the database entirely. It delivers stale point-in-time extracts rather than live access, and it creates a second copy of the data outside the database's access controls.
  • D. Sending an approved TNS names file is client-side connectivity configuration. Even with perfect naming, without a login and grants the application still cannot authenticate and read data, so this is at best a later step and it is the wrong first task.
  • E. Opening a port only affects network reachability. Database access is authenticated per login, not per port, so a new port grants no permissions and would in fact broaden the server's exposure unnecessarily.

DS0-001 exam tip

New app needs data → first create a service account with least privilege. Network/port/TNS changes only affect reachability; they never substitute for a login and grants.

5Which of the following scripts would set the database recovery model for sys.database?
CompTIA DataSys+ (DS0-001) question 5CompTIA DataSys+ (DS0-001) question 5CompTIA DataSys+ (DS0-001) question 5CompTIA DataSys+ (DS0-001) question 5
Answer: A

The short version

A — it uses the valid form ALTER DATABASE ... SET RECOVERY <model> against the target database.

Changing a database's recovery model is a database-level administrative command, and only one syntax actually performs it.

Key concepts

  • Recovery model: a database-level setting (SIMPLE, FULL, BULK_LOGGED) that determines how the transaction log is truncated and whether point-in-time restore is possible.
  • ALTER DATABASE ... SET RECOVERY: the T-SQL statement that changes a database's recovery model; the model name must be one of the three valid keywords.
  • Full vs simple recovery: full recovery keeps the log so it can be replayed for point-in-time recovery; simple recovery truncates the log at checkpoints, so log backups cannot be used.
  • DDL context: the statement must be issued against the intended database (via USE or a three-part name) so the change applies to the correct scope.
  • Syntax vs semantics: a statement can be syntactically invalid (so nothing changes) or valid but scoped to the wrong database or the wrong object.

Why A is correct

Setting a recovery model is a declarative change to a database's configuration, so it must be expressed with ALTER DATABASE followed by SET RECOVERY and one of the model keywords. The correct snippet issues exactly that against the intended database, which changes the setting and makes it persist in the database's configuration. This matters practically because the recovery model governs log truncation behaviour and therefore whether point-in-time recovery is available — so it is the first decision to get right when configuring backup and recovery. Any snippet that uses a different verb, omits the SET keyword, or names a value that is not one of SIMPLE, FULL or BULK_LOGGED is rejected by the engine and leaves the recovery model untouched.

Why the others are wrong

  • B. It does not change the recovery model because it is not valid for this purpose — the required ALTER DATABASE ... SET RECOVERY <model> structure is broken or the model keyword is invalid, so the statement is rejected as a syntax error and the setting stays as it was.
  • C. It uses a data-manipulation verb such as UPDATE on a system catalog or view rather than ALTER DATABASE. UPDATE changes rows in a table or catalog view; it does not issue a database-level configuration command, so the recovery model is unaffected.
  • D. It either targets the wrong scope (a file, a user or the wrong database) or leaves out a required clause. Because the recovery model is a database-level property, a statement that does not name the database with SET RECOVERY cannot achieve the change regardless of how it is worded.

DS0-001 exam tip

Only one form changes a recovery model: ALTER DATABASE <db> SET RECOVERY { SIMPLE | FULL | BULK_LOGGED }. Remember SET and the three legal keywords — everything else is a syntax error.

6A database administrator is conducting a stress test and providing feedback to a team that is developing an application that uses the Entity Framework. Which of the following explains the approach the administrator should use when conducting the stress test?
  • Capture business logic, check the performance of codes, and report findings.
  • Check the clustered and non-clustered indexes, and report findings.
  • Review application tables and columns, and report findings.
  • Write queries directly into the database and report findings.
Answer: A

The short version

A — capture the business logic, exercise it under load, measure code performance and report findings.

A stress test of an Entity Framework application has to drive load through the application, because the ORM's behaviour is part of what is being tested.

Key concepts

  • Stress testing: pushing load beyond expected capacity to observe where the system degrades, and reporting measured behaviour as evidence.
  • Entity Framework (ORM): maps objects to tables; its runtime behaviour includes change tracking, lazy loading, LINQ-to-SQL query translation and connection pooling.
  • N+1 query problem: a common ORM defect where a parent query plus one extra query per related entity turns a single round trip into dozens, and only appears under realistic application-level access patterns.
  • Query translation / lazy loading: ORM features that defer or rewrite SQL at runtime, so their cost cannot be observed by running SQL directly against the database.
  • Business logic as the test workload: representative application operations are what generate realistic reads and writes for the test to exercise.

Why A is correct

The application under test uses Entity Framework, so the ORM sits between the code and the database. Its overheads — change tracking during long units of work, lazy loading firing extra queries per object accessed, LINQ expressions translated into inefficient SQL, connection pool contention — are produced by the application's own code paths, not by the SQL alone. A meaningful stress test therefore captures the real business logic, runs it under expected and peak concurrency, records code-level and database-level performance, and reports the findings. That is the only approach whose results reflect what end users will actually experience, and it produces the evidence needed to recommend optimisations.

Why the others are wrong

  • B. Reviewing clustered and non-clustered indexes is a database tuning task. Index design matters enormously under load, but it only examines one part of the system and never exercises the ORM's runtime behaviour, so it cannot characterise the application's stress behaviour.
  • C. Reviewing tables and columns is a schema and data-modelling review. It is a static design activity that produces no load and therefore no performance measurements.
  • D. Writing queries directly against the database bypasses the application entirely, so it tests the database server's capability rather than the application's. It would hide exactly the defects that matter here — N+1 access patterns, runaway change tracking, lazy loading and connection exhaustion.

DS0-001 exam tip

Testing an ORM app? Load must go through the application code. Hand-written SQL tests the database, not the app — and the ORM's N+1 and lazy-loading problems only appear under application-level access patterns.

7A database administrator is creating a table, which will contain customer data, for an online business. Which of the following SQL syntaxes should the administrator use to create an object?
CompTIA DataSys+ (DS0-001) question 7CompTIA DataSys+ (DS0-001) question 7CompTIA DataSys+ (DS0-001) question 7CompTIA DataSys+ (DS0-001) question 7
Answer: D

The short version

D — it uses CREATE TABLE with explicit column definitions, constraints and data types to create the customer table.

Creating a table is a DDL operation, and only CREATE TABLE with a column list produces that object.

Key concepts

  • DDL vs DML: CREATE, ALTER and DROP are data definition language statements that change schema; SELECT, INSERT, UPDATE and DELETE are data manipulation language statements that change or read rows.
  • CREATE TABLE: syntax of CREATE TABLE <name> ( <column definition>, ... , <table constraint> ) where each column has a name, a data type and optional constraints.
  • Column definition: a column name, datatype and optional NULL/NOT NULL, default, identity or check constraint.
  • Table constraints: PRIMARY KEY, FOREIGN KEY, UNIQUE and CHECK declared at table level, referenced by constraint name for later ALTER TABLE or drop operations.
  • Other object types: CREATE DATABASE, CREATE VIEW, CREATE PROCEDURE and CREATE INDEX also use CREATE, but each creates a different kind of object.

Why D is correct

The administrator needs a new table to hold customer data, and that requires a data definition statement that declares the structure: the table name and, inside parentheses, a comma-separated list of column definitions with datatypes and constraints. CREATE TABLE is the only statement that creates a table, and specifying datatypes and a primary key at creation time means the schema is correct from the outset rather than needing a series of ALTER TABLE operations afterwards. Note that the type must be chosen deliberately — for customer data, character datatypes for names and addresses, fixed-length or money types for identifiers and balances, and a date/time type for signup dates — because column datatypes drive storage and indexing decisions.

Why the others are wrong

  • A. It does not create the customer table. Either it is a data manipulation statement that operates on rows in an existing table, or it creates a different object entirely, so the table the application needs never comes into existence.
  • B. It cannot produce the required table object, either because it is a query or row-level statement rather than DDL, or because it creates a database or another object type rather than a customer table with columns and constraints.
  • C. It likewise fails to create the customer table, using a form that is either non-standard for this database platform or aimed at a different object type; without explicit column definitions there is no usable table structure for customer data.

DS0-001 exam tip

Need a table? CREATE TABLE name (col type [constraints], ...). Anything with SELECT/INSERT/UPDATE is DML and never creates schema; CREATE DATABASE or CREATE VIEW creates the wrong object entirely.

8A database administrator wants to remove inactive customers from a database. Which of the following statements should the administrator use?
CompTIA DataSys+ (DS0-001) question 8CompTIA DataSys+ (DS0-001) question 8CompTIA DataSys+ (DS0-001) question 8CompTIA DataSys+ (DS0-001) question 8
Answer: D

The short version

D — it uses DELETE with a WHERE clause restricting the rows to inactive customers.

DELETE removes rows permanently, and the WHERE clause is what confines the removal to inactive customers.

Key concepts

  • DELETE: removes matching rows from a table; without a WHERE clause it deletes every row.
  • WHERE predicate: the filter that limits the operation to the target subset, for example WHERE Status = 'Inactive' or a date comparison on last activity.
  • TRUNCATE TABLE: removes all rows quickly without logging each one and resets identity values; it cannot be filtered, so it cannot express "inactive only".
  • DROP TABLE: removes the table definition and all its data from the schema, not just rows.
  • UPDATE: marks rows (for example setting a status or a deleted flag) but leaves the records in place, which is soft deletion rather than removal.
  • Referential integrity: child rows referencing a customer must be handled (or the constraint will block the delete) when removing records from a live system.

Why D is correct

The requirement is to remove inactive customers, which means physically deleting a subset of rows. DELETE FROM Customers WHERE <inactive condition> does exactly that: the DELETE verb removes rows and the WHERE clause narrows the operation to inactive customers only, leaving everyone else untouched. On a live system the administrator would normally wrap the statement in a transaction, count or preview the affected rows with a SELECT using the identical predicate first, and confirm that no child rows block the delete — but the statement pattern the question is testing is DELETE plus a restricting WHERE clause.

Why the others are wrong

  • A. TRUNCATE TABLE cannot be filtered with a WHERE clause, so it would empty the table and destroy active customer records as well. It also resets identity values and is not transaction-logged row by row, which is a further reason it is unsuitable for a partial, sensitive deletion.
  • B. DROP TABLE deletes the table itself — its definition and all of its data — from the schema. That would destroy the structure the online business depends on, which is the opposite of removing a subset of rows.
  • C. An UPDATE only changes column values, so inactive customers would remain in the table, merely flagged or re-stated. That is soft deletion or a status change, not removal, and it would leave the rows consuming space and appearing in future result sets.

DS0-001 exam tip

"Remove some rows" = DELETE + WHERE. TRUNCATE = all rows, no filter. DROP = the table. UPDATE = flags the row, data stays.

9Which of the following is the correct order of the steps in the database deployment process?
  • 1. Connect 2. Install 3. Configure 4. Confirm prerequisites 5. Validate 6. Test 7. Release
  • 1. Configure 2. Install 3. Connect 4. Test 5. Confirm prerequisites 6. Validate 7. Release
  • 1. Confirm prerequisites 2. Install 3. Configure 4. Connect 5. Test 6. Validate 7. Release
  • 1. Install 2. Configure 3. Confirm prerequisites 4. Connect 5. Test 6. Validate 7. Release
Answer: C

The short version

C — Confirm prerequisites, install, configure, connect, test, validate, release.

The order is forced by dependencies: you cannot install before verifying prerequisites, and you cannot configure before the software exists.

Key concepts

  • Prerequisites: hardware, OS version, memory, disk space, licensed software and dependent services that must exist before an installation can succeed.
  • Install: placing and unpacking the database engine or application binaries onto the host.
  • Configure: instance parameters, listener/service settings, storage layout, init parameters and connectivity configuration.
  • Connect: establishing and verifying a client session — the TNS names/service registration and connection test.
  • Test then validate: a functional test proves the components work; validation proves they meet the business and security requirements. Release makes it available to users.

Why C is correct

The sequence is determined by what each step depends on. Prerequisites come first because an unmet requirement discovered after installation means starting over. Installation precedes configuration because there is nothing to configure until the binaries exist. Connection follows configuration, because a client cannot reach a listener until the service and its network configuration are in place. Testing comes after a successful connection, since you cannot test behaviour you have not yet been able to reach. Validation follows testing, because validation asks the separate question of whether the working system meets the specified requirements — and only then is it released to users. C is the only option that respects every one of those dependencies.

Why the others are wrong

  • A. It puts "Connect" before "Install" and "Configure", and buries "Confirm prerequisites" as step four. You cannot connect to a database that has not been installed or configured, and verifying prerequisites after installation defeats the purpose of checking them.
  • B. It starts with "Configure" and only installs in second place, and it places "Connect" before "Test". Configuration before installation is impossible, and testing before a connection has been established assumes a working path that has not been verified.
  • D. It begins with "Install" and does not confirm prerequisites until step three. Installing before confirming prerequisites is exactly the mistake the first step exists to prevent — a failed prerequisite check means the installation has already wasted time or left partial files.

DS0-001 exam tip

Memorise the deployment ladder: prerequisites → install → configure → connect → test → validate → release. Any option that installs before checking prerequisites, or connects before configuring, is out of order.

10A company wants to deploy a new application that will distribute the workload to five different database instances. The database administrator needs to ensure that, for each copy of the database, users are able to read and write data that will be synchronized across all of the instances. Which of the following should the administrator use to achieve this objective?
  • Peer-to-peer replication
  • Failover clustering
  • Log shipping
  • Availability groups
Answer: A

The short version

A — Peer-to-peer (multi-master) replication.

Only multi-master replication lets users read and write on all five instances while changes are synchronised between them.

Key concepts

  • Peer-to-peer / multi-master replication: every node in the topology is both a publisher and a subscriber, so writes are accepted on any instance and propagated to the others.
  • Conflict resolution: the mechanism a multi-master design uses to reconcile concurrent changes on the same row, since no node is the sole authority.
  • Failover clustering: a high-availability design with one active instance (active/passive or active/active at the cluster level) that owns the data, with other nodes standing by.
  • Log shipping: a one-way, periodic transaction-log backup from a primary to a standby, typically in a restore state, so the copy is read-only and lags behind.
  • Availability groups: a primary/replica topology where the primary accepts writes and replicas can be configured for read-only routing.
  • Sharding vs replication: sharding splits rows across instances for scale-out with no automatic synchronisation, which is a different objective from the one stated.

Why A is correct

The requirement is unusual and specific: the workload is distributed across five instances, and users must be able to both read and write on each copy, with changes synchronised everywhere. That is the definition of a multi-master, peer-to-peer replication topology — each instance accepts writes and forwards its transaction log to the peers, so any instance can serve both reads and writes. Because all nodes accept changes, the design must also include conflict resolution for simultaneous edits to the same row, and that capability is what the answer is really testing. The other three options cannot satisfy it: none of them allows writes on every copy.

Why the others are wrong

  • B. Failover clustering provides high availability for a single data set, with one active instance owning writes and others standing by to take over. Users would be writing to one instance and reading from it, not writing to all five.
  • C. Log shipping is a one-way, periodic transfer of the transaction log to a standby, and the standby is normally in a restoring state, so it cannot accept writes. It is a DR mechanism, not a synchronised multi-writer topology.
  • D. Availability groups follow a primary/replica model: writes go only to the primary, and replicas are read-only unless configured for read-only routing. That still leaves a single writer, so "users able to read and write data" on every copy is not met.

DS0-001 exam tip

Ask one question of every replication answer: can more than one node accept writes? Multi-writer = peer-to-peer/multi-master. Single writer = PITR, log shipping, or availability groups — all read-only standbys.

Want the full bank of 10 questions for CompTIA DataSys+ (DS0-001)? See all practice exams.