[SPARK-14471][SQL] Aliases in SELECT could be used in GROUP BY #17191

maropu · 2017-03-07T15:18:02Z

What changes were proposed in this pull request?

This pr added a new rule in Analyzer to resolve aliases in GROUP BY.
The current master throws an exception if GROUP BY clauses have aliases in SELECT;

scala> spark.sql("select a a1, a1 + 1 as b, count(1) from t group by a1")
org.apache.spark.sql.AnalysisException: cannot resolve '`a1`' given input columns: [a]; line 1 pos 51;
'Aggregate ['a1], [a#83L AS a1#87L, ('a1 + 1) AS b#88, count(1) AS count(1)#90L]
+- SubqueryAlias t
   +- Project [id#80L AS a#83L]
      +- Range (0, 10, step=1, splits=Some(8))

  at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:42)
  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:77)
  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:74)
  at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:289)

How was this patch tested?

Added tests in SQLQuerySuite and SQLQueryTestSuite.

SparkQA · 2017-03-07T17:24:34Z

Test build #74110 has finished for PR 17191 at commit 3ba9e44.

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

nsyca · 2017-03-07T18:29:40Z

@maropu Would your code work for the problem in the PR description?

sql("create table t(a int) using parquet")
sql("select a a1, a1 + 1 as b, count(1) from t group by a1")

maropu · 2017-03-08T00:03:10Z

@nsyca oh, good suggestion. yes, it seems the case does not work. I'll update this pr soon. Thanks!

SparkQA · 2017-03-10T13:28:23Z

Test build #74320 has finished for PR 17191 at commit 034f51f.

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

nsyca · 2017-03-13T13:33:58Z

sql/core/src/test/scala/org/apache/spark/sql/SQLQuerySuite.scala

+    checkAnswer(
+      sql("SELECT k1 AS key1, key1 + 1 AS key2, COUNT(1) FROM t GROUP BY key1, key2"),
+      Row(1, 2, 2) :: Row(2, 3, 1) :: Nil)
+  }


What if the alias has a collision with a valid column name, like,

select k1 as k2, k2 from t
select k1 as k2 from t group by k1
select k1 as k2 from t group by k2

This would be an interesting test case to add.

I think the target of this pr just replaces unresolved exprs in grouping keys with resolved ones by using resolved exprs in SELECT clauses. So, I think we'd better to discuss the name collision case you described in follow-up other tickets.

nsyca · 2017-03-13T14:52:27Z

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/Analyzer.scala

+                q.resolveChildren(nameParts, resolver).getOrElse {
+                  resolvedExprs.find(ne => resolver(ne.name, u.name)).getOrElse(u)
+                }
+              }


With your new code, unresolved attributes will get a second chance to be resolved with any aliases in ALL operators. Is this an intended behaviour? If it is, you'd better update the PR description. The description currently refers to aliases in SELECT to be used in GROUP BY.

Using your definition in the new test cases:

Seq((1, "a", 0), (2, "a", 1), (1, "a", 2)).toDF("k1", "k2", "v").createOrReplaceTempView("t")

You can see that when there is a name collision, it shows a different behaviour. The one below has the unresolved kx in GROUP BY clause resolved to k1.

sql("select k1 as kx from t group by kx")

While this one below returns an error that k1 in SELECT clause is not found in GROUP BY clause.

sql("select k1 as k2 from t group by k2")

I think it'd better to go back to the drawing board and make a decision what we are going to support before we verify the code works as designed.

nsyca · 2017-03-13T15:03:39Z

@maropu: I have made a few comments in the code and test cases. IMO, we should go back to define what we want to fix before jumping into the code.

I am sorry if my previous statement gave you an impression that we need to solve the problem in your PR description. I personally think the example in your PR description goes too far to resolve an undefined column in the SELECT clause from any aliases from its LHS.

Example:

select k1 as kx, kx from t

I think this should result in an error that kx is an undefined column from table t.

