Refer to the Exhibit Practice Questions

The database is currently offline.

Why it fails: If the database were offline, the initial connection attempt would fail entirely before the metadata extraction phase. Since the connection is successfully established, the issue is not the server's uptime, but rather the specific permissions or constraints on the table level within the database.

The data table is empty.

Why it fails: Empty tables are perfectly valid in relational databases and Tableau can connect to them without issue. The metadata (column headers) exists regardless of whether the table contains any rows. Therefore, an empty table would not trigger a 'schema is inaccessible' error during metadata retrieval.

The Oracle driver is incompatible with the version.

Why it fails: Driver incompatibility typically leads to immediate connection failure or errors during query execution, not specific metadata access failures after the connection is established. A successful connection indicates that the driver is functioning correctly for basic communication, pointing the root cause toward database permissions instead.

The fields must be joined in the physical layer first.

Why it fails: The error is related to the calculation logic, not the data source structure. Even if the tables were joined, mixing aggregate and non-aggregate fields would still trigger this error. The problem lies strictly in the mathematical syntax used within the calculated field definition.

Calculations cannot reference dimension fields.

Why it fails: Calculations can reference any field, including dimensions. The issue here is that the dimension needs to be aggregated (e.g., using SUM or MIN) so that it matches the aggregate grain of the 'Sales' measure, allowing the math to resolve correctly at the appropriate level.

The data source requires a live connection.

Why it fails: The connection type has no bearing on calculation syntax. Whether you are using a live connection or an extract, the rule regarding mixing aggregate and non-aggregate fields remains the same. This is a fundamental constraint of the calculation language, regardless of how the data is stored.

Change the database schema of the original source

Why it fails: While changing the schema works, it is often outside the scope of a Tableau user's permissions and can have negative impacts on other applications using the same database. It is much better to handle the type mismatch within the Tableau environment using calculations or metadata changes.

Delete the Relationship and use a join instead

Why it fails: Joins also require matching data types for the join key. Switching to a join will not solve the underlying issue of incompatible data formats. You would still face the same error because the database engine cannot compare a string to an integer, regardless of the integration method used.

Restart the Tableau instance

Why it fails: Restarting the software does not resolve structural metadata errors. This is a data preparation issue caused by incompatible types, not a software glitch. Troubleshooting by restarting is a waste of time and does not address the core requirement for aligning data fields as defined by the system.

The data files are too large for the extract engine

Why it fails: File size is unrelated to circular dependency errors. Circularity refers to the logical structure of your join keys, not the volume of records. Tableau's extract engine is highly scalable and handles massive datasets, so you should focus on the schema logic rather than the physical file size.

The primary keys are missing from all tables

Why it fails: While primary keys are good practice for performance, their absence will not cause a circular dependency error. The error specifically addresses the topological structure of the join connections, not the quality or presence of keys within the underlying database schema or the flat file structure.

The join condition involves incompatible data types

Why it fails: Incompatible data types result in join failures or empty sets, but they do not cause a 'circular dependency' error. A circular dependency is a structural issue regarding how the tables are connected to one another, which is independent of the specific values or types within the columns.

Create a new parameter to force numeric conversion.

Why it fails: Parameters are user-input controls used to change values in formulas; they do not convert the data type of an existing field. Using a parameter for type casting is an inefficient workaround that does not solve the underlying issue of the data being incorrectly imported as a string.

Use a hide and unhide operation to refresh the schema.

Why it fails: Hiding and unhiding fields only affects the visibility of the field in the workbook workspace. It has absolutely no effect on the data type or the internal metadata of the source data, meaning it will not resolve errors related to incompatible data types for mathematical operations.

Export the data to CSV and re-import it.

Why it fails: Exporting to CSV and re-importing is a destructive and time-consuming process. It does not guarantee the data type will be correctly inferred upon re-import, and it is entirely unnecessary given that Tableau provides built-in tools to change the metadata interpretation of any field directly within the software.

The join condition uses an incorrect join type.

