[SPARK-31349][SQL][DOCS] Document built-in aggregate functions in SQL Reference #28120

kevinyu98 · 2020-04-04T19:53:45Z

What changes were proposed in this pull request?

Document buildin aggregate functions

Why are the changes needed?

To make SQL Reference complete

Does this PR introduce any user-facing change?

Yes
before:
None
After:

How was this patch tested?

Manually build and check

Notes:
I list the aggregate function based on the functionRegistry aggregate functions session.
Here are the ones I didn't included, let me know if it is needed in this pr.
- cube
- rollup
- grouping
- grouping_id
- aggregate

huaxingao · 2020-04-05T03:43:06Z

docs/sql-ref-functions-builtin-aggregate.md

defines in dataset API -> defined in the dataset API?

thanks, done.

huaxingao · 2020-04-05T03:44:37Z

docs/sql-ref-functions-builtin-aggregate.md

+  <tbody>
+    <tr>
+      <td> <b>{avg | mean}</b>(<i>e: Column</i>)</td>


Could you list the functions in alphabetical order?

huaxingao · 2020-04-05T04:31:40Z

docs/sql-ref-functions-builtin-aggregate.md

+    </tr>
+    <tr>
+      <td> <b>approx_count_distinct</b>(<i>e: Column</i>)</td>


It has the optional relativeSD. Change to approx_count_distinct(expr[, relativeSD])?

thanks, done

huaxingao · 2020-04-05T04:32:05Z

docs/sql-ref-functions-builtin-aggregate.md

+      <td> <b>count_if</b>(<i>Predicate</i>)</td>
+      <td>Expression that will be used for aggregation calculation</td>
+      <td>Returns the count number from the predicate evaluate to `TRUE` values</td>


backtick doesn't work inside html, use <code>TRUE</code>?

huaxingao · 2020-04-05T04:32:14Z

docs/sql-ref-functions-builtin-aggregate.md

+      <td> <b>{first | first_value}</b>(<i>e: Column[, isIgnoreNull]</i>)</td>
+      <td>Column name[, True/False(default)]</td>
+      <td>Returns the first value of column for a group of rows. If `isIgnoreNull` is true, returns only non-null values, default is false. This function is non-deterministic</td>


<code>isIgnoreNull</code>?

huaxingao · 2020-04-05T04:32:58Z

docs/sql-ref-functions-builtin-aggregate.md

+    </tr>        
+    <tr>
+      <td> <b>{percentile_approx | percentile_approx}</b>(<i>e: Column, percentage [, frequency]</i>)</td>


Is this a 3.1 function?

