Free C1000-190 practice test: 30 questions with answers

A lakehouse uses an open table format with shared metadata over object storage, so SQL engines and data science tools read the same governed tables. Manual nightly copies create drift and extra cost, a single relational server does not suit raw file volumes at scale, and spreadsheets cannot serve SQL or model-training workloads.

Separating storage from compute lets teams add or stop query capacity without moving the data, which remains in shared object storage. The other options describe tightly coupled or duplicated architectures that the lakehouse model is designed to avoid.

Table formats such as Iceberg commit each write through atomic metadata updates, so an incomplete write is never published as a new snapshot. Duplicating files, deleting old files or compressing rows does not stop partial results from being visible.

Bronze holds raw data, Silver holds cleansed and conformed data for joins and downstream processing, and Gold holds business-ready aggregates for reporting. The staging area is a temporary landing step, not one of the medallion layers.

A lakehouse keeps open file formats in object storage but adds table-level transactions, metadata and schema management that plain data lakes lack. The other options describe formats or architectures that are not required or are not defining features.

Iceberg-style table formats keep snapshot history, so a query can read the table as it was at an earlier point in time. Encryption, partitioning and broadcast joins solve different problems and do not restore earlier table states.

In watsonx.data an engine can only use the catalogs it is associated with, which gives it access to table metadata and storage locations. Copying files to workers, exporting CSVs or restarting engines for each query are not required to query catalog tables.

External databases are attached as data sources, and engines can then reference their tables in federated queries alongside lakehouse data. The other options misdescribe the database as a storage replacement, a Spark cluster or a metadata-only catalog.

Spark is designed for distributed batch processing of very large datasets, which suits nightly transformations. Presto is optimised for interactive SQL, while a single database server or a spreadsheet cannot handle terabyte-scale work well.

A catalog maps table names to their metadata, including schema and file locations, so any engine connected to it can read the same tables consistently. It does not store duplicate data, run queries for engines or restrict tables to the engine that created them.

Connecting the existing metastore as a catalog lets engines use the tables where they already are, without a rewrite. Recreating tables by hand, disabling the metastore or archiving the files would add work or break existing jobs.

An engine needs permission to reach the storage location and a catalog association that tells it where the tables are. Bucket naming, manual file copies and a separate results database are not requirements for reading catalog tables.

Column-level policies enforce different visibility per role on the same governed table. A stripped copy creates a second table to maintain, a shared login removes accountability, and monthly history reviews do not prevent exposure.

Least privilege limits every identity to the minimum access required for its role, which reduces the impact of misuse or compromise. Default administrator rights, bucket-wide grants and rare reviews all widen exposure.

Audit logs capture who accessed data and when, which is the evidence needed for a review. Row counts, backups and compression do not record query activity by user.

Secrets managers keep credentials out of code and control who can read them, and regular rotation limits how long a leaked password stays useful. Plain-text comments, shared passwords and committed connection strings all expose credentials.

Dynamic masking applies different visibility to the same column based on the querying role, which satisfies both groups. Renaming columns, moving data to laptops and sharing one key for everyone do not give role-based visibility and create their own risks.

Managing access through groups keeps permissions consistent and easy to audit as people join or leave. Administrator copies, shared logins and lakehouse-wide grants give far more access than the role needs.

Incremental loads with a merge step capture only new and changed rows, which keeps hourly runs fast and the target current. Full reloads, weekly manual exports and drop-and-recreate jobs either reload unnecessary history or fall behind the source.

ETL performs transformations in the pipeline before loading, whereas ELT lands raw data in the target and transforms it there using the target's compute. The other options reverse the order or invent constraints that do not apply.

Enforcing expected types and handling invalid values explicitly keeps good rows flowing while making bad ones traceable. Renaming the table, disabling checks or discarding the whole file either hides the problem or loses valid data.

Table formats such as Iceberg support schema evolution through metadata changes, so an added column does not require rewriting existing data files. Recreating the table, stripping the column or locking the table would each add work or block ingestion.

Idempotent writes and a recorded watermark let a retry resume without duplicating or skipping data. Deleting staging files early, blindly appending retries and hiding errors all make a re-run less reliable.

Continuous streaming ingestion keeps latency within seconds, which batch jobs and periodic uploads cannot provide. Nightly, monthly and weekly loads all introduce delays far longer than the requirement allows.

Partition pruning uses the filter to skip partitions that cannot contain matching rows, which reduces the data read. Column projection, federation and predicate broadcasting are different mechanisms and do not describe skipping partitions.

Federated queries let one SQL statement reference tables across configured catalogs and data sources. Exporting to text files, restricting views to one bucket or creating indexes do not provide cross-source joins in a single statement.

Naming only the needed columns lets a columnar reader skip the others, which reduces the input read. Sorting by every column, nesting full-table copies or exporting to CSV add work rather than reducing the columns read.

Views expose a curated shape of the data, such as selected columns or filtered rows, while the base tables remain the single source. They do not create backups, restrict execution to one node or bypass access controls on the base tables.

JDBC and ODBC drivers are the standard way for BI tools to send SQL to a query engine and receive results without custom code. Copying files, scraping consoles or manual email imports are fragile and do not give the tool live query access.

A left outer join keeps every row from the left table and fills missing order values with nulls, which fits this need. An inner join drops customers without orders, while cross joins and unions do not match customers to their own orders.