LookML-Developer 試験問題を無料オンラインアクセス

A developer has a persistent derived table view called user_facts that contains aggregated data for each user. The developer needs to query the data from this table in another derived table view called user_region_facts.
Which strategy should the developer use to write the query for user_region_facts that will leverage the existing derived table?

• A.Copy the name of the database table in the scratch schema for the user_facts derived table.
• B.Write a subquery in the FROM clause and alias with ${user_facts}.
• C.Use ${user_facts.SQL_TABLE_NAME} to reference the user_facts derived table.
• D.Writhe the query form user_facts into a common table expression (WITH user_facts AS...).

Users report that every time they change the filter on their Explore, the filters take a very long time to populate.
How can the developer improve the filtering experience with this Explore?

• A.Add persistence to the base view of the Explore.
• B.Use an access_filter parameter to automatically apply filters.
• C.Limit the filter suggestions using the suggestions parameter.
• D.Add an always_filter parameter to restrict the filter suggestions.

A user reports an error message on an Explore: "Non-unique value/primary key (or sql_distinct_key), value overflow or collision when computing sum".
What should the LookML developer check for in the joined views of the Explore?

• A.Symmetric_aggregates: no is not present in the Explore definition.
• B.No concatenated primary keys are used.
• C.The sum measure used is defined correctly.
• D.A unique primary key is defined in each view.

A developer needs to implement three persistent derived tables (PDTs) as described below.
The PDTs need to be refreshed after the daily ETL pipeline adds incremental loads to the underlying tables.
Each PDT is built off of one underlying table in the database (one PDT per table).
The underlying tables for each PDT are updated one after the other, and a new row is added to an ETL log table each time a table is updated.
Due to the unpredictable nature of the ETL pipeline, each PDT does not refresh at the same time from day to day.
Each PDT takes over an hour to build, and to save on compute costs each PDT should only be refreshed once per day.
How can the developer set up the PDTs according to these requirements?

• A.Create three separate datagroups tied to three PDTs that run when a new row is added to the ETL log table.
• B.Create one datagroup tied to all three PDTs that runs when the total row count across all three tables changes.
• C.Create three separate datagroups tied to three PDTs that run when each corresponding table's row count changes.
• D.Create one datagroup tied to all three PDTs that parameterizes the view name for each PDT in the SQL trigger condition.

A LookML developer has written the following persistent derived table. It references orders_rollup, another persistent derived table that also rebuilds with the same SQL trigger value.

Which change is needed to guarantee that user_facts will always rebuild with the latest data from orders_rollup?

• A.Change the sql_trigger_value parameter of user_facts to select the current date plus one hour, so it triggers an hour after orders_rollup.
• B.Change the orders_rollup view reference to ${orders_rollup.DERVIED_TABLE_NAME}
• C.Change the sql_trigger_value parameter for both persistent derived tables to a datagroup_trigger parameter, and set them to use the same datagroup.
• D.Change the orders_rollup view reference to the literal table name from the database's scratch schema.