Free Databricks Associate-Developer-Apache-Spark Exam Questions & Answer from Training Expert VCEDumps [Q25-Q43]

admin July 23, 2022 0 Comments

4.3/5 - (7 votes)

Free Databricks Associate-Developer-Apache-Spark Exam Questions and Answer from Training Expert VCEDumps

Top Databricks Associate-Developer-Apache-Spark Courses Online

Q25. Which of the following describes characteristics of the Spark UI?

Via the Spark UI, workloads can be manually distributed across executors.

Via the Spark UI, stage execution speed can be modified.

The Scheduler tab shows how jobs that are run in parallel by multiple users are distributed across the cluster.

There is a place in the Spark UI that shows the property spark.executor.memory.

Some of the tabs in the Spark UI are named Jobs, Stages, Storage, DAGs, Executors, and SQL.

Q26. Which of the following options describes the responsibility of the executors in Spark?

The executors accept jobs from the driver, analyze those jobs, and return results to the driver.

The executors accept tasks from the driver, execute those tasks, and return results to the cluster manager.

The executors accept tasks from the driver, execute those tasks, and return results to the driver.

The executors accept tasks from the cluster manager, execute those tasks, and return results to the driver.

The executors accept jobs from the driver, plan those jobs, and return results to the cluster manager.

Q27. Which of the following describes tasks?

A task is a command sent from the driver to the executors in response to a transformation.

Tasks transform jobs into DAGs.

A task is a collection of slots.

A task is a collection of rows.

Tasks get assigned to the executors by the driver.

Q28. Which of the following code blocks returns all unique values of column storeId in DataFrame transactionsDf?

transactionsDf[“storeId”].distinct()

transactionsDf.select(“storeId”).distinct()
(Correct)

transactionsDf.filter(“storeId”).distinct()

transactionsDf.select(col(“storeId”).distinct())

transactionsDf.distinct(“storeId”)

Q29. Which of the elements in the labeled panels represent the operation performed for broadcast variables?
Larger image

2, 5

2, 3

1, 2

1, 3, 4

Q30. Which of the following statements about executors is correct, assuming that one can consider each of the JVMs working as executors as a pool of task execution slots?

Slot is another name for executor.

There must be less executors than tasks.

An executor runs on a single core.

There must be more slots than tasks.

Tasks run in parallel via slots.

Q31. The code block displayed below contains an error. The code block should trigger Spark to cache DataFrame transactionsDf in executor memory where available, writing to disk where insufficient executor memory is available, in a fault-tolerant way. Find the error.
Code block:
transactionsDf.persist(StorageLevel.MEMORY_AND_DISK)

Caching is not supported in Spark, data are always recomputed.

Data caching capabilities can be accessed through the spark object, but not through the DataFrame API.

The storage level is inappropriate for fault-tolerant storage.

The code block uses the wrong operator for caching.

The DataFrameWriter needs to be invoked.

Q32. Which of the following describes characteristics of the Spark driver?

The Spark driver requests the transformation of operations into DAG computations from the worker nodes.

If set in the Spark configuration, Spark scales the Spark driver horizontally to improve parallel processing performance.

The Spark driver processes partitions in an optimized, distributed fashion.

In a non-interactive Spark application, the Spark driver automatically creates the SparkSession object.

The Spark driver’s responsibility includes scheduling queries for execution on worker nodes.

Q33. The code block shown below should return a DataFrame with columns transactionsId, predError, value, and f from DataFrame transactionsDf. Choose the answer that correctly fills the blanks in the code block to accomplish this.
transactionsDf.__1__(__2__)

1. filter
2. “transactionId”, “predError”, “value”, “f”

1. select
2. “transactionId, predError, value, f”

1. select
2. [“transactionId”, “predError”, “value”, “f”]

1. where
2. col(“transactionId”), col(“predError”), col(“value”), col(“f”)

1. select
2. col([“transactionId”, “predError”, “value”, “f”])

Q34. The code block displayed below contains an error. The code block should return DataFrame transactionsDf, but with the column storeId renamed to storeNumber. Find the error.
Code block:
transactionsDf.withColumn(“storeNumber”, “storeId”)

Instead of withColumn, the withColumnRenamed method should be used.

Arguments “storeNumber” and “storeId” each need to be wrapped in a col() operator.

Argument “storeId” should be the first and argument “storeNumber” should be the second argument to the withColumn method.

The withColumn operator should be replaced with the copyDataFrame operator.

Instead of withColumn, the withColumnRenamed method should be used and argument “storeId” should be the first and argument “storeNumber” should be the second argument to that method.