Why it fails: Changing the join type would not resolve the fundamental issue of grain mismatch. Whether you use an inner or left join, if the relationship between the tables is one-to-many, rows from the side with the lower grain will always be duplicated to match the higher grain side.

The connection is set to Live instead of Extract.

Why it fails: Connection mode has no impact on row duplication during a join. Row duplication is a product of the logical structure of the data and the join conditions applied. Switching to an extract would simply store the duplicated rows in a hyper file, failing to solve the underlying data model issue.

The data contains null values in the join key.

Why it fails: Null values in join keys generally result in dropped rows rather than duplicated rows in a standard left join. The issue here is related to the cardinality of the tables involved, specifically the one-to-many nature of the relationship, which causes the base table records to expand beyond their actual count.

The 10 customers with the lowest profit.

Why it fails: The sort order is set to 'desc', which means descending. In the context of a Top N filter, this retrieves the top 10 highest values. To get the lowest profit, the sort order would need to be changed to 'asc' (ascending) to capture the bottom end of the profit spectrum.

All customers, sorted by profit.

Why it fails: The limit is explicitly set to 10. A Top N filter is inherently exclusionary; it removes all data points that do not fall within the specified top 10 ranking. Therefore, it is impossible for the view to display all customers while the Top 10 limit remains active in the filter policy.

The top 10 customers based on count of records.

Why it fails: The filter policy explicitly names 'Profit' as the field for the ranking calculation. Therefore, the ranking is based on the aggregate value of Profit, not the count of records. If the filter was meant to be based on the count of records, the field parameter would be set differently.

The calculation is using an invalid syntax for the IF statement.

Why it fails: The IF syntax itself is likely correct; the error specifically identifies an aggregation mismatch. Tableau syntax requires that if any part of the logic involves an aggregate function, the other components must be either aggregated or treated as constants, otherwise the calculation engine cannot determine the correct level of granularity.

The data source has not been refreshed with the latest metadata.

Why it fails: Aggregation errors are logical calculation issues, not connectivity or metadata synchronization problems. Refreshing the data source will not resolve a mismatch in the mathematical dimensionality of a formula. The issue lies within the calculation logic authored by the user, independent of the external data source's current status or metadata.

The calculation uses a field that is not in the current view.

Why it fails: Calculations can reference fields not present in the view. The error stems from how fields are combined mathematically within the expression, not their presence in the visualization shelves. The core issue is the logical incompatibility between row-level data and aggregated data when evaluated against each other in a single statement.

The field 'Sales' is a dimension and cannot be used in a calculation.

Why it fails: Dimensions can certainly be used in calculations, even if they are string or date types. The error specifically relates to the mismatch between aggregation levels, not the data type of the field itself. The problem is the mixture of row-level data and a specific aggregate function.

The calculation syntax is invalid because forward slashes are not permitted.

Why it fails: The forward slash is the standard operator for division in Tableau calculated fields. The syntax is perfectly valid; the issue is the mixing of aggregation levels. The error message explicitly points to aggregate/non-aggregate mismatch, not a syntax error related to the mathematical operator being used here.

The 'Profit' field must be converted to a dimension before it can be used.

Why it fails: Converting a measure to a dimension would not fix an aggregation mismatch error. In fact, it would make it impossible to use the SUM() function at all. The goal is to aggregate both fields to perform a meaningful ratio calculation, not to change the data's fundamental role.

The visualization uses a dual axis, which disables the Grand Total option.

Why it fails: Dual axis charts do not inherently disable grand totals. While they can be complex to format, they still support total calculations if the underlying measures are additive. The error message explicitly mentions 'non-additive,' pointing to a problem with the measure's data nature rather than the visualization layout type.

The data source has a circular reference in the relationship model.

Why it fails: Circular references affect data blending and model performance, but they do not cause specific errors regarding the additive nature of a measure in a grand total calculation. The error provided focuses on the measure's properties, not the structure of the underlying data model or the relationships.

The 'Grand Total' feature is only available for crosstab visualizations.

Why it fails: Tableau supports grand totals for bar charts, scatter plots, and various other visualization types, not just crosstabs. This statement is factually incorrect regarding the software's capabilities. The issue is definitively linked to the measure's inability to be summed, not the type of visualization being used to display it.