IMO, the problem we want to focus is to resolve any unresolved references in a GROUP BY clause by trying to map them to the aliases in the SELECT clause. That is, assuming table t contains column k1 and k2`,

select k1 as k2 from t group by k2

should resolve in an error that k1 is not part of the GROUP BY clause whereas

select k1 as kx from t group by kx

should resolve the unresolved reference kx in the GROUP BY clause with the alias kx from the column k1 in the SELECT clause.

It may be that the code in your first commit is good for the above problem definition.

You may want to involve any committers who are willing to concur with your problem definition, review your code and merge it in. In any case, the PR description should be updated and the test cases with name collision between aliases in SELECT clause and valid columns in the table should be added.

maropu · 2017-03-15T00:16:00Z

Ah, I see. In a basic stance, I think we should do the same behaviour with existing databases. You're right and select k1 as kx from t group by kx should fail;

// PostgreSQL
 Column |  Type   | Modifiers
--------+---------+-----------
 key    | integer |
 value  | integer |

postgres=# select key AS k, k FROM t;
ERROR:  column "k" does not exist at character 18

Anyway, I agree with your suggestion; we should make PRs as much small as possible, and so I reconsider this pr again to fix the point in the description.

SparkQA · 2017-03-15T06:57:32Z

Test build #74585 has started for PR 17191 at commit c4b40aa.

maropu · 2017-03-15T07:19:54Z

Jenkins, retest this please.

dilipbiswal · 2017-03-15T08:53:02Z

@maropu Hello, Perhaps you have already seen .. there have been PRs to fix this in the past. Here are a few i could find -

#12794 by @dongjoon-hyun
#10967 by @kevinyu98
Some more discussions on https://issues.apache.org/jira/browse/SPARK-9338.

Hope this helps ..

SparkQA · 2017-03-15T08:58:01Z

Test build #74589 has finished for PR 17191 at commit c4b40aa.

This patch fails Spark unit tests.
This patch merges cleanly.
This patch adds no public classes.

maropu · 2017-03-15T09:24:37Z

@dilipbiswal oh, I didn't notice that. I check them and I'll close this. Thanks!

dilipbiswal · 2017-03-15T16:36:12Z

@maropu We may want to implement this extension if mysql and postgres support it. Just wanted to point you to the past discussions on this topic. Do we know if hive allows this ?

dongjoon-hyun · 2017-03-15T17:29:15Z

@maropu . I think you had better ask committers before closing this issue once more.

gatorsmile · 2017-03-16T01:07:18Z

Could you please do a check which systems support it and which systems disallow it? Thanks!

maropu · 2017-03-16T01:10:29Z

okay, I'll check

maropu · 2017-03-16T17:08:36Z

@gatorsmile I checked;

// PostgreSQL v9.5
postgres=# \d t
   Table "public.t"
 Column |  Type   | Modifiers 
--------+---------+-----------
 gkey   | integer | 
 value  | integer | 

postgres=# SELECT gkey AS k, COUNT(value) FROM t GROUP BY k;
 k  | count 
----+-------
  1 |     1
(1 row)

// MySQL v5.7.13 
mysql> SHOW COLUMNS FROM t1;
+-------+---------+------+-----+---------+-------+
| Field | Type    | Null | Key | Default | Extra |
+-------+---------+------+-----+---------+-------+
| gkey  | int(11) | YES  |     | NULL    |       |
| value | int(11) | YES  |     | NULL    |       |
+-------+---------+------+-----+---------+-------+
2 rows in set (0.00 sec)

mysql> SELECT gkey AS k, COUNT(value) FROM t1 GROUP BY k;
+------+--------------+
| k    | count(value) |
+------+--------------+
|    1 |            1 |
+------+--------------+
1 row in set (0.00 sec)

// SQLite v3.8.8.3
Use ".open FILENAME" to reopen on a persistent database.

sqlite> .schema
CREATE TABLE t(gkey int, value int);

sqlite> SELECT gkey AS k, COUNT(value) FROM t GROUP BY k;
1|1

// Hive v2.0.1
hive> describe t;
OK
gkey                    int                                         
value                   int                                         
Time taken: 0.09 seconds, Fetched: 2 row(s)

hive> SELECT gkey AS k, COUNT(value) FROM t GROUP BY k;
FAILED: SemanticException [Error 10004]: Line 1:47 Invalid table alias or column reference 'k': (possible column names are: gkey, value)

And you know Oracle and SQLServer does not support this syntax;
#10967 (comment)

In summary,
Supported: PostgreSQL, MySQL, and SQLite
Not-Supported: Hive, Oracle, and SQLServer

WDYT?

gatorsmile · 2017-03-16T18:19:43Z

We hit this issue multiple times. Although it looks not right to support it for the users of major enterprise RDBMS, two popular open source RDBMS PostgreSQL and MySQL support it.

This is the design decision we need to make. Should we keep the previous decision? @rxin @marmbrus @hvanhovell @cloud-fan Thanks!

rxin · 2017-03-16T19:14:39Z

I personally have run into this issue and was surprised that we didn't support it ... it's pretty verbose to retype everything.

If Postgres and MySQL both support it, I think we should do it too!

Can we introduce a config flag to not break old workloads?

SparkQA · 2017-03-16T19:44:46Z

Test build #74677 has finished for PR 17191 at commit f62a75a.

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

nsyca · 2017-03-16T21:51:53Z

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/Analyzer.scala

+              }.getOrElse(u)
+            case e => e
+          })
+


Nit: Should we place this Aggregate pattern next to the other Aggregate that deals with the wildcard character (*) above? Otherwise, LGTM.

The code block you suggested has some rules for replacing wildcards and so I feel putting this rule there is a little weird. But, I don't have a strong opinion on this, so both is okay to me.

@maropu I did not suggest to merge the two code blocks. I suggested to move them next to each other so readers will easily see the code handling Aggregate with two different patterns.

maropu · 2017-03-17T01:44:58Z

I'll add a config soon

cloud-fan · 2017-03-17T02:56:20Z

It's kind of weird if we have both "group by ordinal" feature and this "group by alias" feature, shall we only pick one of them?

SparkQA · 2017-03-17T02:59:08Z

Test build #74712 has finished for PR 17191 at commit c25b1b3.

This patch fails Scala style tests.
This patch merges cleanly.
This patch adds no public classes.

maropu · 2017-03-17T03:49:42Z

@cloud-fan Even in the mixed case, it seems PotgreSQL and MySQL support the syntax;


// PostgreSQL v9.5
postgres=# \d t2
      Table "public.t2"
 Column |  Type   | Modifiers 
--------+---------+-----------
 gkey1  | integer | 
 gkey2  | integer | 
 value  | integer | 

postgres=# select gkey1 AS key1, gkey2, count(value) from t2 group by key1, 2;
 key1 | gkey2 | count 
------+-------+-------
    1 |     1 |     1
(1 row)

// MySQL v5.7.13 
mysql> SHOW COLUMNS FROM t2;
+-------+---------+------+-----+---------+-------+
| Field | Type    | Null | Key | Default | Extra |
+-------+---------+------+-----+---------+-------+
| gkey1 | int(11) | YES  |     | NULL    |       |
| gkey2 | int(11) | YES  |     | NULL    |       |
| value | int(11) | YES  |     | NULL    |       |
+-------+---------+------+-----+---------+-------+
3 rows in set (0.00 sec)

mysql> select gkey1 AS key1, gkey2, count(value) from t2 group by key1, 2;
+------+-------+--------------+
| key1 | gkey2 | count(value) |
+------+-------+--------------+
|    1 |     1 |            1 |
+------+-------+--------------+
1 row in set (0.00 sec)

SparkQA · 2017-03-17T04:23:26Z

Test build #74713 has finished for PR 17191 at commit 5d8c853.

This patch fails Spark unit tests.
This patch merges cleanly.
This patch adds no public classes.

cloud-fan · 2017-03-17T04:51:06Z

ok makes sense, let's support it

maropu · 2017-03-17T04:52:00Z

okay, I'll recheck the code and add tests for the case.

maropu · 2017-04-26T14:37:03Z

I tried to move ResolveOrdinalInOrderByAndGroupBy and ResolveAggAliasInGroupBy into postHocResolutionRules(commit), but I found I got some exceptions in SQLQueryTestSuite. To solve the exceptions, we need to move some rules there, too (e.g., ResolveMissingReferences, ResolveSubquery, and ResolveAggregateFunctions). WDYT? cc: @cloud-fan

SparkQA · 2017-04-26T15:47:17Z

Test build #76187 has finished for PR 17191 at commit 1340862.

This patch fails Spark unit tests.
This patch merges cleanly.
This patch adds no public classes.

This reverts commit 1340862.

maropu · 2017-04-26T23:01:46Z

For now, I reverted the latest commit and I'll look for other better way to fix this.

SparkQA · 2017-04-27T01:18:09Z

Test build #76202 has finished for PR 17191 at commit 65f6e7c.

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

cloud-fan · 2017-04-27T01:24:43Z

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/Analyzer.scala

+    override def apply(plan: LogicalPlan): LogicalPlan = plan.resolveOperators {
+      case agg @ Aggregate(groups, aggs, child)
+          if conf.groupByAliases && child.resolved && aggs.forall(_.resolved) &&
+            groups.exists(!_.resolved) =>


nit: we can check groups.exists(_.isInstanceOf[UnresolvedAttribute])

cloud-fan · 2017-04-27T01:25:51Z

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/Analyzer.scala

@@ -998,6 +998,22 @@ class Analyzer(
  }

  /**
+   * Replace unresolved expressions in grouping keys with resolved ones in SELECT clauses.


add a comment to say that this rule has to be run after ResolveReferences

ok, I'll update

cloud-fan · 2017-04-27T01:36:09Z

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/Analyzer.scala

+
+    override def apply(plan: LogicalPlan): LogicalPlan = plan.resolveOperators {
+      case agg @ Aggregate(groups, aggs, child)
+          if conf.groupByAliases && child.resolved && aggs.forall(_.resolved) &&


I'm not very confident about this condition, we may mistakenly resolve grouping expression by aggregate list while it should be resolved by child output.

one example is the star. If the aggregate list contains a star, then we will expand the star in ResolveReferences, without resolving grouping expressions. When we reach here, the condition will match but the grouping expression should not be resolved by aggregate list.

cc @gatorsmile

How about this code for the check? https://github.com/apache/spark/pull/17191/files#diff-57b3d87be744b7d79a9beacf8e5e5eb2R1011

I think an UnresolvedAttribute in grouping expressions here already implicitly indicates it is not in child plan's output?

I'm not 100% sure though, since the resolution batch currently has this rule, it seems this rule is firstly applied into unresolved grouping keys in the star case @cloud-fan suggested.

I think the UnresolvedAttribute in grouping expressions that can be resolved by child's output, should be already resolved by ResolveReferences.

I got debug info and it seemed ResolveAggAliasInGroupBy was firstly applied in that case?

scala> sql("SELECT *, count(1) FROM (select 1 AS a, 1 AS b) GROUP BY a, b").show === Applying Rule org.apache.spark.sql.catalyst.analysis.Analyzer$ResolveReferences === !'Aggregate ['a, 'b], [*, unresolvedalias('count(1), None)] 'Aggregate ['a, 'b], [a#0, b#1, unresolvedalias('count(1), None)] +- Project [1 AS a#0, 1 AS b#1] +- Project [1 AS a#0, 1 AS b#1] +- OneRowRelation$ +- OneRowRelation$ <-- ResolveAggAliasInGroupBy applied --> === Applying Rule org.apache.spark.sql.catalyst.analysis.Analyzer$ResolveFunctions === !'Aggregate ['a, 'b], [a#0, b#1, unresolvedalias('count(1), None)] 'Aggregate ['a, 'b], [a#0, b#1, unresolvedalias(count(1), None)] +- Project [1 AS a#0, 1 AS b#1] +- Project [1 AS a#0, 1 AS b#1] +- OneRowRelation$ +- OneRowRelation$ === Applying Rule org.apache.spark.sql.catalyst.analysis.Analyzer$ResolveAliases === !'Aggregate ['a, 'b], [a#0, b#1, unresolvedalias(count(1), None)] 'Aggregate ['a, 'b], [a#0, b#1, count(1) AS count(1)#3L] +- Project [1 AS a#0, 1 AS b#1] +- Project [1 AS a#0, 1 AS b#1] +- OneRowRelation$ +- OneRowRelation$ === Applying Rule org.apache.spark.sql.catalyst.analysis.Analyzer$ResolveReferences === !'Aggregate ['a, 'b], [a#0, b#1, count(1) AS count(1)#3L] Aggregate [a#0, b#1], [a#0, b#1, count(1) AS count(1)#3L] +- Project [1 AS a#0, 1 AS b#1] +- Project [1 AS a#0, 1 AS b#1] +- OneRowRelation$ +- OneRowRelation$ <-- ResolveAggAliasInGroupBy applied -->

ok I have an idea: first, check there is UnresolvedAttribute in grouping expression, then check these UnresolvedAttributes can't be resolved by child.output.

The latest fix is not enough for your suggestion?;
This fix checks if UnresolvedAttribute exists there, then filter out by child.output.
https://github.com/apache/spark/pull/17191/files#diff-57b3d87be744b7d79a9beacf8e5e5eb2R1014

+ // This is a strict check though, we put this to apply the rule only in alias expressions + def checkIfChildOutputHasNo(attrName: String): Boolean = + !child.output.exists(a => resolver(a.name, attrName)) + agg.copy(groupingExpressions = groups.map { + case u: UnresolvedAttribute if checkIfChildOutputHasNo(u.name) => + aggs.find(ne => resolver(ne.name, u.name)).getOrElse(u) + case e => e + })

yea it works, but maybe give it a better name like notResolvableByChild

SparkQA · 2017-04-27T10:25:20Z

Test build #76218 has finished for PR 17191 at commit 7264150.

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

SparkQA · 2017-04-27T10:34:43Z

Test build #76220 has finished for PR 17191 at commit 0ae48d8.

This patch fails SparkR unit tests.
This patch merges cleanly.
This patch adds no public classes.

maropu · 2017-04-27T10:39:44Z

Jenkins, retest this please.

SparkQA · 2017-04-27T12:59:26Z

Test build #76224 has finished for PR 17191 at commit 0ae48d8.

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

SparkQA · 2017-04-27T18:56:14Z

Test build #76232 has finished for PR 17191 at commit d3071fa.

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

maropu · 2017-04-27T23:26:13Z

@cloud-fan ok, could you check again? Thanks!

cloud-fan · 2017-04-28T06:28:26Z

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/Analyzer.scala

@@ -998,6 +998,27 @@ class Analyzer(
  }

  /**
+   * Replace unresolved expressions in grouping keys with resolved ones in SELECT clauses.
+   * This rule is expected to run after [[ResolveReferences]] applied.


we can remove this now. With the new check, the order doesn't matter

cloud-fan · 2017-04-28T06:42:18Z

thanks, mering to master/2.2!

## What changes were proposed in this pull request? This pr added a new rule in `Analyzer` to resolve aliases in `GROUP BY`. The current master throws an exception if `GROUP BY` clauses have aliases in `SELECT`; ``` scala> spark.sql("select a a1, a1 + 1 as b, count(1) from t group by a1") org.apache.spark.sql.AnalysisException: cannot resolve '`a1`' given input columns: [a]; line 1 pos 51; 'Aggregate ['a1], [a#83L AS a1#87L, ('a1 + 1) AS b#88, count(1) AS count(1)#90L] +- SubqueryAlias t +- Project [id#80L AS a#83L] +- Range (0, 10, step=1, splits=Some(8)) at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:42) at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:77) at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:74) at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:289) ``` ## How was this patch tested? Added tests in `SQLQuerySuite` and `SQLQueryTestSuite`. Author: Takeshi Yamamuro <yamamuro@apache.org> Closes #17191 from maropu/SPARK-14471. (cherry picked from commit 59e3a56) Signed-off-by: Wenchen Fan <wenchen@databricks.com>

## What changes were proposed in this pull request? This pr added `Analyzer` code for supporting aliases in CUBE/ROLLUP/GROUPING SETS (This is follow-up of apache#17191). ## How was this patch tested? Added tests in `SQLQueryTestSuite`. Author: Takeshi Yamamuro <yamamuro@apache.org> Closes apache#17948 from maropu/SPARK-20710.

## What changes were proposed in this pull request? This pr added `Analyzer` code for supporting aliases in CUBE/ROLLUP/GROUPING SETS (This is follow-up of #17191). ## How was this patch tested? Added tests in `SQLQueryTestSuite`. Author: Takeshi Yamamuro <yamamuro@apache.org> Closes #17948 from maropu/SPARK-20710. (cherry picked from commit 92ea7fd) Signed-off-by: Wenchen Fan <wenchen@databricks.com>

## What changes were proposed in this pull request? This pr added `Analyzer` code for supporting aliases in CUBE/ROLLUP/GROUPING SETS (This is follow-up of apache#17191). ## How was this patch tested? Added tests in `SQLQueryTestSuite`. Author: Takeshi Yamamuro <yamamuro@apache.org> Closes apache#17948 from maropu/SPARK-20710.

nsyca suggested changes Mar 13, 2017

View reviewed changes

maropu force-pushed the SPARK-14471 branch from c4b40aa to f62a75a Compare March 16, 2017 17:33

nsyca reviewed Mar 16, 2017

View reviewed changes

maropu force-pushed the SPARK-14471 branch from c25b1b3 to 5d8c853 Compare March 17, 2017 03:13

Revert "Move some rules into postHocResolutionRules"

65f6e7c

This reverts commit 1340862.

cloud-fan reviewed Apr 27, 2017

View reviewed changes

maropu added 2 commits April 27, 2017 16:25

Apply review comments

86402b0

Put strick checker

0ae48d8

maropu force-pushed the SPARK-14471 branch from 7264150 to 0ae48d8 Compare April 27, 2017 08:13

Rename a function

d3071fa

cloud-fan reviewed Apr 28, 2017

View reviewed changes

asfgit closed this in 59e3a56 Apr 28, 2017

maropu mentioned this pull request May 11, 2017

[SPARK-20710][SQL] Support aliases in CUBE/ROLLUP/GROUPING SETS #17948

Closed

gengliangwang mentioned this pull request Apr 12, 2021

[SPARK-35028][SQL] ANSI mode: disallow group by aliases #32129

Closed

[SPARK-14471][SQL] Aliases in SELECT could be used in GROUP BY #17191

[SPARK-14471][SQL] Aliases in SELECT could be used in GROUP BY #17191

Conversation

maropu commented Mar 7, 2017

What changes were proposed in this pull request?

How was this patch tested?

SparkQA commented Mar 7, 2017

nsyca commented Mar 7, 2017

maropu commented Mar 8, 2017 • edited

SparkQA commented Mar 10, 2017

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

nsyca commented Mar 13, 2017

maropu commented Mar 15, 2017

SparkQA commented Mar 15, 2017

maropu commented Mar 15, 2017

dilipbiswal commented Mar 15, 2017

SparkQA commented Mar 15, 2017

maropu commented Mar 15, 2017

dilipbiswal commented Mar 15, 2017 • edited

dongjoon-hyun commented Mar 15, 2017 • edited

gatorsmile commented Mar 16, 2017

maropu commented Mar 16, 2017

maropu commented Mar 16, 2017 • edited

gatorsmile commented Mar 16, 2017

rxin commented Mar 16, 2017 • edited

SparkQA commented Mar 16, 2017

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

maropu commented Mar 17, 2017

cloud-fan commented Mar 17, 2017

SparkQA commented Mar 17, 2017

maropu commented Mar 17, 2017 • edited

SparkQA commented Mar 17, 2017

cloud-fan commented Mar 17, 2017

maropu commented Mar 17, 2017 • edited

maropu commented Apr 26, 2017 • edited

SparkQA commented Apr 26, 2017

maropu commented Apr 26, 2017

SparkQA commented Apr 27, 2017

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

maropu Apr 27, 2017 • edited

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

maropu Apr 27, 2017 • edited

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

SparkQA commented Apr 27, 2017

SparkQA commented Apr 27, 2017

maropu commented Apr 27, 2017

SparkQA commented Apr 27, 2017

SparkQA commented Apr 27, 2017

maropu commented Apr 27, 2017

Choose a reason for hiding this comment

Choose a reason for hiding this comment

cloud-fan commented Apr 28, 2017

maropu commented Mar 8, 2017 •

edited

dilipbiswal commented Mar 15, 2017 •

edited

dongjoon-hyun commented Mar 15, 2017 •

edited

maropu commented Mar 16, 2017 •

edited

rxin commented Mar 16, 2017 •

edited

maropu commented Mar 17, 2017 •

edited

maropu commented Mar 17, 2017 •

edited

maropu commented Apr 26, 2017 •

edited

maropu Apr 27, 2017 •

edited

maropu Apr 27, 2017 •

edited