Q35. The code block shown below should add column transactionDateForm to DataFrame transactionsDf. The column should express the unix-format timestamps in column transactionDate as string type like Apr 26 (Sunday). Choose the answer that correctly fills the blanks in the code block to accomplish this.
transactionsDf.__1__(__2__, from_unixtime(__3__, __4__))

1. withColumn
2. “transactionDateForm”
3. “MMM d (EEEE)”
4. “transactionDate”

1. select
2. “transactionDate”
3. “transactionDateForm”
4. “MMM d (EEEE)”

1. withColumn
2. “transactionDateForm”
3. “transactionDate”
4. “MMM d (EEEE)”

1. withColumn
2. “transactionDateForm”
3. “transactionDate”
4. “MM d (EEE)”

1. withColumnRenamed
2. “transactionDate”
3. “transactionDateForm”
4. “MM d (EEE)”

itemsDf.filter(col(supplier).not_contains(‘X’)).select(supplier).distinct()

itemsDf.select(~col(‘supplier’).contains(‘X’)).distinct()

itemsDf.filter(not(col(‘supplier’).contains(‘X’))).select(‘supplier’).unique()

itemsDf.filter(~col(‘supplier’).contains(‘X’)).select(‘supplier’).distinct()

itemsDf.filter(!col(‘supplier’).contains(‘X’)).select(col(‘supplier’)).unique()

Q37. Which of the following code blocks creates a new DataFrame with two columns season and wind_speed_ms where column season is of data type string and column wind_speed_ms is of data type double?

spark.DataFrame({“season”: [“winter”,”summer”], “wind_speed_ms”: [4.5, 7.5]})

spark.createDataFrame([(“summer”, 4.5), (“winter”, 7.5)], [“season”, “wind_speed_ms”])

1. from pyspark.sql import types as T
2. spark.createDataFrame(((“summer”, 4.5), (“winter”, 7.5)), T.StructType([T.StructField(“season”,

CharType()), T.StructField(“season”, T.DoubleType())]))

spark.newDataFrame([(“summer”, 4.5), (“winter”, 7.5)], [“season”, “wind_speed_ms”])

spark.createDataFrame({“season”: [“winter”,”summer”], “wind_speed_ms”: [4.5, 7.5]})

Explanation
spark.createDataFrame([(“summer”, 4.5), (“winter”, 7.5)], [“season”, “wind_speed_ms”]) Correct. This command uses the Spark Session’s createDataFrame method to create a new DataFrame. Notice how rows, columns, and column names are passed in here: The rows are specified as a Python list. Every entry in the list is a new row. Columns are specified as Python tuples (for example (“summer”, 4.5)). Every column is one entry in the tuple.
The column names are specified as the second argument to createDataFrame(). The documentation (link below) shows that “when schema is a list of column names, the type of each column will be inferred from data” (the first argument). Since values 4.5 and 7.5 are both float variables, Spark will correctly infer the double type for column wind_speed_ms. Given that all values in column
“season” contain only strings, Spark will cast the column appropriately as string.
Find out more about SparkSession.createDataFrame() via the link below.
spark.newDataFrame([(“summer”, 4.5), (“winter”, 7.5)], [“season”, “wind_speed_ms”]) No, the SparkSession does not have a newDataFrame method.
from pyspark.sql import types as T
spark.createDataFrame(((“summer”, 4.5), (“winter”, 7.5)), T.StructType([T.StructField(“season”,
T.CharType()), T.StructField(“season”, T.DoubleType())]))
No. pyspark.sql.types does not have a CharType type. See link below for available data types in Spark.
spark.createDataFrame({“season”: [“winter”,”summer”], “wind_speed_ms”: [4.5, 7.5]}) No, this is not correct Spark syntax. If you have considered this option to be correct, you may have some experience with Python’s pandas package, in which this would be correct syntax. To create a Spark DataFrame from a Pandas DataFrame, you can simply use spark.createDataFrame(pandasDf) where pandasDf is the Pandas DataFrame.
Find out more about Spark syntax options using the examples in the documentation for SparkSession.createDataFrame linked below.
spark.DataFrame({“season”: [“winter”,”summer”], “wind_speed_ms”: [4.5, 7.5]}) No, the Spark Session (indicated by spark in the code above) does not have a DataFrame method.
More info: pyspark.sql.SparkSession.createDataFrame – PySpark 3.1.1 documentation and Data Types – Spark 3.1.2 Documentation Static notebook | Dynamic notebook: See test 1

Q38. Which of the following statements about DAGs is correct?

DAGs help direct how Spark executors process tasks, but are a limitation to the proper execution of a query when an executor fails.