To increase dashboard rendering speed

Why it fails: Row-level security policies like this are designed for security and compliance, not performance optimization. In fact, applying row-level filters can sometimes decrease performance, as the database must evaluate these filters for every single user request, potentially adding overhead to query execution time and dashboard response.

To automate the creation of new user accounts

Why it fails: User account management is handled by the identity provider or the Tableau Server administrative interface, not by data-level filter mapping policies. The exhibit strictly defines how data should be restricted for existing users, not how those users should be provisioned or authenticated into the system.

To cache data for multiple users in a shared view

Why it fails: Caching behavior is controlled by the server's data engine and workbook configuration. The provided JSON policy is clearly focused on row-level access control. Caching is generally managed at the application server level and is distinct from the filtering logic used to enforce data row visibility.

It calculates the average of all months

Why it fails: The calculation does not average the entire dataset; it uses a window of -3 to 0. This restricts the calculation to a rolling look-back period of 4 months. If it averaged all months, the window parameters would be unnecessary or set differently to reflect the entire data scope.

It calculates the average for the current year

Why it fails: The calculation is based on the partition 'Date_Month', which acts sequentially regardless of the year. There is no logic in the WINDOW_AVG function that resets or filters based on the calendar year, so it would continue across year boundaries rather than restricting itself to a single year.

It is a row-level calculation

Why it fails: WINDOW_AVG is a table calculation, not a row-level calculation. It requires the data to be aggregated in the view first, as it operates on the summarized values in the result set. Row-level calculations are computed for every individual row in the data source, which this does not do.

Create a parameter to divide by total sales

Why it fails: Using a parameter to perform this calculation is overly complex and requires manual updates. It does not provide the dynamic responsiveness of a quick table calculation, which automatically adjusts to filters or data changes, making it a poor choice for this analytical task.

Filter out the top performing regions

Why it fails: Filtering out data is an destructive action that would lead to inaccurate conclusions about the total regional contribution. It solves the readability issue by deleting data rather than by normalizing it, which contradicts the goal of performing a relative comparison of all regions.

Use the 'Running Total' calculation

Why it fails: A running total calculates a cumulative sum across the data, which is useful for trends but does not display the relative proportion or contribution of each individual region. It would not solve the problem of making the map readable for relative performance analysis.

The currency formatting is set to a locale that isn't supported.

Why it fails: Locale settings affect how currency is displayed, but they do not prevent a field from being treated as a numeric type if it was correctly ingested. The issue here is that the field is explicitly identified as a 'String' type, which overrides any formatting rules applied by the locale settings.

The data source requires a live connection for aggregation.

Why it fails: Aggregation is a core function of the Tableau engine and works identically regardless of whether the connection is live or extracted. The type of connection does not determine whether a field can be aggregated; rather, the data type of the field itself dictates which functions are available for analysis.

Tableau automatically treats all revenue fields as dimensions.

Why it fails: Tableau does not automatically treat all revenue fields as dimensions. If a field is numeric, Tableau will default to importing it as a measure. The reason this specific field is a dimension is because it was imported as a string due to the presence of non-numeric currency characters.

The data source requires a data blend, causing a granularity mismatch in the view.

Why it fails: While data blends can cause aggregation issues, the formula provided uses standard measures. The error described is a classic mathematical mistake related to how ratios behave in aggregate functions. Blending is not the primary cause of incorrect ratio totals when working within a single data source context.

The Profit Ratio field is set to a Continuous measure instead of a Discrete dimension.

Why it fails: Continuous vs. Discrete defines the axis and color palette behavior, not the underlying arithmetic. Changing the field to a dimension would not fix the ratio calculation; it would only convert the quantitative measure into discrete headers, which would not solve the core issue of how the sum is computed.

The view is missing a table calculation to define the scope of the aggregation.

Why it fails: Table calculations are used for running totals or percentage of total relative to the window. They are not necessary for a simple ratio of two measures. The issue lies in the definition of the calculated field and its interaction with the visualization's level of detail, not missing table scope.