av9ash/GitBugs huggingface dataset:
Bug: Avoid reordering decimal Add for canonicalization
Status: Resolved | Priority: Major | Resolution: Fixed
Created: 24/Oct/22 20:47
Affects Version/s: 3.4.0

Avoid reordering Add for canonicalizing if it is decimal type.
Expressions are canonicalized for comparisons and explanations. For non-decimal Add expression, the order can be sorted by hashcode, and the result is supposed to be the same.
However, for Add expression of Decimal type, the behavior is different: Given decimal (p1, s1) and another decimal (p2, s2), the result integral part is `max(p1-s1, p2-s2) +1`, the result decimal part is `max(s1, s2)`. Thus the result data type is `(max(p1-s1, p2-s2) +1 + max(s1, s2), max(s1, s2))`.
Thus the order matters:
* For `(decimal(12,5) + decimal(12,6)) + decimal(3, 2)`, the first add `decimal(12,5) + decimal(12,6)` results in `decimal(14, 6)`, and then `decimal(14, 6) + decimal(3, 2)`  results in `decimal(15, 6)`
* For `(decimal(12, 6) + decimal(3,2)) + decimal(12, 5)`, the first add `decimal(12, 6) + decimal(3,2)` results in `decimal(13, 6)`, and then `decimal(13, 6) + decimal(12, 5)` results in `decimal(14, 6)`

In the following query:
```
create table foo(a decimal(12, 5), b decimal(12, 6)) using orc
select sum(coalesce(a+b+ 1.75, a)) from foo
```
At first `coalesce(a+b+ 1.75, a)` is resolved as `coalesce(a+b+ 1.75, cast(a as decimal(15, 6))`. In the canonicalized version, the expression becomes `coalesce(1.75+b+a, cast(a as decimal(15, 6))`. As explained above, `1.75+b+a` is of decimal(14, 6), which is different from  `cast(a as decimal(15, 6)`. Thus the following error will happen:
{code:java}
java.lang.IllegalArgumentException: requirement failed: All input types must be the same except nullable, containsNull, valueContainsNull flags. The input types found are
	DecimalType(14,6)
	DecimalType(15,6)
	at scala.Predef$.require(Predef.scala:281)
	at org.apache.spark.sql.catalyst.expressions.ComplexTypeMergingExpression.dataTypeCheck(Expression.scala:1149)
	at org.apache.spark.sql.catalyst.expressions.ComplexTypeMergingExpression.dataTypeCheck$(Expression.scala:1143) {code}
Bug: Migrate type check failures of aggregate expressions onto error classes
Status: Resolved | Priority: Major | Resolution: Fixed
Created: 12/Oct/22 07:06
Affects Version/s: 3.4.0

Replace TypeCheckFailure by DataTypeMismatch in type checks in the aggregate expressions:
1. Count (1):
https://github.com/apache/spark/blob/08678456d16bacfa91ad5f718b6d3fa51b1f6cc0/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/aggregate/Count.scala#L59
2. CollectSet (1):
https://github.com/apache/spark/blob/08678456d16bacfa91ad5f718b6d3fa51b1f6cc0/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/aggregate/collect.scala#L180
3. CountMinSketchAgg (4):
https://github.com/apache/spark/blob/08678456d16bacfa91ad5f718b6d3fa51b1f6cc0/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/aggregate/CountMinSketchAgg.scala#L87-L95
4. HistogramNumeric (3):
https://github.com/apache/spark/blob/08678456d16bacfa91ad5f718b6d3fa51b1f6cc0/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/aggregate/HistogramNumeric.scala#L92-L96
Bug: Migrate type check failures of generators onto error classes
Status: Resolved | Priority: Major | Resolution: Fixed
Created: 11/Oct/22 13:27
Affects Version/s: 3.4.0