DAG stands for “Directing Acyclic Graph”.

Spark strategically hides DAGs from developers, since the high degree of automation in Spark means that developers never need to consider DAG layouts.

In contrast to transformations, DAGs are never lazily executed.

DAGs can be decomposed into tasks that are executed in parallel.

Q39. Which of the following code blocks reads all CSV files in directory filePath into a single DataFrame, with column names defined in the CSV file headers?
Content of directory filePath:
1._SUCCESS
2._committed_2754546451699747124
3._started_2754546451699747124
4.part-00000-tid-2754546451699747124-10eb85bf-8d91-4dd0-b60b-2f3c02eeecaa-298-1-c000.csv.gz
5.part-00001-tid-2754546451699747124-10eb85bf-8d91-4dd0-b60b-2f3c02eeecaa-299-1-c000.csv.gz
6.part-00002-tid-2754546451699747124-10eb85bf-8d91-4dd0-b60b-2f3c02eeecaa-300-1-c000.csv.gz
7.part-00003-tid-2754546451699747124-10eb85bf-8d91-4dd0-b60b-2f3c02eeecaa-301-1-c000.csv.gz spark.option(“header”,True).csv(filePath)

spark.read.format(“csv”).option(“header”,True).option(“compression”,”zip”).load(filePath)

spark.read().option(“header”,True).load(filePath)

spark.read.format(“csv”).option(“header”,True).load(filePath)

spark.read.load(filePath)

Q40. Which of the following code blocks stores DataFrame itemsDf in executor memory and, if insufficient memory is available, serializes it and saves it to disk?

itemsDf.persist(StorageLevel.MEMORY_ONLY)

itemsDf.cache(StorageLevel.MEMORY_AND_DISK)

itemsDf.store()

itemsDf.cache()

itemsDf.write.option(‘destination’, ‘memory’).save()

1. length
2. regexp_extract
3. upper
4. col(“itemName”)
5. as

1. size
2. regexp_replace
3. lower
4. “itemName”
5. alias

1. lower
2. regexp_replace
3. length
4. “itemName”
5. alias

1. length
2. regexp_replace
3. lower
4. col(“itemName”)
5. alias

1. size
2. regexp_extract
3. lower
4. col(“itemName”)
5. alias

Q42. The code block shown below should return a DataFrame with only columns from DataFrame transactionsDf for which there is a corresponding transactionId in DataFrame itemsDf. DataFrame itemsDf is very small and much smaller than DataFrame transactionsDf. The query should be executed in an optimized way. Choose the answer that correctly fills the blanks in the code block to accomplish this.
__1__.__2__(__3__, __4__, __5__)

1. transactionsDf
2. join
3. broadcast(itemsDf)
4. transactionsDf.transactionId==itemsDf.transactionId
5. “outer”

1. transactionsDf
2. join
3. itemsDf
4. transactionsDf.transactionId==itemsDf.transactionId
5. “anti”

1. transactionsDf
2. join
3. broadcast(itemsDf)
4. “transactionId”
5. “left_semi”

1. itemsDf
2. broadcast
3. transactionsDf
4. “transactionId”
5. “left_semi”

1. itemsDf
2. join
3. broadcast(transactionsDf)
4. “transactionId”
5. “left_semi”

Q43. The code block displayed below contains an error. The code block should return a new DataFrame that only contains rows from DataFrame transactionsDf in which the value in column predError is at least 5. Find the error.
Code block:
transactionsDf.where(“col(predError) >= 5”)

The argument to the where method should be “predError >= 5”.

Instead of where(), filter() should be used.

The expression returns the original DataFrame transactionsDf and not a new DataFrame. To avoid this, the code block should be transactionsDf.toNewDataFrame().where(“col(predError) >= 5”).

The argument to the where method cannot be a string.

Instead of >=, the SQL operator GEQ should be used.

New (2022) Databricks Associate-Developer-Apache-Spark Exam Dumps: https://www.vcedumps.com/Associate-Developer-Apache-Spark-examcollection.html

Tags: Associate-Developer-Apache-Spark reliable dumps questions, Associate-Developer-Apache-Spark reliable exam dumps.zip, Associate-Developer-Apache-Spark reliable exam guide materials, Associate-Developer-Apache-Spark test simulator online, new Associate-Developer-Apache-Spark test topics

Free Databricks Associate-Developer-Apache-Spark Exam Questions & Answer from Training Expert VCEDumps [Q25-Q43]

Leave a Reply Cancel reply

Associate-Developer-Apache-Spark Practice Tests

Related Certifications

Recent Posts

Categories

Archives