* @group agg_funcs * @since 3.1.0 */ def percentile_approx(e: Column, percentage: Column, accuracy: Column): Column = {

huaxingao · 2020-04-05T04:34:12Z

docs/sql-ref-functions-builtin-aggregate.md

+</table>
+
+### Example


Nit: Example -> Examples?
Sometimes you have a blank line between examples, sometimes you don't. I guess make it consistent and always have a blank line in between?

thanks, done

huaxingao · 2020-04-05T04:36:42Z

docs/sql-ref-functions-builtin-aggregate.md

+Spark SQL Aggregate functions are grouped as <code>agg_funcs</code> in spark SQL. Below is the list of functions.
+
+**Note:** Every below function has another signature which take String as a column name instead of Column.


which take String -> which takes String?

huaxingao · 2020-04-05T04:38:03Z

docs/sql-ref-functions-builtin-aggregate.md

+      <td> <b>{last | last_value}</b>(<i>e: Column[, isIgnoreNull]</i>)</td>
+      <td>Column name[, True/False(default)]</td>
+      <td>Returns the last value of column for a group of rows. If `isIgnoreNull` is true, returns only non-null values, default is false. This function is non-deterministic</td>


<code>isIgnoreNull</code>?

maropu · 2020-04-06T02:10:43Z

ok to test

maropu · 2020-04-06T02:26:13Z

docs/sql-ref-functions-builtin-aggregate.md

nit: Aggregate -> aggregate along with the others? e.g., https://github.com/apache/spark/blame/master/docs/sql-ref-syntax-qry-select-having.md#L71

thanks, changed.

maropu · 2020-04-06T02:27:14Z

docs/sql-ref-functions-builtin-aggregate.md

+operate on a group of rows and return a single value.
+
+Spark SQL Aggregate functions are grouped as <code>agg_funcs</code> in spark SQL. Below is the list of functions.


nit: spark SQL -> Spark SQL

SparkQA · 2020-04-06T02:30:45Z

Test build #120853 has finished for PR 28120 at commit f4aadff.

This patch passes all tests.
This patch merges cleanly.
This patch adds no public classes.

maropu · 2020-04-06T02:32:21Z

docs/sql-ref-functions-builtin-aggregate.md

+Spark SQL Aggregate functions are grouped as <code>agg_funcs</code> in spark SQL. Below is the list of functions.
+
+**Note:** Every below function has another signature which takes String as a column name instead of Column.


All functions below have another signature...?

Thanks, will make changes.

maropu · 2020-04-06T02:43:28Z

docs/sql-ref-functions-builtin-aggregate.md

+  <tbody>
+    <tr>
+      <td> <b>{any | some | bool_or}</b>(<i>e: Column</i>)</td>


nit: e -> c in the argument?

thanks, changed all the e -> c .

maropu · 2020-04-06T03:18:34Z

docs/sql-ref-functions-builtin-aggregate.md

+|count_min_sketch(c1, 0.9, 0.2, 3)                                                                                                                            |
+-------------------------------------------------------------------------------------------------------------------------------------------------------------+
+|[00 00 00 01 00 00 00 00 00 00 00 07 00 00 00 01 00 00 00 03 00 00 00 00 5D 93 49 A6 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 06]|


I feel a bit too long... how about ommitting the output, e.g., [00 00 00 01 00...?

SparkQA · 2020-04-06T06:19:49Z

Test build #120858 has finished for PR 28120 at commit 5cbecf4.

This patch passes all tests.
This patch merges cleanly.
This patch adds no public classes.

maropu · 2020-04-06T13:11:06Z

docs/sql-ref-functions-builtin-aggregate.md

+
+* Table of contents
+{:toc}


Since there are few sections, how about removing {:toc}?

maropu · 2020-04-06T13:18:00Z

docs/sql-ref-functions-builtin-aggregate.md

+      <td> <b>{avg | mean}</b>(<i>c: Column</i>)</td>
+      <td>Column name</td>
+      <td> Returns the average of values in the input column.</td> 


super nit: could you remove unnecessary spaces? e.g., <td> Returns...

maropu · 2020-04-06T13:19:28Z

docs/sql-ref-functions-builtin-aggregate.md

+      <td> <b>{bool_and | every}</b>(<i>c: Column</i>)</td>
+      <td>Column name</td>
+      <td>Returns true if all values are true</td>


nit: add a period in the end.

maropu · 2020-04-06T13:19:37Z

docs/sql-ref-functions-builtin-aggregate.md

+      <td> <b>collect_list</b>(<i>c: Column</i>)</td>
+      <td>Column name</td>
+      <td>Collects and returns a list of non-unique elements. The function is non-deterministic because the order of collected results depends on the order of the rows which may be non-deterministic after a shuffle</td>


nit: add a period in the end.

maropu · 2020-04-06T13:19:57Z

docs/sql-ref-functions-builtin-aggregate.md

+      <td> <b>corr</b>(<i>c1: Column, c2: Column</i>)</td>
+      <td>Column name</td>
+      <td>Returns Pearson coefficient of correlation between a set of number pairs</td>


nit: add a period in the end.

maropu · 2020-04-06T13:23:59Z

docs/sql-ref-functions-builtin-aggregate.md

+    </tr>
+    <tr>
+      <td> <b>count</b>(<b>DISTINCT</b> <i> c: Column[, c: Column</i>])</td>


Could we merge the entries for count into a single entry?

maropu · 2020-04-06T13:27:53Z

docs/sql-ref-functions-builtin-aggregate.md

+      <td> <b>count_if</b>(<i>Predicate</i>)</td>
+      <td>Expression that will be used for aggregation calculation</td>
+      <td>Returns the count number from the predicate evaluate to <code>TRUE</code> values</td>


It seems no <code>TRUE</code> exists in the existing docs, so <code>TRUE</code> -> `TRUE`?

maropu · 2020-04-06T13:29:18Z

docs/sql-ref-functions-builtin-aggregate.md

+        <td> <b>count_min_sketch</b>(<i>c: Column, eps: double, confidence: double, seed integer</i>)</td>
+        <td>Column name; eps is a value between 0.0 and 1.0; confidence is a value between 0.0 and 1.0; seed is a positive integer</td>
+        <td>Returns a count-min sketch of a column with the given esp, confidence and seed. The result is an array of bytes, which can be deserialized to a `CountMinSketch` before usage. Count-min sketch is a probabilistic data structure used for cardinality estimation using sub-linear space..</td>


space..</td> -> space.</td>

maropu · 2020-04-06T13:39:24Z

docs/sql-ref-functions-builtin-aggregate.md

+    </tr>  
+    <tr>
+      <td> <b>{first | first_value}</b>(<i>c: Column[, isIgnoreNull]</i>)</td>


isIgnoreNull -> isIgnoreNull: Boolean? btw, what does Column mean? I think we need to use concrete SQL types. How about following the PostgreSQL docs? https://www.postgresql.org/docs/current/functions-aggregate.html

I was thinking that Column is a type in spark, it is not a concrete type. I changed to use expression, maybe it is a better name. I changed the table format to use the concrete SQL types. I used the concrete type which internal code is checking, although they may take other data type as input(spark will try to cast).

Ah, the current one looks better! Thanks for the work!

btw, I think its better to use the same type names here with https://github.com/apache/spark/blob/master/docs/sql-ref-datatypes.md

Does my current type name look ok? boolean , numeric , string

SparkQA · 2020-04-07T04:01:33Z

Test build #120893 has finished for PR 28120 at commit 85f4181.

This patch passes all tests.
This patch merges cleanly.
This patch adds no public classes.

maropu · 2020-04-07T04:36:42Z

docs/sql-ref-functions-builtin-aggregate.md

+Spark SQL aggregate functions are grouped as <code>agg_funcs</code> in Spark SQL. Below is the list of functions.
+
+**Note:** All functions below have another signature which takes String as a expression.


We don't need this now?

maropu · 2020-04-07T04:39:11Z

docs/sql-ref-functions-builtin-aggregate.md

+operate on a group of rows and return a single value.
+
+Spark SQL aggregate functions are grouped as <code>agg_funcs</code> in Spark SQL. Below is the list of functions.


What does this mean? Is this info useful for users?
Spark SQL aggregate functions are grouped as <code>agg_funcs</code> in Spark SQL.

I see, yah, it is internal. I will remove.

maropu · 2020-04-07T04:41:12Z

docs/sql-ref-functions-builtin-aggregate.md

+<table class="table">
+  <thead>
+    <tr><th style="width:25%">Function</th><th>Parameter Type(s)</th><th>Description</th></tr>


nit: as the Pg doc does so, I like Argument better than Parameter.

maropu · 2020-04-07T04:43:23Z

docs/sql-ref-functions-builtin-aggregate.md

+      <td><b>approx_count_distinct</b>(<i>expression[, relativeSD]</i>)</td>
+      <td>(long, double)</td>
+      <td>RelativeSD is the maximum estimation error allowed. Returns the estimated cardinality by HyperLogLog++.</td>


nit: better to wrap RelativeSD with `?

maropu · 2020-04-07T04:50:08Z

docs/sql-ref-functions-builtin-aggregate.md

+### Examples
+{% highlight sql %}
+--base table 


nit: need a space after --

-- A test table used in the following examples?

SparkQA · 2020-04-08T18:14:38Z

Test build #120979 has finished for PR 28120 at commit 14d303f.

This patch passes all tests.
This patch merges cleanly.
This patch adds no public classes.

maropu · 2020-04-09T00:43:08Z

Could you apply the same cleanup with #28151 ?

maropu · 2020-04-09T00:45:40Z

docs/sql-ref-functions-builtin-aggregate.md

+    <tr>
+      <td><b>approx_count_distinct</b>(<i>expression[, relativeSD]</i>)</td>
+      <td>(long, double)</td>


How about using more SQL-like type names? e.g., long -> bigint https://github.com/apache/spark/blob/master/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/FunctionRegistry.scala#L547-L558

Also, how about using the same format for optional params? e.g., (long, double) -> (long[, double])

maropu · 2020-04-09T00:54:39Z

docs/sql-ref-functions-builtin-aggregate.md

+    <tr>
+      <td><b>{avg | mean}</b>(<i>expression</i>)</td>
+      <td>short, float, byte, decimal, double, int, long or string</td>


<td>tinyint, short, int, bigint, float, double, or decimal</td>?

maropu · 2020-04-09T00:57:52Z

docs/sql-ref-functions-builtin-aggregate.md

+      <td><b>count</b>([<b>DISTINCT</b>] <i>*</i>)</td>
+      <td>none</td>
+      <td>If specified <code>DISTINCT</code>, returns the total number of retrieved rows are unique and not null; Otherwise, returns the total number of retrieved rows, including rows containing null.</td>


nit: ; Otherwise -> ; otherwise?

thanks, done

maropu · 2020-04-09T00:58:35Z

docs/sql-ref-functions-builtin-aggregate.md

+      <td><b>count</b>([<b>DISTINCT</b>] <i>expression1[, expression2</i>])</td>
+      <td>(any, any)</td>
+      <td>If specified <code>DISTINCT</code>, returns the number of rows for which the supplied expression(s) are unique and not null; Otherwise, returns the number of rows for which the supplied expression(s) are all not null.</td>


ditto: ; Otherwise -> ; otherwise?

maropu · 2020-04-09T00:59:16Z

docs/sql-ref-functions-builtin-aggregate.md

+    <tr>
+      <td><b>count</b>([<b>DISTINCT</b>] <i>expression1[, expression2</i>])</td>
+      <td>(any, any)</td>


(any, any) -> (any[, any])

maropu · 2020-04-09T01:02:36Z

docs/sql-ref-functions-builtin-aggregate.md

+    <tr>
+      <td><b>count_min_sketch</b>(<i>expression, eps, confidence, seed</i>)</td>
+      <td>(byte, short, int, long, string or binary, double,  double, integer)</td>


nit: double, double, -> double, double,

maropu · 2020-04-09T01:06:11Z

docs/sql-ref-functions-builtin-aggregate.md

+    <tr>
+      <td><b>count_if</b>(<i>predicate</i>)</td>
+      <td>expression that will be used for aggregation calculation</td>


How about expression that will be used for aggregation calculation -> expression that returns a boolean value?

yah, this is better. Done

maropu · 2020-04-09T01:06:53Z

docs/sql-ref-functions-builtin-aggregate.md

+    <tr>
+      <td><b>{first | first_value}</b>(<i>expression[, isIgnoreNull]</i>)</td>
+      <td>(any, boolean)</td>


(any, boolean) -> (any[, boolean])

maropu · 2020-04-09T01:10:33Z

docs/sql-ref-functions-builtin-aggregate.md

+      <td><b>{first | first_value}</b>(<i>expression[, isIgnoreNull]</i>)</td>
+      <td>(any, boolean)</td>
+      <td>Returns the first value of expression for a group of rows. If <code>isIgnoreNull</code> is true, returns only non-null values, default is false. This function is non-deterministic.</td>


<code>isIgnoreNull</code> -> isIgnoreNull? Should we use ` or <code> for arguments?

maybe , seems we don't have this isIgnoreNull` in spark code.

maropu · 2020-04-09T01:11:07Z

docs/sql-ref-functions-builtin-aggregate.md

+    <tr>
+      <td><b>{last | last_value}</b>(<i>expression[, isIgnoreNull]</i>)</td>
+      <td>(any, boolean)</td>


(any[, boolean])

maropu · 2020-04-09T01:12:54Z

docs/sql-ref-functions-builtin-aggregate.md

+    <tr>
+      <td><b>max</b>(<i>expression</i>)</td>
+      <td>short, float, byte, decimal, double, int, long, string, date, timestamp or arrays of these types</td>


better to sort this in a consistent order, e.g,. tinyint, short, int, bigint, float, double, date, timestamp, string, or arrays of these types?

maropu · 2020-04-09T01:25:34Z

docs/sql-ref-functions-builtin-aggregate.md

+    <tr>
+      <td><b>percentile</b>(<i>expression, percentage [, frequency]</i>)</td>
+      <td>short, float, byte, decimal, double, int, or long, double, int</td>


maropu · 2020-04-09T01:28:16Z

docs/sql-ref-functions-builtin-aggregate.md

+    <tr>
+      <td><b>percentile</b>(<i>expression, <b>array</b>(percentage1 [, percentage2]...) [, frequency]</i>)</td>
+      <td>short, float, byte, decimal, double, int, or long, double, int</td>


maropu · 2020-04-09T01:30:39Z

docs/sql-ref-functions-builtin-aggregate.md

+SELECT COLLECT_LIST(c4) FROM buildin_agg;
+------------------------------------------------------+
+|collect_list(c4)                                      |


Could you make the output right-aligned along with the others?

maropu · 2020-04-09T01:32:57Z

docs/sql-ref-functions-builtin-aggregate.md

+-------+
+
+SELECT BOOL_OR(c5) FROM buildin_agg;


Could you use lowercases except for the SQL keywords? e.g., SELECT bool_or(c5) FROM buildin_agg;

BOOL_OR is the agg function, it is the alias of any.

Yea, I know that. What do you mean? Since it is the alias of any, you cannot lowercase it?

SparkQA · 2020-04-09T21:14:20Z

Test build #121046 has finished for PR 28120 at commit 9e283b4.

This patch passes all tests.
This patch merges cleanly.
This patch adds no public classes.

maropu · 2020-04-10T07:15:33Z

docs/sql-ref-functions-builtin-aggregate.md

+      <td><b>{percentile_approx | percentile_approx}</b>(<i>expression, percentage [, frequency]</i>)</td>
+      <td>(short|float|byte|decimal|double|int|bigint, double[, int])</td>
+      <td>`percentage` is a number between 0 and 1; `frequency` is a positive integer. Returns the approximate percentile value of numeric expression at the given percentage.</td>
+    </tr>    
+   <tr>
+      <td><b>{percentile_approx | percentile_approx}</b>(<i>expression, percentage [, frequency]</i>)</td>
+      <td>(date|timestamp, double[, int])</td>
+      <td>`percentage` is a number between 0 and 1; `frequency` is a positive integer. Returns the approximate percentile value of numeric expression at the given percentage.</td>
+    </tr>                  
+    <tr>
+      <td><b>{percentile_approx | percentile_approx}</b>(<i>expression, <b>array</b>(percentage1 [, percentage2]...) [, frequency]</i>)</td>
+      <td>(short|float|byte|decimal|double|int|bigint, array of double[, int])</td>
+      <td>`percentage` is a number between 0 and 1; `frequency` is a positive integer. Returns the approximate percentile value of numeric expression at the given percentage.</td>
+    </tr>             
+    <tr>
+      <td><b>{percentile_approx | percentile_approx}</b>(<i>expression, <b>array</b>(percentage1 [, percentage2]...) [, frequency]</i>)</td>
+      <td>(date|timestamp, array of double[, int])</td>
+      <td>`percentage` is a number between 0 and 1; `frequency` is a positive integer. Returns the approximate percentile value of numeric expression at the given percentage.</td>
+    </tr>             


Could you check the 4 entries above again? {percentile_approx | percentile_approx}? we need the 4 entries for percentile_approx? We cannot merge them?

maropu · 2020-04-10T07:18:50Z

docs/sql-ref-functions-builtin-aggregate.md

+    <tr>
+      <td><b>{percentile_approx | percentile_approx}</b>(<i>expression, <b>array</b>(percentage1 [, percentage2]...) [, frequency]</i>)</td>
+      <td>(short|float|byte|decimal|double|int|bigint, array of double[, int])</td>


short or smallint? https://github.com/apache/spark/pull/28120/files#diff-b5f189f25bd299f827099b77bc343531R179

no tinyint?

maropu · 2020-04-10T07:29:28Z

docs/sql-ref-functions-builtin-aggregate.md

+    </tr>  
+    <tr>
+      <td><b>{first | first_value}</b>(<i>expression[, `isIgnoreNull`]</i>)</td>


we need the backquote here in the argument type section?

maropu · 2020-04-10T07:34:01Z

docs/sql-ref-functions-builtin-aggregate.md

+    <tr>
+      <td><b>max_by</b>(<i>expression1, expression2</i>)</td>
+      <td>tinyint|short|int|bigint|float|double|date|timestamp|string, or arrays of these types</td>


Could you check again if all the input types are correct? max_by/min_by seems to accept null types and a struct of orderable element types?
https://github.com/apache/spark/blob/master/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/aggregate/MaxByAndMinBy.scala#L49
https://github.com/apache/spark/blob/master/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/ordering.scala#L101

HyukjinKwon · 2020-04-10T07:36:16Z

Sorry guys I saw this just now. Can we reuse https://spark.apache.org/docs/latest/api/sql/index.html? I don't think we should duplicate them.

We should auto-generate (see also #27459) probably after adding some more fields in ExpressionDescription (see also #24259)

maropu · 2020-04-10T07:36:31Z

docs/sql-ref-functions-builtin-aggregate.md

+    </tr>         
+    <tr>
+      <td><b>percentile</b>(<i>expression, <b>array</b>(percentage1 [, percentage2]...) [, frequency]</i>)</td>


I think we don't need to say array here because you said array of double in the argument section below.

maropu · 2020-04-10T07:38:30Z

docs/sql-ref-functions-builtin-aggregate.md

+    </tr>        
+    <tr>
+      <td><b>{percentile_approx | percentile_approx}</b>(<i>expression, percentage [, frequency]</i>)</td>


frequency -> accuracy?

maropu · 2020-04-22T00:07:25Z

This issue has been resolved in #28224. Welcome any activity to improve the document. Anyway, thanks for the work!

kevinyu98 added 2 commits April 3, 2020 18:26

init doc

6a26282

first version

d3a508e

huaxingao reviewed Apr 5, 2020

View reviewed changes

address comments

f4aadff

maropu reviewed Apr 6, 2020

View reviewed changes

maropu changed the title ~~[SPARK-31349][SQL][DOCS] Sql ref buildin-aggregate~~ [SPARK-31349][SQL][DOCS] Document built-in aggregate functions in SQL Reference Apr 6, 2020

maropu reviewed Apr 6, 2020

View reviewed changes

address comments

5cbecf4

maropu reviewed Apr 6, 2020

View reviewed changes

add concrete sql type

85f4181

maropu reviewed Apr 7, 2020

View reviewed changes

maropu reviewed Apr 9, 2020

View reviewed changes

maropu mentioned this pull request Apr 9, 2020

[SPARK-31390][SQL][DOCS] Document Window Function #28157

Closed

adjust style

9e283b4

maropu reviewed Apr 10, 2020

View reviewed changes

HyukjinKwon mentioned this pull request Apr 10, 2020

[SPARK-31369][SQL][DOCS] Documentation for JSON Functions #28170

Closed

maropu closed this Apr 22, 2020

		Spark SQL Aggregate functions are grouped as <code>agg_funcs</code> in spark SQL. Below is the list of functions.

		Note: Every below function has another signature which take String as a column name instead of Column.

		operate on a group of rows and return a single value.

		Spark SQL Aggregate functions are grouped as <code>agg_funcs</code> in spark SQL. Below is the list of functions.

		Spark SQL aggregate functions are grouped as <code>agg_funcs</code> in Spark SQL. Below is the list of functions.

		Note: All functions below have another signature which takes String as a expression.

		</table>

		### Example

[SPARK-31349][SQL][DOCS] Document built-in aggregate functions in SQL Reference #28120

[SPARK-31349][SQL][DOCS] Document built-in aggregate functions in SQL Reference #28120

Uh oh!

Conversation

kevinyu98 commented Apr 4, 2020

What changes were proposed in this pull request?

Why are the changes needed?

Does this PR introduce any user-facing change?

How was this patch tested?

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

maropu commented Apr 6, 2020

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

SparkQA commented Apr 6, 2020

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

SparkQA commented Apr 6, 2020

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!