Replace TypeCheckFailure by DataTypeMismatch in type checks in the generator expressions:
1. Stack (3): https://github.com/apache/spark/blob/1431975723d8df30a25b2333eddcfd0bb6c57677/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/generators.scala#L163-L170
2. ExplodeBase (1): https://github.com/apache/spark/blob/1431975723d8df30a25b2333eddcfd0bb6c57677/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/generators.scala#L299
3. Inline (1):
https://github.com/apache/spark/blob/1431975723d8df30a25b2333eddcfd0bb6c57677/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/generators.scala#L441
Bug: Use error classes for Protobuf exceptions
Status: Resolved | Priority: Major | Resolution: Fixed
Created: 12/Oct/22 22:32
Affects Version/s: 3.3.0

We should use error classes for all the exceptions.

A follow up from Protobuf PR [https://github.com/apache/spark/pull/37972]

 

cc: [~sanysandish@gmail.com]
Bug: KubernetesConf.getResourceNamePrefix creates invalid name prefixes
Status: Resolved | Priority: Major | Resolution: Fixed
Created: 21/Oct/22 10:29
Affects Version/s: 3.3.0

If `KubernetesConf.getResourceNamePrefix` is called with e.g. `_name_`, it generates an invalid name prefix, e.g. `-name-0123456789abcdef`.
Bug: Migrate type check failures of conditions onto error classes
Status: Resolved | Priority: Major | Resolution: Fixed
Created: 11/Oct/22 13:24
Affects Version/s: 3.4.0

Replace TypeCheckFailure by DataTypeMismatch in type checks in the conditional expressions:
1. If (2): https://github.com/apache/spark/blob/1431975723d8df30a25b2333eddcfd0bb6c57677/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/conditionalExpressions.scala#L61-L67
2. CaseWhen (2): https://github.com/apache/spark/blob/1431975723d8df30a25b2333eddcfd0bb6c57677/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/conditionalExpressions.scala#L175-L183
3. InSubquery (2);
https://github.com/apache/spark/blob/1431975723d8df30a25b2333eddcfd0bb6c57677/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/predicates.scala#L378-L396
4. In (1):
https://github.com/apache/spark/blob/1431975723d8df30a25b2333eddcfd0bb6c57677/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/predicates.scala#L453
Bug: Add WHEN NOT MATCHED BY SOURCE clause to MERGE INTO command
Status: Resolved | Priority: Major | Resolution: Fixed
Created: 26/Oct/22 13:39
Affects Version/s: 3.4.0

The MERGE INTO syntax in Spark allows two types of WHEN clause:
 * WHEN MATCHED: Specify optional condition and actions (delete or update) to apply to rows that satisfy the merge condition.
 * WHEN NOT MATCHED: Specify optional condition and actions (insert) to apply toi rows from the source table that don't satisfy the match condition.

Other products also offer a third type of WHEN clause:
 * WHEN NOT MATCHED BY SOURCE: Specify optional condition and actions (delete or update) to apply to rows from the target table that don't satisfy the merge condition.

See for example [T-SQL Merge Documentation|https://learn.microsoft.com/en-us/sql/t-sql/statements/merge-transact-sql?view=sql-server-ver16]

Example:
{code:java}
MERGE INTO target
USING source
ON target.key = source.key
WHEN MATCHED THEN UPDATE SET *
WHEN NOT MATCHED THEN INSERT *
WHEN NOT MATCHED BY SOURCE THEN DELETE {code}
Bug: Unable to download spark 3.3.0 tarball after 3.3.1 release in spark-docker
Status: Resolved | Priority: Major | Resolution: Fixed
Created: 31/Oct/22 03:06
Affects Version/s: 3.3.1

Unable to download spark 3.3.0 tarball in spark-docker. 


{code:sh}
#7 0.229 + wget -nv -O spark.tgz https://dlcdn.apache.org/spark/spark-3.3.0/spark-3.3.0-bin-hadoop3.tgz
#7 1.061 https://dlcdn.apache.org/spark/spark-3.3.0/spark-3.3.0-bin-hadoop3.tgz:
#7 1.061 2022-10-31 02:59:20 ERROR 404: Not Found.
------
executor failed running [/bin/sh -c set -ex;     export SPARK_TMP="$(mktemp -d)";     cd $SPARK_TMP;     wget -nv -O spark.tgz "$SPARK_TGZ_URL";     wget -nv -O spark.tgz.asc "$SPARK_TGZ_ASC_URL";     export GNUPGHOME="$(mktemp -d)";     gpg --keyserver hkps://keys.openpgp.org --recv-key "$GPG_KEY" ||     gpg --keyserver hkps://keyserver.ubuntu.com --recv-keys "$GPG_KEY";     gpg --batch --verify spark.tgz.asc spark.tgz;     gpgconf --kill all;     rm -rf "$GNUPGHOME" spark.tgz.asc;         tar -xf spark.tgz --strip-components=1;     chown -R spark:spark .;     mv jars /opt/spark/;     mv bin /opt/spark/;     mv sbin /opt/spark/;     mv kubernetes/dockerfiles/spark/decom.sh /opt/;     mv examples /opt/spark/;     mv kubernetes/tests /opt/spark/;     mv data /opt/spark/;     mv python/pyspark /opt/spark/python/pyspark/;     mv python/lib /opt/spark/python/lib/;     cd ..;     rm -rf "$SPARK_TMP";]: exit code: 8
{code}
And spark 3.3.1 docker is ok

{code:sh}
=> [4/9] RUN set -ex;     export SPARK_TMP="$(mktemp -d)";     cd $SPARK_TMP;     wget -nv -O spark.tgz "https://dlcdn.apache.org/spark/spark-3.3.1/spark-3.3.1-bin-hadoop3.tgz";     wget -nv -O spark.tgz.asc "https://downlo  77.8s
 => [5/9] COPY entrypoint.sh /opt/
{code}
Bug: Relax ordering constraint for CREATE TABLE column options
Status: Resolved | Priority: Major | Resolution: Fixed
Created: 27/Oct/22 22:32
Affects Version/s: 3.4.0

Currently the grammar for each CREATE TABLE column is:

createOrReplaceTableColType
    : colName=errorCapturingIdentifier dataType (NOT NULL)? defaultExpression? commentSpec?
    ;

This enforces a constraint on the order of: (NOT NULL, DEFAULT value, COMMENT value). We can update the grammar to allow these options in any order instead, to improve usability.
Bug: Allow DSV2 Predicate pushdown in FileScanBuilder.pushedDataFilter 
Status: Open | Priority: Major | Resolution: 
Created: 28/Oct/22 16:19
Affects Version/s: 3.3.1

{+}overall{+}: 


Allow FileScanBuilder to push `Predicate` instead of `Filter` for data filters being pushed down to source. This would allow new (arbitrary) DS V2 Predicates to be pushed down to the file source. 




Hello spark developers,

Thank you in advance for reading. Please excuse me if I make mistakes; this is my first time working on apache/spark internals. I am asking these questions to better understand whether my proposed changes fall within the intended scope of Data Source V2 API functionality.


+Motivation / Background:+

I am working on a branch in [apache/incubator-sedona|https://github.com/apache/incubator-sedona] to extend its support of geoparquet files to include predicate pushdown of postGIS style spatial predicates (e.g. `ST_Contains()`) that can take advantage of spatial info in file metadata. We would like to inherit as much as possible from the Parquet classes (because geoparquet basically just adds a binary geometry column). However, {{FileScanBuilder.scala}} appears to be missing some functionality I need for DSV2 {{{}Predicates{}}}.


+My understanding of the problem so far:+

The ST_* {{Expression}} must be detected as a pushable predicate (ParquetScanBuilder.scala:71) and passed as a {{pushedDataFilter}} to the {{parquetPartitionReaderFactory}} where it will be translated into a (user defined) {{{}FilterPredicate{}}}.

The [Filter class is sealed|https://github.com/apache/spark/blob/branch-3.3/sql/catalyst/src/main/scala/org/apache/spark/sql/sources/filters.scala] so the sedona package can’t define new Filters; DSV2 Predicate appears to be the preferred method for accomplishing this task (referred to as “V2 Filter”, SPARK-39966). However, `pushedDataFilters` in FileScanBuilder.scala is of type {{{}sources.Filter{}}}.

Some recent work (SPARK-39139) added the ability to detect user defined functions in  {{DataSourceV2Strategy.translateFilterV2() > V2ExpressionBuilder.generateExpression()}}  , which I think could accomplish detection correctly if {{FileScanBuilder}} called {{DataSourceV2Strategy.translateFilterV2()}} instead of {{{}DataSourceStrategy.translateFilter(){}}}.

However, changing {{FileScanBuilder}} to use {{Predicate}} instead of {{Filter}} would require many changes to all file based data sources. I don’t want to spend effort making sweeping changes if the current behavior of Spark is intentional.

 

+Concluding Questions:+

Should {{FileScanBuilder}} be pushing {{Predicate}} instead of {{Filter}} for data filters being pushed down to source? Or maybe in a FileScanBuilderV2?

If not, how can a developer of a data source push down a new (or user defined) predicate to the file source?

Thank you again for reading. Pending feedback, I will start working on a PR for this functionality.



[~beliefer] [~cloud_fan] [~huaxingao]   have worked on DSV2 related spark issues and I welcome your input. Please ignore this if I "@" you incorrectly.
Bug: Migrate type check failures of misc expressions onto error classes
Status: Resolved | Priority: Major | Resolution: Fixed
Created: 11/Oct/22 13:41
Affects Version/s: 3.4.0

Replace TypeCheckFailure by DataTypeMismatch in type checks in the misc expressions:
1. Coalesce(1)
https://github.com/apache/spark/blob/1431975723d8df30a25b2333eddcfd0bb6c57677/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/nullExpressions.scala#L60
2. SortOrder(1)
https://github.com/apache/spark/blob/1431975723d8df30a25b2333eddcfd0bb6c57677/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/SortOrder.scala#L75
3. UnwrapUDT(1):
https://github.com/apache/spark/blob/1431975723d8df30a25b2333eddcfd0bb6c57677/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/UnwrapUDT.scala#L36
4. ParseUrl(1):
https://github.com/apache/spark/blob/1431975723d8df30a25b2333eddcfd0bb6c57677/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/urlExpressions.scala#L185
5. XPathExtract(1)
https://github.com/apache/spark/blob/a241256ed0778005245253fb147db8a16105f75c/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/xml/xpath.scala#L45
Bug: Support data masking built-in function 'diff_privacy'
Status: Open | Priority: Major | Resolution: 
Created: 28/Oct/22 17:39
Affects Version/s: 3.4.0

This function can compute the Laplace distribution for integer values.

It may be sufficient to implement a basic version of this for integer values only; full differential privacy support remains a separate effort.

Background on the math:

https://en.wikipedia.org/wiki/Laplace_distribution
Bug: Always inline expressions in OptimizeOneRowRelationSubquery
Status: Resolved | Priority: Major | Resolution: Fixed
Created: 14/Oct/22 15:52
Affects Version/s: 3.4.0

SPARK-39699 made `CollpaseProjects` more conservative. This has impacted correlated subqueries that Spark used to be able to support. For example, a correlated one-row scalar subquery that has a higher-order function:
{code:java}
CREATE TEMP VIEW t1 AS SELECT ARRAY('a', 'b') a 

SELECT (
  SELECT array_sort(a, (i, j) -> rank[i] - rank[j]) AS sorted
  FROM (SELECT MAP('a', 1, 'b', 2) rank)
) FROM t1{code}
This will throw an exception after SPARK-39699:
{code:java}
Unexpected operator Join Inner
:- Aggregate [[a,b]], [[a,b] AS a#252]
:  +- OneRowRelation
+- Project [map(keys: [a,b], values: [1,2]) AS rank#241]
   +- OneRowRelation
 in correlated subquery{code}
because the projects inside the subquery can no longer be collapsed. We should always inline expressions if possible to avoid adding domain joins and support a wider range of correlated subqueries.
Bug: Unexpected operators when rewriting scalar subqueries with non-deterministic expressions
Status: Resolved | Priority: Major | Resolution: Fixed
Created: 20/Oct/22 21:14
Affects Version/s: 3.4.0

Since SPARK-28379, Spark has supported non-aggregated single-row correlated subqueries. SPARK-40800 handles the majority of the cases where projects can be collapsed. But Spark can throw exceptions for single-row subqueries with non-deterministic expressions. For example:
{code:java}
CREATE TEMP VIEW t1 AS SELECT ARRAY('a', 'b') a 

SELECT (
  SELECT array_sort(a, (i, j) -> rank[i] - rank[j])[0] + r + r AS sorted
  FROM (SELECT MAP('a', 1, 'b', 2) rank, rand() as r)
) FROM t1{code}
This throws an exception:
{code:java}
Unexpected operator Join Inner
:- Aggregate [[a,b]], [[a,b] AS a#253]
:  +- OneRowRelation
+- Project [map(keys: [a,b], values: [1,2]) AS rank#241, rand(86882494013664043) AS r#242]
   +- OneRowRelation
 in correlated subquery{code}
This is because when Spark rewrites correlated subqueries, it checks whether a scalar subquery is subject to the COUNT bug. It splits the query into parts above the aggregate, the aggregate, and the parts below the aggregate (see `splitSubquery` in the `RewriteCorrelatedScalarSubquery` rule). 

This pattern is very restrictive and does not work well with non-aggregated single-row subqueries. We should fix this issue.
Bug: Fix doctest for `Index.(isin|isnull|notnull)` to work properly with pandas 1.5
Status: Resolved | Priority: Major | Resolution: Fixed
Created: 24/Oct/22 08:08
Affects Version/s: 3.4.0

The bahavior of Index.(isin|isnull|notnull) is changed from pandas 1.5.0.

 

It's now return bool type Series rather than object type Series which is more reasonable.
Bug: Loosen the requirement of window_time rule - allow multiple window_time calls
Status: Resolved | Priority: Major | Resolution: Fixed
Created: 23/Oct/22 23:36
Affects Version/s: 3.4.0

SPARK-40821 introduces a new SQL function "window_time" to extract the representative time from window (which also carries over the event time metadata as well if feasible).

SPARK-40821 followed the existing rule of time window / session window which only allows a single function call in a same projection (strictly saying, it considers the call of function as once if the function is called with same parameters).

For existing rules, the restriction makes sense since allowing this would produce cartesian product of rows (although Spark can handle it). But given that window_time only produces one value, the restriction no longer makes sense.

It would be better to unlock the functionality. Note that this means the resulting column of "window_time()" is no longer be "window_time". (Note that this is the practice most of function calls do. The rules time window and session window don't follow the practice so arguably they have a bug, but fixing the bug would bring backward incompatibility...)
Bug: Allow for negative initial watermark value
Status: Open | Priority: Major | Resolution: 
Created: 27/Oct/22 20:34
Affects Version/s: 3.4.0

Currently at Spark SS pipeline start, the initial watermark value is 0 and thus records with event time 0 will be filtered out as late due to the requirement of event time > watermark. This is untypical scenario as event 0 is probably synthetic, but still probably should be handled.
Bug: SVD: matrix U has wrong row order
Status: Open | Priority: Major | Resolution: 
Created: 26/Oct/22 11:58
Affects Version/s: 3.3.0

When performing SVD on a RowMatrix, the matrix U has the wrong row order and the original matrix is not correctly restored with the given matrix. 

 

Consider the following code:
{code:java}
x_np = np.random.random((14, 3)) # the size matters, it works for smaller sizes
x = ctx.parallelize(x_np).zipWithIndex().map(
    lambda r: [MatrixEntry(r[1], i, r[0][i]) for i in range(len(r[0]))])
x = CoordinateMatrix(x.flatMap(lambda x: x))
x_inv = matrix_inverse(x) {code}
with 
{code:java}
def matrix_inverse(matrix: CoordinateMatrix) -> DenseMatrix:
    mtrx = matrix.toRowMatrix()
    svd = matrix.toRowMatrix().computeSVD(k=mtrx.numCols(), computeU=True, rCond=1e-15)  # do the SVD

    s_inv = 1 / svd.s
    mtrx_orig = matrix.toBlockMatrix().blocks.first()[1].toArray()
    u_dense = mtrx_orig @ (svd.V.toArray() * s_inv[np.newaxis, :])
    cov_inv = np.matmul(svd.V.toArray(), np.multiply(s_inv[:, np.newaxis], u_dense.T))
    u_from_spark = np.array(svd.U.rows.map(lambda x: x.toArray()).collect())
    return DenseMatrix(numRows=cov_inv.shape[0], numCols=cov_inv.shape[1],
                       values=cov_inv.ravel(order="F"))  # return inverse as dense matrix {code}
Then, u_dense is the correct U but differs from the U produced by Spark. In particular, the U in Spark does not return the correct pseudoinverse and U@[S@V.T|mailto:S@V.T] does not reproduce the input matrix. 

 

With the following input matrix x

!image-2022-10-26-13-58-52-998.png!

I get the following u_dense

!image-2022-10-26-13-59-04-608.png!

but the following u_from_spark

!image-2022-10-26-13-59-13-425.png!

 

On careful inspection, it seems that the row order is wrong.
Bug: Migrate type check failures of high order functions onto error classes
Status: Resolved | Priority: Major | Resolution: Fixed
Created: 11/Oct/22 13:37
Affects Version/s: 3.4.0

Replace TypeCheckFailure by DataTypeMismatch in type checks in the high-order functions expressions:
1. ArraySort (2): 
https://github.com/apache/spark/blob/1431975723d8df30a25b2333eddcfd0bb6c57677/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/higherOrderFunctions.scala#L403-L407
2. ArrayAggregate (1): 
https://github.com/apache/spark/blob/1431975723d8df30a25b2333eddcfd0bb6c57677/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/higherOrderFunctions.scala#L807
3. MapZipWith (1):
https://github.com/apache/spark/blob/1431975723d8df30a25b2333eddcfd0bb6c57677/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/higherOrderFunctions.scala#L1028
Bug: Migrate type check failures of time window onto error classes
Status: Resolved | Priority: Major | Resolution: Fixed
Created: 11/Oct/22 15:15
Affects Version/s: 3.4.0

Replace TypeCheckFailure by DataTypeMismatch in type checks in the time window expressions:
1. TimeWindow (4):
https://github.com/apache/spark/blob/1431975723d8df30a25b2333eddcfd0bb6c57677/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/TimeWindow.scala#L117-L127
Bug: Bad case of `AnalysisTest#assertAnalysisErrorClass` when `expectedMessageParameters.size between [2, 4]`
Status: Resolved | Priority: Major | Resolution: Fixed
Created: 26/Oct/22 11:50
Affects Version/s: 3.4.0

If the size of the input parameter `expectedMessageParameters` of the `AnalysisTest#assertAnalysisErrorClass` method is between 2 and 4, the result of `

e.messageParameters.sameElements(expectedMessageParameters)` is related to order.

For example

 
{code:java}
bin/scala
Welcome to Scala 2.12.16 (OpenJDK 64-Bit Server VM, Java 1.8.0_352).
Type in expressions for evaluation. Or try :help.


scala> :paste
// Entering paste mode (ctrl-D to finish)


val messageParameters = Map(
      "exprName" -> "`window_duration`",
      "valueRange" -> s"(0, 9223372036854775807]",
      "currentValue" -> "-1000000L",
      "sqlExpr" -> "\"window(2016-01-01 01:01:01, -1000000, 1000000, 0)\""
    )
val expectedMessageParameters =  Map(
      "sqlExpr" -> "\"window(2016-01-01 01:01:01, -1000000, 1000000, 0)\"",
      "exprName" -> "`window_duration`",
      "valueRange" -> s"(0, 9223372036854775807]",
      "currentValue" -> "-1000000L"
    )


val ret = messageParameters.sameElements(expectedMessageParameters)


// Exiting paste mode, now interpreting.


messageParameters: scala.collection.immutable.Map[String,String] = Map(exprName -> `window_duration`, valueRange -> (0, 9223372036854775807], currentValue -> -1000000L, sqlExpr -> "window(2016-01-01 01:01:01, -1000000, 1000000, 0)")
expectedMessageParameters: scala.collection.immutable.Map[String,String] = Map(sqlExpr -> "window(2016-01-01 01:01:01, -1000000, 1000000, 0)", exprName -> `window_duration`, valueRange -> (0, 9223372036854775807], currentValue -> -1000000L)
ret: Boolean = false{code}