From b8ba3a51810de41ef1b38b8c0a478e0d519ddb6b Mon Sep 17 00:00:00 2001
From: Huaxin Gao <huaxin_gao@apple.com>
Date: Sun, 22 Aug 2021 09:11:23 -0700
Subject: [PATCH 01/24] [SPARK-36556][SQL] Add DSV2 filters

---
 .../expressions/filter/AlwaysFalse.java       |  39 ++++++
 .../expressions/filter/AlwaysTrue.java        |  39 ++++++
 .../sql/connector/expressions/filter/And.java |  56 ++++++++
 .../expressions/filter/EqualNullSafe.java     |  59 +++++++++
 .../connector/expressions/filter/EqualTo.java |  62 +++++++++
 .../expressions/filter/FilterV2.java          |  43 ++++++
 .../expressions/filter/GreaterThan.java       |  58 ++++++++
 .../filter/GreaterThanOrEqual.java            |  57 ++++++++
 .../sql/connector/expressions/filter/In.java  |  80 +++++++++++
 .../expressions/filter/IsNotNull.java         |  51 +++++++
 .../connector/expressions/filter/IsNull.java  |  51 +++++++
 .../expressions/filter/LessThan.java          |  58 ++++++++
 .../expressions/filter/LessThanOrEqual.java   |  58 ++++++++
 .../sql/connector/expressions/filter/Not.java |  46 +++++++
 .../sql/connector/expressions/filter/Or.java  |  56 ++++++++
 .../expressions/filter/StringContains.java    |  55 ++++++++
 .../expressions/filter/StringEndsWith.java    |  55 ++++++++
 .../expressions/filter/StringStartsWith.java  |  60 +++++++++
 .../datasources/v2/FiltersV2Suite.scala       | 124 ++++++++++++++++++
 19 files changed, 1107 insertions(+)
 create mode 100644 sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java
 create mode 100644 sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java
 create mode 100644 sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
 create mode 100644 sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
 create mode 100644 sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
 create mode 100644 sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/FilterV2.java
 create mode 100644 sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
 create mode 100644 sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
 create mode 100644 sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
 create mode 100644 sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
 create mode 100644 sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
 create mode 100644 sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
 create mode 100644 sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
 create mode 100644 sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java
 create mode 100644 sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
 create mode 100644 sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
 create mode 100644 sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
 create mode 100644 sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
 create mode 100644 sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/FiltersV2Suite.scala

diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java
new file mode 100644
index 0000000000000..c38ba446dac6d
--- /dev/null
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java
@@ -0,0 +1,39 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.spark.sql.connector.expressions.filter;
+
+import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.NamedReference;
+
+/**
+ * A filter that always evaluates to `false`.
+ *
+ * @since 3.3.0
+ */
+@Evolving
+public final class AlwaysFalse extends FilterV2 {
+
+  @Override
+  public String toString() { return "AlwaysFalse"; }
+
+  @Override
+  public String describe() { return this.toString(); }
+
+  @Override
+  public NamedReference[] references() { return new NamedReference[0]; }
+}
\ No newline at end of file
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java
new file mode 100644
index 0000000000000..66554c97a3134
--- /dev/null
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java
@@ -0,0 +1,39 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.spark.sql.connector.expressions.filter;
+
+import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.NamedReference;
+
+/**
+ * A filter that always evaluates to `true`.
+ *
+ * @since 3.3.0
+ */
+@Evolving
+public final class AlwaysTrue extends FilterV2 {
+
+  @Override
+  public String toString() { return "AlwaysTrue"; }
+
+  @Override
+  public String describe() { return this.toString(); }
+
+  @Override
+  public NamedReference[] references() { return new NamedReference[0]; }
+}
\ No newline at end of file
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
new file mode 100644
index 0000000000000..a710ab2c3da78
--- /dev/null
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
@@ -0,0 +1,56 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.spark.sql.connector.expressions.filter;
+
+import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.NamedReference;
+
+/**
+ * A filter that evaluates to `true` iff both `left` or `right` evaluate to `true`.
+ *
+ * @since 3.3.0
+ */
+@Evolving
+public final class And extends FilterV2 {
+  private final FilterV2 left;
+  private final FilterV2 right;
+
+  public And(FilterV2 left, FilterV2 right) {
+    this.left = left;
+    this.right = right;
+  }
+
+  public FilterV2 left() { return left; }
+  public FilterV2 right() { return right; }
+
+  @Override
+  public String toString() { return left.describe() + " and " + right.describe(); }
+
+  @Override
+  public String describe() { return this.toString(); }
+
+  @Override
+  public NamedReference[] references() {
+    NamedReference[] refLeft = left.references();
+    NamedReference[] refRight = right.references();
+    NamedReference[] arr = new NamedReference[refLeft.length + refRight.length];
+    System.arraycopy(refLeft, 0, arr, 0, refLeft.length);
+    System.arraycopy(refRight, 0, arr, refLeft.length, refRight.length);
+    return arr;
+  }
+}
\ No newline at end of file
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
new file mode 100644
index 0000000000000..ce145e9ec801e
--- /dev/null
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
@@ -0,0 +1,59 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.spark.sql.connector.expressions.filter;
+
+import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.Expression;
+import org.apache.spark.sql.connector.expressions.FieldReference;
+import org.apache.spark.sql.connector.expressions.NamedReference;
+
+/**
+ * Performs equality comparison, similar to [[EqualTo]]. However, this differs from [[EqualTo]]
+ * in that it returns `true` (rather than NULL) if both inputs are NULL, and `false`
+ * (rather than NULL) if one of the input is NULL and the other is not NULL.
+ *
+ * @since 3.3.0
+ */
+@Evolving
+public final class EqualNullSafe extends FilterV2 {
+  private final FieldReference column;
+  private final Expression value;
+
+  public EqualNullSafe(FieldReference column, Expression value) {
+    this.column = column;
+    this.value = value;
+  }
+
+  public FieldReference column() { return column; }
+  public Expression value() { return value; }
+
+  @Override
+  public String toString() { return column.describe() + " EqualNullSafe: " + value.describe(); }
+
+  @Override
+  public String describe() { return this.toString(); }
+
+  @Override
+  public NamedReference[] references() {
+    NamedReference[] refs = findReferences(value);
+    NamedReference[] arr = new NamedReference[1 + refs.length];
+    arr[0] = column;
+    System.arraycopy(refs, 0, arr, 1, refs.length);
+    return arr;
+  }
+}
\ No newline at end of file
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
new file mode 100644
index 0000000000000..c7c1c0deb4a46
--- /dev/null
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
@@ -0,0 +1,62 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.spark.sql.connector.expressions.filter;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.Expression;
+import org.apache.spark.sql.connector.expressions.NamedReference;
+import org.apache.spark.sql.connector.expressions.FieldReference;
+
+/**
+ * A filter that evaluates to `true` iff the field evaluates to a value
+ * equal to `value`.
+ *
+ * @since 3.3.0
+ */
+@Evolving
+public final class EqualTo extends FilterV2 {
+  private final FieldReference column;
+  private final Expression value;
+
+  public EqualTo(FieldReference column, Expression value) {
+    this.column = column;
+    this.value = value;
+  }
+
+  public FieldReference column() { return column; }
+  public Expression value() { return value; }
+
+  @Override
+  public String toString() { return column.describe() + " EqualTo: " + value.describe(); }
+
+  @Override
+  public String describe() { return this.toString(); }
+
+  @Override
+  public NamedReference[] references() {
+    NamedReference[] refs = findReferences(value);
+    NamedReference[] arr = new NamedReference[1 + refs.length];
+    arr[0] = column;
+    System.arraycopy(refs, 0, arr, 1, refs.length);
+    return arr;
+  }
+}
\ No newline at end of file
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/FilterV2.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/FilterV2.java
new file mode 100644
index 0000000000000..6bfbbd17e833a
--- /dev/null
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/FilterV2.java
@@ -0,0 +1,43 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.spark.sql.connector.expressions.filter;
+
+import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.Expression;
+import org.apache.spark.sql.connector.expressions.NamedReference;
+
+/**
+ * Filter base class
+ *
+ * @since 3.3.0
+ */
+@Evolving
+public abstract class FilterV2 implements Expression {
+  /**
+   * Returns list of columns that are referenced by this filter.
+   */
+  public abstract NamedReference[] references();
+
+  protected NamedReference[] findReferences(Object filter) {
+    if (filter instanceof FilterV2) {
+      return ((FilterV2) filter).references();
+    } else {
+      return new NamedReference[0];
+    }
+  }
+}
\ No newline at end of file
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
new file mode 100644
index 0000000000000..1a1fb719e0073
--- /dev/null
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
@@ -0,0 +1,58 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.spark.sql.connector.expressions.filter;
+
+import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.Expression;
+import org.apache.spark.sql.connector.expressions.FieldReference;
+import org.apache.spark.sql.connector.expressions.NamedReference;
+
+/**
+ * A filter that evaluates to `true` iff the field evaluates to a value
+ * greater than `value`.
+ *
+ * @since 3.3.0
+ */
+@Evolving
+public final class GreaterThan extends FilterV2 {
+  private final FieldReference column;
+  private final Expression value;
+
+  public GreaterThan(FieldReference column, Expression value) {
+    this.column = column;
+    this.value = value;
+  }
+
+  public FieldReference column() { return column; }
+  public Expression value() { return value; }
+
+  @Override
+  public String toString() { return column.describe() + " GreaterThan: " + value.describe(); }
+
+  @Override
+  public String describe() { return this.toString(); }
+
+  @Override
+  public NamedReference[] references() {
+    NamedReference[] refs = findReferences(value);
+    NamedReference[] arr = new NamedReference[1 + refs.length];
+    arr[0] = column;
+    System.arraycopy(refs, 0, arr, 1, refs.length);
+    return arr;
+  }
+}
\ No newline at end of file
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
new file mode 100644
index 0000000000000..aea071bd59581
--- /dev/null
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
@@ -0,0 +1,57 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.spark.sql.connector.expressions.filter;
+
+import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.Expression;
+import org.apache.spark.sql.connector.expressions.FieldReference;
+import org.apache.spark.sql.connector.expressions.NamedReference;
+
+/**
+ * A filter that evaluates to `true` iff the field evaluates to a value
+ * greater than or equal to `value`.
+ *
+ * @since 3.3.0
+ */
+@Evolving
+public final class GreaterThanOrEqual extends FilterV2 {
+  private final FieldReference column;
+  private final Expression value;
+
+  public GreaterThanOrEqual(FieldReference column, Expression value) {
+    this.column = column;
+    this.value = value;
+  }
+
+  public FieldReference column() { return column; }
+  public Expression value() { return value; }
+
+  @Override
+  public String toString() { return column.describe() + " GreaterThanOrEqual: " + value.describe(); }
+
+  @Override
+  public String describe() { return this.toString(); }
+
+  public NamedReference[] references() {
+    NamedReference[] refs = findReferences(value);
+    NamedReference[] arr = new NamedReference[1 + refs.length];
+    arr[0] = column;
+    System.arraycopy(refs, 0, arr, 1, refs.length);
+    return arr;
+  }
+}
\ No newline at end of file
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
new file mode 100644
index 0000000000000..c5552abcc56a7
--- /dev/null
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
@@ -0,0 +1,80 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.spark.sql.connector.expressions.filter;
+
+import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.Expression;
+import org.apache.spark.sql.connector.expressions.FieldReference;
+import org.apache.spark.sql.connector.expressions.NamedReference;
+
+import java.util.Arrays;
+import java.util.stream.Stream;
+
+/**
+ * A filter that evaluates to `true` iff the field evaluates to one of the values in the array.
+ *
+ * @since 3.3.0
+ */
+@Evolving
+public final class In extends FilterV2 {
+  private final FieldReference column;
+  private final Expression[] values;
+
+  public In(FieldReference column, Expression[] values) {
+    this.column = column;
+    this.values = values;
+  }
+
+  public FieldReference column() { return column; }
+  public Expression[] values() { return values; }
+
+  public int hashCode() {
+    int h = column.hashCode();
+    for (Expression v : values) {
+      h *= 41;
+      h += v.hashCode();
+    }
+    return h;
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder str = new StringBuilder();
+    for (Expression v : values) {
+      str.append(v.describe()).append(", ");
+    }
+    return column.describe() + " in: " + str;
+  }
+
+  @Override
+  public String describe() { return this.toString(); }
+
+  @Override
+  public NamedReference[] references() {
+    Stream<NamedReference> stream = Stream.of();
+    NamedReference[] arr = new NamedReference[1];
+    arr[0] = column;
+    stream = Stream.concat(stream, Arrays.stream(arr));
+    for (Expression value : values) {
+      NamedReference[] ref = findReferences(value);
+      stream = Stream.concat(stream, Arrays.stream(ref));
+    }
+
+    return stream.toArray(NamedReference[]::new);
+  }
+}
\ No newline at end of file
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
new file mode 100644
index 0000000000000..3c71eb603d207
--- /dev/null
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
@@ -0,0 +1,51 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.spark.sql.connector.expressions.filter;
+
+import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.FieldReference;
+import org.apache.spark.sql.connector.expressions.NamedReference;
+
+/**
+ * A filter that evaluates to `true` iff the field evaluates to a non-null value.
+ *
+ * @since 3.3.0
+ */
+@Evolving
+public final class IsNotNull extends FilterV2 {
+  private final FieldReference column;
+
+  public IsNotNull(FieldReference column) {
+    this.column = column;
+  }
+
+  public FieldReference column() { return column; }
+
+  @Override
+  public String toString() { return column.describe() + " IsNotNull"; }
+
+  @Override
+  public String describe() { return this.toString(); }
+
+  @Override
+  public NamedReference[] references() {
+    NamedReference[] arr = new NamedReference[1];
+    arr[0] = column;
+    return arr;
+  }
+}
\ No newline at end of file
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
new file mode 100644
index 0000000000000..51b441cfa19d5
--- /dev/null
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
@@ -0,0 +1,51 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.spark.sql.connector.expressions.filter;
+
+import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.FieldReference;
+import org.apache.spark.sql.connector.expressions.NamedReference;
+
+/**
+ * A filter that evaluates to `true` iff the field evaluates to null.
+ *
+ * @since 3.3.0
+ */
+@Evolving
+public final class IsNull extends FilterV2 {
+  private final FieldReference column;
+
+  public IsNull(FieldReference column) {
+    this.column = column;
+  }
+
+  public FieldReference column() { return column; }
+
+  @Override
+  public String toString() { return column.describe() + " IsNull"; }
+
+  @Override
+  public String describe() { return this.toString(); }
+
+  @Override
+  public NamedReference[] references() {
+    NamedReference[] arr = new NamedReference[1];
+    arr[0] = column;
+    return arr;
+  }
+}
\ No newline at end of file
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
new file mode 100644
index 0000000000000..96d1a25624713
--- /dev/null
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
@@ -0,0 +1,58 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.spark.sql.connector.expressions.filter;
+
+import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.Expression;
+import org.apache.spark.sql.connector.expressions.FieldReference;
+import org.apache.spark.sql.connector.expressions.NamedReference;
+
+/**
+ * A filter that evaluates to `true` iff the field evaluates to a value
+ * less than `value`.
+ *
+ * @since 3.3.0
+ */
+@Evolving
+public final class LessThan extends FilterV2 {
+  private final FieldReference column;
+  private final Expression value;
+
+  public LessThan(FieldReference column, Expression value) {
+    this.column = column;
+    this.value = value;
+  }
+
+  public FieldReference column() { return column; }
+  public Expression value() { return value; }
+
+  @Override
+  public String toString() { return column.describe() + " LessThan: " + value.describe(); }
+
+  @Override
+  public String describe() { return this.toString(); }
+
+  @Override
+  public NamedReference[] references() {
+    NamedReference[] refs = findReferences(value);
+    NamedReference[] arr = new NamedReference[1 + refs.length];
+    arr[0] = column;
+    System.arraycopy(refs, 0, arr, 1, refs.length);
+    return arr;
+  }
+}
\ No newline at end of file
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
new file mode 100644
index 0000000000000..c581cd650b274
--- /dev/null
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
@@ -0,0 +1,58 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.spark.sql.connector.expressions.filter;
+
+import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.Expression;
+import org.apache.spark.sql.connector.expressions.FieldReference;
+import org.apache.spark.sql.connector.expressions.NamedReference;
+
+/**
+ * A filter that evaluates to `true` iff the field evaluates to a value
+ * less than or equal to `value`.
+ *
+ * @since 3.3.0
+ */
+@Evolving
+public final class LessThanOrEqual extends FilterV2 {
+  private final FieldReference column;
+  private final Expression value;
+
+  public LessThanOrEqual(FieldReference column, Expression value) {
+    this.column = column;
+    this.value = value;
+  }
+
+  public FieldReference column() { return column; }
+  public Expression value() { return value; }
+
+  @Override
+  public String toString() { return column.describe() + " LessThanOrEqual: " + value.describe(); }
+
+  @Override
+  public String describe() { return this.toString(); }
+
+  @Override
+  public NamedReference[] references() {
+    NamedReference[] refs = findReferences(value);
+    NamedReference[] arr = new NamedReference[1 + refs.length];
+    arr[0] = column;
+    System.arraycopy(refs, 0, arr, 1, refs.length);
+    return arr;
+  }
+}
\ No newline at end of file
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java
new file mode 100644
index 0000000000000..0d3e52df9b7d5
--- /dev/null
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java
@@ -0,0 +1,46 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.spark.sql.connector.expressions.filter;
+
+import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.NamedReference;
+
+/**
+ * A filter that evaluates to `true` iff `child` is evaluated to `false`.
+ *
+ * @since 3.3.0
+ */
+@Evolving
+public final class Not extends FilterV2 {
+  private final FilterV2 child;
+
+  public Not(FilterV2 child) { this.child = child; }
+
+  public FilterV2 child() { return child; }
+
+  @Override
+  public String toString() { return child.describe() + " Not"; }
+
+  @Override
+  public String describe() { return this.toString(); }
+
+  @Override
+  public NamedReference[] references() {
+    return child.references();
+  }
+}
\ No newline at end of file
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
new file mode 100644
index 0000000000000..4ba4dda221058
--- /dev/null
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
@@ -0,0 +1,56 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.spark.sql.connector.expressions.filter;
+
+import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.NamedReference;
+
+/**
+ * A filter that evaluates to `true` iff at least one of `left` or `right` evaluates to `true`.
+ *
+ * @since 3.3.0
+ */
+@Evolving
+public final class Or extends FilterV2 {
+  private final FilterV2 left;
+  private final FilterV2 right;
+
+  public Or(FilterV2 left, FilterV2 right) {
+    this.left = left;
+    this.right = right;
+  }
+
+  public FilterV2 left() { return left; }
+  public FilterV2 right() { return right; }
+
+  @Override
+  public String toString() { return left.describe() + " or " + right.describe(); }
+
+  @Override
+  public String describe() { return this.toString(); }
+
+  @Override
+  public NamedReference[] references() {
+    NamedReference[] refLeft = left.references();
+    NamedReference[] refRight = right.references();
+    NamedReference[] arr = new NamedReference[refLeft.length + refRight.length];
+    System.arraycopy(refLeft, 0, arr, 0, refLeft.length);
+    System.arraycopy(refRight, 0, arr, refLeft.length, refRight.length);
+    return arr;
+  }
+}
\ No newline at end of file
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
new file mode 100644
index 0000000000000..05b816f049ac3
--- /dev/null
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
@@ -0,0 +1,55 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.spark.sql.connector.expressions.filter;
+
+import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.FieldReference;
+import org.apache.spark.sql.connector.expressions.NamedReference;
+
+/**
+ * A filter that evaluates to `true` iff the field evaluates to
+ * a string that contains `value`.
+ *
+ * @since 3.3.0
+ */
+@Evolving
+public final class StringContains extends FilterV2 {
+  private final FieldReference column;
+  private final String value;
+
+  public StringContains(FieldReference column, String value) {
+    this.column = column;
+    this.value = value;
+  }
+
+  public FieldReference column() { return column; }
+  public String value() { return value; }
+
+  @Override
+  public String toString() { return column.describe() + " StringContains: " + value; }
+
+  @Override
+  public String describe() { return this.toString(); }
+
+  @Override
+  public NamedReference[] references() {
+    NamedReference[] arr = new NamedReference[1];
+    arr[0] = column;
+    return arr;
+  }
+}
\ No newline at end of file
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
new file mode 100644
index 0000000000000..2baa733366e95
--- /dev/null
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
@@ -0,0 +1,55 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.spark.sql.connector.expressions.filter;
+
+import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.FieldReference;
+import org.apache.spark.sql.connector.expressions.NamedReference;
+
+/**
+ * A filter that evaluates to `true` iff the field evaluates to
+ * a string that ends with `value`.
+ *
+ * @since 3.3.0
+ */
+@Evolving
+public final class StringEndsWith extends FilterV2 {
+  private final FieldReference column;
+  private final String value;
+
+  public StringEndsWith(FieldReference column, String value) {
+    this.column = column;
+    this.value = value;
+  }
+
+  public FieldReference column() { return column; }
+  public String value() { return value; }
+
+  @Override
+  public String toString() { return column.describe() + " StringEndsWith: " + value; }
+
+  @Override
+  public String describe() { return this.toString(); }
+
+  @Override
+  public NamedReference[] references() {
+    NamedReference[] arr = new NamedReference[1];
+    arr[0] = column;
+    return arr;
+  }
+}
\ No newline at end of file
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
new file mode 100644
index 0000000000000..23af9b63ba20c
--- /dev/null
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
@@ -0,0 +1,60 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.spark.sql.connector.expressions.filter;
+
+import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.Expression;
+import org.apache.spark.sql.connector.expressions.FieldReference;
+import org.apache.spark.sql.connector.expressions.NamedReference;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * A filter that evaluates to `true` iff the field evaluates to
+ * a string that starts with `value`.
+ *
+ * @since 3.3.0
+ */
+@Evolving
+public final class StringStartsWith extends FilterV2 {
+  private final FieldReference column;
+  private final String value;
+
+  public StringStartsWith(FieldReference column, String value) {
+    this.column = column;
+    this.value = value;
+  }
+
+  public FieldReference column() { return column; }
+  public String value() { return value; }
+
+  @Override
+  public String toString() { return column.describe() + " StringStartsWith: " + value; }
+
+  @Override
+  public String describe() { return this.toString(); }
+
+  @Override
+  public NamedReference[] references() {
+    NamedReference[] arr = new NamedReference[1];
+    arr[0] = column;
+    return arr;
+  }
+}
\ No newline at end of file
diff --git a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/FiltersV2Suite.scala b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/FiltersV2Suite.scala
new file mode 100644
index 0000000000000..604287e3dc584
--- /dev/null
+++ b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/FiltersV2Suite.scala
@@ -0,0 +1,124 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.spark.sql.execution.datasources.v2
+
+import org.apache.spark.SparkFunSuite
+import org.apache.spark.sql.connector.expressions.{FieldReference, LiteralValue}
+import org.apache.spark.sql.connector.expressions.filter._
+import org.apache.spark.sql.execution.datasources.v2.FiltersV2Suite.ref
+import org.apache.spark.sql.types.IntegerType
+
+class FiltersV2Suite extends SparkFunSuite {
+
+  test("References with nested columns") {
+    assert(new EqualTo(ref("a", "B"), LiteralValue(1, IntegerType))
+      .references.map(_.describe()).toSeq == Seq("a.B"))
+    assert(new EqualTo(ref("a", "b.c"), LiteralValue(1, IntegerType))
+      .references.map(_.describe()).toSeq == Seq("a.`b.c`"))
+    assert(new EqualTo(ref("`a`.b", "c"), LiteralValue(1, IntegerType))
+      .references.map(_.describe()).toSeq == Seq("```a``.b`.c"))
+  }
+
+  test("EqualTo references") {
+    assert(new EqualTo(ref("a"), LiteralValue(1, IntegerType))
+      .references.map(_.describe()).toSeq == Seq("a"))
+    assert(new EqualTo(ref("a"), new EqualTo(ref("b"), LiteralValue(1, IntegerType)))
+      .references.map(_.describe()).toSeq == Seq("a", "b"))
+  }
+
+  test("EqualNullSafe references") {
+    assert(new EqualNullSafe(ref("a"), LiteralValue(1, IntegerType))
+      .references.map(_.describe()).toSeq == Seq("a"))
+    assert(new EqualNullSafe(ref("a"), new EqualTo(ref("b"), LiteralValue(2, IntegerType)))
+      .references.map(_.describe()).toSeq == Seq("a", "b"))
+  }
+
+  test("GreaterThan references") {
+    assert(new GreaterThan(ref("a"), LiteralValue(1, IntegerType))
+      .references.map(_.describe()).toSeq == Seq("a"))
+    assert(new GreaterThan(ref("a"), new EqualTo(ref("b"), LiteralValue(2, IntegerType)))
+      .references.map(_.describe()).toSeq == Seq("a", "b"))
+  }
+
+  test("GreaterThanOrEqual references") {
+    assert(new GreaterThanOrEqual(ref("a"), LiteralValue(1, IntegerType))
+      .references.map(_.describe()).toSeq == Seq("a"))
+    assert(new GreaterThanOrEqual(ref("a"), new EqualTo(ref("b"), LiteralValue(1, IntegerType)))
+      .references.map(_.describe()).toSeq == Seq("a", "b"))
+  }
+
+  test("LessThan references") {
+    assert(new LessThan(ref("a"), LiteralValue(1, IntegerType))
+      .references.map(_.describe()).toSeq == Seq("a"))
+    assert(new LessThan(ref("a"), new EqualTo(ref("b"), LiteralValue(2, IntegerType)))
+      .references.map(_.describe()).toSeq == Seq("a", "b"))
+  }
+
+  test("LessThanOrEqual references") {
+    assert(new LessThanOrEqual(ref("a"), LiteralValue(1, IntegerType))
+      .references.map(_.describe()).toSeq == Seq("a"))
+    assert(new LessThanOrEqual(ref("a"), new EqualTo(ref("b"), LiteralValue(2, IntegerType)))
+      .references.map(_.describe()).toSeq == Seq("a", "b"))
+  }
+
+  test("In references") {
+    assert(new In(ref("a"), Array(LiteralValue(1, IntegerType)))
+      .references.map(_.describe()).toSeq == Seq("a"))
+    assert(new In(ref("a"),
+      Array(LiteralValue(1, IntegerType), new EqualTo(ref("b"), LiteralValue(2, IntegerType))))
+      .references.map(_.describe()).toSeq == Seq("a", "b"))
+  }
+
+  test("IsNull references") {
+    assert(new IsNull(ref("a")).references.map(_.describe()).toSeq == Seq("a"))
+  }
+
+  test("IsNotNull references") {
+    assert(new IsNotNull(ref("a")).references.map(_.describe()).toSeq == Seq("a"))
+  }
+
+  test("And references") {
+    assert(new And(new EqualTo(ref("a"), LiteralValue(1, IntegerType)),
+      new EqualTo(ref("b"), LiteralValue(1, IntegerType)))
+      .references.map(_.describe()).toSeq == Seq("a", "b"))
+  }
+
+  test("Or references") {
+    assert(new Or(new EqualTo(ref("a"), LiteralValue(1, IntegerType)),
+      new EqualTo(ref("b"), LiteralValue(1, IntegerType)))
+      .references.map(_.describe()).toSeq == Seq("a", "b"))
+  }
+
+  test("StringStartsWith references") {
+    assert(new StringStartsWith(ref("a"), "str").references.map(_.describe()).toSeq == Seq("a"))
+  }
+
+  test("StringEndsWith references") {
+    assert(new StringEndsWith(ref("a"), "str").references.map(_.describe()).toSeq == Seq("a"))
+  }
+
+  test("StringContains references") {
+    assert(new StringContains(ref("a"), "str").references.map(_.describe()).toSeq == Seq("a"))
+  }
+}
+
+object FiltersV2Suite {
+  private[sql] def ref(parts: String*): FieldReference = {
+    new FieldReference(parts)
+  }
+}

From a7983da7c48ba55b0af33be7d7ce8981b67b2452 Mon Sep 17 00:00:00 2001
From: Huaxin Gao <huaxin_gao@apple.com>
Date: Sun, 22 Aug 2021 09:30:52 -0700
Subject: [PATCH 02/24] fix style

---
 .../expressions/filter/AlwaysFalse.java          |  4 ++--
 .../connector/expressions/filter/AlwaysTrue.java |  4 ++--
 .../sql/connector/expressions/filter/And.java    | 16 ++++++++--------
 .../expressions/filter/EqualNullSafe.java        |  8 +++++---
 .../connector/expressions/filter/EqualTo.java    | 14 ++++++--------
 .../filter/{FilterV2.java => Filter.java}        |  8 ++++----
 .../expressions/filter/GreaterThan.java          |  8 +++++---
 .../expressions/filter/GreaterThanOrEqual.java   |  8 +++++---
 .../sql/connector/expressions/filter/In.java     |  6 +++---
 .../connector/expressions/filter/IsNotNull.java  |  4 ++--
 .../sql/connector/expressions/filter/IsNull.java |  4 ++--
 .../connector/expressions/filter/LessThan.java   |  8 +++++---
 .../expressions/filter/LessThanOrEqual.java      |  8 +++++---
 .../sql/connector/expressions/filter/Not.java    | 14 ++++++--------
 .../sql/connector/expressions/filter/Or.java     | 14 +++++++-------
 .../expressions/filter/StringContains.java       |  8 +++++---
 .../expressions/filter/StringEndsWith.java       |  8 +++++---
 .../expressions/filter/StringStartsWith.java     | 13 +++++--------
 ...FiltersV2Suite.scala => V2FiltersSuite.scala} |  7 +++++--
 19 files changed, 87 insertions(+), 77 deletions(-)
 rename sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/{FilterV2.java => Filter.java} (90%)
 rename sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/{FiltersV2Suite.scala => V2FiltersSuite.scala} (96%)

diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java
index c38ba446dac6d..37df57bc5380d 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java
@@ -26,7 +26,7 @@
  * @since 3.3.0
  */
 @Evolving
-public final class AlwaysFalse extends FilterV2 {
+public final class AlwaysFalse extends Filter {
 
   @Override
   public String toString() { return "AlwaysFalse"; }
@@ -36,4 +36,4 @@ public final class AlwaysFalse extends FilterV2 {
 
   @Override
   public NamedReference[] references() { return new NamedReference[0]; }
-}
\ No newline at end of file
+}
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java
index 66554c97a3134..1897bcfc81cae 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java
@@ -26,7 +26,7 @@
  * @since 3.3.0
  */
 @Evolving
-public final class AlwaysTrue extends FilterV2 {
+public final class AlwaysTrue extends Filter {
 
   @Override
   public String toString() { return "AlwaysTrue"; }
@@ -36,4 +36,4 @@ public final class AlwaysTrue extends FilterV2 {
 
   @Override
   public NamedReference[] references() { return new NamedReference[0]; }
-}
\ No newline at end of file
+}
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
index a710ab2c3da78..4b9b8f3309821 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
@@ -21,22 +21,22 @@
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
- * A filter that evaluates to `true` iff both `left` or `right` evaluate to `true`.
+ * A filter that evaluates to `true` iff both `left` and `right` evaluate to `true`.
  *
  * @since 3.3.0
  */
 @Evolving
-public final class And extends FilterV2 {
-  private final FilterV2 left;
-  private final FilterV2 right;
+public final class And extends Filter {
+  private final Filter left;
+  private final Filter right;
 
-  public And(FilterV2 left, FilterV2 right) {
+  public And(Filter left, Filter right) {
     this.left = left;
     this.right = right;
   }
 
-  public FilterV2 left() { return left; }
-  public FilterV2 right() { return right; }
+  public Filter left() { return left; }
+  public Filter right() { return right; }
 
   @Override
   public String toString() { return left.describe() + " and " + right.describe(); }
@@ -53,4 +53,4 @@ public NamedReference[] references() {
     System.arraycopy(refRight, 0, arr, refLeft.length, refRight.length);
     return arr;
   }
-}
\ No newline at end of file
+}
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
index ce145e9ec801e..8ebc1a408a9ce 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
@@ -30,7 +30,7 @@
  * @since 3.3.0
  */
 @Evolving
-public final class EqualNullSafe extends FilterV2 {
+public final class EqualNullSafe extends Filter {
   private final FieldReference column;
   private final Expression value;
 
@@ -43,7 +43,9 @@ public EqualNullSafe(FieldReference column, Expression value) {
   public Expression value() { return value; }
 
   @Override
-  public String toString() { return column.describe() + " EqualNullSafe: " + value.describe(); }
+  public String toString() {
+    return column.describe() + " EqualNullSafe: (" + value.describe() + ")";
+  }
 
   @Override
   public String describe() { return this.toString(); }
@@ -56,4 +58,4 @@ public NamedReference[] references() {
     System.arraycopy(refs, 0, arr, 1, refs.length);
     return arr;
   }
-}
\ No newline at end of file
+}
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
index c7c1c0deb4a46..cf9ffdaf1dd7d 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
@@ -17,14 +17,10 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.Set;
-
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.Expression;
-import org.apache.spark.sql.connector.expressions.NamedReference;
 import org.apache.spark.sql.connector.expressions.FieldReference;
+import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * A filter that evaluates to `true` iff the field evaluates to a value
@@ -33,7 +29,7 @@
  * @since 3.3.0
  */
 @Evolving
-public final class EqualTo extends FilterV2 {
+public final class EqualTo extends Filter {
   private final FieldReference column;
   private final Expression value;
 
@@ -46,7 +42,9 @@ public EqualTo(FieldReference column, Expression value) {
   public Expression value() { return value; }
 
   @Override
-  public String toString() { return column.describe() + " EqualTo: " + value.describe(); }
+  public String toString() {
+    return column.describe() + " EqualTo: (" + value.describe() + ")";
+  }
 
   @Override
   public String describe() { return this.toString(); }
@@ -59,4 +57,4 @@ public NamedReference[] references() {
     System.arraycopy(refs, 0, arr, 1, refs.length);
     return arr;
   }
-}
\ No newline at end of file
+}
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/FilterV2.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Filter.java
similarity index 90%
rename from sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/FilterV2.java
rename to sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Filter.java
index 6bfbbd17e833a..98943916e8dec 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/FilterV2.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Filter.java
@@ -27,17 +27,17 @@
  * @since 3.3.0
  */
 @Evolving
-public abstract class FilterV2 implements Expression {
+public abstract class Filter implements Expression {
   /**
    * Returns list of columns that are referenced by this filter.
    */
   public abstract NamedReference[] references();
 
   protected NamedReference[] findReferences(Object filter) {
-    if (filter instanceof FilterV2) {
-      return ((FilterV2) filter).references();
+    if (filter instanceof Filter) {
+      return ((Filter) filter).references();
     } else {
       return new NamedReference[0];
     }
   }
-}
\ No newline at end of file
+}
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
index 1a1fb719e0073..d926591723860 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
@@ -29,7 +29,7 @@
  * @since 3.3.0
  */
 @Evolving
-public final class GreaterThan extends FilterV2 {
+public final class GreaterThan extends Filter {
   private final FieldReference column;
   private final Expression value;
 
@@ -42,7 +42,9 @@ public GreaterThan(FieldReference column, Expression value) {
   public Expression value() { return value; }
 
   @Override
-  public String toString() { return column.describe() + " GreaterThan: " + value.describe(); }
+  public String toString() {
+    return column.describe() + " GreaterThan: (" + value.describe() + ")";
+  }
 
   @Override
   public String describe() { return this.toString(); }
@@ -55,4 +57,4 @@ public NamedReference[] references() {
     System.arraycopy(refs, 0, arr, 1, refs.length);
     return arr;
   }
-}
\ No newline at end of file
+}
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
index aea071bd59581..9776d0498fe45 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
@@ -29,7 +29,7 @@
  * @since 3.3.0
  */
 @Evolving
-public final class GreaterThanOrEqual extends FilterV2 {
+public final class GreaterThanOrEqual extends Filter {
   private final FieldReference column;
   private final Expression value;
 
@@ -42,7 +42,9 @@ public GreaterThanOrEqual(FieldReference column, Expression value) {
   public Expression value() { return value; }
 
   @Override
-  public String toString() { return column.describe() + " GreaterThanOrEqual: " + value.describe(); }
+  public String toString() {
+    return column.describe() + " GreaterThanOrEqual: (" + value.describe() + ")";
+  }
 
   @Override
   public String describe() { return this.toString(); }
@@ -54,4 +56,4 @@ public NamedReference[] references() {
     System.arraycopy(refs, 0, arr, 1, refs.length);
     return arr;
   }
-}
\ No newline at end of file
+}
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
index c5552abcc56a7..92ea2b10583ec 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
@@ -31,7 +31,7 @@
  * @since 3.3.0
  */
 @Evolving
-public final class In extends FilterV2 {
+public final class In extends Filter {
   private final FieldReference column;
   private final Expression[] values;
 
@@ -58,7 +58,7 @@ public String toString() {
     for (Expression v : values) {
       str.append(v.describe()).append(", ");
     }
-    return column.describe() + " in: " + str;
+    return column.describe() + " in: (" + str + ")";
   }
 
   @Override
@@ -77,4 +77,4 @@ public NamedReference[] references() {
 
     return stream.toArray(NamedReference[]::new);
   }
-}
\ No newline at end of file
+}
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
index 3c71eb603d207..8a3bd801a6dbb 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
@@ -27,7 +27,7 @@
  * @since 3.3.0
  */
 @Evolving
-public final class IsNotNull extends FilterV2 {
+public final class IsNotNull extends Filter {
   private final FieldReference column;
 
   public IsNotNull(FieldReference column) {
@@ -48,4 +48,4 @@ public NamedReference[] references() {
     arr[0] = column;
     return arr;
   }
-}
\ No newline at end of file
+}
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
index 51b441cfa19d5..d72c362c62169 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
@@ -27,7 +27,7 @@
  * @since 3.3.0
  */
 @Evolving
-public final class IsNull extends FilterV2 {
+public final class IsNull extends Filter {
   private final FieldReference column;
 
   public IsNull(FieldReference column) {
@@ -48,4 +48,4 @@ public NamedReference[] references() {
     arr[0] = column;
     return arr;
   }
-}
\ No newline at end of file
+}
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
index 96d1a25624713..cc30ec0bd12ae 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
@@ -29,7 +29,7 @@
  * @since 3.3.0
  */
 @Evolving
-public final class LessThan extends FilterV2 {
+public final class LessThan extends Filter {
   private final FieldReference column;
   private final Expression value;
 
@@ -42,7 +42,9 @@ public LessThan(FieldReference column, Expression value) {
   public Expression value() { return value; }
 
   @Override
-  public String toString() { return column.describe() + " LessThan: " + value.describe(); }
+  public String toString() {
+    return column.describe() + " LessThan: (" + value.describe() + ")";
+  }
 
   @Override
   public String describe() { return this.toString(); }
@@ -55,4 +57,4 @@ public NamedReference[] references() {
     System.arraycopy(refs, 0, arr, 1, refs.length);
     return arr;
   }
-}
\ No newline at end of file
+}
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
index c581cd650b274..70825c917ba51 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
@@ -29,7 +29,7 @@
  * @since 3.3.0
  */
 @Evolving
-public final class LessThanOrEqual extends FilterV2 {
+public final class LessThanOrEqual extends Filter {
   private final FieldReference column;
   private final Expression value;
 
@@ -42,7 +42,9 @@ public LessThanOrEqual(FieldReference column, Expression value) {
   public Expression value() { return value; }
 
   @Override
-  public String toString() { return column.describe() + " LessThanOrEqual: " + value.describe(); }
+  public String toString() {
+    return column.describe() + " LessThanOrEqual: (" + value.describe() + ")";
+  }
 
   @Override
   public String describe() { return this.toString(); }
@@ -55,4 +57,4 @@ public NamedReference[] references() {
     System.arraycopy(refs, 0, arr, 1, refs.length);
     return arr;
   }
-}
\ No newline at end of file
+}
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java
index 0d3e52df9b7d5..e5da7c95ba7d2 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java
@@ -26,12 +26,12 @@
  * @since 3.3.0
  */
 @Evolving
-public final class Not extends FilterV2 {
-  private final FilterV2 child;
+public final class Not extends Filter {
+  private final Filter child;
 
-  public Not(FilterV2 child) { this.child = child; }
+  public Not(Filter child) { this.child = child; }
 
-  public FilterV2 child() { return child; }
+  public Filter child() { return child; }
 
   @Override
   public String toString() { return child.describe() + " Not"; }
@@ -40,7 +40,5 @@ public final class Not extends FilterV2 {
   public String describe() { return this.toString(); }
 
   @Override
-  public NamedReference[] references() {
-    return child.references();
-  }
-}
\ No newline at end of file
+  public NamedReference[] references() { return child.references(); }
+}
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
index 4ba4dda221058..c89f53f451286 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
@@ -26,17 +26,17 @@
  * @since 3.3.0
  */
 @Evolving
-public final class Or extends FilterV2 {
-  private final FilterV2 left;
-  private final FilterV2 right;
+public final class Or extends Filter {
+  private final Filter left;
+  private final Filter right;
 
-  public Or(FilterV2 left, FilterV2 right) {
+  public Or(Filter left, Filter right) {
     this.left = left;
     this.right = right;
   }
 
-  public FilterV2 left() { return left; }
-  public FilterV2 right() { return right; }
+  public Filter left() { return left; }
+  public Filter right() { return right; }
 
   @Override
   public String toString() { return left.describe() + " or " + right.describe(); }
@@ -53,4 +53,4 @@ public NamedReference[] references() {
     System.arraycopy(refRight, 0, arr, refLeft.length, refRight.length);
     return arr;
   }
-}
\ No newline at end of file
+}
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
index 05b816f049ac3..067e6a1b68545 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
@@ -28,7 +28,7 @@
  * @since 3.3.0
  */
 @Evolving
-public final class StringContains extends FilterV2 {
+public final class StringContains extends Filter {
   private final FieldReference column;
   private final String value;
 
@@ -41,7 +41,9 @@ public StringContains(FieldReference column, String value) {
   public String value() { return value; }
 
   @Override
-  public String toString() { return column.describe() + " StringContains: " + value; }
+  public String toString() {
+    return column.describe() + " StringContains: (" + value + ")";
+  }
 
   @Override
   public String describe() { return this.toString(); }
@@ -52,4 +54,4 @@ public NamedReference[] references() {
     arr[0] = column;
     return arr;
   }
-}
\ No newline at end of file
+}
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
index 2baa733366e95..c5a298eaae0a1 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
@@ -28,7 +28,7 @@
  * @since 3.3.0
  */
 @Evolving
-public final class StringEndsWith extends FilterV2 {
+public final class StringEndsWith extends Filter {
   private final FieldReference column;
   private final String value;
 
@@ -41,7 +41,9 @@ public StringEndsWith(FieldReference column, String value) {
   public String value() { return value; }
 
   @Override
-  public String toString() { return column.describe() + " StringEndsWith: " + value; }
+  public String toString() {
+    return column.describe() + " StringEndsWith: (" + value + ")";
+  }
 
   @Override
   public String describe() { return this.toString(); }
@@ -52,4 +54,4 @@ public NamedReference[] references() {
     arr[0] = column;
     return arr;
   }
-}
\ No newline at end of file
+}
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
index 23af9b63ba20c..03a0f93036222 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
@@ -18,14 +18,9 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.Expression;
 import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.Set;
-
 /**
  * A filter that evaluates to `true` iff the field evaluates to
  * a string that starts with `value`.
@@ -33,7 +28,7 @@
  * @since 3.3.0
  */
 @Evolving
-public final class StringStartsWith extends FilterV2 {
+public final class StringStartsWith extends Filter {
   private final FieldReference column;
   private final String value;
 
@@ -46,7 +41,9 @@ public StringStartsWith(FieldReference column, String value) {
   public String value() { return value; }
 
   @Override
-  public String toString() { return column.describe() + " StringStartsWith: " + value; }
+  public String toString() {
+    return column.describe() + " StringStartsWith: (" + value + ")";
+  }
 
   @Override
   public String describe() { return this.toString(); }
@@ -57,4 +54,4 @@ public NamedReference[] references() {
     arr[0] = column;
     return arr;
   }
-}
\ No newline at end of file
+}
diff --git a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/FiltersV2Suite.scala b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
similarity index 96%
rename from sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/FiltersV2Suite.scala
rename to sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
index 604287e3dc584..da7166aab5453 100644
--- a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/FiltersV2Suite.scala
+++ b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
@@ -80,8 +80,9 @@ class FiltersV2Suite extends SparkFunSuite {
     assert(new In(ref("a"), Array(LiteralValue(1, IntegerType)))
       .references.map(_.describe()).toSeq == Seq("a"))
     assert(new In(ref("a"),
-      Array(LiteralValue(1, IntegerType), new EqualTo(ref("b"), LiteralValue(2, IntegerType))))
-      .references.map(_.describe()).toSeq == Seq("a", "b"))
+      Array(LiteralValue(1, IntegerType), new EqualTo(ref("b"), LiteralValue(2, IntegerType)),
+        new EqualTo(ref("c"), new EqualTo(ref("d"), LiteralValue(3, IntegerType)))))
+      .references.map(_.describe()).toSeq == Seq("a", "b", "c", "d"))
   }
 
   test("IsNull references") {
@@ -122,3 +123,5 @@ object FiltersV2Suite {
     new FieldReference(parts)
   }
 }
+
+

From 71e9c17a4558371332f350974f25c9a77b5f14d7 Mon Sep 17 00:00:00 2001
From: Huaxin Gao <huaxin_gao@apple.com>
Date: Sun, 22 Aug 2021 09:33:37 -0700
Subject: [PATCH 03/24] remove extra blank line

---
 .../spark/sql/execution/datasources/v2/V2FiltersSuite.scala     | 2 --
 1 file changed, 2 deletions(-)

diff --git a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
index da7166aab5453..58abb7b49e78f 100644
--- a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
+++ b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
@@ -123,5 +123,3 @@ object FiltersV2Suite {
     new FieldReference(parts)
   }
 }
-
-

From 14e3c69e546d372b6008e837621c136c79044d92 Mon Sep 17 00:00:00 2001
From: Huaxin Gao <huaxin_gao@apple.com>
Date: Tue, 24 Aug 2021 10:44:42 -0700
Subject: [PATCH 04/24] address comments

---
 .../expressions/filter/EqualNullSafe.java     | 12 +++++------
 .../connector/expressions/filter/EqualTo.java | 12 +++++------
 .../expressions/filter/GreaterThan.java       | 12 +++++------
 .../filter/GreaterThanOrEqual.java            | 12 +++++------
 .../sql/connector/expressions/filter/In.java  | 20 +++++++++++--------
 .../expressions/filter/LessThan.java          | 12 +++++------
 .../expressions/filter/LessThanOrEqual.java   | 12 +++++------
 .../expressions/filter/StringContains.java    |  4 +---
 .../expressions/filter/StringEndsWith.java    |  4 +---
 .../expressions/filter/StringStartsWith.java  |  4 +---
 .../datasources/v2/V2FiltersSuite.scala       | 16 ---------------
 11 files changed, 45 insertions(+), 75 deletions(-)

diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
index 8ebc1a408a9ce..b2008dc21bb18 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
@@ -18,8 +18,8 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.Expression;
 import org.apache.spark.sql.connector.expressions.FieldReference;
+import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
@@ -32,20 +32,18 @@
 @Evolving
 public final class EqualNullSafe extends Filter {
   private final FieldReference column;
-  private final Expression value;
+  private final Literal value;
 
-  public EqualNullSafe(FieldReference column, Expression value) {
+  public EqualNullSafe(FieldReference column, Literal value) {
     this.column = column;
     this.value = value;
   }
 
   public FieldReference column() { return column; }
-  public Expression value() { return value; }
+  public Literal value() { return value; }
 
   @Override
-  public String toString() {
-    return column.describe() + " EqualNullSafe: (" + value.describe() + ")";
-  }
+  public String toString() { return column.describe() + " <=> " + value.describe(); }
 
   @Override
   public String describe() { return this.toString(); }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
index cf9ffdaf1dd7d..7237f8a958b5b 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
@@ -18,8 +18,8 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.Expression;
 import org.apache.spark.sql.connector.expressions.FieldReference;
+import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
@@ -31,20 +31,18 @@
 @Evolving
 public final class EqualTo extends Filter {
   private final FieldReference column;
-  private final Expression value;
+  private final Literal value;
 
-  public EqualTo(FieldReference column, Expression value) {
+  public EqualTo(FieldReference column, Literal value) {
     this.column = column;
     this.value = value;
   }
 
   public FieldReference column() { return column; }
-  public Expression value() { return value; }
+  public Literal value() { return value; }
 
   @Override
-  public String toString() {
-    return column.describe() + " EqualTo: (" + value.describe() + ")";
-  }
+  public String toString() { return column.describe() + " = " + value.describe(); }
 
   @Override
   public String describe() { return this.toString(); }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
index d926591723860..719bd1087011c 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
@@ -18,8 +18,8 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.Expression;
 import org.apache.spark.sql.connector.expressions.FieldReference;
+import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
@@ -31,20 +31,18 @@
 @Evolving
 public final class GreaterThan extends Filter {
   private final FieldReference column;
-  private final Expression value;
+  private final Literal value;
 
-  public GreaterThan(FieldReference column, Expression value) {
+  public GreaterThan(FieldReference column, Literal value) {
     this.column = column;
     this.value = value;
   }
 
   public FieldReference column() { return column; }
-  public Expression value() { return value; }
+  public Literal value() { return value; }
 
   @Override
-  public String toString() {
-    return column.describe() + " GreaterThan: (" + value.describe() + ")";
-  }
+  public String toString() { return column.describe() + " > " + value.describe(); }
 
   @Override
   public String describe() { return this.toString(); }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
index 9776d0498fe45..c566637298a13 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
@@ -18,8 +18,8 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.Expression;
 import org.apache.spark.sql.connector.expressions.FieldReference;
+import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
@@ -31,20 +31,18 @@
 @Evolving
 public final class GreaterThanOrEqual extends Filter {
   private final FieldReference column;
-  private final Expression value;
+  private final Literal value;
 
-  public GreaterThanOrEqual(FieldReference column, Expression value) {
+  public GreaterThanOrEqual(FieldReference column, Literal value) {
     this.column = column;
     this.value = value;
   }
 
   public FieldReference column() { return column; }
-  public Expression value() { return value; }
+  public Literal value() { return value; }
 
   @Override
-  public String toString() {
-    return column.describe() + " GreaterThanOrEqual: (" + value.describe() + ")";
-  }
+  public String toString() { return column.describe() + " >= " + value.describe(); }
 
   @Override
   public String describe() { return this.toString(); }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
index 92ea2b10583ec..1cf39913720f4 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
@@ -18,8 +18,8 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.Expression;
 import org.apache.spark.sql.connector.expressions.FieldReference;
+import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 import java.util.Arrays;
@@ -33,19 +33,19 @@
 @Evolving
 public final class In extends Filter {
   private final FieldReference column;
-  private final Expression[] values;
+  private final Literal[] values;
 
-  public In(FieldReference column, Expression[] values) {
+  public In(FieldReference column, Literal[] values) {
     this.column = column;
     this.values = values;
   }
 
   public FieldReference column() { return column; }
-  public Expression[] values() { return values; }
+  public Literal[] values() { return values; }
 
   public int hashCode() {
     int h = column.hashCode();
-    for (Expression v : values) {
+    for (Literal v : values) {
       h *= 41;
       h += v.hashCode();
     }
@@ -55,10 +55,14 @@ public int hashCode() {
   @Override
   public String toString() {
     StringBuilder str = new StringBuilder();
-    for (Expression v : values) {
+    for (Literal v : values) {
       str.append(v.describe()).append(", ");
     }
-    return column.describe() + " in: (" + str + ")";
+    String res = "";
+    if (!str.toString().isEmpty()) {
+      res = str.substring(0, str.length() - 2);
+    }
+    return column.describe() + " in: (" + res + ")";
   }
 
   @Override
@@ -70,7 +74,7 @@ public NamedReference[] references() {
     NamedReference[] arr = new NamedReference[1];
     arr[0] = column;
     stream = Stream.concat(stream, Arrays.stream(arr));
-    for (Expression value : values) {
+    for (Literal value : values) {
       NamedReference[] ref = findReferences(value);
       stream = Stream.concat(stream, Arrays.stream(ref));
     }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
index cc30ec0bd12ae..f28f6211911ca 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
@@ -18,8 +18,8 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.Expression;
 import org.apache.spark.sql.connector.expressions.FieldReference;
+import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
@@ -31,20 +31,18 @@
 @Evolving
 public final class LessThan extends Filter {
   private final FieldReference column;
-  private final Expression value;
+  private final Literal value;
 
-  public LessThan(FieldReference column, Expression value) {
+  public LessThan(FieldReference column, Literal value) {
     this.column = column;
     this.value = value;
   }
 
   public FieldReference column() { return column; }
-  public Expression value() { return value; }
+  public Literal value() { return value; }
 
   @Override
-  public String toString() {
-    return column.describe() + " LessThan: (" + value.describe() + ")";
-  }
+  public String toString() { return column.describe() + " < " + value.describe(); }
 
   @Override
   public String describe() { return this.toString(); }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
index 70825c917ba51..6cdaa55199146 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
@@ -18,8 +18,8 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.Expression;
 import org.apache.spark.sql.connector.expressions.FieldReference;
+import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
@@ -31,20 +31,18 @@
 @Evolving
 public final class LessThanOrEqual extends Filter {
   private final FieldReference column;
-  private final Expression value;
+  private final Literal value;
 
-  public LessThanOrEqual(FieldReference column, Expression value) {
+  public LessThanOrEqual(FieldReference column, Literal value) {
     this.column = column;
     this.value = value;
   }
 
   public FieldReference column() { return column; }
-  public Expression value() { return value; }
+  public Literal value() { return value; }
 
   @Override
-  public String toString() {
-    return column.describe() + " LessThanOrEqual: (" + value.describe() + ")";
-  }
+  public String toString() { return column.describe() + " <= " + value.describe(); }
 
   @Override
   public String describe() { return this.toString(); }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
index 067e6a1b68545..86cd12046961d 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
@@ -41,9 +41,7 @@ public StringContains(FieldReference column, String value) {
   public String value() { return value; }
 
   @Override
-  public String toString() {
-    return column.describe() + " StringContains: (" + value + ")";
-  }
+  public String toString() { return column.describe() + " StringContains: " + value; }
 
   @Override
   public String describe() { return this.toString(); }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
index c5a298eaae0a1..4692b4779c379 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
@@ -41,9 +41,7 @@ public StringEndsWith(FieldReference column, String value) {
   public String value() { return value; }
 
   @Override
-  public String toString() {
-    return column.describe() + " StringEndsWith: (" + value + ")";
-  }
+  public String toString() { return column.describe() + " StringEndsWith: " + value; }
 
   @Override
   public String describe() { return this.toString(); }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
index 03a0f93036222..ac4dae3210e0d 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
@@ -41,9 +41,7 @@ public StringStartsWith(FieldReference column, String value) {
   public String value() { return value; }
 
   @Override
-  public String toString() {
-    return column.describe() + " StringStartsWith: (" + value + ")";
-  }
+  public String toString() { return column.describe() + " StringStartsWith: " + value; }
 
   @Override
   public String describe() { return this.toString(); }
diff --git a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
index 58abb7b49e78f..63a7581ae95a1 100644
--- a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
+++ b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
@@ -37,52 +37,36 @@ class FiltersV2Suite extends SparkFunSuite {
   test("EqualTo references") {
     assert(new EqualTo(ref("a"), LiteralValue(1, IntegerType))
       .references.map(_.describe()).toSeq == Seq("a"))
-    assert(new EqualTo(ref("a"), new EqualTo(ref("b"), LiteralValue(1, IntegerType)))
-      .references.map(_.describe()).toSeq == Seq("a", "b"))
   }
 
   test("EqualNullSafe references") {
     assert(new EqualNullSafe(ref("a"), LiteralValue(1, IntegerType))
       .references.map(_.describe()).toSeq == Seq("a"))
-    assert(new EqualNullSafe(ref("a"), new EqualTo(ref("b"), LiteralValue(2, IntegerType)))
-      .references.map(_.describe()).toSeq == Seq("a", "b"))
   }
 
   test("GreaterThan references") {
     assert(new GreaterThan(ref("a"), LiteralValue(1, IntegerType))
       .references.map(_.describe()).toSeq == Seq("a"))
-    assert(new GreaterThan(ref("a"), new EqualTo(ref("b"), LiteralValue(2, IntegerType)))
-      .references.map(_.describe()).toSeq == Seq("a", "b"))
   }
 
   test("GreaterThanOrEqual references") {
     assert(new GreaterThanOrEqual(ref("a"), LiteralValue(1, IntegerType))
       .references.map(_.describe()).toSeq == Seq("a"))
-    assert(new GreaterThanOrEqual(ref("a"), new EqualTo(ref("b"), LiteralValue(1, IntegerType)))
-      .references.map(_.describe()).toSeq == Seq("a", "b"))
   }
 
   test("LessThan references") {
     assert(new LessThan(ref("a"), LiteralValue(1, IntegerType))
       .references.map(_.describe()).toSeq == Seq("a"))
-    assert(new LessThan(ref("a"), new EqualTo(ref("b"), LiteralValue(2, IntegerType)))
-      .references.map(_.describe()).toSeq == Seq("a", "b"))
   }
 
   test("LessThanOrEqual references") {
     assert(new LessThanOrEqual(ref("a"), LiteralValue(1, IntegerType))
       .references.map(_.describe()).toSeq == Seq("a"))
-    assert(new LessThanOrEqual(ref("a"), new EqualTo(ref("b"), LiteralValue(2, IntegerType)))
-      .references.map(_.describe()).toSeq == Seq("a", "b"))
   }
 
   test("In references") {
     assert(new In(ref("a"), Array(LiteralValue(1, IntegerType)))
       .references.map(_.describe()).toSeq == Seq("a"))
-    assert(new In(ref("a"),
-      Array(LiteralValue(1, IntegerType), new EqualTo(ref("b"), LiteralValue(2, IntegerType)),
-        new EqualTo(ref("c"), new EqualTo(ref("d"), LiteralValue(3, IntegerType)))))
-      .references.map(_.describe()).toSeq == Seq("a", "b", "c", "d"))
   }
 
   test("IsNull references") {

From 5d084536be3273124581b514d2ede7369e503c4c Mon Sep 17 00:00:00 2001
From: Huaxin Gao <huaxin_gao@apple.com>
Date: Tue, 24 Aug 2021 17:54:10 -0700
Subject: [PATCH 05/24] address comments

---
 .../expressions/filter/AlwaysFalse.java       |  3 -
 .../expressions/filter/AlwaysTrue.java        |  3 -
 .../sql/connector/expressions/filter/And.java |  3 -
 .../expressions/filter/EqualNullSafe.java     | 15 +--
 .../connector/expressions/filter/EqualTo.java | 15 +--
 .../connector/expressions/filter/Filter.java  |  7 +-
 .../expressions/filter/GreaterThan.java       | 15 +--
 .../filter/GreaterThanOrEqual.java            | 15 +--
 .../sql/connector/expressions/filter/In.java  | 37 ++++----
 .../expressions/filter/IsNotNull.java         |  3 -
 .../connector/expressions/filter/IsNull.java  |  3 -
 .../expressions/filter/LessThan.java          | 15 +--
 .../expressions/filter/LessThanOrEqual.java   | 15 +--
 .../sql/connector/expressions/filter/Not.java |  5 +-
 .../sql/connector/expressions/filter/Or.java  |  3 -
 .../expressions/filter/StringContains.java    |  5 +-
 .../expressions/filter/StringEndsWith.java    |  5 +-
 .../expressions/filter/StringStartsWith.java  |  5 +-
 .../datasources/v2/V2FiltersSuite.scala       | 94 +++++++++++++------
 19 files changed, 123 insertions(+), 143 deletions(-)

diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java
index 37df57bc5380d..242617d2622dd 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java
@@ -31,9 +31,6 @@ public final class AlwaysFalse extends Filter {
   @Override
   public String toString() { return "AlwaysFalse"; }
 
-  @Override
-  public String describe() { return this.toString(); }
-
   @Override
   public NamedReference[] references() { return new NamedReference[0]; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java
index 1897bcfc81cae..7eb83b9146ceb 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java
@@ -31,9 +31,6 @@ public final class AlwaysTrue extends Filter {
   @Override
   public String toString() { return "AlwaysTrue"; }
 
-  @Override
-  public String describe() { return this.toString(); }
-
   @Override
   public NamedReference[] references() { return new NamedReference[0]; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
index 4b9b8f3309821..57db9bb86665d 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
@@ -41,9 +41,6 @@ public And(Filter left, Filter right) {
   @Override
   public String toString() { return left.describe() + " and " + right.describe(); }
 
-  @Override
-  public String describe() { return this.toString(); }
-
   @Override
   public NamedReference[] references() {
     NamedReference[] refLeft = left.references();
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
index b2008dc21bb18..7ebede1be7022 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
@@ -30,30 +30,25 @@
  * @since 3.3.0
  */
 @Evolving
-public final class EqualNullSafe extends Filter {
+public final class EqualNullSafe<T> extends Filter {
   private final FieldReference column;
-  private final Literal value;
+  private final Literal<T> value;
 
-  public EqualNullSafe(FieldReference column, Literal value) {
+  public EqualNullSafe(FieldReference column, Literal<T> value) {
     this.column = column;
     this.value = value;
   }
 
   public FieldReference column() { return column; }
-  public Literal value() { return value; }
+  public Literal<T> value() { return value; }
 
   @Override
   public String toString() { return column.describe() + " <=> " + value.describe(); }
 
-  @Override
-  public String describe() { return this.toString(); }
-
   @Override
   public NamedReference[] references() {
-    NamedReference[] refs = findReferences(value);
-    NamedReference[] arr = new NamedReference[1 + refs.length];
+    NamedReference[] arr = new NamedReference[1];
     arr[0] = column;
-    System.arraycopy(refs, 0, arr, 1, refs.length);
     return arr;
   }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
index 7237f8a958b5b..1114c2f5a4466 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
@@ -29,30 +29,25 @@
  * @since 3.3.0
  */
 @Evolving
-public final class EqualTo extends Filter {
+public final class EqualTo<T> extends Filter {
   private final FieldReference column;
-  private final Literal value;
+  private final Literal<T> value;
 
-  public EqualTo(FieldReference column, Literal value) {
+  public EqualTo(FieldReference column, Literal<T> value) {
     this.column = column;
     this.value = value;
   }
 
   public FieldReference column() { return column; }
-  public Literal value() { return value; }
+  public Literal<T> value() { return value; }
 
   @Override
   public String toString() { return column.describe() + " = " + value.describe(); }
 
-  @Override
-  public String describe() { return this.toString(); }
-
   @Override
   public NamedReference[] references() {
-    NamedReference[] refs = findReferences(value);
-    NamedReference[] arr = new NamedReference[1 + refs.length];
+    NamedReference[] arr = new NamedReference[1];
     arr[0] = column;
-    System.arraycopy(refs, 0, arr, 1, refs.length);
     return arr;
   }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Filter.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Filter.java
index 98943916e8dec..192e7c5491307 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Filter.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Filter.java
@@ -28,6 +28,8 @@
  */
 @Evolving
 public abstract class Filter implements Expression {
+
+  private static final NamedReference[] EMPTY_REFERENCE = new NamedReference[0];
   /**
    * Returns list of columns that are referenced by this filter.
    */
@@ -37,7 +39,10 @@ protected NamedReference[] findReferences(Object filter) {
     if (filter instanceof Filter) {
       return ((Filter) filter).references();
     } else {
-      return new NamedReference[0];
+      return EMPTY_REFERENCE;
     }
   }
+
+  @Override
+  public String describe() { return this.toString(); }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
index 719bd1087011c..19c57313aea12 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
@@ -29,30 +29,25 @@
  * @since 3.3.0
  */
 @Evolving
-public final class GreaterThan extends Filter {
+public final class GreaterThan<T> extends Filter {
   private final FieldReference column;
-  private final Literal value;
+  private final Literal<T> value;
 
-  public GreaterThan(FieldReference column, Literal value) {
+  public GreaterThan(FieldReference column, Literal<T> value) {
     this.column = column;
     this.value = value;
   }
 
   public FieldReference column() { return column; }
-  public Literal value() { return value; }
+  public Literal<T> value() { return value; }
 
   @Override
   public String toString() { return column.describe() + " > " + value.describe(); }
 
-  @Override
-  public String describe() { return this.toString(); }
-
   @Override
   public NamedReference[] references() {
-    NamedReference[] refs = findReferences(value);
-    NamedReference[] arr = new NamedReference[1 + refs.length];
+    NamedReference[] arr = new NamedReference[1];
     arr[0] = column;
-    System.arraycopy(refs, 0, arr, 1, refs.length);
     return arr;
   }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
index c566637298a13..8a418c66f3b5b 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
@@ -29,29 +29,24 @@
  * @since 3.3.0
  */
 @Evolving
-public final class GreaterThanOrEqual extends Filter {
+public final class GreaterThanOrEqual<T> extends Filter {
   private final FieldReference column;
-  private final Literal value;
+  private final Literal<T> value;
 
-  public GreaterThanOrEqual(FieldReference column, Literal value) {
+  public GreaterThanOrEqual(FieldReference column, Literal<T> value) {
     this.column = column;
     this.value = value;
   }
 
   public FieldReference column() { return column; }
-  public Literal value() { return value; }
+  public Literal<T> value() { return value; }
 
   @Override
   public String toString() { return column.describe() + " >= " + value.describe(); }
 
-  @Override
-  public String describe() { return this.toString(); }
-
   public NamedReference[] references() {
-    NamedReference[] refs = findReferences(value);
-    NamedReference[] arr = new NamedReference[1 + refs.length];
+    NamedReference[] arr = new NamedReference[1];
     arr[0] = column;
-    System.arraycopy(refs, 0, arr, 1, refs.length);
     return arr;
   }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
index 1cf39913720f4..007636ddd2d9d 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
@@ -17,32 +17,32 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
+import java.util.Arrays;
+
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
-import java.util.Arrays;
-import java.util.stream.Stream;
-
 /**
  * A filter that evaluates to `true` iff the field evaluates to one of the values in the array.
  *
  * @since 3.3.0
  */
 @Evolving
-public final class In extends Filter {
+public final class In<T> extends Filter {
   private final FieldReference column;
-  private final Literal[] values;
+  private final Literal<T>[] values;
 
-  public In(FieldReference column, Literal[] values) {
+  public In(FieldReference column, Literal<T>[] values) {
     this.column = column;
     this.values = values;
   }
 
   public FieldReference column() { return column; }
-  public Literal[] values() { return values; }
+  public Literal<T>[] values() { return values; }
 
+  @Override
   public int hashCode() {
     int h = column.hashCode();
     for (Literal v : values) {
@@ -52,6 +52,15 @@ public int hashCode() {
     return h;
   }
 
+  @Override
+  public boolean equals(Object obj) {
+    if (obj instanceof In) {
+      return (((In) obj).column.equals(column) && Arrays.equals(((In) obj).values, values));
+    } else {
+      return false;
+    }
+  }
+
   @Override
   public String toString() {
     StringBuilder str = new StringBuilder();
@@ -62,23 +71,13 @@ public String toString() {
     if (!str.toString().isEmpty()) {
       res = str.substring(0, str.length() - 2);
     }
-    return column.describe() + " in: (" + res + ")";
+    return column.describe() + " in (" + res + ")";
   }
 
-  @Override
-  public String describe() { return this.toString(); }
-
   @Override
   public NamedReference[] references() {
-    Stream<NamedReference> stream = Stream.of();
     NamedReference[] arr = new NamedReference[1];
     arr[0] = column;
-    stream = Stream.concat(stream, Arrays.stream(arr));
-    for (Literal value : values) {
-      NamedReference[] ref = findReferences(value);
-      stream = Stream.concat(stream, Arrays.stream(ref));
-    }
-
-    return stream.toArray(NamedReference[]::new);
+    return arr;
   }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
index 8a3bd801a6dbb..5b28efb3dd7dd 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
@@ -39,9 +39,6 @@ public IsNotNull(FieldReference column) {
   @Override
   public String toString() { return column.describe() + " IsNotNull"; }
 
-  @Override
-  public String describe() { return this.toString(); }
-
   @Override
   public NamedReference[] references() {
     NamedReference[] arr = new NamedReference[1];
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
index d72c362c62169..55d42b3e8ce13 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
@@ -39,9 +39,6 @@ public IsNull(FieldReference column) {
   @Override
   public String toString() { return column.describe() + " IsNull"; }
 
-  @Override
-  public String describe() { return this.toString(); }
-
   @Override
   public NamedReference[] references() {
     NamedReference[] arr = new NamedReference[1];
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
index f28f6211911ca..a6475bfd0ff68 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
@@ -29,30 +29,25 @@
  * @since 3.3.0
  */
 @Evolving
-public final class LessThan extends Filter {
+public final class LessThan<T> extends Filter {
   private final FieldReference column;
-  private final Literal value;
+  private final Literal<T> value;
 
-  public LessThan(FieldReference column, Literal value) {
+  public LessThan(FieldReference column, Literal<T> value) {
     this.column = column;
     this.value = value;
   }
 
   public FieldReference column() { return column; }
-  public Literal value() { return value; }
+  public Literal<T> value() { return value; }
 
   @Override
   public String toString() { return column.describe() + " < " + value.describe(); }
 
-  @Override
-  public String describe() { return this.toString(); }
-
   @Override
   public NamedReference[] references() {
-    NamedReference[] refs = findReferences(value);
-    NamedReference[] arr = new NamedReference[1 + refs.length];
+    NamedReference[] arr = new NamedReference[1];
     arr[0] = column;
-    System.arraycopy(refs, 0, arr, 1, refs.length);
     return arr;
   }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
index 6cdaa55199146..420a6f149ac74 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
@@ -29,30 +29,25 @@
  * @since 3.3.0
  */
 @Evolving
-public final class LessThanOrEqual extends Filter {
+public final class LessThanOrEqual<T> extends Filter {
   private final FieldReference column;
-  private final Literal value;
+  private final Literal<T> value;
 
-  public LessThanOrEqual(FieldReference column, Literal value) {
+  public LessThanOrEqual(FieldReference column, Literal<T> value) {
     this.column = column;
     this.value = value;
   }
 
   public FieldReference column() { return column; }
-  public Literal value() { return value; }
+  public Literal<T> value() { return value; }
 
   @Override
   public String toString() { return column.describe() + " <= " + value.describe(); }
 
-  @Override
-  public String describe() { return this.toString(); }
-
   @Override
   public NamedReference[] references() {
-    NamedReference[] refs = findReferences(value);
-    NamedReference[] arr = new NamedReference[1 + refs.length];
+    NamedReference[] arr = new NamedReference[1];
     arr[0] = column;
-    System.arraycopy(refs, 0, arr, 1, refs.length);
     return arr;
   }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java
index e5da7c95ba7d2..199aa26e9b141 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java
@@ -34,10 +34,7 @@ public final class Not extends Filter {
   public Filter child() { return child; }
 
   @Override
-  public String toString() { return child.describe() + " Not"; }
-
-  @Override
-  public String describe() { return this.toString(); }
+  public String toString() { return "Not " + child.describe(); }
 
   @Override
   public NamedReference[] references() { return child.references(); }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
index c89f53f451286..c4c4fa6ddbb2f 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
@@ -41,9 +41,6 @@ public Or(Filter left, Filter right) {
   @Override
   public String toString() { return left.describe() + " or " + right.describe(); }
 
-  @Override
-  public String describe() { return this.toString(); }
-
   @Override
   public NamedReference[] references() {
     NamedReference[] refLeft = left.references();
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
index 86cd12046961d..e83fbde3a68df 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
@@ -41,10 +41,7 @@ public StringContains(FieldReference column, String value) {
   public String value() { return value; }
 
   @Override
-  public String toString() { return column.describe() + " StringContains: " + value; }
-
-  @Override
-  public String describe() { return this.toString(); }
+  public String toString() { return column.describe() + " StringContains " + value; }
 
   @Override
   public NamedReference[] references() {
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
index 4692b4779c379..0b74543f193b2 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
@@ -41,10 +41,7 @@ public StringEndsWith(FieldReference column, String value) {
   public String value() { return value; }
 
   @Override
-  public String toString() { return column.describe() + " StringEndsWith: " + value; }
-
-  @Override
-  public String describe() { return this.toString(); }
+  public String toString() { return column.describe() + " StringEndsWith " + value; }
 
   @Override
   public NamedReference[] references() {
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
index ac4dae3210e0d..8b135497548bf 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
@@ -41,10 +41,7 @@ public StringStartsWith(FieldReference column, String value) {
   public String value() { return value; }
 
   @Override
-  public String toString() { return column.describe() + " StringStartsWith: " + value; }
-
-  @Override
-  public String describe() { return this.toString(); }
+  public String toString() { return column.describe() + " StringStartsWith " + value; }
 
   @Override
   public NamedReference[] references() {
diff --git a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
index 63a7581ae95a1..0c44e0dd7d61b 100644
--- a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
+++ b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
@@ -26,79 +26,115 @@ import org.apache.spark.sql.types.IntegerType
 class FiltersV2Suite extends SparkFunSuite {
 
   test("References with nested columns") {
-    assert(new EqualTo(ref("a", "B"), LiteralValue(1, IntegerType))
-      .references.map(_.describe()).toSeq == Seq("a.B"))
-    assert(new EqualTo(ref("a", "b.c"), LiteralValue(1, IntegerType))
-      .references.map(_.describe()).toSeq == Seq("a.`b.c`"))
-    assert(new EqualTo(ref("`a`.b", "c"), LiteralValue(1, IntegerType))
-      .references.map(_.describe()).toSeq == Seq("```a``.b`.c"))
+    val filter1 = new EqualTo(ref("a", "B"), LiteralValue(1, IntegerType))
+    assert(filter1.references.map(_.describe()).toSeq == Seq("a.B"))
+    assert(filter1.describe.equals("a.B = 1"))
+
+    val filter2 = new EqualTo(ref("a", "b.c"), LiteralValue(1, IntegerType))
+    assert(filter2.references.map(_.describe()).toSeq == Seq("a.`b.c`"))
+    assert(filter2.describe.equals("a.`b.c` = 1"))
+
+    val filter3 = new EqualTo(ref("`a`.b", "c"), LiteralValue(1, IntegerType))
+    assert(filter3.references.map(_.describe()).toSeq == Seq("```a``.b`.c"))
+    assert(filter3.describe.equals("```a``.b`.c = 1"))
   }
 
   test("EqualTo references") {
-    assert(new EqualTo(ref("a"), LiteralValue(1, IntegerType))
-      .references.map(_.describe()).toSeq == Seq("a"))
+    val filter = new EqualTo(ref("a"), LiteralValue(1, IntegerType))
+    assert(filter.references.map(_.describe()).toSeq == Seq("a"))
+    assert(filter.describe.equals("a = 1"))
   }
 
   test("EqualNullSafe references") {
-    assert(new EqualNullSafe(ref("a"), LiteralValue(1, IntegerType))
-      .references.map(_.describe()).toSeq == Seq("a"))
+    val filter = new EqualNullSafe(ref("a"), LiteralValue(1, IntegerType))
+    assert(filter.references.map(_.describe()).toSeq == Seq("a"))
+    assert(filter.describe.equals("a <=> 1"))
   }
 
   test("GreaterThan references") {
-    assert(new GreaterThan(ref("a"), LiteralValue(1, IntegerType))
-      .references.map(_.describe()).toSeq == Seq("a"))
+    val filter = new GreaterThan(ref("a"), LiteralValue(1, IntegerType))
+    assert(filter.references.map(_.describe()).toSeq == Seq("a"))
+    assert(filter.describe.equals("a > 1"))
   }
 
   test("GreaterThanOrEqual references") {
-    assert(new GreaterThanOrEqual(ref("a"), LiteralValue(1, IntegerType))
-      .references.map(_.describe()).toSeq == Seq("a"))
+    val filter = new GreaterThanOrEqual(ref("a"), LiteralValue(1, IntegerType))
+    assert(filter.references.map(_.describe()).toSeq == Seq("a"))
+    assert(filter.describe.equals("a >= 1"))
   }
 
   test("LessThan references") {
-    assert(new LessThan(ref("a"), LiteralValue(1, IntegerType))
-      .references.map(_.describe()).toSeq == Seq("a"))
+    val filter = new LessThan(ref("a"), LiteralValue(1, IntegerType))
+    assert(filter.references.map(_.describe()).toSeq == Seq("a"))
+    assert(filter.describe.equals("a < 1"))
   }
 
   test("LessThanOrEqual references") {
-    assert(new LessThanOrEqual(ref("a"), LiteralValue(1, IntegerType))
-      .references.map(_.describe()).toSeq == Seq("a"))
+    val filter = new LessThanOrEqual(ref("a"), LiteralValue(1, IntegerType))
+    assert(filter.references.map(_.describe()).toSeq == Seq("a"))
+    assert(filter.describe.equals("a <= 1"))
   }
 
   test("In references") {
-    assert(new In(ref("a"), Array(LiteralValue(1, IntegerType)))
-      .references.map(_.describe()).toSeq == Seq("a"))
+    val filter1 = new In[Integer](ref("a"),
+      Array(LiteralValue(1, IntegerType), LiteralValue(2, IntegerType),
+        LiteralValue(3, IntegerType), LiteralValue(4, IntegerType)))
+    val filter2 = new In[Integer](ref("a"),
+      Array(LiteralValue(1, IntegerType), LiteralValue(2, IntegerType),
+        LiteralValue(3, IntegerType), LiteralValue(4, IntegerType)))
+    assert(filter1.equals(filter2))
+    assert(filter1.references.map(_.describe()).toSeq == Seq("a"))
+    assert(filter1.describe.equals("a in (1, 2, 3, 4)"))
   }
 
   test("IsNull references") {
-    assert(new IsNull(ref("a")).references.map(_.describe()).toSeq == Seq("a"))
+    val filter = new IsNull(ref("a"))
+    assert(filter.references.map(_.describe()).toSeq == Seq("a"))
+    assert(filter.describe.equals("a IsNull"))
   }
 
   test("IsNotNull references") {
-    assert(new IsNotNull(ref("a")).references.map(_.describe()).toSeq == Seq("a"))
+    val filter = new IsNotNull(ref("a"))
+    assert(filter.references.map(_.describe()).toSeq == Seq("a"))
+    assert(filter.describe.equals("a IsNotNull"))
+  }
+
+  test("Not references") {
+    val filter = new Not(new LessThan(ref("a"), LiteralValue(1, IntegerType)))
+    assert(filter.references.map(_.describe()).toSeq == Seq("a"))
+    assert(filter.describe.equals("Not a < 1"))
   }
 
   test("And references") {
-    assert(new And(new EqualTo(ref("a"), LiteralValue(1, IntegerType)),
+    val filter = new And(new EqualTo(ref("a"), LiteralValue(1, IntegerType)),
       new EqualTo(ref("b"), LiteralValue(1, IntegerType)))
-      .references.map(_.describe()).toSeq == Seq("a", "b"))
+    assert(filter.references.map(_.describe()).toSeq == Seq("a", "b"))
+    assert(filter.describe.equals("a = 1 and b = 1"))
   }
 
   test("Or references") {
-    assert(new Or(new EqualTo(ref("a"), LiteralValue(1, IntegerType)),
+    val filter = new Or(new EqualTo(ref("a"), LiteralValue(1, IntegerType)),
       new EqualTo(ref("b"), LiteralValue(1, IntegerType)))
-      .references.map(_.describe()).toSeq == Seq("a", "b"))
+    assert(filter.references.map(_.describe()).toSeq == Seq("a", "b"))
+    assert(filter.describe.equals("a = 1 or b = 1"))
   }
 
   test("StringStartsWith references") {
-    assert(new StringStartsWith(ref("a"), "str").references.map(_.describe()).toSeq == Seq("a"))
+    val filter = new StringStartsWith(ref("a"), "str")
+    assert(filter.references.map(_.describe()).toSeq == Seq("a"))
+    assert(filter.describe.equals("a StringStartsWith str"))
   }
 
   test("StringEndsWith references") {
-    assert(new StringEndsWith(ref("a"), "str").references.map(_.describe()).toSeq == Seq("a"))
+    val filter = new StringEndsWith(ref("a"), "str")
+    assert(filter.references.map(_.describe()).toSeq == Seq("a"))
+    assert(filter.describe.equals("a StringEndsWith str"))
   }
 
   test("StringContains references") {
-    assert(new StringContains(ref("a"), "str").references.map(_.describe()).toSeq == Seq("a"))
+    val filter = new StringContains(ref("a"), "str")
+    assert(filter.references.map(_.describe()).toSeq == Seq("a"))
+    assert(filter.describe.equals("a StringContains str"))
   }
 }
 

From 444f91b394b1d6216b673185c1c655ab31313526 Mon Sep 17 00:00:00 2001
From: Huaxin Gao <huaxin_gao@apple.com>
Date: Tue, 24 Aug 2021 17:58:20 -0700
Subject: [PATCH 06/24] change tests names

---
 .../datasources/v2/V2FiltersSuite.scala       | 32 +++++++++----------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
index 0c44e0dd7d61b..d1d933d86df62 100644
--- a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
+++ b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
@@ -25,7 +25,7 @@ import org.apache.spark.sql.types.IntegerType
 
 class FiltersV2Suite extends SparkFunSuite {
 
-  test("References with nested columns") {
+  test("nested columns") {
     val filter1 = new EqualTo(ref("a", "B"), LiteralValue(1, IntegerType))
     assert(filter1.references.map(_.describe()).toSeq == Seq("a.B"))
     assert(filter1.describe.equals("a.B = 1"))
@@ -39,43 +39,43 @@ class FiltersV2Suite extends SparkFunSuite {
     assert(filter3.describe.equals("```a``.b`.c = 1"))
   }
 
-  test("EqualTo references") {
+  test("EqualTo") {
     val filter = new EqualTo(ref("a"), LiteralValue(1, IntegerType))
     assert(filter.references.map(_.describe()).toSeq == Seq("a"))
     assert(filter.describe.equals("a = 1"))
   }
 
-  test("EqualNullSafe references") {
+  test("EqualNullSafe") {
     val filter = new EqualNullSafe(ref("a"), LiteralValue(1, IntegerType))
     assert(filter.references.map(_.describe()).toSeq == Seq("a"))
     assert(filter.describe.equals("a <=> 1"))
   }
 
-  test("GreaterThan references") {
+  test("GreaterThan") {
     val filter = new GreaterThan(ref("a"), LiteralValue(1, IntegerType))
     assert(filter.references.map(_.describe()).toSeq == Seq("a"))
     assert(filter.describe.equals("a > 1"))
   }
 
-  test("GreaterThanOrEqual references") {
+  test("GreaterThanOrEqual") {
     val filter = new GreaterThanOrEqual(ref("a"), LiteralValue(1, IntegerType))
     assert(filter.references.map(_.describe()).toSeq == Seq("a"))
     assert(filter.describe.equals("a >= 1"))
   }
 
-  test("LessThan references") {
+  test("LessThan") {
     val filter = new LessThan(ref("a"), LiteralValue(1, IntegerType))
     assert(filter.references.map(_.describe()).toSeq == Seq("a"))
     assert(filter.describe.equals("a < 1"))
   }
 
-  test("LessThanOrEqual references") {
+  test("LessThanOrEqual") {
     val filter = new LessThanOrEqual(ref("a"), LiteralValue(1, IntegerType))
     assert(filter.references.map(_.describe()).toSeq == Seq("a"))
     assert(filter.describe.equals("a <= 1"))
   }
 
-  test("In references") {
+  test("In") {
     val filter1 = new In[Integer](ref("a"),
       Array(LiteralValue(1, IntegerType), LiteralValue(2, IntegerType),
         LiteralValue(3, IntegerType), LiteralValue(4, IntegerType)))
@@ -87,51 +87,51 @@ class FiltersV2Suite extends SparkFunSuite {
     assert(filter1.describe.equals("a in (1, 2, 3, 4)"))
   }
 
-  test("IsNull references") {
+  test("IsNull") {
     val filter = new IsNull(ref("a"))
     assert(filter.references.map(_.describe()).toSeq == Seq("a"))
     assert(filter.describe.equals("a IsNull"))
   }
 
-  test("IsNotNull references") {
+  test("IsNotNull") {
     val filter = new IsNotNull(ref("a"))
     assert(filter.references.map(_.describe()).toSeq == Seq("a"))
     assert(filter.describe.equals("a IsNotNull"))
   }
 
-  test("Not references") {
+  test("Not") {
     val filter = new Not(new LessThan(ref("a"), LiteralValue(1, IntegerType)))
     assert(filter.references.map(_.describe()).toSeq == Seq("a"))
     assert(filter.describe.equals("Not a < 1"))
   }
 
-  test("And references") {
+  test("And") {
     val filter = new And(new EqualTo(ref("a"), LiteralValue(1, IntegerType)),
       new EqualTo(ref("b"), LiteralValue(1, IntegerType)))
     assert(filter.references.map(_.describe()).toSeq == Seq("a", "b"))
     assert(filter.describe.equals("a = 1 and b = 1"))
   }
 
-  test("Or references") {
+  test("Or") {
     val filter = new Or(new EqualTo(ref("a"), LiteralValue(1, IntegerType)),
       new EqualTo(ref("b"), LiteralValue(1, IntegerType)))
     assert(filter.references.map(_.describe()).toSeq == Seq("a", "b"))
     assert(filter.describe.equals("a = 1 or b = 1"))
   }
 
-  test("StringStartsWith references") {
+  test("StringStartsWith") {
     val filter = new StringStartsWith(ref("a"), "str")
     assert(filter.references.map(_.describe()).toSeq == Seq("a"))
     assert(filter.describe.equals("a StringStartsWith str"))
   }
 
-  test("StringEndsWith references") {
+  test("StringEndsWith") {
     val filter = new StringEndsWith(ref("a"), "str")
     assert(filter.references.map(_.describe()).toSeq == Seq("a"))
     assert(filter.describe.equals("a StringEndsWith str"))
   }
 
-  test("StringContains references") {
+  test("StringContains") {
     val filter = new StringContains(ref("a"), "str")
     assert(filter.references.map(_.describe()).toSeq == Seq("a"))
     assert(filter.describe.equals("a StringContains str"))

From 1a1a98b89c16792293af538900401e4c0ba56ccc Mon Sep 17 00:00:00 2001
From: DB Tsai <d_tsai@apple.com>
Date: Tue, 24 Aug 2021 19:21:59 -0700
Subject: [PATCH 07/24] add co-author


From f7f17c2a1e9dcfc17a890f082e86f24bd7ded234 Mon Sep 17 00:00:00 2001
From: Huaxin Gao <huaxin_gao@apple.com>
Date: Wed, 25 Aug 2021 16:03:57 -0700
Subject: [PATCH 08/24] address comments

---
 .../expressions/filter/AlwaysFalse.java       |  4 +-
 .../expressions/filter/AlwaysTrue.java        |  4 +-
 .../sql/connector/expressions/filter/And.java |  2 +-
 .../expressions/filter/EqualNullSafe.java     |  6 +--
 .../connector/expressions/filter/EqualTo.java |  6 +--
 .../connector/expressions/filter/Filter.java  |  3 +-
 .../expressions/filter/GreaterThan.java       |  6 +--
 .../filter/GreaterThanOrEqual.java            |  6 +--
 .../sql/connector/expressions/filter/In.java  | 41 +++++++------------
 .../expressions/filter/IsNotNull.java         |  8 +---
 .../connector/expressions/filter/IsNull.java  |  8 +---
 .../expressions/filter/LessThan.java          |  6 +--
 .../expressions/filter/LessThanOrEqual.java   |  6 +--
 .../sql/connector/expressions/filter/Not.java |  2 +-
 .../sql/connector/expressions/filter/Or.java  |  2 +-
 .../expressions/filter/StringContains.java    |  8 +---
 .../expressions/filter/StringEndsWith.java    |  8 +---
 .../expressions/filter/StringStartsWith.java  |  8 +---
 .../datasources/v2/V2FiltersSuite.scala       | 18 ++++----
 19 files changed, 48 insertions(+), 104 deletions(-)

diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java
index 242617d2622dd..81c35be818723 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java
@@ -29,8 +29,8 @@
 public final class AlwaysFalse extends Filter {
 
   @Override
-  public String toString() { return "AlwaysFalse"; }
+  public String toString() { return "FALSE"; }
 
   @Override
-  public NamedReference[] references() { return new NamedReference[0]; }
+  public NamedReference[] references() { return EMPTY_REFERENCE; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java
index 7eb83b9146ceb..53a1718df80be 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java
@@ -29,8 +29,8 @@
 public final class AlwaysTrue extends Filter {
 
   @Override
-  public String toString() { return "AlwaysTrue"; }
+  public String toString() { return "TRUE"; }
 
   @Override
-  public NamedReference[] references() { return new NamedReference[0]; }
+  public NamedReference[] references() { return EMPTY_REFERENCE; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
index 57db9bb86665d..26c0346111b38 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
@@ -39,7 +39,7 @@ public And(Filter left, Filter right) {
   public Filter right() { return right; }
 
   @Override
-  public String toString() { return left.describe() + " and " + right.describe(); }
+  public String toString() { return left.describe() + " AND " + right.describe(); }
 
   @Override
   public NamedReference[] references() {
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
index 7ebede1be7022..8fed8ddc26aa0 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
@@ -46,9 +46,5 @@ public EqualNullSafe(FieldReference column, Literal<T> value) {
   public String toString() { return column.describe() + " <=> " + value.describe(); }
 
   @Override
-  public NamedReference[] references() {
-    NamedReference[] arr = new NamedReference[1];
-    arr[0] = column;
-    return arr;
-  }
+  public NamedReference[] references() { return new NamedReference[] { column }; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
index 1114c2f5a4466..b937e9b7c3a5f 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
@@ -45,9 +45,5 @@ public EqualTo(FieldReference column, Literal<T> value) {
   public String toString() { return column.describe() + " = " + value.describe(); }
 
   @Override
-  public NamedReference[] references() {
-    NamedReference[] arr = new NamedReference[1];
-    arr[0] = column;
-    return arr;
-  }
+  public NamedReference[] references() { return new NamedReference[] { column }; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Filter.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Filter.java
index 192e7c5491307..75739361ec826 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Filter.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Filter.java
@@ -29,7 +29,8 @@
 @Evolving
 public abstract class Filter implements Expression {
 
-  private static final NamedReference[] EMPTY_REFERENCE = new NamedReference[0];
+  protected static final NamedReference[] EMPTY_REFERENCE = new NamedReference[0];
+
   /**
    * Returns list of columns that are referenced by this filter.
    */
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
index 19c57313aea12..762e6bb3f7690 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
@@ -45,9 +45,5 @@ public GreaterThan(FieldReference column, Literal<T> value) {
   public String toString() { return column.describe() + " > " + value.describe(); }
 
   @Override
-  public NamedReference[] references() {
-    NamedReference[] arr = new NamedReference[1];
-    arr[0] = column;
-    return arr;
-  }
+  public NamedReference[] references() { return new NamedReference[] { column }; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
index 8a418c66f3b5b..59c4c82dec429 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
@@ -44,9 +44,5 @@ public GreaterThanOrEqual(FieldReference column, Literal<T> value) {
   @Override
   public String toString() { return column.describe() + " >= " + value.describe(); }
 
-  public NamedReference[] references() {
-    NamedReference[] arr = new NamedReference[1];
-    arr[0] = column;
-    return arr;
-  }
+  public NamedReference[] references() { return new NamedReference[] { column }; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
index 007636ddd2d9d..4f6178ec0100a 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
@@ -18,6 +18,8 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import java.util.Arrays;
+import java.util.Objects;
+import java.util.stream.Collectors;
 
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.FieldReference;
@@ -43,41 +45,26 @@ public In(FieldReference column, Literal<T>[] values) {
   public Literal<T>[] values() { return values; }
 
   @Override
-  public int hashCode() {
-    int h = column.hashCode();
-    for (Literal v : values) {
-      h *= 41;
-      h += v.hashCode();
-    }
-    return h;
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    In<?> in = (In<?>) o;
+    return Objects.equals(column, in.column) && Arrays.equals(values, in.values);
   }
 
   @Override
-  public boolean equals(Object obj) {
-    if (obj instanceof In) {
-      return (((In) obj).column.equals(column) && Arrays.equals(((In) obj).values, values));
-    } else {
-      return false;
-    }
+  public int hashCode() {
+    int result = Objects.hash(column);
+    result = 31 * result + Arrays.hashCode(values);
+    return result;
   }
 
   @Override
   public String toString() {
-    StringBuilder str = new StringBuilder();
-    for (Literal v : values) {
-      str.append(v.describe()).append(", ");
-    }
-    String res = "";
-    if (!str.toString().isEmpty()) {
-      res = str.substring(0, str.length() - 2);
-    }
-    return column.describe() + " in (" + res + ")";
+    String res = Arrays.stream(values).map(Literal::describe).collect(Collectors.joining(", "));
+    return column.describe() + " IN (" + res + ")";
   }
 
   @Override
-  public NamedReference[] references() {
-    NamedReference[] arr = new NamedReference[1];
-    arr[0] = column;
-    return arr;
-  }
+  public NamedReference[] references() { return new NamedReference[] { column }; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
index 5b28efb3dd7dd..24845725ed2a8 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
@@ -37,12 +37,8 @@ public IsNotNull(FieldReference column) {
   public FieldReference column() { return column; }
 
   @Override
-  public String toString() { return column.describe() + " IsNotNull"; }
+  public String toString() { return column.describe() + " IS NOT NULL"; }
 
   @Override
-  public NamedReference[] references() {
-    NamedReference[] arr = new NamedReference[1];
-    arr[0] = column;
-    return arr;
-  }
+  public NamedReference[] references() { return new NamedReference[] { column }; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
index 55d42b3e8ce13..1462e4e41f5aa 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
@@ -37,12 +37,8 @@ public IsNull(FieldReference column) {
   public FieldReference column() { return column; }
 
   @Override
-  public String toString() { return column.describe() + " IsNull"; }
+  public String toString() { return column.describe() + " IS NULL"; }
 
   @Override
-  public NamedReference[] references() {
-    NamedReference[] arr = new NamedReference[1];
-    arr[0] = column;
-    return arr;
-  }
+  public NamedReference[] references() { return new NamedReference[] { column }; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
index a6475bfd0ff68..fca536a9c1763 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
@@ -45,9 +45,5 @@ public LessThan(FieldReference column, Literal<T> value) {
   public String toString() { return column.describe() + " < " + value.describe(); }
 
   @Override
-  public NamedReference[] references() {
-    NamedReference[] arr = new NamedReference[1];
-    arr[0] = column;
-    return arr;
-  }
+  public NamedReference[] references() { return new NamedReference[] { column }; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
index 420a6f149ac74..63d89f9440196 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
@@ -45,9 +45,5 @@ public LessThanOrEqual(FieldReference column, Literal<T> value) {
   public String toString() { return column.describe() + " <= " + value.describe(); }
 
   @Override
-  public NamedReference[] references() {
-    NamedReference[] arr = new NamedReference[1];
-    arr[0] = column;
-    return arr;
-  }
+  public NamedReference[] references() { return new NamedReference[] { column }; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java
index 199aa26e9b141..a61235365f452 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java
@@ -34,7 +34,7 @@ public final class Not extends Filter {
   public Filter child() { return child; }
 
   @Override
-  public String toString() { return "Not " + child.describe(); }
+  public String toString() { return "NOT " + child.describe(); }
 
   @Override
   public NamedReference[] references() { return child.references(); }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
index c4c4fa6ddbb2f..5ccd7ee161b5f 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
@@ -39,7 +39,7 @@ public Or(Filter left, Filter right) {
   public Filter right() { return right; }
 
   @Override
-  public String toString() { return left.describe() + " or " + right.describe(); }
+  public String toString() { return left.describe() + " OR " + right.describe(); }
 
   @Override
   public NamedReference[] references() {
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
index e83fbde3a68df..8a0cf6c2b950d 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
@@ -41,12 +41,8 @@ public StringContains(FieldReference column, String value) {
   public String value() { return value; }
 
   @Override
-  public String toString() { return column.describe() + " StringContains " + value; }
+  public String toString() { return "STRING CONTAINS(" + column.describe() + ", " + value + ")"; }
 
   @Override
-  public NamedReference[] references() {
-    NamedReference[] arr = new NamedReference[1];
-    arr[0] = column;
-    return arr;
-  }
+  public NamedReference[] references() { return new NamedReference[] { column }; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
index 0b74543f193b2..564748647a64c 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
@@ -41,12 +41,8 @@ public StringEndsWith(FieldReference column, String value) {
   public String value() { return value; }
 
   @Override
-  public String toString() { return column.describe() + " StringEndsWith " + value; }
+  public String toString() { return column.describe() + " ENDS WITH " + value; }
 
   @Override
-  public NamedReference[] references() {
-    NamedReference[] arr = new NamedReference[1];
-    arr[0] = column;
-    return arr;
-  }
+  public NamedReference[] references() { return new NamedReference[] { column }; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
index 8b135497548bf..d72e032a13318 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
@@ -41,12 +41,8 @@ public StringStartsWith(FieldReference column, String value) {
   public String value() { return value; }
 
   @Override
-  public String toString() { return column.describe() + " StringStartsWith " + value; }
+  public String toString() { return column.describe() + " STARTS WITH " + value; }
 
   @Override
-  public NamedReference[] references() {
-    NamedReference[] arr = new NamedReference[1];
-    arr[0] = column;
-    return arr;
-  }
+  public NamedReference[] references() { return new NamedReference[] { column }; }
 }
diff --git a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
index d1d933d86df62..b022e46e02da4 100644
--- a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
+++ b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
@@ -84,57 +84,57 @@ class FiltersV2Suite extends SparkFunSuite {
         LiteralValue(3, IntegerType), LiteralValue(4, IntegerType)))
     assert(filter1.equals(filter2))
     assert(filter1.references.map(_.describe()).toSeq == Seq("a"))
-    assert(filter1.describe.equals("a in (1, 2, 3, 4)"))
+    assert(filter1.describe.equals("a IN (1, 2, 3, 4)"))
   }
 
   test("IsNull") {
     val filter = new IsNull(ref("a"))
     assert(filter.references.map(_.describe()).toSeq == Seq("a"))
-    assert(filter.describe.equals("a IsNull"))
+    assert(filter.describe.equals("a IS NULL"))
   }
 
   test("IsNotNull") {
     val filter = new IsNotNull(ref("a"))
     assert(filter.references.map(_.describe()).toSeq == Seq("a"))
-    assert(filter.describe.equals("a IsNotNull"))
+    assert(filter.describe.equals("a IS NOT NULL"))
   }
 
   test("Not") {
     val filter = new Not(new LessThan(ref("a"), LiteralValue(1, IntegerType)))
     assert(filter.references.map(_.describe()).toSeq == Seq("a"))
-    assert(filter.describe.equals("Not a < 1"))
+    assert(filter.describe.equals("NOT a < 1"))
   }
 
   test("And") {
     val filter = new And(new EqualTo(ref("a"), LiteralValue(1, IntegerType)),
       new EqualTo(ref("b"), LiteralValue(1, IntegerType)))
     assert(filter.references.map(_.describe()).toSeq == Seq("a", "b"))
-    assert(filter.describe.equals("a = 1 and b = 1"))
+    assert(filter.describe.equals("a = 1 AND b = 1"))
   }
 
   test("Or") {
     val filter = new Or(new EqualTo(ref("a"), LiteralValue(1, IntegerType)),
       new EqualTo(ref("b"), LiteralValue(1, IntegerType)))
     assert(filter.references.map(_.describe()).toSeq == Seq("a", "b"))
-    assert(filter.describe.equals("a = 1 or b = 1"))
+    assert(filter.describe.equals("a = 1 OR b = 1"))
   }
 
   test("StringStartsWith") {
     val filter = new StringStartsWith(ref("a"), "str")
     assert(filter.references.map(_.describe()).toSeq == Seq("a"))
-    assert(filter.describe.equals("a StringStartsWith str"))
+    assert(filter.describe.equals("a STARTS WITH str"))
   }
 
   test("StringEndsWith") {
     val filter = new StringEndsWith(ref("a"), "str")
     assert(filter.references.map(_.describe()).toSeq == Seq("a"))
-    assert(filter.describe.equals("a StringEndsWith str"))
+    assert(filter.describe.equals("a ENDS WITH str"))
   }
 
   test("StringContains") {
     val filter = new StringContains(ref("a"), "str")
     assert(filter.references.map(_.describe()).toSeq == Seq("a"))
-    assert(filter.describe.equals("a StringContains str"))
+    assert(filter.describe.equals("STRING CONTAINS(a, str)"))
   }
 }
 

From 612edcf2483a02f07dbdede06e67653ba82c4284 Mon Sep 17 00:00:00 2001
From: Huaxin Gao <huaxin_gao@apple.com>
Date: Wed, 25 Aug 2021 16:30:55 -0700
Subject: [PATCH 09/24] change column type to Expression

---
 .../sql/connector/expressions/filter/AlwaysFalse.java |  4 ++--
 .../sql/connector/expressions/filter/AlwaysTrue.java  |  4 ++--
 .../spark/sql/connector/expressions/filter/And.java   |  7 ++++---
 .../connector/expressions/filter/EqualNullSafe.java   | 11 +++++------
 .../sql/connector/expressions/filter/EqualTo.java     | 11 +++++------
 .../sql/connector/expressions/filter/Filter.java      |  7 +++----
 .../sql/connector/expressions/filter/GreaterThan.java | 11 +++++------
 .../expressions/filter/GreaterThanOrEqual.java        | 11 +++++------
 .../spark/sql/connector/expressions/filter/In.java    | 11 +++++------
 .../sql/connector/expressions/filter/IsNotNull.java   | 11 +++++------
 .../sql/connector/expressions/filter/IsNull.java      | 11 +++++------
 .../sql/connector/expressions/filter/LessThan.java    | 11 +++++------
 .../connector/expressions/filter/LessThanOrEqual.java | 11 +++++------
 .../spark/sql/connector/expressions/filter/Not.java   |  3 ++-
 .../spark/sql/connector/expressions/filter/Or.java    |  7 ++++---
 .../connector/expressions/filter/StringContains.java  | 11 +++++------
 .../connector/expressions/filter/StringEndsWith.java  | 11 +++++------
 .../expressions/filter/StringStartsWith.java          | 11 +++++------
 18 files changed, 77 insertions(+), 87 deletions(-)

diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java
index 81c35be818723..e2ab62748351e 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java
@@ -18,7 +18,7 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.NamedReference;
+import org.apache.spark.sql.connector.expressions.Expression;
 
 /**
  * A filter that always evaluates to `false`.
@@ -32,5 +32,5 @@ public final class AlwaysFalse extends Filter {
   public String toString() { return "FALSE"; }
 
   @Override
-  public NamedReference[] references() { return EMPTY_REFERENCE; }
+  public Expression[] references() { return EMPTY_REFERENCE; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java
index 53a1718df80be..64cc310693993 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java
@@ -18,7 +18,7 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.NamedReference;
+import org.apache.spark.sql.connector.expressions.Expression;
 
 /**
  * A filter that always evaluates to `true`.
@@ -32,5 +32,5 @@ public final class AlwaysTrue extends Filter {
   public String toString() { return "TRUE"; }
 
   @Override
-  public NamedReference[] references() { return EMPTY_REFERENCE; }
+  public Expression[] references() { return EMPTY_REFERENCE; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
index 26c0346111b38..d8db6858d92a4 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
@@ -18,6 +18,7 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.Expression;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
@@ -42,9 +43,9 @@ public And(Filter left, Filter right) {
   public String toString() { return left.describe() + " AND " + right.describe(); }
 
   @Override
-  public NamedReference[] references() {
-    NamedReference[] refLeft = left.references();
-    NamedReference[] refRight = right.references();
+  public Expression[] references() {
+    Expression[] refLeft = left.references();
+    Expression[] refRight = right.references();
     NamedReference[] arr = new NamedReference[refLeft.length + refRight.length];
     System.arraycopy(refLeft, 0, arr, 0, refLeft.length);
     System.arraycopy(refRight, 0, arr, refLeft.length, refRight.length);
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
index 8fed8ddc26aa0..c16d99a9ec977 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
@@ -18,9 +18,8 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.FieldReference;
+import org.apache.spark.sql.connector.expressions.Expression;
 import org.apache.spark.sql.connector.expressions.Literal;
-import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * Performs equality comparison, similar to [[EqualTo]]. However, this differs from [[EqualTo]]
@@ -31,20 +30,20 @@
  */
 @Evolving
 public final class EqualNullSafe<T> extends Filter {
-  private final FieldReference column;
+  private final Expression column;
   private final Literal<T> value;
 
-  public EqualNullSafe(FieldReference column, Literal<T> value) {
+  public EqualNullSafe(Expression column, Literal<T> value) {
     this.column = column;
     this.value = value;
   }
 
-  public FieldReference column() { return column; }
+  public Expression column() { return column; }
   public Literal<T> value() { return value; }
 
   @Override
   public String toString() { return column.describe() + " <=> " + value.describe(); }
 
   @Override
-  public NamedReference[] references() { return new NamedReference[] { column }; }
+  public Expression[] references() { return new Expression[] { column }; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
index b937e9b7c3a5f..f5cd0c6e4bed0 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
@@ -18,9 +18,8 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.FieldReference;
+import org.apache.spark.sql.connector.expressions.Expression;
 import org.apache.spark.sql.connector.expressions.Literal;
-import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * A filter that evaluates to `true` iff the field evaluates to a value
@@ -30,20 +29,20 @@
  */
 @Evolving
 public final class EqualTo<T> extends Filter {
-  private final FieldReference column;
+  private final Expression column;
   private final Literal<T> value;
 
-  public EqualTo(FieldReference column, Literal<T> value) {
+  public EqualTo(Expression column, Literal<T> value) {
     this.column = column;
     this.value = value;
   }
 
-  public FieldReference column() { return column; }
+  public Expression column() { return column; }
   public Literal<T> value() { return value; }
 
   @Override
   public String toString() { return column.describe() + " = " + value.describe(); }
 
   @Override
-  public NamedReference[] references() { return new NamedReference[] { column }; }
+  public Expression[] references() { return new Expression[] { column }; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Filter.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Filter.java
index 75739361ec826..a686104017513 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Filter.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Filter.java
@@ -19,7 +19,6 @@
 
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.Expression;
-import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * Filter base class
@@ -29,14 +28,14 @@
 @Evolving
 public abstract class Filter implements Expression {
 
-  protected static final NamedReference[] EMPTY_REFERENCE = new NamedReference[0];
+  protected static final Expression[] EMPTY_REFERENCE = new Expression[0];
 
   /**
    * Returns list of columns that are referenced by this filter.
    */
-  public abstract NamedReference[] references();
+  public abstract Expression[] references();
 
-  protected NamedReference[] findReferences(Object filter) {
+  protected Expression[] findReferences(Object filter) {
     if (filter instanceof Filter) {
       return ((Filter) filter).references();
     } else {
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
index 762e6bb3f7690..6c49a9250db84 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
@@ -18,9 +18,8 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.FieldReference;
+import org.apache.spark.sql.connector.expressions.Expression;
 import org.apache.spark.sql.connector.expressions.Literal;
-import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * A filter that evaluates to `true` iff the field evaluates to a value
@@ -30,20 +29,20 @@
  */
 @Evolving
 public final class GreaterThan<T> extends Filter {
-  private final FieldReference column;
+  private final Expression column;
   private final Literal<T> value;
 
-  public GreaterThan(FieldReference column, Literal<T> value) {
+  public GreaterThan(Expression column, Literal<T> value) {
     this.column = column;
     this.value = value;
   }
 
-  public FieldReference column() { return column; }
+  public Expression column() { return column; }
   public Literal<T> value() { return value; }
 
   @Override
   public String toString() { return column.describe() + " > " + value.describe(); }
 
   @Override
-  public NamedReference[] references() { return new NamedReference[] { column }; }
+  public Expression[] references() { return new Expression[] { column }; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
index 59c4c82dec429..513325faeee00 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
@@ -18,9 +18,8 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.FieldReference;
+import org.apache.spark.sql.connector.expressions.Expression;
 import org.apache.spark.sql.connector.expressions.Literal;
-import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * A filter that evaluates to `true` iff the field evaluates to a value
@@ -30,19 +29,19 @@
  */
 @Evolving
 public final class GreaterThanOrEqual<T> extends Filter {
-  private final FieldReference column;
+  private final Expression column;
   private final Literal<T> value;
 
-  public GreaterThanOrEqual(FieldReference column, Literal<T> value) {
+  public GreaterThanOrEqual(Expression column, Literal<T> value) {
     this.column = column;
     this.value = value;
   }
 
-  public FieldReference column() { return column; }
+  public Expression column() { return column; }
   public Literal<T> value() { return value; }
 
   @Override
   public String toString() { return column.describe() + " >= " + value.describe(); }
 
-  public NamedReference[] references() { return new NamedReference[] { column }; }
+  public Expression[] references() { return new Expression[] { column }; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
index 4f6178ec0100a..2289e15f90d52 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
@@ -22,9 +22,8 @@
 import java.util.stream.Collectors;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.FieldReference;
+import org.apache.spark.sql.connector.expressions.Expression;
 import org.apache.spark.sql.connector.expressions.Literal;
-import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * A filter that evaluates to `true` iff the field evaluates to one of the values in the array.
@@ -33,15 +32,15 @@
  */
 @Evolving
 public final class In<T> extends Filter {
-  private final FieldReference column;
+  private final Expression column;
   private final Literal<T>[] values;
 
-  public In(FieldReference column, Literal<T>[] values) {
+  public In(Expression column, Literal<T>[] values) {
     this.column = column;
     this.values = values;
   }
 
-  public FieldReference column() { return column; }
+  public Expression column() { return column; }
   public Literal<T>[] values() { return values; }
 
   @Override
@@ -66,5 +65,5 @@ public String toString() {
   }
 
   @Override
-  public NamedReference[] references() { return new NamedReference[] { column }; }
+  public Expression[] references() { return new Expression[] { column }; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
index 24845725ed2a8..5c715e0a6c2eb 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
@@ -18,8 +18,7 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.FieldReference;
-import org.apache.spark.sql.connector.expressions.NamedReference;
+import org.apache.spark.sql.connector.expressions.Expression;
 
 /**
  * A filter that evaluates to `true` iff the field evaluates to a non-null value.
@@ -28,17 +27,17 @@
  */
 @Evolving
 public final class IsNotNull extends Filter {
-  private final FieldReference column;
+  private final Expression column;
 
-  public IsNotNull(FieldReference column) {
+  public IsNotNull(Expression column) {
     this.column = column;
   }
 
-  public FieldReference column() { return column; }
+  public Expression column() { return column; }
 
   @Override
   public String toString() { return column.describe() + " IS NOT NULL"; }
 
   @Override
-  public NamedReference[] references() { return new NamedReference[] { column }; }
+  public Expression[] references() { return new Expression[] { column }; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
index 1462e4e41f5aa..c8ec0689bd04b 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
@@ -18,8 +18,7 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.FieldReference;
-import org.apache.spark.sql.connector.expressions.NamedReference;
+import org.apache.spark.sql.connector.expressions.Expression;
 
 /**
  * A filter that evaluates to `true` iff the field evaluates to null.
@@ -28,17 +27,17 @@
  */
 @Evolving
 public final class IsNull extends Filter {
-  private final FieldReference column;
+  private final Expression column;
 
-  public IsNull(FieldReference column) {
+  public IsNull(Expression column) {
     this.column = column;
   }
 
-  public FieldReference column() { return column; }
+  public Expression column() { return column; }
 
   @Override
   public String toString() { return column.describe() + " IS NULL"; }
 
   @Override
-  public NamedReference[] references() { return new NamedReference[] { column }; }
+  public Expression[] references() { return new Expression[] { column }; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
index fca536a9c1763..ea2b1dff0bc6a 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
@@ -18,9 +18,8 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.FieldReference;
+import org.apache.spark.sql.connector.expressions.Expression;
 import org.apache.spark.sql.connector.expressions.Literal;
-import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * A filter that evaluates to `true` iff the field evaluates to a value
@@ -30,20 +29,20 @@
  */
 @Evolving
 public final class LessThan<T> extends Filter {
-  private final FieldReference column;
+  private final Expression column;
   private final Literal<T> value;
 
-  public LessThan(FieldReference column, Literal<T> value) {
+  public LessThan(Expression column, Literal<T> value) {
     this.column = column;
     this.value = value;
   }
 
-  public FieldReference column() { return column; }
+  public Expression column() { return column; }
   public Literal<T> value() { return value; }
 
   @Override
   public String toString() { return column.describe() + " < " + value.describe(); }
 
   @Override
-  public NamedReference[] references() { return new NamedReference[] { column }; }
+  public Expression[] references() { return new Expression[] { column }; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
index 63d89f9440196..2ae8c4e841b14 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
@@ -18,9 +18,8 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.FieldReference;
+import org.apache.spark.sql.connector.expressions.Expression;
 import org.apache.spark.sql.connector.expressions.Literal;
-import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * A filter that evaluates to `true` iff the field evaluates to a value
@@ -30,20 +29,20 @@
  */
 @Evolving
 public final class LessThanOrEqual<T> extends Filter {
-  private final FieldReference column;
+  private final Expression column;
   private final Literal<T> value;
 
-  public LessThanOrEqual(FieldReference column, Literal<T> value) {
+  public LessThanOrEqual(Expression column, Literal<T> value) {
     this.column = column;
     this.value = value;
   }
 
-  public FieldReference column() { return column; }
+  public Expression column() { return column; }
   public Literal<T> value() { return value; }
 
   @Override
   public String toString() { return column.describe() + " <= " + value.describe(); }
 
   @Override
-  public NamedReference[] references() { return new NamedReference[] { column }; }
+  public Expression[] references() { return new Expression[] { column }; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java
index a61235365f452..b346a0de3cb8d 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java
@@ -18,6 +18,7 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.Expression;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
@@ -37,5 +38,5 @@ public final class Not extends Filter {
   public String toString() { return "NOT " + child.describe(); }
 
   @Override
-  public NamedReference[] references() { return child.references(); }
+  public Expression[] references() { return child.references(); }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
index 5ccd7ee161b5f..54c0969df58ce 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
@@ -18,6 +18,7 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.Expression;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
@@ -42,9 +43,9 @@ public Or(Filter left, Filter right) {
   public String toString() { return left.describe() + " OR " + right.describe(); }
 
   @Override
-  public NamedReference[] references() {
-    NamedReference[] refLeft = left.references();
-    NamedReference[] refRight = right.references();
+  public Expression[] references() {
+    Expression[] refLeft = left.references();
+    Expression[] refRight = right.references();
     NamedReference[] arr = new NamedReference[refLeft.length + refRight.length];
     System.arraycopy(refLeft, 0, arr, 0, refLeft.length);
     System.arraycopy(refRight, 0, arr, refLeft.length, refRight.length);
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
index 8a0cf6c2b950d..9f3f1f8b0d739 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
@@ -18,8 +18,7 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.FieldReference;
-import org.apache.spark.sql.connector.expressions.NamedReference;
+import org.apache.spark.sql.connector.expressions.Expression;
 
 /**
  * A filter that evaluates to `true` iff the field evaluates to
@@ -29,20 +28,20 @@
  */
 @Evolving
 public final class StringContains extends Filter {
-  private final FieldReference column;
+  private final Expression column;
   private final String value;
 
-  public StringContains(FieldReference column, String value) {
+  public StringContains(Expression column, String value) {
     this.column = column;
     this.value = value;
   }
 
-  public FieldReference column() { return column; }
+  public Expression column() { return column; }
   public String value() { return value; }
 
   @Override
   public String toString() { return "STRING CONTAINS(" + column.describe() + ", " + value + ")"; }
 
   @Override
-  public NamedReference[] references() { return new NamedReference[] { column }; }
+  public Expression[] references() { return new Expression[] { column }; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
index 564748647a64c..01ac5dc00cded 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
@@ -18,8 +18,7 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.FieldReference;
-import org.apache.spark.sql.connector.expressions.NamedReference;
+import org.apache.spark.sql.connector.expressions.Expression;
 
 /**
  * A filter that evaluates to `true` iff the field evaluates to
@@ -29,20 +28,20 @@
  */
 @Evolving
 public final class StringEndsWith extends Filter {
-  private final FieldReference column;
+  private final Expression column;
   private final String value;
 
-  public StringEndsWith(FieldReference column, String value) {
+  public StringEndsWith(Expression column, String value) {
     this.column = column;
     this.value = value;
   }
 
-  public FieldReference column() { return column; }
+  public Expression column() { return column; }
   public String value() { return value; }
 
   @Override
   public String toString() { return column.describe() + " ENDS WITH " + value; }
 
   @Override
-  public NamedReference[] references() { return new NamedReference[] { column }; }
+  public Expression[] references() { return new Expression[] { column }; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
index d72e032a13318..86b8c6b9b49cd 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
@@ -18,8 +18,7 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.FieldReference;
-import org.apache.spark.sql.connector.expressions.NamedReference;
+import org.apache.spark.sql.connector.expressions.Expression;
 
 /**
  * A filter that evaluates to `true` iff the field evaluates to
@@ -29,20 +28,20 @@
  */
 @Evolving
 public final class StringStartsWith extends Filter {
-  private final FieldReference column;
+  private final Expression column;
   private final String value;
 
-  public StringStartsWith(FieldReference column, String value) {
+  public StringStartsWith(Expression column, String value) {
     this.column = column;
     this.value = value;
   }
 
-  public FieldReference column() { return column; }
+  public Expression column() { return column; }
   public String value() { return value; }
 
   @Override
   public String toString() { return column.describe() + " STARTS WITH " + value; }
 
   @Override
-  public NamedReference[] references() { return new NamedReference[] { column }; }
+  public Expression[] references() { return new Expression[] { column }; }
 }

From a56fbd0d7597020ed6bbb1c1dfe96261c6610bd1 Mon Sep 17 00:00:00 2001
From: Huaxin Gao <huaxin_gao@apple.com>
Date: Wed, 25 Aug 2021 16:36:12 -0700
Subject: [PATCH 10/24] STRING CONTAINS -> CONTAINS

---
 .../spark/sql/connector/expressions/filter/StringContains.java  | 2 +-
 .../spark/sql/execution/datasources/v2/V2FiltersSuite.scala     | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
index 9f3f1f8b0d739..5534dec01f7de 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
@@ -40,7 +40,7 @@ public StringContains(Expression column, String value) {
   public String value() { return value; }
 
   @Override
-  public String toString() { return "STRING CONTAINS(" + column.describe() + ", " + value + ")"; }
+  public String toString() { return column.describe() + " CONTAINS " + value; }
 
   @Override
   public Expression[] references() { return new Expression[] { column }; }
diff --git a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
index b022e46e02da4..318b88cbebbe1 100644
--- a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
+++ b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
@@ -134,7 +134,7 @@ class FiltersV2Suite extends SparkFunSuite {
   test("StringContains") {
     val filter = new StringContains(ref("a"), "str")
     assert(filter.references.map(_.describe()).toSeq == Seq("a"))
-    assert(filter.describe.equals("STRING CONTAINS(a, str)"))
+    assert(filter.describe.equals("a CONTAINS str"))
   }
 }
 

From 31d41ef6b8588618a7bb5ab852ed9157b77a6cc2 Mon Sep 17 00:00:00 2001
From: Huaxin Gao <huaxin_gao@apple.com>
Date: Wed, 25 Aug 2021 16:40:32 -0700
Subject: [PATCH 11/24] make lint-java happy

---
 .../org/apache/spark/sql/connector/expressions/filter/Not.java   | 1 -
 1 file changed, 1 deletion(-)

diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java
index b346a0de3cb8d..db0d2d36f05af 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java
@@ -19,7 +19,6 @@
 
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.Expression;
-import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * A filter that evaluates to `true` iff `child` is evaluated to `false`.

From 2d86c4af1ebba553c56d41b4521f43ca6fbb2131 Mon Sep 17 00:00:00 2001
From: Huaxin Gao <huaxin_gao@apple.com>
Date: Wed, 1 Sep 2021 16:10:08 -0700
Subject: [PATCH 12/24] address comments

---
 .../expressions/filter/AlwaysFalse.java       |  4 +--
 .../expressions/filter/AlwaysTrue.java        |  4 +--
 .../sql/connector/expressions/filter/And.java | 11 ++++---
 .../expressions/filter/EqualNullSafe.java     | 25 +++++++++------
 .../connector/expressions/filter/EqualTo.java | 25 +++++++++------
 .../connector/expressions/filter/Filter.java  |  7 ++--
 .../expressions/filter/GreaterThan.java       | 25 +++++++++------
 .../filter/GreaterThanOrEqual.java            | 26 +++++++++------
 .../sql/connector/expressions/filter/In.java  | 32 ++++++++++++-------
 .../expressions/filter/IsNotNull.java         | 19 +++++++----
 .../connector/expressions/filter/IsNull.java  | 19 +++++++----
 .../expressions/filter/LessThan.java          | 25 +++++++++------
 .../expressions/filter/LessThanOrEqual.java   | 25 +++++++++------
 .../sql/connector/expressions/filter/Not.java |  4 +--
 .../sql/connector/expressions/filter/Or.java  | 11 ++++---
 .../expressions/filter/StringContains.java    | 19 +++++++----
 .../expressions/filter/StringEndsWith.java    | 19 +++++++----
 .../expressions/filter/StringStartsWith.java  | 19 +++++++----
 .../datasources/v2/V2FiltersSuite.scala       | 14 ++++----
 19 files changed, 211 insertions(+), 122 deletions(-)

diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java
index e2ab62748351e..81c35be818723 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java
@@ -18,7 +18,7 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.Expression;
+import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * A filter that always evaluates to `false`.
@@ -32,5 +32,5 @@ public final class AlwaysFalse extends Filter {
   public String toString() { return "FALSE"; }
 
   @Override
-  public Expression[] references() { return EMPTY_REFERENCE; }
+  public NamedReference[] references() { return EMPTY_REFERENCE; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java
index 64cc310693993..53a1718df80be 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java
@@ -18,7 +18,7 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.Expression;
+import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * A filter that always evaluates to `true`.
@@ -32,5 +32,5 @@ public final class AlwaysTrue extends Filter {
   public String toString() { return "TRUE"; }
 
   @Override
-  public Expression[] references() { return EMPTY_REFERENCE; }
+  public NamedReference[] references() { return EMPTY_REFERENCE; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
index d8db6858d92a4..65d932a4d7e7c 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
@@ -18,7 +18,6 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.Expression;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
@@ -40,12 +39,14 @@ public And(Filter left, Filter right) {
   public Filter right() { return right; }
 
   @Override
-  public String toString() { return left.describe() + " AND " + right.describe(); }
+  public String toString() {
+    return String.format("(%s) AND (%s)", left.describe(), right.describe());
+  }
 
   @Override
-  public Expression[] references() {
-    Expression[] refLeft = left.references();
-    Expression[] refRight = right.references();
+  public  NamedReference[] references() {
+    NamedReference[] refLeft = left.references();
+    NamedReference[] refRight = right.references();
     NamedReference[] arr = new NamedReference[refLeft.length + refRight.length];
     System.arraycopy(refLeft, 0, arr, 0, refLeft.length);
     System.arraycopy(refRight, 0, arr, refLeft.length, refRight.length);
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
index c16d99a9ec977..7e43c9dadbc44 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
@@ -19,7 +19,9 @@
 
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.Expression;
+import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.Literal;
+import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * Performs equality comparison, similar to [[EqualTo]]. However, this differs from [[EqualTo]]
@@ -29,21 +31,26 @@
  * @since 3.3.0
  */
 @Evolving
-public final class EqualNullSafe<T> extends Filter {
-  private final Expression column;
-  private final Literal<T> value;
+public final class EqualNullSafe extends Filter {
+  private final Expression expr;
+  private final Literal<?> value;
 
-  public EqualNullSafe(Expression column, Literal<T> value) {
-    this.column = column;
+  public EqualNullSafe(Expression expr, Literal<?> value) {
+    this.expr = expr;
     this.value = value;
   }
 
-  public Expression column() { return column; }
-  public Literal<T> value() { return value; }
+  public Expression expr() { return expr; }
+  public Literal<?> value() { return value; }
 
   @Override
-  public String toString() { return column.describe() + " <=> " + value.describe(); }
+  public String toString() { return expr.describe() + " <=> " + value.describe(); }
 
   @Override
-  public Expression[] references() { return new Expression[] { column }; }
+  public NamedReference[] references() {
+    if (expr instanceof FieldReference){
+      return new NamedReference[] { (FieldReference)expr };
+    }
+    return EMPTY_REFERENCE;
+  }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
index f5cd0c6e4bed0..f9e48634c2c3a 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
@@ -19,7 +19,9 @@
 
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.Expression;
+import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.Literal;
+import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * A filter that evaluates to `true` iff the field evaluates to a value
@@ -28,21 +30,26 @@
  * @since 3.3.0
  */
 @Evolving
-public final class EqualTo<T> extends Filter {
-  private final Expression column;
-  private final Literal<T> value;
+public final class EqualTo extends Filter {
+  private final Expression expr;
+  private final Literal<?> value;
 
-  public EqualTo(Expression column, Literal<T> value) {
-    this.column = column;
+  public EqualTo(Expression expr, Literal<?> value) {
+    this.expr = expr;
     this.value = value;
   }
 
-  public Expression column() { return column; }
-  public Literal<T> value() { return value; }
+  public Expression expr() { return expr; }
+  public Literal<?> value() { return value; }
 
   @Override
-  public String toString() { return column.describe() + " = " + value.describe(); }
+  public String toString() { return expr.describe() + " = " + value.describe(); }
 
   @Override
-  public Expression[] references() { return new Expression[] { column }; }
+  public NamedReference[] references() {
+    if (expr instanceof FieldReference){
+      return new NamedReference[] { (FieldReference)expr };
+    }
+    return EMPTY_REFERENCE;
+  }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Filter.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Filter.java
index a686104017513..75739361ec826 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Filter.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Filter.java
@@ -19,6 +19,7 @@
 
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.Expression;
+import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * Filter base class
@@ -28,14 +29,14 @@
 @Evolving
 public abstract class Filter implements Expression {
 
-  protected static final Expression[] EMPTY_REFERENCE = new Expression[0];
+  protected static final NamedReference[] EMPTY_REFERENCE = new NamedReference[0];
 
   /**
    * Returns list of columns that are referenced by this filter.
    */
-  public abstract Expression[] references();
+  public abstract NamedReference[] references();
 
-  protected Expression[] findReferences(Object filter) {
+  protected NamedReference[] findReferences(Object filter) {
     if (filter instanceof Filter) {
       return ((Filter) filter).references();
     } else {
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
index 6c49a9250db84..83493a2444061 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
@@ -19,7 +19,9 @@
 
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.Expression;
+import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.Literal;
+import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * A filter that evaluates to `true` iff the field evaluates to a value
@@ -28,21 +30,26 @@
  * @since 3.3.0
  */
 @Evolving
-public final class GreaterThan<T> extends Filter {
-  private final Expression column;
-  private final Literal<T> value;
+public final class GreaterThan extends Filter {
+  private final Expression expr;
+  private final Literal<?> value;
 
-  public GreaterThan(Expression column, Literal<T> value) {
-    this.column = column;
+  public GreaterThan(Expression expr, Literal<?> value) {
+    this.expr = expr;
     this.value = value;
   }
 
-  public Expression column() { return column; }
-  public Literal<T> value() { return value; }
+  public Expression column() { return expr; }
+  public Literal<?> value() { return value; }
 
   @Override
-  public String toString() { return column.describe() + " > " + value.describe(); }
+  public String toString() { return expr.describe() + " > " + value.describe(); }
 
   @Override
-  public Expression[] references() { return new Expression[] { column }; }
+  public NamedReference[] references() {
+    if (expr instanceof FieldReference){
+      return new NamedReference[] { (FieldReference)expr };
+    }
+    return EMPTY_REFERENCE;
+  }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
index 513325faeee00..e1ebd6da303b8 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
@@ -19,7 +19,9 @@
 
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.Expression;
+import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.Literal;
+import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * A filter that evaluates to `true` iff the field evaluates to a value
@@ -28,20 +30,26 @@
  * @since 3.3.0
  */
 @Evolving
-public final class GreaterThanOrEqual<T> extends Filter {
-  private final Expression column;
-  private final Literal<T> value;
+public final class GreaterThanOrEqual extends Filter {
+  private final Expression expr;
+  private final Literal<?> value;
 
-  public GreaterThanOrEqual(Expression column, Literal<T> value) {
-    this.column = column;
+  public GreaterThanOrEqual(Expression expr, Literal<?> value) {
+    this.expr = expr;
     this.value = value;
   }
 
-  public Expression column() { return column; }
-  public Literal<T> value() { return value; }
+  public Expression expr() { return expr; }
+  public Literal<?> value() { return value; }
 
   @Override
-  public String toString() { return column.describe() + " >= " + value.describe(); }
+  public String toString() { return expr.describe() + " >= " + value.describe(); }
 
-  public Expression[] references() { return new Expression[] { column }; }
+  @Override
+  public NamedReference[] references() {
+    if (expr instanceof FieldReference){
+      return new NamedReference[] { (FieldReference)expr };
+    }
+    return EMPTY_REFERENCE;
+  }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
index 2289e15f90d52..c25696018be34 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
@@ -23,7 +23,9 @@
 
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.Expression;
+import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.Literal;
+import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * A filter that evaluates to `true` iff the field evaluates to one of the values in the array.
@@ -31,29 +33,29 @@
  * @since 3.3.0
  */
 @Evolving
-public final class In<T> extends Filter {
-  private final Expression column;
-  private final Literal<T>[] values;
+public final class In extends Filter {
+  private final Expression expr;
+  private final Literal<?>[] values;
 
-  public In(Expression column, Literal<T>[] values) {
-    this.column = column;
+  public In(Expression expr, Literal<?>[] values) {
+    this.expr = expr;
     this.values = values;
   }
 
-  public Expression column() { return column; }
-  public Literal<T>[] values() { return values; }
+  public Expression expr() { return expr; }
+  public Literal<?>[] values() { return values; }
 
   @Override
   public boolean equals(Object o) {
     if (this == o) return true;
     if (o == null || getClass() != o.getClass()) return false;
-    In<?> in = (In<?>) o;
-    return Objects.equals(column, in.column) && Arrays.equals(values, in.values);
+    In in = (In) o;
+    return Objects.equals(expr, in.expr) && Arrays.equals(values, in.values);
   }
 
   @Override
   public int hashCode() {
-    int result = Objects.hash(column);
+    int result = Objects.hash(expr);
     result = 31 * result + Arrays.hashCode(values);
     return result;
   }
@@ -61,9 +63,15 @@ public int hashCode() {
   @Override
   public String toString() {
     String res = Arrays.stream(values).map(Literal::describe).collect(Collectors.joining(", "));
-    return column.describe() + " IN (" + res + ")";
+    return expr.describe() + " IN (" + res + ")";
   }
 
   @Override
-  public Expression[] references() { return new Expression[] { column }; }
+  public NamedReference[] references() {
+    if (expr instanceof FieldReference){
+      return new NamedReference[] { (FieldReference)expr };
+    }
+    return EMPTY_REFERENCE;
+  }
+
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
index 5c715e0a6c2eb..86758b72b648d 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
@@ -19,6 +19,8 @@
 
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.Expression;
+import org.apache.spark.sql.connector.expressions.FieldReference;
+import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * A filter that evaluates to `true` iff the field evaluates to a non-null value.
@@ -27,17 +29,22 @@
  */
 @Evolving
 public final class IsNotNull extends Filter {
-  private final Expression column;
+  private final Expression expr;
 
-  public IsNotNull(Expression column) {
-    this.column = column;
+  public IsNotNull(Expression expr) {
+    this.expr = expr;
   }
 
-  public Expression column() { return column; }
+  public Expression column() { return expr; }
 
   @Override
-  public String toString() { return column.describe() + " IS NOT NULL"; }
+  public String toString() { return expr.describe() + " IS NOT NULL"; }
 
   @Override
-  public Expression[] references() { return new Expression[] { column }; }
+  public NamedReference[] references() {
+    if (expr instanceof FieldReference){
+      return new NamedReference[] { (FieldReference)expr };
+    }
+    return EMPTY_REFERENCE;
+  }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
index c8ec0689bd04b..6554334ccd9cf 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
@@ -19,6 +19,8 @@
 
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.Expression;
+import org.apache.spark.sql.connector.expressions.FieldReference;
+import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * A filter that evaluates to `true` iff the field evaluates to null.
@@ -27,17 +29,22 @@
  */
 @Evolving
 public final class IsNull extends Filter {
-  private final Expression column;
+  private final Expression expr;
 
-  public IsNull(Expression column) {
-    this.column = column;
+  public IsNull(Expression expr) {
+    this.expr = expr;
   }
 
-  public Expression column() { return column; }
+  public Expression expr() { return expr; }
 
   @Override
-  public String toString() { return column.describe() + " IS NULL"; }
+  public String toString() { return expr.describe() + " IS NULL"; }
 
   @Override
-  public Expression[] references() { return new Expression[] { column }; }
+  public NamedReference[] references() {
+    if (expr instanceof FieldReference){
+      return new NamedReference[] { (FieldReference)expr };
+    }
+    return EMPTY_REFERENCE;
+  }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
index ea2b1dff0bc6a..22b9fced0238d 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
@@ -19,7 +19,9 @@
 
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.Expression;
+import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.Literal;
+import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * A filter that evaluates to `true` iff the field evaluates to a value
@@ -28,21 +30,26 @@
  * @since 3.3.0
  */
 @Evolving
-public final class LessThan<T> extends Filter {
-  private final Expression column;
-  private final Literal<T> value;
+public final class LessThan extends Filter {
+  private final Expression expr;
+  private final Literal<?> value;
 
-  public LessThan(Expression column, Literal<T> value) {
-    this.column = column;
+  public LessThan(Expression expr, Literal<?> value) {
+    this.expr = expr;
     this.value = value;
   }
 
-  public Expression column() { return column; }
-  public Literal<T> value() { return value; }
+  public Expression expr() { return expr; }
+  public Literal<?> value() { return value; }
 
   @Override
-  public String toString() { return column.describe() + " < " + value.describe(); }
+  public String toString() { return expr.describe() + " < " + value.describe(); }
 
   @Override
-  public Expression[] references() { return new Expression[] { column }; }
+  public NamedReference[] references() {
+    if (expr instanceof FieldReference){
+      return new NamedReference[] { (FieldReference)expr };
+    }
+    return EMPTY_REFERENCE;
+  }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
index 2ae8c4e841b14..c2bb7dbfac7a2 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
@@ -19,7 +19,9 @@
 
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.Expression;
+import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.Literal;
+import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * A filter that evaluates to `true` iff the field evaluates to a value
@@ -28,21 +30,26 @@
  * @since 3.3.0
  */
 @Evolving
-public final class LessThanOrEqual<T> extends Filter {
-  private final Expression column;
-  private final Literal<T> value;
+public final class LessThanOrEqual extends Filter {
+  private final Expression expr;
+  private final Literal<?> value;
 
-  public LessThanOrEqual(Expression column, Literal<T> value) {
-    this.column = column;
+  public LessThanOrEqual(Expression expr, Literal<?> value) {
+    this.expr = expr;
     this.value = value;
   }
 
-  public Expression column() { return column; }
-  public Literal<T> value() { return value; }
+  public Expression expr() { return expr; }
+  public Literal<?> value() { return value; }
 
   @Override
-  public String toString() { return column.describe() + " <= " + value.describe(); }
+  public String toString() { return expr.describe() + " <= " + value.describe(); }
 
   @Override
-  public Expression[] references() { return new Expression[] { column }; }
+  public NamedReference[] references() {
+    if (expr instanceof FieldReference){
+      return new NamedReference[] { (FieldReference)expr };
+    }
+    return EMPTY_REFERENCE;
+  }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java
index db0d2d36f05af..a61235365f452 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java
@@ -18,7 +18,7 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.Expression;
+import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * A filter that evaluates to `true` iff `child` is evaluated to `false`.
@@ -37,5 +37,5 @@ public final class Not extends Filter {
   public String toString() { return "NOT " + child.describe(); }
 
   @Override
-  public Expression[] references() { return child.references(); }
+  public NamedReference[] references() { return child.references(); }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
index 54c0969df58ce..c5b7cb139a550 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
@@ -18,7 +18,6 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.Expression;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
@@ -40,12 +39,14 @@ public Or(Filter left, Filter right) {
   public Filter right() { return right; }
 
   @Override
-  public String toString() { return left.describe() + " OR " + right.describe(); }
+  public String toString() {
+    return String.format("(%s) AND (%s)", left.describe(), right.describe());
+  }
 
   @Override
-  public Expression[] references() {
-    Expression[] refLeft = left.references();
-    Expression[] refRight = right.references();
+  public  NamedReference[] references() {
+    NamedReference[] refLeft = left.references();
+    NamedReference[] refRight = right.references();
     NamedReference[] arr = new NamedReference[refLeft.length + refRight.length];
     System.arraycopy(refLeft, 0, arr, 0, refLeft.length);
     System.arraycopy(refRight, 0, arr, refLeft.length, refRight.length);
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
index 5534dec01f7de..14097e535d610 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
@@ -19,6 +19,8 @@
 
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.Expression;
+import org.apache.spark.sql.connector.expressions.FieldReference;
+import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * A filter that evaluates to `true` iff the field evaluates to
@@ -28,20 +30,25 @@
  */
 @Evolving
 public final class StringContains extends Filter {
-  private final Expression column;
+  private final Expression expr;
   private final String value;
 
-  public StringContains(Expression column, String value) {
-    this.column = column;
+  public StringContains(Expression expr, String value) {
+    this.expr = expr;
     this.value = value;
   }
 
-  public Expression column() { return column; }
+  public Expression expr() { return expr; }
   public String value() { return value; }
 
   @Override
-  public String toString() { return column.describe() + " CONTAINS " + value; }
+  public String toString() { return "STRING_CONTAINS(" + expr.describe() + ", " + value + ")"; }
 
   @Override
-  public Expression[] references() { return new Expression[] { column }; }
+  public NamedReference[] references() {
+    if (expr instanceof FieldReference){
+      return new NamedReference[] { (FieldReference)expr };
+    }
+    return EMPTY_REFERENCE;
+  }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
index 01ac5dc00cded..39acdcc829d9a 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
@@ -19,6 +19,8 @@
 
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.Expression;
+import org.apache.spark.sql.connector.expressions.FieldReference;
+import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * A filter that evaluates to `true` iff the field evaluates to
@@ -28,20 +30,25 @@
  */
 @Evolving
 public final class StringEndsWith extends Filter {
-  private final Expression column;
+  private final Expression expr;
   private final String value;
 
-  public StringEndsWith(Expression column, String value) {
-    this.column = column;
+  public StringEndsWith(Expression expr, String value) {
+    this.expr = expr;
     this.value = value;
   }
 
-  public Expression column() { return column; }
+  public Expression expr() { return expr; }
   public String value() { return value; }
 
   @Override
-  public String toString() { return column.describe() + " ENDS WITH " + value; }
+  public String toString() { return "STRING_ENDS_WITH(" + expr.describe() + ", " + value + ")"; }
 
   @Override
-  public Expression[] references() { return new Expression[] { column }; }
+  public NamedReference[] references() {
+    if (expr instanceof FieldReference){
+      return new NamedReference[] { (FieldReference)expr };
+    }
+    return EMPTY_REFERENCE;
+  }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
index 86b8c6b9b49cd..67537356eccb8 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
@@ -19,6 +19,8 @@
 
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.Expression;
+import org.apache.spark.sql.connector.expressions.FieldReference;
+import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * A filter that evaluates to `true` iff the field evaluates to
@@ -28,20 +30,25 @@
  */
 @Evolving
 public final class StringStartsWith extends Filter {
-  private final Expression column;
+  private final Expression expr;
   private final String value;
 
-  public StringStartsWith(Expression column, String value) {
-    this.column = column;
+  public StringStartsWith(Expression expr, String value) {
+    this.expr = expr;
     this.value = value;
   }
 
-  public Expression column() { return column; }
+  public Expression expr() { return expr; }
   public String value() { return value; }
 
   @Override
-  public String toString() { return column.describe() + " STARTS WITH " + value; }
+  public String toString() { return "STRING_STARTS_WITH(" + expr.describe() + ", " + value + ")"; }
 
   @Override
-  public Expression[] references() { return new Expression[] { column }; }
+  public NamedReference[] references() {
+    if (expr instanceof FieldReference){
+      return new NamedReference[] { (FieldReference)expr };
+    }
+    return EMPTY_REFERENCE;
+  }
 }
diff --git a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
index 318b88cbebbe1..57ebf371726cc 100644
--- a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
+++ b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
@@ -76,10 +76,10 @@ class FiltersV2Suite extends SparkFunSuite {
   }
 
   test("In") {
-    val filter1 = new In[Integer](ref("a"),
+    val filter1 = new In(ref("a"),
       Array(LiteralValue(1, IntegerType), LiteralValue(2, IntegerType),
         LiteralValue(3, IntegerType), LiteralValue(4, IntegerType)))
-    val filter2 = new In[Integer](ref("a"),
+    val filter2 = new In(ref("a"),
       Array(LiteralValue(1, IntegerType), LiteralValue(2, IntegerType),
         LiteralValue(3, IntegerType), LiteralValue(4, IntegerType)))
     assert(filter1.equals(filter2))
@@ -109,32 +109,32 @@ class FiltersV2Suite extends SparkFunSuite {
     val filter = new And(new EqualTo(ref("a"), LiteralValue(1, IntegerType)),
       new EqualTo(ref("b"), LiteralValue(1, IntegerType)))
     assert(filter.references.map(_.describe()).toSeq == Seq("a", "b"))
-    assert(filter.describe.equals("a = 1 AND b = 1"))
+    assert(filter.describe.equals("(a = 1) AND (b = 1)"))
   }
 
   test("Or") {
     val filter = new Or(new EqualTo(ref("a"), LiteralValue(1, IntegerType)),
       new EqualTo(ref("b"), LiteralValue(1, IntegerType)))
     assert(filter.references.map(_.describe()).toSeq == Seq("a", "b"))
-    assert(filter.describe.equals("a = 1 OR b = 1"))
+    assert(filter.describe.equals("(a = 1) AND (b = 1)"))
   }
 
   test("StringStartsWith") {
     val filter = new StringStartsWith(ref("a"), "str")
     assert(filter.references.map(_.describe()).toSeq == Seq("a"))
-    assert(filter.describe.equals("a STARTS WITH str"))
+    assert(filter.describe.equals("STRING_STARTS_WITH(a, str)"))
   }
 
   test("StringEndsWith") {
     val filter = new StringEndsWith(ref("a"), "str")
     assert(filter.references.map(_.describe()).toSeq == Seq("a"))
-    assert(filter.describe.equals("a ENDS WITH str"))
+    assert(filter.describe.equals("STRING_ENDS_WITH(a, str)"))
   }
 
   test("StringContains") {
     val filter = new StringContains(ref("a"), "str")
     assert(filter.references.map(_.describe()).toSeq == Seq("a"))
-    assert(filter.describe.equals("a CONTAINS str"))
+    assert(filter.describe.equals("STRING_CONTAINS(a, str)"))
   }
 }
 

From d1b4ec14034341a6191384a206146640a27e5717 Mon Sep 17 00:00:00 2001
From: Huaxin Gao <huaxin_gao@apple.com>
Date: Fri, 3 Sep 2021 18:18:58 -0700
Subject: [PATCH 13/24] remove extra white space and add interface
 FilterColExpr

---
 .../sql/connector/expressions/filter/And.java |  2 +-
 .../expressions/filter/EqualNullSafe.java     | 15 +++-----
 .../connector/expressions/filter/EqualTo.java | 15 +++-----
 .../expressions/filter/FilterColExpr.java     | 35 +++++++++++++++++++
 .../expressions/filter/GreaterThan.java       | 15 +++-----
 .../filter/GreaterThanOrEqual.java            | 15 +++-----
 .../sql/connector/expressions/filter/In.java  | 16 +++------
 .../expressions/filter/IsNotNull.java         | 15 +++-----
 .../connector/expressions/filter/IsNull.java  | 15 +++-----
 .../expressions/filter/LessThan.java          | 15 +++-----
 .../expressions/filter/LessThanOrEqual.java   | 15 +++-----
 .../sql/connector/expressions/filter/Or.java  |  2 +-
 .../expressions/filter/StringContains.java    | 15 +++-----
 .../expressions/filter/StringEndsWith.java    | 15 +++-----
 .../expressions/filter/StringStartsWith.java  | 15 +++-----
 .../connector/expressions/expressions.scala   |  5 ++-
 16 files changed, 89 insertions(+), 136 deletions(-)
 create mode 100644 sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/FilterColExpr.java

diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
index 65d932a4d7e7c..d7887ae7ad3c8 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
@@ -44,7 +44,7 @@ public String toString() {
   }
 
   @Override
-  public  NamedReference[] references() {
+  public NamedReference[] references() {
     NamedReference[] refLeft = left.references();
     NamedReference[] refRight = right.references();
     NamedReference[] arr = new NamedReference[refLeft.length + refRight.length];
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
index 7e43c9dadbc44..b9fbfcfb2db70 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
@@ -18,8 +18,6 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.Expression;
-import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
@@ -32,25 +30,20 @@
  */
 @Evolving
 public final class EqualNullSafe extends Filter {
-  private final Expression expr;
+  private final FilterColExpr expr;
   private final Literal<?> value;
 
-  public EqualNullSafe(Expression expr, Literal<?> value) {
+  public EqualNullSafe(FilterColExpr expr, Literal<?> value) {
     this.expr = expr;
     this.value = value;
   }
 
-  public Expression expr() { return expr; }
+  public FilterColExpr expr() { return expr; }
   public Literal<?> value() { return value; }
 
   @Override
   public String toString() { return expr.describe() + " <=> " + value.describe(); }
 
   @Override
-  public NamedReference[] references() {
-    if (expr instanceof FieldReference){
-      return new NamedReference[] { (FieldReference)expr };
-    }
-    return EMPTY_REFERENCE;
-  }
+  public NamedReference[] references() { return expr.references(); }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
index f9e48634c2c3a..b5247442b12ea 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
@@ -18,8 +18,6 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.Expression;
-import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
@@ -31,25 +29,20 @@
  */
 @Evolving
 public final class EqualTo extends Filter {
-  private final Expression expr;
+  private final FilterColExpr expr;
   private final Literal<?> value;
 
-  public EqualTo(Expression expr, Literal<?> value) {
+  public EqualTo(FilterColExpr expr, Literal<?> value) {
     this.expr = expr;
     this.value = value;
   }
 
-  public Expression expr() { return expr; }
+  public FilterColExpr expr() { return expr; }
   public Literal<?> value() { return value; }
 
   @Override
   public String toString() { return expr.describe() + " = " + value.describe(); }
 
   @Override
-  public NamedReference[] references() {
-    if (expr instanceof FieldReference){
-      return new NamedReference[] { (FieldReference)expr };
-    }
-    return EMPTY_REFERENCE;
-  }
+  public NamedReference[] references() { return expr.references(); }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/FilterColExpr.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/FilterColExpr.java
new file mode 100644
index 0000000000000..42dc88cfcb652
--- /dev/null
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/FilterColExpr.java
@@ -0,0 +1,35 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.spark.sql.connector.expressions.filter;
+
+import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.NamedReference;
+
+/**
+ * Base class of the Filter Column.
+ *
+ * @since 3.3.0
+ */
+@Evolving
+public interface FilterColExpr extends NamedReference {
+
+    /**
+     * Returns all field references of this FilterColExpr.
+     */
+    NamedReference[] references();
+}
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
index 83493a2444061..0e57dab12a4e9 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
@@ -18,8 +18,6 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.Expression;
-import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
@@ -31,25 +29,20 @@
  */
 @Evolving
 public final class GreaterThan extends Filter {
-  private final Expression expr;
+  private final FilterColExpr expr;
   private final Literal<?> value;
 
-  public GreaterThan(Expression expr, Literal<?> value) {
+  public GreaterThan(FilterColExpr expr, Literal<?> value) {
     this.expr = expr;
     this.value = value;
   }
 
-  public Expression column() { return expr; }
+  public FilterColExpr expr() { return expr; }
   public Literal<?> value() { return value; }
 
   @Override
   public String toString() { return expr.describe() + " > " + value.describe(); }
 
   @Override
-  public NamedReference[] references() {
-    if (expr instanceof FieldReference){
-      return new NamedReference[] { (FieldReference)expr };
-    }
-    return EMPTY_REFERENCE;
-  }
+  public NamedReference[] references() { return expr.references(); }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
index e1ebd6da303b8..7e235f4cebef2 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
@@ -18,8 +18,6 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.Expression;
-import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
@@ -31,25 +29,20 @@
  */
 @Evolving
 public final class GreaterThanOrEqual extends Filter {
-  private final Expression expr;
+  private final FilterColExpr expr;
   private final Literal<?> value;
 
-  public GreaterThanOrEqual(Expression expr, Literal<?> value) {
+  public GreaterThanOrEqual(FilterColExpr expr, Literal<?> value) {
     this.expr = expr;
     this.value = value;
   }
 
-  public Expression expr() { return expr; }
+  public FilterColExpr expr() { return expr; }
   public Literal<?> value() { return value; }
 
   @Override
   public String toString() { return expr.describe() + " >= " + value.describe(); }
 
   @Override
-  public NamedReference[] references() {
-    if (expr instanceof FieldReference){
-      return new NamedReference[] { (FieldReference)expr };
-    }
-    return EMPTY_REFERENCE;
-  }
+  public NamedReference[] references() { return expr.references(); }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
index c25696018be34..ca0350b91331e 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
@@ -22,8 +22,6 @@
 import java.util.stream.Collectors;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.Expression;
-import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
@@ -34,15 +32,15 @@
  */
 @Evolving
 public final class In extends Filter {
-  private final Expression expr;
+  private final FilterColExpr expr;
   private final Literal<?>[] values;
 
-  public In(Expression expr, Literal<?>[] values) {
+  public In(FilterColExpr expr, Literal<?>[] values) {
     this.expr = expr;
     this.values = values;
   }
 
-  public Expression expr() { return expr; }
+  public FilterColExpr expr() { return expr; }
   public Literal<?>[] values() { return values; }
 
   @Override
@@ -67,11 +65,5 @@ public String toString() {
   }
 
   @Override
-  public NamedReference[] references() {
-    if (expr instanceof FieldReference){
-      return new NamedReference[] { (FieldReference)expr };
-    }
-    return EMPTY_REFERENCE;
-  }
-
+  public NamedReference[] references() { return expr.references(); }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
index 86758b72b648d..2b1e46f410fb1 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
@@ -18,8 +18,6 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.Expression;
-import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
@@ -29,22 +27,17 @@
  */
 @Evolving
 public final class IsNotNull extends Filter {
-  private final Expression expr;
+  private final FilterColExpr expr;
 
-  public IsNotNull(Expression expr) {
+  public IsNotNull(FilterColExpr expr) {
     this.expr = expr;
   }
 
-  public Expression column() { return expr; }
+  public FilterColExpr expr() { return expr; }
 
   @Override
   public String toString() { return expr.describe() + " IS NOT NULL"; }
 
   @Override
-  public NamedReference[] references() {
-    if (expr instanceof FieldReference){
-      return new NamedReference[] { (FieldReference)expr };
-    }
-    return EMPTY_REFERENCE;
-  }
+  public NamedReference[] references() { return expr.references(); }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
index 6554334ccd9cf..ced21aec8a402 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
@@ -18,8 +18,6 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.Expression;
-import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
@@ -29,22 +27,17 @@
  */
 @Evolving
 public final class IsNull extends Filter {
-  private final Expression expr;
+  private final FilterColExpr expr;
 
-  public IsNull(Expression expr) {
+  public IsNull(FilterColExpr expr) {
     this.expr = expr;
   }
 
-  public Expression expr() { return expr; }
+  public FilterColExpr expr() { return expr; }
 
   @Override
   public String toString() { return expr.describe() + " IS NULL"; }
 
   @Override
-  public NamedReference[] references() {
-    if (expr instanceof FieldReference){
-      return new NamedReference[] { (FieldReference)expr };
-    }
-    return EMPTY_REFERENCE;
-  }
+  public NamedReference[] references() { return expr.references(); }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
index 22b9fced0238d..79a28add4ea18 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
@@ -18,8 +18,6 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.Expression;
-import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
@@ -31,25 +29,20 @@
  */
 @Evolving
 public final class LessThan extends Filter {
-  private final Expression expr;
+  private final FilterColExpr expr;
   private final Literal<?> value;
 
-  public LessThan(Expression expr, Literal<?> value) {
+  public LessThan(FilterColExpr expr, Literal<?> value) {
     this.expr = expr;
     this.value = value;
   }
 
-  public Expression expr() { return expr; }
+  public FilterColExpr expr() { return expr; }
   public Literal<?> value() { return value; }
 
   @Override
   public String toString() { return expr.describe() + " < " + value.describe(); }
 
   @Override
-  public NamedReference[] references() {
-    if (expr instanceof FieldReference){
-      return new NamedReference[] { (FieldReference)expr };
-    }
-    return EMPTY_REFERENCE;
-  }
+  public NamedReference[] references() { return expr.references(); }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
index c2bb7dbfac7a2..aff7678d9db4c 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
@@ -18,8 +18,6 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.Expression;
-import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
@@ -31,25 +29,20 @@
  */
 @Evolving
 public final class LessThanOrEqual extends Filter {
-  private final Expression expr;
+  private final FilterColExpr expr;
   private final Literal<?> value;
 
-  public LessThanOrEqual(Expression expr, Literal<?> value) {
+  public LessThanOrEqual(FilterColExpr expr, Literal<?> value) {
     this.expr = expr;
     this.value = value;
   }
 
-  public Expression expr() { return expr; }
+  public FilterColExpr expr() { return expr; }
   public Literal<?> value() { return value; }
 
   @Override
   public String toString() { return expr.describe() + " <= " + value.describe(); }
 
   @Override
-  public NamedReference[] references() {
-    if (expr instanceof FieldReference){
-      return new NamedReference[] { (FieldReference)expr };
-    }
-    return EMPTY_REFERENCE;
-  }
+  public NamedReference[] references() { return expr.references(); }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
index c5b7cb139a550..6e12e3882f7f9 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
@@ -44,7 +44,7 @@ public String toString() {
   }
 
   @Override
-  public  NamedReference[] references() {
+  public NamedReference[] references() {
     NamedReference[] refLeft = left.references();
     NamedReference[] refRight = right.references();
     NamedReference[] arr = new NamedReference[refLeft.length + refRight.length];
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
index 14097e535d610..5254eb999107b 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
@@ -18,8 +18,6 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.Expression;
-import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
@@ -30,25 +28,20 @@
  */
 @Evolving
 public final class StringContains extends Filter {
-  private final Expression expr;
+  private final FilterColExpr expr;
   private final String value;
 
-  public StringContains(Expression expr, String value) {
+  public StringContains(FilterColExpr expr, String value) {
     this.expr = expr;
     this.value = value;
   }
 
-  public Expression expr() { return expr; }
+  public FilterColExpr expr() { return expr; }
   public String value() { return value; }
 
   @Override
   public String toString() { return "STRING_CONTAINS(" + expr.describe() + ", " + value + ")"; }
 
   @Override
-  public NamedReference[] references() {
-    if (expr instanceof FieldReference){
-      return new NamedReference[] { (FieldReference)expr };
-    }
-    return EMPTY_REFERENCE;
-  }
+  public NamedReference[] references() { return expr.references(); }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
index 39acdcc829d9a..c54cf1c062434 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
@@ -18,8 +18,6 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.Expression;
-import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
@@ -30,25 +28,20 @@
  */
 @Evolving
 public final class StringEndsWith extends Filter {
-  private final Expression expr;
+  private final FilterColExpr expr;
   private final String value;
 
-  public StringEndsWith(Expression expr, String value) {
+  public StringEndsWith(FilterColExpr expr, String value) {
     this.expr = expr;
     this.value = value;
   }
 
-  public Expression expr() { return expr; }
+  public FilterColExpr expr() { return expr; }
   public String value() { return value; }
 
   @Override
   public String toString() { return "STRING_ENDS_WITH(" + expr.describe() + ", " + value + ")"; }
 
   @Override
-  public NamedReference[] references() {
-    if (expr instanceof FieldReference){
-      return new NamedReference[] { (FieldReference)expr };
-    }
-    return EMPTY_REFERENCE;
-  }
+  public NamedReference[] references() { return expr.references(); }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
index 67537356eccb8..3db54ea50fd70 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
@@ -18,8 +18,6 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.Expression;
-import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
@@ -30,25 +28,20 @@
  */
 @Evolving
 public final class StringStartsWith extends Filter {
-  private final Expression expr;
+  private final FilterColExpr expr;
   private final String value;
 
-  public StringStartsWith(Expression expr, String value) {
+  public StringStartsWith(FilterColExpr expr, String value) {
     this.expr = expr;
     this.value = value;
   }
 
-  public Expression expr() { return expr; }
+  public FilterColExpr expr() { return expr; }
   public String value() { return value; }
 
   @Override
   public String toString() { return "STRING_STARTS_WITH(" + expr.describe() + ", " + value + ")"; }
 
   @Override
-  public NamedReference[] references() {
-    if (expr instanceof FieldReference){
-      return new NamedReference[] { (FieldReference)expr };
-    }
-    return EMPTY_REFERENCE;
-  }
+  public NamedReference[] references() { return expr.references(); }
 }
diff --git a/sql/catalyst/src/main/scala/org/apache/spark/sql/connector/expressions/expressions.scala b/sql/catalyst/src/main/scala/org/apache/spark/sql/connector/expressions/expressions.scala
index 2863d94d198b2..a230e1c7dcb30 100644
--- a/sql/catalyst/src/main/scala/org/apache/spark/sql/connector/expressions/expressions.scala
+++ b/sql/catalyst/src/main/scala/org/apache/spark/sql/connector/expressions/expressions.scala
@@ -19,6 +19,7 @@ package org.apache.spark.sql.connector.expressions
 
 import org.apache.spark.sql.catalyst
 import org.apache.spark.sql.catalyst.parser.CatalystSqlParser
+import org.apache.spark.sql.connector.expressions.filter.FilterColExpr
 import org.apache.spark.sql.types.{DataType, IntegerType, StringType}
 
 /**
@@ -328,11 +329,13 @@ private[sql] final case class LiteralValue[T](value: T, dataType: DataType) exte
   override def toString: String = describe
 }
 
-private[sql] final case class FieldReference(parts: Seq[String]) extends NamedReference {
+private[sql] final case class FieldReference(parts: Seq[String])
+  extends NamedReference with FilterColExpr {
   import org.apache.spark.sql.connector.catalog.CatalogV2Implicits.MultipartIdentifierHelper
   override def fieldNames: Array[String] = parts.toArray
   override def describe: String = parts.quoted
   override def toString: String = describe
+  override def references(): Array[NamedReference] = Array[NamedReference](this)
 }
 
 private[sql] object FieldReference {

From ed0b009e973789517a9cce7db581617cf577a38d Mon Sep 17 00:00:00 2001
From: Huaxin Gao <huaxin_gao@apple.com>
Date: Mon, 6 Sep 2021 14:40:18 -0700
Subject: [PATCH 14/24] remove subtype FilterColExpr and use FieldReference for
 left side of Filter

---
 .../expressions/filter/EqualNullSafe.java     |  7 ++--
 .../connector/expressions/filter/EqualTo.java |  7 ++--
 .../expressions/filter/FilterColExpr.java     | 35 -------------------
 .../expressions/filter/GreaterThan.java       |  7 ++--
 .../filter/GreaterThanOrEqual.java            |  7 ++--
 .../sql/connector/expressions/filter/In.java  |  7 ++--
 .../expressions/filter/IsNotNull.java         |  7 ++--
 .../connector/expressions/filter/IsNull.java  |  7 ++--
 .../expressions/filter/LessThan.java          |  7 ++--
 .../expressions/filter/LessThanOrEqual.java   |  7 ++--
 .../expressions/filter/StringContains.java    |  7 ++--
 .../expressions/filter/StringEndsWith.java    |  7 ++--
 .../expressions/filter/StringStartsWith.java  |  7 ++--
 .../connector/expressions/expressions.scala   | 10 +++---
 14 files changed, 54 insertions(+), 75 deletions(-)
 delete mode 100644 sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/FilterColExpr.java

diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
index b9fbfcfb2db70..6918a640f5b6c 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
@@ -18,6 +18,7 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
@@ -30,15 +31,15 @@
  */
 @Evolving
 public final class EqualNullSafe extends Filter {
-  private final FilterColExpr expr;
+  private final FieldReference expr;
   private final Literal<?> value;
 
-  public EqualNullSafe(FilterColExpr expr, Literal<?> value) {
+  public EqualNullSafe(FieldReference expr, Literal<?> value) {
     this.expr = expr;
     this.value = value;
   }
 
-  public FilterColExpr expr() { return expr; }
+  public FieldReference expr() { return expr; }
   public Literal<?> value() { return value; }
 
   @Override
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
index b5247442b12ea..802bd153dac1f 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
@@ -18,6 +18,7 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
@@ -29,15 +30,15 @@
  */
 @Evolving
 public final class EqualTo extends Filter {
-  private final FilterColExpr expr;
+  private final FieldReference expr;
   private final Literal<?> value;
 
-  public EqualTo(FilterColExpr expr, Literal<?> value) {
+  public EqualTo( FieldReference expr, Literal<?> value) {
     this.expr = expr;
     this.value = value;
   }
 
-  public FilterColExpr expr() { return expr; }
+  public FieldReference expr() { return expr; }
   public Literal<?> value() { return value; }
 
   @Override
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/FilterColExpr.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/FilterColExpr.java
deleted file mode 100644
index 42dc88cfcb652..0000000000000
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/FilterColExpr.java
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.spark.sql.connector.expressions.filter;
-
-import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.NamedReference;
-
-/**
- * Base class of the Filter Column.
- *
- * @since 3.3.0
- */
-@Evolving
-public interface FilterColExpr extends NamedReference {
-
-    /**
-     * Returns all field references of this FilterColExpr.
-     */
-    NamedReference[] references();
-}
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
index 0e57dab12a4e9..3ba10719d2757 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
@@ -18,6 +18,7 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
@@ -29,15 +30,15 @@
  */
 @Evolving
 public final class GreaterThan extends Filter {
-  private final FilterColExpr expr;
+  private final FieldReference expr;
   private final Literal<?> value;
 
-  public GreaterThan(FilterColExpr expr, Literal<?> value) {
+  public GreaterThan( FieldReference expr, Literal<?> value) {
     this.expr = expr;
     this.value = value;
   }
 
-  public FilterColExpr expr() { return expr; }
+  public  FieldReference expr() { return expr; }
   public Literal<?> value() { return value; }
 
   @Override
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
index 7e235f4cebef2..77a785eb093a6 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
@@ -18,6 +18,7 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
@@ -29,15 +30,15 @@
  */
 @Evolving
 public final class GreaterThanOrEqual extends Filter {
-  private final FilterColExpr expr;
+  private final FieldReference expr;
   private final Literal<?> value;
 
-  public GreaterThanOrEqual(FilterColExpr expr, Literal<?> value) {
+  public GreaterThanOrEqual( FieldReference expr, Literal<?> value) {
     this.expr = expr;
     this.value = value;
   }
 
-  public FilterColExpr expr() { return expr; }
+  public  FieldReference expr() { return expr; }
   public Literal<?> value() { return value; }
 
   @Override
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
index ca0350b91331e..a23d9217b208f 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
@@ -22,6 +22,7 @@
 import java.util.stream.Collectors;
 
 import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
@@ -32,15 +33,15 @@
  */
 @Evolving
 public final class In extends Filter {
-  private final FilterColExpr expr;
+  private final FieldReference expr;
   private final Literal<?>[] values;
 
-  public In(FilterColExpr expr, Literal<?>[] values) {
+  public In( FieldReference expr, Literal<?>[] values) {
     this.expr = expr;
     this.values = values;
   }
 
-  public FilterColExpr expr() { return expr; }
+  public  FieldReference expr() { return expr; }
   public Literal<?>[] values() { return values; }
 
   @Override
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
index 2b1e46f410fb1..17b1b10fef550 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
@@ -18,6 +18,7 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
@@ -27,13 +28,13 @@
  */
 @Evolving
 public final class IsNotNull extends Filter {
-  private final FilterColExpr expr;
+  private final FieldReference expr;
 
-  public IsNotNull(FilterColExpr expr) {
+  public IsNotNull( FieldReference expr) {
     this.expr = expr;
   }
 
-  public FilterColExpr expr() { return expr; }
+  public  FieldReference expr() { return expr; }
 
   @Override
   public String toString() { return expr.describe() + " IS NOT NULL"; }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
index ced21aec8a402..a0788fcb43d69 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
@@ -18,6 +18,7 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
@@ -27,13 +28,13 @@
  */
 @Evolving
 public final class IsNull extends Filter {
-  private final FilterColExpr expr;
+  private final FieldReference expr;
 
-  public IsNull(FilterColExpr expr) {
+  public IsNull( FieldReference expr) {
     this.expr = expr;
   }
 
-  public FilterColExpr expr() { return expr; }
+  public  FieldReference expr() { return expr; }
 
   @Override
   public String toString() { return expr.describe() + " IS NULL"; }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
index 79a28add4ea18..770847159e38d 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
@@ -18,6 +18,7 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
@@ -29,15 +30,15 @@
  */
 @Evolving
 public final class LessThan extends Filter {
-  private final FilterColExpr expr;
+  private final FieldReference expr;
   private final Literal<?> value;
 
-  public LessThan(FilterColExpr expr, Literal<?> value) {
+  public LessThan( FieldReference expr, Literal<?> value) {
     this.expr = expr;
     this.value = value;
   }
 
-  public FilterColExpr expr() { return expr; }
+  public  FieldReference expr() { return expr; }
   public Literal<?> value() { return value; }
 
   @Override
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
index aff7678d9db4c..fe79b6151899d 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
@@ -18,6 +18,7 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
@@ -29,15 +30,15 @@
  */
 @Evolving
 public final class LessThanOrEqual extends Filter {
-  private final FilterColExpr expr;
+  private final FieldReference expr;
   private final Literal<?> value;
 
-  public LessThanOrEqual(FilterColExpr expr, Literal<?> value) {
+  public LessThanOrEqual( FieldReference expr, Literal<?> value) {
     this.expr = expr;
     this.value = value;
   }
 
-  public FilterColExpr expr() { return expr; }
+  public  FieldReference expr() { return expr; }
   public Literal<?> value() { return value; }
 
   @Override
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
index 5254eb999107b..5768d9f278cdc 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
@@ -18,6 +18,7 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
@@ -28,15 +29,15 @@
  */
 @Evolving
 public final class StringContains extends Filter {
-  private final FilterColExpr expr;
+  private final FieldReference expr;
   private final String value;
 
-  public StringContains(FilterColExpr expr, String value) {
+  public StringContains( FieldReference expr, String value) {
     this.expr = expr;
     this.value = value;
   }
 
-  public FilterColExpr expr() { return expr; }
+  public  FieldReference expr() { return expr; }
   public String value() { return value; }
 
   @Override
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
index c54cf1c062434..3aba78affe021 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
@@ -18,6 +18,7 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
@@ -28,15 +29,15 @@
  */
 @Evolving
 public final class StringEndsWith extends Filter {
-  private final FilterColExpr expr;
+  private final FieldReference expr;
   private final String value;
 
-  public StringEndsWith(FilterColExpr expr, String value) {
+  public StringEndsWith( FieldReference expr, String value) {
     this.expr = expr;
     this.value = value;
   }
 
-  public FilterColExpr expr() { return expr; }
+  public  FieldReference expr() { return expr; }
   public String value() { return value; }
 
   @Override
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
index 3db54ea50fd70..73e9823bfc33e 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
@@ -18,6 +18,7 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
@@ -28,15 +29,15 @@
  */
 @Evolving
 public final class StringStartsWith extends Filter {
-  private final FilterColExpr expr;
+  private final FieldReference expr;
   private final String value;
 
-  public StringStartsWith(FilterColExpr expr, String value) {
+  public StringStartsWith( FieldReference expr, String value) {
     this.expr = expr;
     this.value = value;
   }
 
-  public FilterColExpr expr() { return expr; }
+  public  FieldReference expr() { return expr; }
   public String value() { return value; }
 
   @Override
diff --git a/sql/catalyst/src/main/scala/org/apache/spark/sql/connector/expressions/expressions.scala b/sql/catalyst/src/main/scala/org/apache/spark/sql/connector/expressions/expressions.scala
index a230e1c7dcb30..34879c152b7d0 100644
--- a/sql/catalyst/src/main/scala/org/apache/spark/sql/connector/expressions/expressions.scala
+++ b/sql/catalyst/src/main/scala/org/apache/spark/sql/connector/expressions/expressions.scala
@@ -19,7 +19,6 @@ package org.apache.spark.sql.connector.expressions
 
 import org.apache.spark.sql.catalyst
 import org.apache.spark.sql.catalyst.parser.CatalystSqlParser
-import org.apache.spark.sql.connector.expressions.filter.FilterColExpr
 import org.apache.spark.sql.types.{DataType, IntegerType, StringType}
 
 /**
@@ -329,13 +328,16 @@ private[sql] final case class LiteralValue[T](value: T, dataType: DataType) exte
   override def toString: String = describe
 }
 
-private[sql] final case class FieldReference(parts: Seq[String])
-  extends NamedReference with FilterColExpr {
+private[sql] final case class FieldReference(parts: Seq[String]) extends NamedReference {
   import org.apache.spark.sql.connector.catalog.CatalogV2Implicits.MultipartIdentifierHelper
   override def fieldNames: Array[String] = parts.toArray
   override def describe: String = parts.quoted
   override def toString: String = describe
-  override def references(): Array[NamedReference] = Array[NamedReference](this)
+
+  /**
+   * Returns list of NamedReference that are referenced by this FieldReference.
+   */
+  def references(): Array[NamedReference] = Array[NamedReference](this)
 }
 
 private[sql] object FieldReference {

From 14ac369b4c08dc92f7a6aab9e50b26ff2eb917fb Mon Sep 17 00:00:00 2001
From: Huaxin Gao <huaxin_gao@apple.com>
Date: Tue, 7 Sep 2021 09:32:35 -0700
Subject: [PATCH 15/24] address comments

---
 .../expressions/filter/EqualNullSafe.java     | 13 ++++++-------
 .../connector/expressions/filter/EqualTo.java | 15 +++++++--------
 .../connector/expressions/filter/Filter.java  |  8 --------
 .../expressions/filter/GreaterThan.java       | 15 +++++++--------
 .../filter/GreaterThanOrEqual.java            | 15 +++++++--------
 .../sql/connector/expressions/filter/In.java  | 19 +++++++++----------
 .../expressions/filter/IsNotNull.java         | 15 +++++++--------
 .../connector/expressions/filter/IsNull.java  | 15 +++++++--------
 .../expressions/filter/LessThan.java          | 15 +++++++--------
 .../expressions/filter/LessThanOrEqual.java   | 15 +++++++--------
 .../expressions/filter/StringContains.java    | 15 +++++++--------
 .../expressions/filter/StringEndsWith.java    | 15 +++++++--------
 .../expressions/filter/StringStartsWith.java  | 15 +++++++--------
 .../connector/expressions/expressions.scala   |  5 -----
 14 files changed, 85 insertions(+), 110 deletions(-)

diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
index 6918a640f5b6c..cff1f04df684c 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
@@ -18,7 +18,6 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
@@ -31,20 +30,20 @@
  */
 @Evolving
 public final class EqualNullSafe extends Filter {
-  private final FieldReference expr;
+  private final NamedReference column;
   private final Literal<?> value;
 
-  public EqualNullSafe(FieldReference expr, Literal<?> value) {
-    this.expr = expr;
+  public EqualNullSafe(NamedReference column, Literal<?> value) {
+    this.column = column;
     this.value = value;
   }
 
-  public FieldReference expr() { return expr; }
+  public NamedReference column() { return column; }
   public Literal<?> value() { return value; }
 
   @Override
-  public String toString() { return expr.describe() + " <=> " + value.describe(); }
+  public String toString() { return column.describe() + " <=> " + value.describe(); }
 
   @Override
-  public NamedReference[] references() { return expr.references(); }
+  public NamedReference[] references() { return new NamedReference[]{column}; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
index 802bd153dac1f..639837a668235 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
@@ -18,32 +18,31 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
- * A filter that evaluates to `true` iff the field evaluates to a value
+ * A filter that evaluates to `true` iff the column evaluates to a value
  * equal to `value`.
  *
  * @since 3.3.0
  */
 @Evolving
 public final class EqualTo extends Filter {
-  private final FieldReference expr;
+  private final NamedReference column;
   private final Literal<?> value;
 
-  public EqualTo( FieldReference expr, Literal<?> value) {
-    this.expr = expr;
+  public EqualTo(NamedReference column, Literal<?> value) {
+    this.column = column;
     this.value = value;
   }
 
-  public FieldReference expr() { return expr; }
+  public NamedReference column() { return column; }
   public Literal<?> value() { return value; }
 
   @Override
-  public String toString() { return expr.describe() + " = " + value.describe(); }
+  public String toString() { return column.describe() + " = " + value.describe(); }
 
   @Override
-  public NamedReference[] references() { return expr.references(); }
+  public NamedReference[] references() { return new NamedReference[]{column}; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Filter.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Filter.java
index 75739361ec826..852837496a103 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Filter.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Filter.java
@@ -36,14 +36,6 @@ public abstract class Filter implements Expression {
    */
   public abstract NamedReference[] references();
 
-  protected NamedReference[] findReferences(Object filter) {
-    if (filter instanceof Filter) {
-      return ((Filter) filter).references();
-    } else {
-      return EMPTY_REFERENCE;
-    }
-  }
-
   @Override
   public String describe() { return this.toString(); }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
index 3ba10719d2757..8ff55337252fb 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
@@ -18,32 +18,31 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
- * A filter that evaluates to `true` iff the field evaluates to a value
+ * A filter that evaluates to `true` iff the column evaluates to a value
  * greater than `value`.
  *
  * @since 3.3.0
  */
 @Evolving
 public final class GreaterThan extends Filter {
-  private final FieldReference expr;
+  private final NamedReference column;
   private final Literal<?> value;
 
-  public GreaterThan( FieldReference expr, Literal<?> value) {
-    this.expr = expr;
+  public GreaterThan(NamedReference column, Literal<?> value) {
+    this.column = column;
     this.value = value;
   }
 
-  public  FieldReference expr() { return expr; }
+  public NamedReference column() { return column; }
   public Literal<?> value() { return value; }
 
   @Override
-  public String toString() { return expr.describe() + " > " + value.describe(); }
+  public String toString() { return column.describe() + " > " + value.describe(); }
 
   @Override
-  public NamedReference[] references() { return expr.references(); }
+  public NamedReference[] references() { return new NamedReference[]{column}; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
index 77a785eb093a6..be4918e5e924e 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
@@ -18,32 +18,31 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
- * A filter that evaluates to `true` iff the field evaluates to a value
+ * A filter that evaluates to `true` iff the column evaluates to a value
  * greater than or equal to `value`.
  *
  * @since 3.3.0
  */
 @Evolving
 public final class GreaterThanOrEqual extends Filter {
-  private final FieldReference expr;
+  private final NamedReference column;
   private final Literal<?> value;
 
-  public GreaterThanOrEqual( FieldReference expr, Literal<?> value) {
-    this.expr = expr;
+  public GreaterThanOrEqual(NamedReference column, Literal<?> value) {
+    this.column = column;
     this.value = value;
   }
 
-  public  FieldReference expr() { return expr; }
+  public NamedReference column() { return column; }
   public Literal<?> value() { return value; }
 
   @Override
-  public String toString() { return expr.describe() + " >= " + value.describe(); }
+  public String toString() { return column.describe() + " >= " + value.describe(); }
 
   @Override
-  public NamedReference[] references() { return expr.references(); }
+  public NamedReference[] references() { return new NamedReference[]{column}; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
index a23d9217b208f..d055ed4329886 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
@@ -22,26 +22,25 @@
 import java.util.stream.Collectors;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
- * A filter that evaluates to `true` iff the field evaluates to one of the values in the array.
+ * A filter that evaluates to `true` iff the column evaluates to one of the values in the array.
  *
  * @since 3.3.0
  */
 @Evolving
 public final class In extends Filter {
-  private final FieldReference expr;
+  private final NamedReference column;
   private final Literal<?>[] values;
 
-  public In( FieldReference expr, Literal<?>[] values) {
-    this.expr = expr;
+  public In(NamedReference column, Literal<?>[] values) {
+    this.column = column;
     this.values = values;
   }
 
-  public  FieldReference expr() { return expr; }
+  public NamedReference column() { return column; }
   public Literal<?>[] values() { return values; }
 
   @Override
@@ -49,12 +48,12 @@ public boolean equals(Object o) {
     if (this == o) return true;
     if (o == null || getClass() != o.getClass()) return false;
     In in = (In) o;
-    return Objects.equals(expr, in.expr) && Arrays.equals(values, in.values);
+    return Objects.equals(column, in.column) && Arrays.equals(values, in.values);
   }
 
   @Override
   public int hashCode() {
-    int result = Objects.hash(expr);
+    int result = Objects.hash(column);
     result = 31 * result + Arrays.hashCode(values);
     return result;
   }
@@ -62,9 +61,9 @@ public int hashCode() {
   @Override
   public String toString() {
     String res = Arrays.stream(values).map(Literal::describe).collect(Collectors.joining(", "));
-    return expr.describe() + " IN (" + res + ")";
+    return column.describe() + " IN (" + res + ")";
   }
 
   @Override
-  public NamedReference[] references() { return expr.references(); }
+  public NamedReference[] references() { return new NamedReference[]{column}; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
index 17b1b10fef550..e03db9a061dbb 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
@@ -18,27 +18,26 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
- * A filter that evaluates to `true` iff the field evaluates to a non-null value.
+ * A filter that evaluates to `true` iff the column evaluates to a non-null value.
  *
  * @since 3.3.0
  */
 @Evolving
 public final class IsNotNull extends Filter {
-  private final FieldReference expr;
+  private final NamedReference column;
 
-  public IsNotNull( FieldReference expr) {
-    this.expr = expr;
+  public IsNotNull(NamedReference column) {
+    this.column = column;
   }
 
-  public  FieldReference expr() { return expr; }
+  public NamedReference column() { return column; }
 
   @Override
-  public String toString() { return expr.describe() + " IS NOT NULL"; }
+  public String toString() { return column.describe() + " IS NOT NULL"; }
 
   @Override
-  public NamedReference[] references() { return expr.references(); }
+  public NamedReference[] references() { return new NamedReference[]{column}; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
index a0788fcb43d69..104942cfb6507 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
@@ -18,27 +18,26 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
- * A filter that evaluates to `true` iff the field evaluates to null.
+ * A filter that evaluates to `true` iff the column evaluates to null.
  *
  * @since 3.3.0
  */
 @Evolving
 public final class IsNull extends Filter {
-  private final FieldReference expr;
+  private final NamedReference column;
 
-  public IsNull( FieldReference expr) {
-    this.expr = expr;
+  public IsNull(NamedReference column) {
+    this.column = column;
   }
 
-  public  FieldReference expr() { return expr; }
+  public NamedReference column() { return column; }
 
   @Override
-  public String toString() { return expr.describe() + " IS NULL"; }
+  public String toString() { return column.describe() + " IS NULL"; }
 
   @Override
-  public NamedReference[] references() { return expr.references(); }
+  public NamedReference[] references() { return new NamedReference[]{column}; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
index 770847159e38d..37a6d65d0f1fe 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
@@ -18,32 +18,31 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
- * A filter that evaluates to `true` iff the field evaluates to a value
+ * A filter that evaluates to `true` iff the column evaluates to a value
  * less than `value`.
  *
  * @since 3.3.0
  */
 @Evolving
 public final class LessThan extends Filter {
-  private final FieldReference expr;
+  private final NamedReference column;
   private final Literal<?> value;
 
-  public LessThan( FieldReference expr, Literal<?> value) {
-    this.expr = expr;
+  public LessThan(NamedReference column, Literal<?> value) {
+    this.column = column;
     this.value = value;
   }
 
-  public  FieldReference expr() { return expr; }
+  public NamedReference column() { return column; }
   public Literal<?> value() { return value; }
 
   @Override
-  public String toString() { return expr.describe() + " < " + value.describe(); }
+  public String toString() { return column.describe() + " < " + value.describe(); }
 
   @Override
-  public NamedReference[] references() { return expr.references(); }
+  public NamedReference[] references() { return new NamedReference[]{column}; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
index fe79b6151899d..9113b1e55a36b 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
@@ -18,32 +18,31 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
- * A filter that evaluates to `true` iff the field evaluates to a value
+ * A filter that evaluates to `true` iff the column evaluates to a value
  * less than or equal to `value`.
  *
  * @since 3.3.0
  */
 @Evolving
 public final class LessThanOrEqual extends Filter {
-  private final FieldReference expr;
+  private final NamedReference column;
   private final Literal<?> value;
 
-  public LessThanOrEqual( FieldReference expr, Literal<?> value) {
-    this.expr = expr;
+  public LessThanOrEqual(NamedReference column, Literal<?> value) {
+    this.column = column;
     this.value = value;
   }
 
-  public  FieldReference expr() { return expr; }
+  public NamedReference column() { return column; }
   public Literal<?> value() { return value; }
 
   @Override
-  public String toString() { return expr.describe() + " <= " + value.describe(); }
+  public String toString() { return column.describe() + " <= " + value.describe(); }
 
   @Override
-  public NamedReference[] references() { return expr.references(); }
+  public NamedReference[] references() { return new NamedReference[]{column}; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
index 5768d9f278cdc..5f41cbd32cf6e 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
@@ -18,31 +18,30 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
- * A filter that evaluates to `true` iff the field evaluates to
+ * A filter that evaluates to `true` iff the column evaluates to
  * a string that contains `value`.
  *
  * @since 3.3.0
  */
 @Evolving
 public final class StringContains extends Filter {
-  private final FieldReference expr;
+  private final NamedReference column;
   private final String value;
 
-  public StringContains( FieldReference expr, String value) {
-    this.expr = expr;
+  public StringContains(NamedReference column, String value) {
+    this.column = column;
     this.value = value;
   }
 
-  public  FieldReference expr() { return expr; }
+  public NamedReference column() { return column; }
   public String value() { return value; }
 
   @Override
-  public String toString() { return "STRING_CONTAINS(" + expr.describe() + ", " + value + ")"; }
+  public String toString() { return "STRING_CONTAINS(" + column.describe() + ", " + value + ")"; }
 
   @Override
-  public NamedReference[] references() { return expr.references(); }
+  public NamedReference[] references() { return new NamedReference[]{column}; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
index 3aba78affe021..c3fb2fbc0da90 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
@@ -18,31 +18,30 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
- * A filter that evaluates to `true` iff the field evaluates to
+ * A filter that evaluates to `true` iff the column evaluates to
  * a string that ends with `value`.
  *
  * @since 3.3.0
  */
 @Evolving
 public final class StringEndsWith extends Filter {
-  private final FieldReference expr;
+  private final NamedReference column;
   private final String value;
 
-  public StringEndsWith( FieldReference expr, String value) {
-    this.expr = expr;
+  public StringEndsWith(NamedReference column, String value) {
+    this.column = column;
     this.value = value;
   }
 
-  public  FieldReference expr() { return expr; }
+  public NamedReference column() { return column; }
   public String value() { return value; }
 
   @Override
-  public String toString() { return "STRING_ENDS_WITH(" + expr.describe() + ", " + value + ")"; }
+  public String toString() { return "STRING_ENDS_WITH(" + column.describe() + ", " + value + ")"; }
 
   @Override
-  public NamedReference[] references() { return expr.references(); }
+  public NamedReference[] references() { return new NamedReference[]{column}; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
index 73e9823bfc33e..e90c2ae0b0b4e 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
@@ -18,31 +18,30 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.FieldReference;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
- * A filter that evaluates to `true` iff the field evaluates to
+ * A filter that evaluates to `true` iff the column evaluates to
  * a string that starts with `value`.
  *
  * @since 3.3.0
  */
 @Evolving
 public final class StringStartsWith extends Filter {
-  private final FieldReference expr;
+  private final NamedReference column;
   private final String value;
 
-  public StringStartsWith( FieldReference expr, String value) {
-    this.expr = expr;
+  public StringStartsWith(NamedReference column, String value) {
+    this.column = column;
     this.value = value;
   }
 
-  public  FieldReference expr() { return expr; }
+  public NamedReference column() { return column; }
   public String value() { return value; }
 
   @Override
-  public String toString() { return "STRING_STARTS_WITH(" + expr.describe() + ", " + value + ")"; }
+  public String toString() { return "STRING_STARTS_WITH(" + column.describe() + ", " + value + ")"; }
 
   @Override
-  public NamedReference[] references() { return expr.references(); }
+  public NamedReference[] references() { return new NamedReference[]{column}; }
 }
diff --git a/sql/catalyst/src/main/scala/org/apache/spark/sql/connector/expressions/expressions.scala b/sql/catalyst/src/main/scala/org/apache/spark/sql/connector/expressions/expressions.scala
index 34879c152b7d0..2863d94d198b2 100644
--- a/sql/catalyst/src/main/scala/org/apache/spark/sql/connector/expressions/expressions.scala
+++ b/sql/catalyst/src/main/scala/org/apache/spark/sql/connector/expressions/expressions.scala
@@ -333,11 +333,6 @@ private[sql] final case class FieldReference(parts: Seq[String]) extends NamedRe
   override def fieldNames: Array[String] = parts.toArray
   override def describe: String = parts.quoted
   override def toString: String = describe
-
-  /**
-   * Returns list of NamedReference that are referenced by this FieldReference.
-   */
-  def references(): Array[NamedReference] = Array[NamedReference](this)
 }
 
 private[sql] object FieldReference {

From 8c6f18c9bd83c331db239c7541a93f2a3847895e Mon Sep 17 00:00:00 2001
From: Huaxin Gao <huaxin_gao@apple.com>
Date: Tue, 7 Sep 2021 14:39:17 -0700
Subject: [PATCH 16/24] Use UTF8String in Filters and implement equals/hashCode

---
 .../sql/connector/expressions/filter/And.java |  15 +++
 .../expressions/filter/EqualNullSafe.java     |  15 +++
 .../connector/expressions/filter/EqualTo.java |  15 +++
 .../expressions/filter/GreaterThan.java       |  15 +++
 .../filter/GreaterThanOrEqual.java            |  15 +++
 .../expressions/filter/IsNotNull.java         |  15 +++
 .../connector/expressions/filter/IsNull.java  |  15 +++
 .../expressions/filter/LessThan.java          |  15 +++
 .../expressions/filter/LessThanOrEqual.java   |  15 +++
 .../sql/connector/expressions/filter/Not.java |  15 +++
 .../sql/connector/expressions/filter/Or.java  |  15 +++
 .../expressions/filter/StringContains.java    |  22 +++-
 .../expressions/filter/StringEndsWith.java    |  22 +++-
 .../expressions/filter/StringStartsWith.java  |  26 +++-
 .../datasources/v2/V2FiltersSuite.scala       | 115 +++++++++++-------
 15 files changed, 298 insertions(+), 52 deletions(-)

diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
index d7887ae7ad3c8..f77f92e6a0984 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
@@ -17,6 +17,8 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
+import java.util.Objects;
+
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
@@ -38,6 +40,19 @@ public And(Filter left, Filter right) {
   public Filter left() { return left; }
   public Filter right() { return right; }
 
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    And and = (And) o;
+    return Objects.equals(left, and.left) && Objects.equals(right, and.right);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(left, right);
+  }
+
   @Override
   public String toString() {
     return String.format("(%s) AND (%s)", left.describe(), right.describe());
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
index cff1f04df684c..49c2827012601 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
@@ -17,6 +17,8 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
+import java.util.Objects;
+
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
@@ -41,6 +43,19 @@ public EqualNullSafe(NamedReference column, Literal<?> value) {
   public NamedReference column() { return column; }
   public Literal<?> value() { return value; }
 
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    EqualNullSafe that = (EqualNullSafe) o;
+    return Objects.equals(column, that.column) && Objects.equals(value, that.value);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(column, value);
+  }
+
   @Override
   public String toString() { return column.describe() + " <=> " + value.describe(); }
 
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
index 639837a668235..2c49630bdc9a3 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
@@ -17,6 +17,8 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
+import java.util.Objects;
+
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
@@ -40,6 +42,19 @@ public EqualTo(NamedReference column, Literal<?> value) {
   public NamedReference column() { return column; }
   public Literal<?> value() { return value; }
 
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    EqualTo equalTo = (EqualTo) o;
+    return Objects.equals(column, equalTo.column) && Objects.equals(value, equalTo.value);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(column, value);
+  }
+
   @Override
   public String toString() { return column.describe() + " = " + value.describe(); }
 
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
index 8ff55337252fb..312d5c7c895bc 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
@@ -17,6 +17,8 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
+import java.util.Objects;
+
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
@@ -40,6 +42,19 @@ public GreaterThan(NamedReference column, Literal<?> value) {
   public NamedReference column() { return column; }
   public Literal<?> value() { return value; }
 
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    GreaterThan that = (GreaterThan) o;
+    return Objects.equals(column, that.column) && Objects.equals(value, that.value);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(column, value);
+  }
+
   @Override
   public String toString() { return column.describe() + " > " + value.describe(); }
 
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
index be4918e5e924e..04497e2ad03e9 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
@@ -17,6 +17,8 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
+import java.util.Objects;
+
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
@@ -40,6 +42,19 @@ public GreaterThanOrEqual(NamedReference column, Literal<?> value) {
   public NamedReference column() { return column; }
   public Literal<?> value() { return value; }
 
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    GreaterThanOrEqual that = (GreaterThanOrEqual) o;
+    return Objects.equals(column, that.column) && Objects.equals(value, that.value);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(column, value);
+  }
+
   @Override
   public String toString() { return column.describe() + " >= " + value.describe(); }
 
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
index e03db9a061dbb..528f970aff80a 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
@@ -17,6 +17,8 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
+import java.util.Objects;
+
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
@@ -38,6 +40,19 @@ public IsNotNull(NamedReference column) {
   @Override
   public String toString() { return column.describe() + " IS NOT NULL"; }
 
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    IsNotNull isNotNull = (IsNotNull) o;
+    return Objects.equals(column, isNotNull.column);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(column);
+  }
+
   @Override
   public NamedReference[] references() { return new NamedReference[]{column}; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
index 104942cfb6507..e5027b422c3f0 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
@@ -17,6 +17,8 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
+import java.util.Objects;
+
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
@@ -38,6 +40,19 @@ public IsNull(NamedReference column) {
   @Override
   public String toString() { return column.describe() + " IS NULL"; }
 
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    IsNull isNull = (IsNull) o;
+    return Objects.equals(column, isNull.column);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(column);
+  }
+
   @Override
   public NamedReference[] references() { return new NamedReference[]{column}; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
index 37a6d65d0f1fe..a4f6ce12e2213 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
@@ -17,6 +17,8 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
+import java.util.Objects;
+
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
@@ -40,6 +42,19 @@ public LessThan(NamedReference column, Literal<?> value) {
   public NamedReference column() { return column; }
   public Literal<?> value() { return value; }
 
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    LessThan lessThan = (LessThan) o;
+    return Objects.equals(column, lessThan.column) && Objects.equals(value, lessThan.value);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(column, value);
+  }
+
   @Override
   public String toString() { return column.describe() + " < " + value.describe(); }
 
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
index 9113b1e55a36b..d562c2f6efc82 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
@@ -17,6 +17,8 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
+import java.util.Objects;
+
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
@@ -40,6 +42,19 @@ public LessThanOrEqual(NamedReference column, Literal<?> value) {
   public NamedReference column() { return column; }
   public Literal<?> value() { return value; }
 
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    LessThanOrEqual that = (LessThanOrEqual) o;
+    return Objects.equals(column, that.column) && Objects.equals(value, that.value);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(column, value);
+  }
+
   @Override
   public String toString() { return column.describe() + " <= " + value.describe(); }
 
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java
index a61235365f452..fd5282515e6ae 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java
@@ -17,6 +17,8 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
+import java.util.Objects;
+
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
@@ -33,6 +35,19 @@ public final class Not extends Filter {
 
   public Filter child() { return child; }
 
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    Not not = (Not) o;
+    return Objects.equals(child, not.child);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(child);
+  }
+
   @Override
   public String toString() { return "NOT " + child.describe(); }
 
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
index 6e12e3882f7f9..dc1eb3610182f 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
@@ -17,6 +17,8 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
+import java.util.Objects;
+
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
@@ -38,6 +40,19 @@ public Or(Filter left, Filter right) {
   public Filter left() { return left; }
   public Filter right() { return right; }
 
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    Or or = (Or) o;
+    return Objects.equals(left, or.left) && Objects.equals(right, or.right);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(left, right);
+  }
+
   @Override
   public String toString() {
     return String.format("(%s) AND (%s)", left.describe(), right.describe());
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
index 5f41cbd32cf6e..4ff43a773cb26 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
@@ -17,8 +17,11 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
+import java.util.Objects;
+
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.NamedReference;
+import org.apache.spark.unsafe.types.UTF8String;
 
 /**
  * A filter that evaluates to `true` iff the column evaluates to
@@ -29,15 +32,28 @@
 @Evolving
 public final class StringContains extends Filter {
   private final NamedReference column;
-  private final String value;
+  private final UTF8String value;
 
-  public StringContains(NamedReference column, String value) {
+  public StringContains(NamedReference column, UTF8String value) {
     this.column = column;
     this.value = value;
   }
 
   public NamedReference column() { return column; }
-  public String value() { return value; }
+  public UTF8String value() { return value; }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    StringContains that = (StringContains) o;
+    return Objects.equals(column, that.column) && Objects.equals(value, that.value);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(column, value);
+  }
 
   @Override
   public String toString() { return "STRING_CONTAINS(" + column.describe() + ", " + value + ")"; }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
index c3fb2fbc0da90..4d91f6af57b82 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
@@ -17,8 +17,11 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
+import java.util.Objects;
+
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.NamedReference;
+import org.apache.spark.unsafe.types.UTF8String;
 
 /**
  * A filter that evaluates to `true` iff the column evaluates to
@@ -29,15 +32,28 @@
 @Evolving
 public final class StringEndsWith extends Filter {
   private final NamedReference column;
-  private final String value;
+  private final UTF8String value;
 
-  public StringEndsWith(NamedReference column, String value) {
+  public StringEndsWith(NamedReference column, UTF8String value) {
     this.column = column;
     this.value = value;
   }
 
   public NamedReference column() { return column; }
-  public String value() { return value; }
+  public UTF8String value() { return value; }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    StringEndsWith that = (StringEndsWith) o;
+    return Objects.equals(column, that.column) && Objects.equals(value, that.value);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(column, value);
+  }
 
   @Override
   public String toString() { return "STRING_ENDS_WITH(" + column.describe() + ", " + value + ")"; }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
index e90c2ae0b0b4e..2126bbf4a7a3e 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
@@ -17,8 +17,11 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
+import java.util.Objects;
+
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.NamedReference;
+import org.apache.spark.unsafe.types.UTF8String;
 
 /**
  * A filter that evaluates to `true` iff the column evaluates to
@@ -29,18 +32,33 @@
 @Evolving
 public final class StringStartsWith extends Filter {
   private final NamedReference column;
-  private final String value;
+  private final UTF8String value;
 
-  public StringStartsWith(NamedReference column, String value) {
+  public StringStartsWith(NamedReference column, UTF8String value) {
     this.column = column;
     this.value = value;
   }
 
   public NamedReference column() { return column; }
-  public String value() { return value; }
+  public UTF8String value() { return value; }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    StringStartsWith that = (StringStartsWith) o;
+    return Objects.equals(column, that.column) && Objects.equals(value, that.value);
+  }
 
   @Override
-  public String toString() { return "STRING_STARTS_WITH(" + column.describe() + ", " + value + ")"; }
+  public int hashCode() {
+    return Objects.hash(column, value);
+  }
+
+  @Override
+  public String toString() {
+    return "STRING_STARTS_WITH(" + column.describe() + ", " + value + ")";
+  }
 
   @Override
   public NamedReference[] references() { return new NamedReference[]{column}; }
diff --git a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
index 57ebf371726cc..988e53dbd4843 100644
--- a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
+++ b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
@@ -22,6 +22,7 @@ import org.apache.spark.sql.connector.expressions.{FieldReference, LiteralValue}
 import org.apache.spark.sql.connector.expressions.filter._
 import org.apache.spark.sql.execution.datasources.v2.FiltersV2Suite.ref
 import org.apache.spark.sql.types.IntegerType
+import org.apache.spark.unsafe.types.UTF8String
 
 class FiltersV2Suite extends SparkFunSuite {
 
@@ -40,39 +41,51 @@ class FiltersV2Suite extends SparkFunSuite {
   }
 
   test("EqualTo") {
-    val filter = new EqualTo(ref("a"), LiteralValue(1, IntegerType))
-    assert(filter.references.map(_.describe()).toSeq == Seq("a"))
-    assert(filter.describe.equals("a = 1"))
+    val filter1 = new EqualTo(ref("a"), LiteralValue(1, IntegerType))
+    val filter2 = new EqualTo(ref("a"), LiteralValue(1, IntegerType))
+    assert(filter1.equals(filter2))
+    assert(filter1.references.map(_.describe()).toSeq == Seq("a"))
+    assert(filter1.describe.equals("a = 1"))
   }
 
   test("EqualNullSafe") {
-    val filter = new EqualNullSafe(ref("a"), LiteralValue(1, IntegerType))
-    assert(filter.references.map(_.describe()).toSeq == Seq("a"))
-    assert(filter.describe.equals("a <=> 1"))
+    val filter1 = new EqualNullSafe(ref("a"), LiteralValue(1, IntegerType))
+    val filter2 = new EqualNullSafe(ref("a"), LiteralValue(1, IntegerType))
+    assert(filter1.equals(filter2))
+    assert(filter1.references.map(_.describe()).toSeq == Seq("a"))
+    assert(filter1.describe.equals("a <=> 1"))
   }
 
   test("GreaterThan") {
-    val filter = new GreaterThan(ref("a"), LiteralValue(1, IntegerType))
-    assert(filter.references.map(_.describe()).toSeq == Seq("a"))
-    assert(filter.describe.equals("a > 1"))
+    val filter1 = new GreaterThan(ref("a"), LiteralValue(1, IntegerType))
+    val filter2 = new GreaterThan(ref("a"), LiteralValue(1, IntegerType))
+    assert(filter1.equals(filter2))
+    assert(filter1.references.map(_.describe()).toSeq == Seq("a"))
+    assert(filter1.describe.equals("a > 1"))
   }
 
   test("GreaterThanOrEqual") {
-    val filter = new GreaterThanOrEqual(ref("a"), LiteralValue(1, IntegerType))
-    assert(filter.references.map(_.describe()).toSeq == Seq("a"))
-    assert(filter.describe.equals("a >= 1"))
+    val filter1 = new GreaterThanOrEqual(ref("a"), LiteralValue(1, IntegerType))
+    val filter2 = new GreaterThanOrEqual(ref("a"), LiteralValue(1, IntegerType))
+    assert(filter1.equals(filter2))
+    assert(filter1.references.map(_.describe()).toSeq == Seq("a"))
+    assert(filter1.describe.equals("a >= 1"))
   }
 
   test("LessThan") {
-    val filter = new LessThan(ref("a"), LiteralValue(1, IntegerType))
-    assert(filter.references.map(_.describe()).toSeq == Seq("a"))
-    assert(filter.describe.equals("a < 1"))
+    val filter1 = new LessThan(ref("a"), LiteralValue(1, IntegerType))
+    val filter2 = new LessThan(ref("a"), LiteralValue(1, IntegerType))
+    assert(filter1.equals(filter2))
+    assert(filter1.references.map(_.describe()).toSeq == Seq("a"))
+    assert(filter1.describe.equals("a < 1"))
   }
 
   test("LessThanOrEqual") {
-    val filter = new LessThanOrEqual(ref("a"), LiteralValue(1, IntegerType))
-    assert(filter.references.map(_.describe()).toSeq == Seq("a"))
-    assert(filter.describe.equals("a <= 1"))
+    val filter1 = new LessThanOrEqual(ref("a"), LiteralValue(1, IntegerType))
+    val filter2 = new LessThanOrEqual(ref("a"), LiteralValue(1, IntegerType))
+    assert(filter1.equals(filter2))
+    assert(filter1.references.map(_.describe()).toSeq == Seq("a"))
+    assert(filter1.describe.equals("a <= 1"))
   }
 
   test("In") {
@@ -88,53 +101,71 @@ class FiltersV2Suite extends SparkFunSuite {
   }
 
   test("IsNull") {
-    val filter = new IsNull(ref("a"))
-    assert(filter.references.map(_.describe()).toSeq == Seq("a"))
-    assert(filter.describe.equals("a IS NULL"))
+    val filter1 = new IsNull(ref("a"))
+    val filter2 = new IsNull(ref("a"))
+    assert(filter1.equals(filter2))
+    assert(filter1.references.map(_.describe()).toSeq == Seq("a"))
+    assert(filter1.describe.equals("a IS NULL"))
   }
 
   test("IsNotNull") {
-    val filter = new IsNotNull(ref("a"))
-    assert(filter.references.map(_.describe()).toSeq == Seq("a"))
-    assert(filter.describe.equals("a IS NOT NULL"))
+    val filter1 = new IsNotNull(ref("a"))
+    val filter2 = new IsNotNull(ref("a"))
+    assert(filter1.equals(filter2))
+    assert(filter1.references.map(_.describe()).toSeq == Seq("a"))
+    assert(filter1.describe.equals("a IS NOT NULL"))
   }
 
   test("Not") {
-    val filter = new Not(new LessThan(ref("a"), LiteralValue(1, IntegerType)))
-    assert(filter.references.map(_.describe()).toSeq == Seq("a"))
-    assert(filter.describe.equals("NOT a < 1"))
+    val filter1 = new Not(new LessThan(ref("a"), LiteralValue(1, IntegerType)))
+    val filter2 = new Not(new LessThan(ref("a"), LiteralValue(1, IntegerType)))
+    assert(filter1.equals(filter2))
+    assert(filter1.references.map(_.describe()).toSeq == Seq("a"))
+    assert(filter1.describe.equals("NOT a < 1"))
   }
 
   test("And") {
-    val filter = new And(new EqualTo(ref("a"), LiteralValue(1, IntegerType)),
+    val filter1 = new And(new EqualTo(ref("a"), LiteralValue(1, IntegerType)),
       new EqualTo(ref("b"), LiteralValue(1, IntegerType)))
-    assert(filter.references.map(_.describe()).toSeq == Seq("a", "b"))
-    assert(filter.describe.equals("(a = 1) AND (b = 1)"))
+    val filter2 = new And(new EqualTo(ref("a"), LiteralValue(1, IntegerType)),
+      new EqualTo(ref("b"), LiteralValue(1, IntegerType)))
+    assert(filter1.equals(filter2))
+    assert(filter1.references.map(_.describe()).toSeq == Seq("a", "b"))
+    assert(filter1.describe.equals("(a = 1) AND (b = 1)"))
   }
 
   test("Or") {
-    val filter = new Or(new EqualTo(ref("a"), LiteralValue(1, IntegerType)),
+    val filter1 = new Or(new EqualTo(ref("a"), LiteralValue(1, IntegerType)),
+      new EqualTo(ref("b"), LiteralValue(1, IntegerType)))
+    val filter2 = new Or(new EqualTo(ref("a"), LiteralValue(1, IntegerType)),
       new EqualTo(ref("b"), LiteralValue(1, IntegerType)))
-    assert(filter.references.map(_.describe()).toSeq == Seq("a", "b"))
-    assert(filter.describe.equals("(a = 1) AND (b = 1)"))
+    assert(filter1.equals(filter2))
+    assert(filter1.references.map(_.describe()).toSeq == Seq("a", "b"))
+    assert(filter1.describe.equals("(a = 1) AND (b = 1)"))
   }
 
   test("StringStartsWith") {
-    val filter = new StringStartsWith(ref("a"), "str")
-    assert(filter.references.map(_.describe()).toSeq == Seq("a"))
-    assert(filter.describe.equals("STRING_STARTS_WITH(a, str)"))
+    val filter1 = new StringStartsWith(ref("a"), UTF8String.fromString("str"))
+    val filter2 = new StringStartsWith(ref("a"), UTF8String.fromString("str"))
+    assert(filter1.equals(filter2))
+    assert(filter1.references.map(_.describe()).toSeq == Seq("a"))
+    assert(filter1.describe.equals("STRING_STARTS_WITH(a, str)"))
   }
 
   test("StringEndsWith") {
-    val filter = new StringEndsWith(ref("a"), "str")
-    assert(filter.references.map(_.describe()).toSeq == Seq("a"))
-    assert(filter.describe.equals("STRING_ENDS_WITH(a, str)"))
+    val filter1 = new StringEndsWith(ref("a"), UTF8String.fromString("str"))
+    val filter2 = new StringEndsWith(ref("a"), UTF8String.fromString("str"))
+    assert(filter1.equals(filter2))
+    assert(filter1.references.map(_.describe()).toSeq == Seq("a"))
+    assert(filter1.describe.equals("STRING_ENDS_WITH(a, str)"))
   }
 
   test("StringContains") {
-    val filter = new StringContains(ref("a"), "str")
-    assert(filter.references.map(_.describe()).toSeq == Seq("a"))
-    assert(filter.describe.equals("STRING_CONTAINS(a, str)"))
+    val filter1 = new StringContains(ref("a"), UTF8String.fromString("str"))
+    val filter2 = new StringContains(ref("a"), UTF8String.fromString("str"))
+    assert(filter1.equals(filter2))
+    assert(filter1.references.map(_.describe()).toSeq == Seq("a"))
+    assert(filter1.describe.equals("STRING_CONTAINS(a, str)"))
   }
 }
 

From 3c200a5ed00dd6da3365964635fbba2a793291cc Mon Sep 17 00:00:00 2001
From: Huaxin Gao <huaxin_gao@apple.com>
Date: Tue, 7 Sep 2021 22:08:28 -0700
Subject: [PATCH 17/24] address comments

---
 .../apache/spark/sql/connector/expressions/filter/Not.java    | 2 +-
 .../org/apache/spark/sql/connector/expressions/filter/Or.java | 2 +-
 .../spark/sql/execution/datasources/v2/V2FiltersSuite.scala   | 4 ++--
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java
index fd5282515e6ae..f5bfedd50be49 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java
@@ -49,7 +49,7 @@ public int hashCode() {
   }
 
   @Override
-  public String toString() { return "NOT " + child.describe(); }
+  public String toString() { return "NOT (" + child.describe() + ")"; }
 
   @Override
   public NamedReference[] references() { return child.references(); }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
index dc1eb3610182f..7e1906093a95d 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
@@ -55,7 +55,7 @@ public int hashCode() {
 
   @Override
   public String toString() {
-    return String.format("(%s) AND (%s)", left.describe(), right.describe());
+    return String.format("(%s) OR (%s)", left.describe(), right.describe());
   }
 
   @Override
diff --git a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
index 988e53dbd4843..301a5e44925cc 100644
--- a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
+++ b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
@@ -121,7 +121,7 @@ class FiltersV2Suite extends SparkFunSuite {
     val filter2 = new Not(new LessThan(ref("a"), LiteralValue(1, IntegerType)))
     assert(filter1.equals(filter2))
     assert(filter1.references.map(_.describe()).toSeq == Seq("a"))
-    assert(filter1.describe.equals("NOT a < 1"))
+    assert(filter1.describe.equals("NOT (a < 1)"))
   }
 
   test("And") {
@@ -141,7 +141,7 @@ class FiltersV2Suite extends SparkFunSuite {
       new EqualTo(ref("b"), LiteralValue(1, IntegerType)))
     assert(filter1.equals(filter2))
     assert(filter1.references.map(_.describe()).toSeq == Seq("a", "b"))
-    assert(filter1.describe.equals("(a = 1) AND (b = 1)"))
+    assert(filter1.describe.equals("(a = 1) OR (b = 1)"))
   }
 
   test("StringStartsWith") {

From 1bdf241f35586d48caf213afa5e737a6f7d104cf Mon Sep 17 00:00:00 2001
From: Huaxin Gao <huaxin_gao@apple.com>
Date: Tue, 7 Sep 2021 23:34:31 -0700
Subject: [PATCH 18/24] fix java doc

---
 .../spark/sql/connector/expressions/filter/AlwaysFalse.java | 2 +-
 .../spark/sql/connector/expressions/filter/AlwaysTrue.java  | 2 +-
 .../apache/spark/sql/connector/expressions/filter/And.java  | 3 ++-
 .../sql/connector/expressions/filter/EqualNullSafe.java     | 6 +++---
 .../spark/sql/connector/expressions/filter/EqualTo.java     | 4 ++--
 .../spark/sql/connector/expressions/filter/GreaterThan.java | 4 ++--
 .../connector/expressions/filter/GreaterThanOrEqual.java    | 4 ++--
 .../apache/spark/sql/connector/expressions/filter/In.java   | 3 ++-
 .../spark/sql/connector/expressions/filter/IsNotNull.java   | 2 +-
 .../spark/sql/connector/expressions/filter/IsNull.java      | 2 +-
 .../spark/sql/connector/expressions/filter/LessThan.java    | 4 ++--
 .../sql/connector/expressions/filter/LessThanOrEqual.java   | 4 ++--
 .../apache/spark/sql/connector/expressions/filter/Not.java  | 2 +-
 .../apache/spark/sql/connector/expressions/filter/Or.java   | 3 ++-
 .../sql/connector/expressions/filter/StringContains.java    | 4 ++--
 .../sql/connector/expressions/filter/StringEndsWith.java    | 4 ++--
 .../sql/connector/expressions/filter/StringStartsWith.java  | 4 ++--
 17 files changed, 30 insertions(+), 27 deletions(-)

diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java
index 81c35be818723..106f809bafa13 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java
@@ -21,7 +21,7 @@
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
- * A filter that always evaluates to `false`.
+ * A filter that always evaluates to {@code false}.
  *
  * @since 3.3.0
  */
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java
index 53a1718df80be..44fd7608d777f 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java
@@ -21,7 +21,7 @@
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
- * A filter that always evaluates to `true`.
+ * A filter that always evaluates to {@code true}.
  *
  * @since 3.3.0
  */
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
index f77f92e6a0984..3fc2304cb54f4 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
@@ -23,7 +23,8 @@
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
- * A filter that evaluates to `true` iff both `left` and `right` evaluate to `true`.
+ * A filter that evaluates to {@code true} iff both {@code left} and {@code right} evaluate to
+ * {@code true}.
  *
  * @since 3.3.0
  */
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
index 49c2827012601..406ca5fcbfbf9 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
@@ -24,9 +24,9 @@
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
- * Performs equality comparison, similar to [[EqualTo]]. However, this differs from [[EqualTo]]
- * in that it returns `true` (rather than NULL) if both inputs are NULL, and `false`
- * (rather than NULL) if one of the input is NULL and the other is not NULL.
+ * Performs equality comparison, similar to {@link EqualTo}. However, this differs from
+ * {@link EqualTo} in that it returns {@code true} (rather than NULL) if both inputs are NULL,
+ * and {@code false} (rather than NULL) if one of the input is NULL and the other is not NULL.
  *
  * @since 3.3.0
  */
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
index 2c49630bdc9a3..73ebea5a7cac3 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
@@ -24,8 +24,8 @@
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
- * A filter that evaluates to `true` iff the column evaluates to a value
- * equal to `value`.
+ * A filter that evaluates to {@code true} iff the {@code column} evaluates to a value
+ * equal to {@code value}.
  *
  * @since 3.3.0
  */
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
index 312d5c7c895bc..cb60410796ff1 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
@@ -24,8 +24,8 @@
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
- * A filter that evaluates to `true` iff the column evaluates to a value
- * greater than `value`.
+ * A filter that evaluates to {@code true} iff the {@code column} evaluates to a value
+ * greater than {@code value}.
  *
  * @since 3.3.0
  */
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
index 04497e2ad03e9..3c1b7027a4a39 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
@@ -24,8 +24,8 @@
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
- * A filter that evaluates to `true` iff the column evaluates to a value
- * greater than or equal to `value`.
+ * A filter that evaluates to {@code true} iff the {@code column} evaluates to a value
+ * greater than or equal to {@code value}.
  *
  * @since 3.3.0
  */
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
index d055ed4329886..bddcd872ba932 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
@@ -26,7 +26,8 @@
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
- * A filter that evaluates to `true` iff the column evaluates to one of the values in the array.
+ * A filter that evaluates to {@code true} iff the {@code column} evaluates to one of the
+ * {@code values} in the array.
  *
  * @since 3.3.0
  */
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
index 528f970aff80a..74e2fb61d5c1f 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
@@ -23,7 +23,7 @@
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
- * A filter that evaluates to `true` iff the column evaluates to a non-null value.
+ * A filter that evaluates to {@code true} iff the {@code column} evaluates to a non-null value.
  *
  * @since 3.3.0
  */
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
index e5027b422c3f0..23d1e914f7de2 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
@@ -23,7 +23,7 @@
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
- * A filter that evaluates to `true` iff the column evaluates to null.
+ * A filter that evaluates to {@code true} iff the {@code column} evaluates to null.
  *
  * @since 3.3.0
  */
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
index a4f6ce12e2213..0bf94a88b0533 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
@@ -24,8 +24,8 @@
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
- * A filter that evaluates to `true` iff the column evaluates to a value
- * less than `value`.
+ * A filter that evaluates to {@code true} iff the {@code column} evaluates to a value
+ * less than {@code value}.
  *
  * @since 3.3.0
  */
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
index d562c2f6efc82..2341f46707a99 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
@@ -24,8 +24,8 @@
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
- * A filter that evaluates to `true` iff the column evaluates to a value
- * less than or equal to `value`.
+ * A filter that evaluates to {@code true} iff the {@code column} evaluates to a value
+ * less than or equal to {@code value}.
  *
  * @since 3.3.0
  */
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java
index f5bfedd50be49..69746f59ee933 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Not.java
@@ -23,7 +23,7 @@
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
- * A filter that evaluates to `true` iff `child` is evaluated to `false`.
+ * A filter that evaluates to {@code true} iff {@code child} is evaluated to {@code false}.
  *
  * @since 3.3.0
  */
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
index 7e1906093a95d..5a48ffff01e73 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
@@ -23,7 +23,8 @@
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
- * A filter that evaluates to `true` iff at least one of `left` or `right` evaluates to `true`.
+ * A filter that evaluates to {@code true} iff at least one of {@code left} or {@code right}
+ * evaluates to {@code true}.
  *
  * @since 3.3.0
  */
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
index 4ff43a773cb26..dc414fb34391b 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
@@ -24,8 +24,8 @@
 import org.apache.spark.unsafe.types.UTF8String;
 
 /**
- * A filter that evaluates to `true` iff the column evaluates to
- * a string that contains `value`.
+ * A filter that evaluates to {@code true} iff the {@code column} evaluates to
+ * a string that contains {@code value}.
  *
  * @since 3.3.0
  */
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
index 4d91f6af57b82..db015b5b4a8c7 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
@@ -24,8 +24,8 @@
 import org.apache.spark.unsafe.types.UTF8String;
 
 /**
- * A filter that evaluates to `true` iff the column evaluates to
- * a string that ends with `value`.
+ * A filter that evaluates to {@code true} iff the {@code column} evaluates to
+ * a string that ends with {@code value}.
  *
  * @since 3.3.0
  */
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
index 2126bbf4a7a3e..5d0b77debdea1 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
@@ -24,8 +24,8 @@
 import org.apache.spark.unsafe.types.UTF8String;
 
 /**
- * A filter that evaluates to `true` iff the column evaluates to
- * a string that starts with `value`.
+ * A filter that evaluates to {@code true} iff the {@code column} evaluates to
+ * a string that starts with {@code value}.
  *
  * @since 3.3.0
  */

From 091b91e04732672a5ddc20241511436254792dfa Mon Sep 17 00:00:00 2001
From: Huaxin Gao <huaxin_gao@apple.com>
Date: Wed, 8 Sep 2021 07:47:04 -0700
Subject: [PATCH 19/24] truncate string if there are more than 50 elements in
 the IN set

---
 .../sql/connector/expressions/filter/In.java      |  7 ++++++-
 .../execution/datasources/v2/V2FiltersSuite.scala | 15 ++++++++++++++-
 2 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
index bddcd872ba932..d0290949a91cd 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
@@ -61,7 +61,12 @@ public int hashCode() {
 
   @Override
   public String toString() {
-    String res = Arrays.stream(values).map(Literal::describe).collect(Collectors.joining(", "));
+    int maxLenToPrint = 50;
+    String res = Arrays.stream(values).limit((maxLenToPrint)).map(Literal::describe)
+      .collect(Collectors.joining(", "));
+    if(values.length > maxLenToPrint){
+      res += "...";
+    }
     return column.describe() + " IN (" + res + ")";
   }
 
diff --git a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
index 301a5e44925cc..b920a79e24d3e 100644
--- a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
+++ b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
@@ -18,7 +18,7 @@
 package org.apache.spark.sql.execution.datasources.v2
 
 import org.apache.spark.SparkFunSuite
-import org.apache.spark.sql.connector.expressions.{FieldReference, LiteralValue}
+import org.apache.spark.sql.connector.expressions.{FieldReference, Literal, LiteralValue}
 import org.apache.spark.sql.connector.expressions.filter._
 import org.apache.spark.sql.execution.datasources.v2.FiltersV2Suite.ref
 import org.apache.spark.sql.types.IntegerType
@@ -98,6 +98,19 @@ class FiltersV2Suite extends SparkFunSuite {
     assert(filter1.equals(filter2))
     assert(filter1.references.map(_.describe()).toSeq == Seq("a"))
     assert(filter1.describe.equals("a IN (1, 2, 3, 4)"))
+    
+    val values: Array[Literal[_]] = new Array[Literal[_]](1000)
+    for (i <- 0 until 1000) {
+      values(i) = LiteralValue(i, IntegerType)
+    }
+    val filter3 = new In(ref("a"), values)
+    var expected = "a IN ("
+    for (i <- 0 until 50) {
+      expected += i + ", "
+    }
+    expected = expected.dropRight(2)  // remove the last ", "
+    expected += "...)"
+    assert(filter3.describe.equals(expected))
   }
 
   test("IsNull") {

From b50cf33ab050388ca1f9c3d4afb9bd6a5d89159e Mon Sep 17 00:00:00 2001
From: Huaxin Gao <huaxin_gao@apple.com>
Date: Wed, 8 Sep 2021 08:12:56 -0700
Subject: [PATCH 20/24] make lint scala happy :)

---
 .../spark/sql/execution/datasources/v2/V2FiltersSuite.scala      | 1 -
 1 file changed, 1 deletion(-)

diff --git a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
index b920a79e24d3e..76ce6c7e60826 100644
--- a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
+++ b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
@@ -98,7 +98,6 @@ class FiltersV2Suite extends SparkFunSuite {
     assert(filter1.equals(filter2))
     assert(filter1.references.map(_.describe()).toSeq == Seq("a"))
     assert(filter1.describe.equals("a IN (1, 2, 3, 4)"))
-    
     val values: Array[Literal[_]] = new Array[Literal[_]](1000)
     for (i <- 0 until 1000) {
       values(i) = LiteralValue(i, IntegerType)

From 997e1718bab773271f6bc120ebbca814d873b2e7 Mon Sep 17 00:00:00 2001
From: Huaxin Gao <huaxin_gao@apple.com>
Date: Wed, 8 Sep 2021 18:04:57 -0700
Subject: [PATCH 21/24] divide filters into sub-categories

---
 .../expressions/filter/AlwaysFalse.java       |  7 +-
 .../expressions/filter/AlwaysTrue.java        |  7 +-
 .../sql/connector/expressions/filter/And.java | 36 +---------
 .../expressions/filter/BinaryFilter.java      | 60 +++++++++++++++++
 .../expressions/filter/CompoundFilter.java    | 65 +++++++++++++++++++
 .../expressions/filter/EqualNullSafe.java     | 30 +--------
 .../connector/expressions/filter/EqualTo.java | 28 +-------
 .../expressions/filter/GreaterThan.java       | 28 +-------
 .../filter/GreaterThanOrEqual.java            | 28 +-------
 .../sql/connector/expressions/filter/In.java  |  6 +-
 .../expressions/filter/IsNotNull.java         | 25 +------
 .../connector/expressions/filter/IsNull.java  | 25 +------
 .../expressions/filter/LessThan.java          | 28 +-------
 .../expressions/filter/LessThanOrEqual.java   | 28 +-------
 .../expressions/filter/NullCmpFilter.java     | 55 ++++++++++++++++
 .../sql/connector/expressions/filter/Or.java  | 36 +---------
 .../expressions/filter/StringCmpFilter.java   | 60 +++++++++++++++++
 .../expressions/filter/StringContains.java    | 28 +-------
 .../expressions/filter/StringEndsWith.java    | 28 +-------
 .../expressions/filter/StringStartsWith.java  | 28 +-------
 .../expressions/filter/TrueFalseFilter.java   | 47 ++++++++++++++
 .../datasources/v2/V2FiltersSuite.scala       | 16 +++++
 22 files changed, 335 insertions(+), 364 deletions(-)
 create mode 100644 sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/BinaryFilter.java
 create mode 100644 sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/CompoundFilter.java
 create mode 100644 sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/NullCmpFilter.java
 create mode 100644 sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringCmpFilter.java
 create mode 100644 sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/TrueFalseFilter.java

diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java
index 106f809bafa13..f363a58ee4556 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java
@@ -18,7 +18,6 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * A filter that always evaluates to {@code false}.
@@ -26,11 +25,7 @@
  * @since 3.3.0
  */
 @Evolving
-public final class AlwaysFalse extends Filter {
-
+public final class AlwaysFalse extends TrueFalseFilter {
   @Override
   public String toString() { return "FALSE"; }
-
-  @Override
-  public NamedReference[] references() { return EMPTY_REFERENCE; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java
index 44fd7608d777f..f1ecc6ce3283f 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java
@@ -18,7 +18,6 @@
 package org.apache.spark.sql.connector.expressions.filter;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * A filter that always evaluates to {@code true}.
@@ -26,11 +25,7 @@
  * @since 3.3.0
  */
 @Evolving
-public final class AlwaysTrue extends Filter {
-
+public final class AlwaysTrue extends TrueFalseFilter {
   @Override
   public String toString() { return "TRUE"; }
-
-  @Override
-  public NamedReference[] references() { return EMPTY_REFERENCE; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
index 3fc2304cb54f4..b6e1f329fdd97 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
@@ -17,10 +17,7 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
-import java.util.Objects;
-
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * A filter that evaluates to {@code true} iff both {@code left} and {@code right} evaluate to
@@ -29,43 +26,14 @@
  * @since 3.3.0
  */
 @Evolving
-public final class And extends Filter {
-  private final Filter left;
-  private final Filter right;
+public final class And extends CompoundFilter {
 
   public And(Filter left, Filter right) {
-    this.left = left;
-    this.right = right;
-  }
-
-  public Filter left() { return left; }
-  public Filter right() { return right; }
-
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) return true;
-    if (o == null || getClass() != o.getClass()) return false;
-    And and = (And) o;
-    return Objects.equals(left, and.left) && Objects.equals(right, and.right);
-  }
-
-  @Override
-  public int hashCode() {
-    return Objects.hash(left, right);
+    super(left, right);
   }
 
   @Override
   public String toString() {
     return String.format("(%s) AND (%s)", left.describe(), right.describe());
   }
-
-  @Override
-  public NamedReference[] references() {
-    NamedReference[] refLeft = left.references();
-    NamedReference[] refRight = right.references();
-    NamedReference[] arr = new NamedReference[refLeft.length + refRight.length];
-    System.arraycopy(refLeft, 0, arr, 0, refLeft.length);
-    System.arraycopy(refRight, 0, arr, refLeft.length, refRight.length);
-    return arr;
-  }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/BinaryFilter.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/BinaryFilter.java
new file mode 100644
index 0000000000000..bb4445a16a948
--- /dev/null
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/BinaryFilter.java
@@ -0,0 +1,60 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.spark.sql.connector.expressions.filter;
+
+import java.util.Objects;
+
+import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.Literal;
+import org.apache.spark.sql.connector.expressions.NamedReference;
+
+/**
+ * Base class for {@link EqualNullSafe}, {@link EqualTo}, {@link GreaterThan},
+ * {@link GreaterThanOrEqual}, {@link LessThan}, {@link LessThanOrEqual}
+ *
+ * @since 3.3.0
+ */
+@Evolving
+public class BinaryFilter extends Filter {
+  protected final NamedReference column;
+  protected final Literal<?> value;
+
+  protected BinaryFilter(NamedReference column, Literal<?> value) {
+    this.column = column;
+    this.value = value;
+  }
+
+  public NamedReference column() { return column; }
+  public Literal<?> value() { return value; }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    BinaryFilter that = (BinaryFilter) o;
+    return Objects.equals(column, that.column) && Objects.equals(value, that.value);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(column, value);
+  }
+
+  @Override
+  public NamedReference[] references() { return new NamedReference[]{column}; }
+}
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/CompoundFilter.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/CompoundFilter.java
new file mode 100644
index 0000000000000..d22cd1600ba66
--- /dev/null
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/CompoundFilter.java
@@ -0,0 +1,65 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.spark.sql.connector.expressions.filter;
+
+import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.NamedReference;
+
+import java.util.Objects;
+
+/**
+ * Base class for {@link And}, {@link Or}
+ *
+ * @since 3.3.0
+ */
+@Evolving
+public class CompoundFilter extends Filter {
+  protected final Filter left;
+  protected final Filter right;
+
+  protected CompoundFilter(Filter left, Filter right) {
+    this.left = left;
+    this.right = right;
+  }
+
+  public Filter left() { return left; }
+  public Filter right() { return right; }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    CompoundFilter and = (CompoundFilter) o;
+    return Objects.equals(left, and.left) && Objects.equals(right, and.right);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(left, right);
+  }
+
+  @Override
+  public NamedReference[] references() {
+    NamedReference[] refLeft = left.references();
+    NamedReference[] refRight = right.references();
+    NamedReference[] arr = new NamedReference[refLeft.length + refRight.length];
+    System.arraycopy(refLeft, 0, arr, 0, refLeft.length);
+    System.arraycopy(refRight, 0, arr, refLeft.length, refRight.length);
+    return arr;
+  }
+}
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
index 406ca5fcbfbf9..b9560b0f0c395 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
@@ -17,8 +17,6 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
-import java.util.Objects;
-
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
@@ -31,34 +29,12 @@
  * @since 3.3.0
  */
 @Evolving
-public final class EqualNullSafe extends Filter {
-  private final NamedReference column;
-  private final Literal<?> value;
+public final class EqualNullSafe extends BinaryFilter {
 
   public EqualNullSafe(NamedReference column, Literal<?> value) {
-    this.column = column;
-    this.value = value;
-  }
-
-  public NamedReference column() { return column; }
-  public Literal<?> value() { return value; }
-
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) return true;
-    if (o == null || getClass() != o.getClass()) return false;
-    EqualNullSafe that = (EqualNullSafe) o;
-    return Objects.equals(column, that.column) && Objects.equals(value, that.value);
+    super(column, value);
   }
 
   @Override
-  public int hashCode() {
-    return Objects.hash(column, value);
-  }
-
-  @Override
-  public String toString() { return column.describe() + " <=> " + value.describe(); }
-
-  @Override
-  public NamedReference[] references() { return new NamedReference[]{column}; }
+  public String toString() { return this.column.describe() + " <=> " + value.describe(); }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
index 73ebea5a7cac3..3396738208241 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
@@ -17,8 +17,6 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
-import java.util.Objects;
-
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
@@ -30,34 +28,12 @@
  * @since 3.3.0
  */
 @Evolving
-public final class EqualTo extends Filter {
-  private final NamedReference column;
-  private final Literal<?> value;
+public final class EqualTo extends BinaryFilter {
 
   public EqualTo(NamedReference column, Literal<?> value) {
-    this.column = column;
-    this.value = value;
-  }
-
-  public NamedReference column() { return column; }
-  public Literal<?> value() { return value; }
-
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) return true;
-    if (o == null || getClass() != o.getClass()) return false;
-    EqualTo equalTo = (EqualTo) o;
-    return Objects.equals(column, equalTo.column) && Objects.equals(value, equalTo.value);
-  }
-
-  @Override
-  public int hashCode() {
-    return Objects.hash(column, value);
+    super(column, value);
   }
 
   @Override
   public String toString() { return column.describe() + " = " + value.describe(); }
-
-  @Override
-  public NamedReference[] references() { return new NamedReference[]{column}; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
index cb60410796ff1..562c5f3a7796c 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
@@ -17,8 +17,6 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
-import java.util.Objects;
-
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
@@ -30,34 +28,12 @@
  * @since 3.3.0
  */
 @Evolving
-public final class GreaterThan extends Filter {
-  private final NamedReference column;
-  private final Literal<?> value;
+public final class GreaterThan  extends BinaryFilter {
 
   public GreaterThan(NamedReference column, Literal<?> value) {
-    this.column = column;
-    this.value = value;
-  }
-
-  public NamedReference column() { return column; }
-  public Literal<?> value() { return value; }
-
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) return true;
-    if (o == null || getClass() != o.getClass()) return false;
-    GreaterThan that = (GreaterThan) o;
-    return Objects.equals(column, that.column) && Objects.equals(value, that.value);
-  }
-
-  @Override
-  public int hashCode() {
-    return Objects.hash(column, value);
+    super(column, value);
   }
 
   @Override
   public String toString() { return column.describe() + " > " + value.describe(); }
-
-  @Override
-  public NamedReference[] references() { return new NamedReference[]{column}; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
index 3c1b7027a4a39..2be9b73d62121 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
@@ -17,8 +17,6 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
-import java.util.Objects;
-
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
@@ -30,34 +28,12 @@
  * @since 3.3.0
  */
 @Evolving
-public final class GreaterThanOrEqual extends Filter {
-  private final NamedReference column;
-  private final Literal<?> value;
+public final class GreaterThanOrEqual extends BinaryFilter {
 
   public GreaterThanOrEqual(NamedReference column, Literal<?> value) {
-    this.column = column;
-    this.value = value;
-  }
-
-  public NamedReference column() { return column; }
-  public Literal<?> value() { return value; }
-
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) return true;
-    if (o == null || getClass() != o.getClass()) return false;
-    GreaterThanOrEqual that = (GreaterThanOrEqual) o;
-    return Objects.equals(column, that.column) && Objects.equals(value, that.value);
-  }
-
-  @Override
-  public int hashCode() {
-    return Objects.hash(column, value);
+    super(column, value);
   }
 
   @Override
   public String toString() { return column.describe() + " >= " + value.describe(); }
-
-  @Override
-  public NamedReference[] references() { return new NamedReference[]{column}; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
index d0290949a91cd..e5074c91df667 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
@@ -33,6 +33,7 @@
  */
 @Evolving
 public final class In extends Filter {
+  static final int MAX_LEN_TO_PRINT = 50;
   private final NamedReference column;
   private final Literal<?>[] values;
 
@@ -61,10 +62,9 @@ public int hashCode() {
 
   @Override
   public String toString() {
-    int maxLenToPrint = 50;
-    String res = Arrays.stream(values).limit((maxLenToPrint)).map(Literal::describe)
+    String res = Arrays.stream(values).limit((MAX_LEN_TO_PRINT)).map(Literal::describe)
       .collect(Collectors.joining(", "));
-    if(values.length > maxLenToPrint){
+    if(values.length > MAX_LEN_TO_PRINT) {
       res += "...";
     }
     return column.describe() + " IN (" + res + ")";
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
index 74e2fb61d5c1f..2c482f4cbcd79 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
@@ -17,8 +17,6 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
-import java.util.Objects;
-
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
@@ -28,31 +26,12 @@
  * @since 3.3.0
  */
 @Evolving
-public final class IsNotNull extends Filter {
-  private final NamedReference column;
+public final class IsNotNull extends NullCmpFilter {
 
   public IsNotNull(NamedReference column) {
-    this.column = column;
+    super(column);
   }
 
-  public NamedReference column() { return column; }
-
   @Override
   public String toString() { return column.describe() + " IS NOT NULL"; }
-
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) return true;
-    if (o == null || getClass() != o.getClass()) return false;
-    IsNotNull isNotNull = (IsNotNull) o;
-    return Objects.equals(column, isNotNull.column);
-  }
-
-  @Override
-  public int hashCode() {
-    return Objects.hash(column);
-  }
-
-  @Override
-  public NamedReference[] references() { return new NamedReference[]{column}; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
index 23d1e914f7de2..28ded5627789d 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
@@ -17,8 +17,6 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
-import java.util.Objects;
-
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
@@ -28,31 +26,12 @@
  * @since 3.3.0
  */
 @Evolving
-public final class IsNull extends Filter {
-  private final NamedReference column;
+public final class IsNull extends NullCmpFilter {
 
   public IsNull(NamedReference column) {
-    this.column = column;
+    super(column);
   }
 
-  public NamedReference column() { return column; }
-
   @Override
   public String toString() { return column.describe() + " IS NULL"; }
-
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) return true;
-    if (o == null || getClass() != o.getClass()) return false;
-    IsNull isNull = (IsNull) o;
-    return Objects.equals(column, isNull.column);
-  }
-
-  @Override
-  public int hashCode() {
-    return Objects.hash(column);
-  }
-
-  @Override
-  public NamedReference[] references() { return new NamedReference[]{column}; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
index 0bf94a88b0533..bc79988c61cd1 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
@@ -17,8 +17,6 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
-import java.util.Objects;
-
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
@@ -30,34 +28,12 @@
  * @since 3.3.0
  */
 @Evolving
-public final class LessThan extends Filter {
-  private final NamedReference column;
-  private final Literal<?> value;
+public final class LessThan extends BinaryFilter {
 
   public LessThan(NamedReference column, Literal<?> value) {
-    this.column = column;
-    this.value = value;
-  }
-
-  public NamedReference column() { return column; }
-  public Literal<?> value() { return value; }
-
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) return true;
-    if (o == null || getClass() != o.getClass()) return false;
-    LessThan lessThan = (LessThan) o;
-    return Objects.equals(column, lessThan.column) && Objects.equals(value, lessThan.value);
-  }
-
-  @Override
-  public int hashCode() {
-    return Objects.hash(column, value);
+    super(column, value);
   }
 
   @Override
   public String toString() { return column.describe() + " < " + value.describe(); }
-
-  @Override
-  public NamedReference[] references() { return new NamedReference[]{column}; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
index 2341f46707a99..035722f28dc15 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
@@ -17,8 +17,6 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
-import java.util.Objects;
-
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
@@ -30,34 +28,12 @@
  * @since 3.3.0
  */
 @Evolving
-public final class LessThanOrEqual extends Filter {
-  private final NamedReference column;
-  private final Literal<?> value;
+public final class LessThanOrEqual extends BinaryFilter {
 
   public LessThanOrEqual(NamedReference column, Literal<?> value) {
-    this.column = column;
-    this.value = value;
-  }
-
-  public NamedReference column() { return column; }
-  public Literal<?> value() { return value; }
-
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) return true;
-    if (o == null || getClass() != o.getClass()) return false;
-    LessThanOrEqual that = (LessThanOrEqual) o;
-    return Objects.equals(column, that.column) && Objects.equals(value, that.value);
-  }
-
-  @Override
-  public int hashCode() {
-    return Objects.hash(column, value);
+    super(column, value);
   }
 
   @Override
   public String toString() { return column.describe() + " <= " + value.describe(); }
-
-  @Override
-  public NamedReference[] references() { return new NamedReference[]{column}; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/NullCmpFilter.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/NullCmpFilter.java
new file mode 100644
index 0000000000000..c3c9a17789688
--- /dev/null
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/NullCmpFilter.java
@@ -0,0 +1,55 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.spark.sql.connector.expressions.filter;
+
+import java.util.Objects;
+
+import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.NamedReference;
+
+/**
+ * Base class for {@link IsNull}, {@link IsNotNull}
+ *
+ * @since 3.3.0
+ */
+@Evolving
+public class NullCmpFilter extends Filter {
+  protected final NamedReference column;
+
+  protected NullCmpFilter(NamedReference column) {
+    this.column = column;
+  }
+
+  public NamedReference column() { return column; }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    NullCmpFilter isNull = (NullCmpFilter) o;
+    return Objects.equals(column, isNull.column);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(column);
+  }
+
+  @Override
+  public NamedReference[] references() { return new NamedReference[]{column}; }
+}
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
index 5a48ffff01e73..683ec516220de 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
@@ -17,10 +17,7 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
-import java.util.Objects;
-
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * A filter that evaluates to {@code true} iff at least one of {@code left} or {@code right}
@@ -29,43 +26,14 @@
  * @since 3.3.0
  */
 @Evolving
-public final class Or extends Filter {
-  private final Filter left;
-  private final Filter right;
+public final class Or extends CompoundFilter {
 
   public Or(Filter left, Filter right) {
-    this.left = left;
-    this.right = right;
-  }
-
-  public Filter left() { return left; }
-  public Filter right() { return right; }
-
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) return true;
-    if (o == null || getClass() != o.getClass()) return false;
-    Or or = (Or) o;
-    return Objects.equals(left, or.left) && Objects.equals(right, or.right);
-  }
-
-  @Override
-  public int hashCode() {
-    return Objects.hash(left, right);
+    super(left, right);
   }
 
   @Override
   public String toString() {
     return String.format("(%s) OR (%s)", left.describe(), right.describe());
   }
-
-  @Override
-  public NamedReference[] references() {
-    NamedReference[] refLeft = left.references();
-    NamedReference[] refRight = right.references();
-    NamedReference[] arr = new NamedReference[refLeft.length + refRight.length];
-    System.arraycopy(refLeft, 0, arr, 0, refLeft.length);
-    System.arraycopy(refRight, 0, arr, refLeft.length, refRight.length);
-    return arr;
-  }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringCmpFilter.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringCmpFilter.java
new file mode 100644
index 0000000000000..dd583fb2485d8
--- /dev/null
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringCmpFilter.java
@@ -0,0 +1,60 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.spark.sql.connector.expressions.filter;
+
+import java.util.Objects;
+
+import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.NamedReference;
+import org.apache.spark.unsafe.types.UTF8String;
+
+/**
+ * Base class for {@link StringContains}, {@link StringStartsWith},
+ * {@link StringEndsWith}
+ *
+ * @since 3.3.0
+ */
+@Evolving
+public class StringCmpFilter extends Filter {
+  protected final NamedReference column;
+  protected final UTF8String value;
+
+  protected StringCmpFilter(NamedReference column, UTF8String value) {
+    this.column = column;
+    this.value = value;
+  }
+
+  public NamedReference column() { return column; }
+  public UTF8String value() { return value; }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    StringCmpFilter that = (StringCmpFilter) o;
+    return Objects.equals(column, that.column) && Objects.equals(value, that.value);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(column, value);
+  }
+
+  @Override
+  public NamedReference[] references() { return new NamedReference[]{column}; }
+}
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
index dc414fb34391b..fa5dc939a57a0 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
@@ -17,8 +17,6 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
-import java.util.Objects;
-
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 import org.apache.spark.unsafe.types.UTF8String;
@@ -30,34 +28,12 @@
  * @since 3.3.0
  */
 @Evolving
-public final class StringContains extends Filter {
-  private final NamedReference column;
-  private final UTF8String value;
+public final class StringContains extends StringCmpFilter {
 
   public StringContains(NamedReference column, UTF8String value) {
-    this.column = column;
-    this.value = value;
-  }
-
-  public NamedReference column() { return column; }
-  public UTF8String value() { return value; }
-
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) return true;
-    if (o == null || getClass() != o.getClass()) return false;
-    StringContains that = (StringContains) o;
-    return Objects.equals(column, that.column) && Objects.equals(value, that.value);
-  }
-
-  @Override
-  public int hashCode() {
-    return Objects.hash(column, value);
+    super(column, value);
   }
 
   @Override
   public String toString() { return "STRING_CONTAINS(" + column.describe() + ", " + value + ")"; }
-
-  @Override
-  public NamedReference[] references() { return new NamedReference[]{column}; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
index db015b5b4a8c7..c92af14abb5f4 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
@@ -17,8 +17,6 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
-import java.util.Objects;
-
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 import org.apache.spark.unsafe.types.UTF8String;
@@ -30,34 +28,12 @@
  * @since 3.3.0
  */
 @Evolving
-public final class StringEndsWith extends Filter {
-  private final NamedReference column;
-  private final UTF8String value;
+public final class StringEndsWith extends StringCmpFilter {
 
   public StringEndsWith(NamedReference column, UTF8String value) {
-    this.column = column;
-    this.value = value;
-  }
-
-  public NamedReference column() { return column; }
-  public UTF8String value() { return value; }
-
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) return true;
-    if (o == null || getClass() != o.getClass()) return false;
-    StringEndsWith that = (StringEndsWith) o;
-    return Objects.equals(column, that.column) && Objects.equals(value, that.value);
-  }
-
-  @Override
-  public int hashCode() {
-    return Objects.hash(column, value);
+    super(column, value);
   }
 
   @Override
   public String toString() { return "STRING_ENDS_WITH(" + column.describe() + ", " + value + ")"; }
-
-  @Override
-  public NamedReference[] references() { return new NamedReference[]{column}; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
index 5d0b77debdea1..381b11a6eb6b6 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
@@ -17,8 +17,6 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
-import java.util.Objects;
-
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 import org.apache.spark.unsafe.types.UTF8String;
@@ -30,36 +28,14 @@
  * @since 3.3.0
  */
 @Evolving
-public final class StringStartsWith extends Filter {
-  private final NamedReference column;
-  private final UTF8String value;
+public final class StringStartsWith extends StringCmpFilter {
 
   public StringStartsWith(NamedReference column, UTF8String value) {
-    this.column = column;
-    this.value = value;
-  }
-
-  public NamedReference column() { return column; }
-  public UTF8String value() { return value; }
-
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) return true;
-    if (o == null || getClass() != o.getClass()) return false;
-    StringStartsWith that = (StringStartsWith) o;
-    return Objects.equals(column, that.column) && Objects.equals(value, that.value);
-  }
-
-  @Override
-  public int hashCode() {
-    return Objects.hash(column, value);
+    super(column, value);
   }
 
   @Override
   public String toString() {
     return "STRING_STARTS_WITH(" + column.describe() + ", " + value + ")";
   }
-
-  @Override
-  public NamedReference[] references() { return new NamedReference[]{column}; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/TrueFalseFilter.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/TrueFalseFilter.java
new file mode 100644
index 0000000000000..5a323013d71b3
--- /dev/null
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/TrueFalseFilter.java
@@ -0,0 +1,47 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.spark.sql.connector.expressions.filter;
+
+import java.util.Objects;
+
+import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.NamedReference;
+
+/**
+ * Base class for {@link AlwaysFalse}, {@link AlwaysTrue}
+ *
+ * @since 3.3.0
+ */
+@Evolving
+public class TrueFalseFilter extends Filter {
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    return true;
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash();
+  }
+
+  @Override
+  public NamedReference[] references() { return EMPTY_REFERENCE; }
+}
diff --git a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
index 76ce6c7e60826..7f9c09999ff82 100644
--- a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
+++ b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
@@ -40,6 +40,22 @@ class FiltersV2Suite extends SparkFunSuite {
     assert(filter3.describe.equals("```a``.b`.c = 1"))
   }
 
+  test("AlwaysTrue") {
+    val filter1 = new AlwaysTrue
+    val filter2 = new AlwaysTrue
+    assert(filter1.equals(filter2))
+    assert(filter1.references.map(_.describe()).length == 0)
+    assert(filter1.describe.equals("TRUE"))
+  }
+
+  test("AlwaysFalse") {
+    val filter1 = new AlwaysFalse
+    val filter2 = new AlwaysFalse
+    assert(filter1.equals(filter2))
+    assert(filter1.references.map(_.describe()).length == 0)
+    assert(filter1.describe.equals("FALSE"))
+  }
+
   test("EqualTo") {
     val filter1 = new EqualTo(ref("a"), LiteralValue(1, IntegerType))
     val filter2 = new EqualTo(ref("a"), LiteralValue(1, IntegerType))

From 0c246f61d01f5d468209655e16cfbbdd374c0580 Mon Sep 17 00:00:00 2001
From: Huaxin Gao <huaxin_gao@apple.com>
Date: Wed, 8 Sep 2021 22:52:55 -0700
Subject: [PATCH 22/24] address comments

---
 .../expressions/filter/AlwaysFalse.java       | 21 +++++-
 .../expressions/filter/AlwaysTrue.java        | 21 +++++-
 .../sql/connector/expressions/filter/And.java |  2 +-
 ...llCmpFilter.java => BinaryComparison.java} | 19 ++++--
 .../expressions/filter/BinaryFilter.java      | 35 +++++-----
 .../expressions/filter/CompoundFilter.java    | 65 -------------------
 .../expressions/filter/EqualNullSafe.java     |  2 +-
 .../connector/expressions/filter/EqualTo.java |  2 +-
 .../expressions/filter/GreaterThan.java       |  2 +-
 .../filter/GreaterThanOrEqual.java            |  2 +-
 .../sql/connector/expressions/filter/In.java  |  2 +-
 .../expressions/filter/IsNotNull.java         | 25 ++++++-
 .../connector/expressions/filter/IsNull.java  | 25 ++++++-
 .../expressions/filter/LessThan.java          |  2 +-
 .../expressions/filter/LessThanOrEqual.java   |  2 +-
 .../sql/connector/expressions/filter/Or.java  |  2 +-
 .../expressions/filter/StringContains.java    |  2 +-
 .../expressions/filter/StringEndsWith.java    |  2 +-
 ...ingCmpFilter.java => StringPredicate.java} |  8 +--
 .../expressions/filter/StringStartsWith.java  |  2 +-
 .../expressions/filter/TrueFalseFilter.java   | 47 --------------
 21 files changed, 134 insertions(+), 156 deletions(-)
 rename sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/{NullCmpFilter.java => BinaryComparison.java} (69%)
 delete mode 100644 sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/CompoundFilter.java
 rename sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/{StringCmpFilter.java => StringPredicate.java} (90%)
 delete mode 100644 sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/TrueFalseFilter.java

diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java
index f363a58ee4556..72ed83f86df6d 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysFalse.java
@@ -17,7 +17,10 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
+import java.util.Objects;
+
 import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * A filter that always evaluates to {@code false}.
@@ -25,7 +28,23 @@
  * @since 3.3.0
  */
 @Evolving
-public final class AlwaysFalse extends TrueFalseFilter {
+public final class AlwaysFalse extends Filter {
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    return true;
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash();
+  }
+
   @Override
   public String toString() { return "FALSE"; }
+
+  @Override
+  public NamedReference[] references() { return EMPTY_REFERENCE; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java
index f1ecc6ce3283f..b6d39c3f64a77 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/AlwaysTrue.java
@@ -17,7 +17,10 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
+import java.util.Objects;
+
 import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
  * A filter that always evaluates to {@code true}.
@@ -25,7 +28,23 @@
  * @since 3.3.0
  */
 @Evolving
-public final class AlwaysTrue extends TrueFalseFilter {
+public final class AlwaysTrue extends Filter {
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    return true;
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash();
+  }
+
   @Override
   public String toString() { return "TRUE"; }
+
+  @Override
+  public NamedReference[] references() { return EMPTY_REFERENCE; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
index b6e1f329fdd97..e0b8b13acb158 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/And.java
@@ -26,7 +26,7 @@
  * @since 3.3.0
  */
 @Evolving
-public final class And extends CompoundFilter {
+public final class And extends BinaryFilter {
 
   public And(Filter left, Filter right) {
     super(left, right);
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/NullCmpFilter.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/BinaryComparison.java
similarity index 69%
rename from sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/NullCmpFilter.java
rename to sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/BinaryComparison.java
index c3c9a17789688..dd70831357edb 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/NullCmpFilter.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/BinaryComparison.java
@@ -20,36 +20,41 @@
 import java.util.Objects;
 
 import org.apache.spark.annotation.Evolving;
+import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
- * Base class for {@link IsNull}, {@link IsNotNull}
+ * Base class for {@link EqualNullSafe}, {@link EqualTo}, {@link GreaterThan},
+ * {@link GreaterThanOrEqual}, {@link LessThan}, {@link LessThanOrEqual}
  *
  * @since 3.3.0
  */
 @Evolving
-public class NullCmpFilter extends Filter {
+public abstract class BinaryComparison extends Filter {
   protected final NamedReference column;
+  protected final Literal<?> value;
 
-  protected NullCmpFilter(NamedReference column) {
+  protected BinaryComparison(NamedReference column, Literal<?> value) {
     this.column = column;
+    this.value = value;
   }
 
   public NamedReference column() { return column; }
+  public Literal<?> value() { return value; }
 
   @Override
   public boolean equals(Object o) {
     if (this == o) return true;
     if (o == null || getClass() != o.getClass()) return false;
-    NullCmpFilter isNull = (NullCmpFilter) o;
-    return Objects.equals(column, isNull.column);
+    BinaryComparison that = (BinaryComparison) o;
+    return Objects.equals(column, that.column) && Objects.equals(value, that.value);
   }
 
   @Override
   public int hashCode() {
-    return Objects.hash(column);
+    return Objects.hash(column, value);
   }
 
   @Override
-  public NamedReference[] references() { return new NamedReference[]{column}; }
+  public NamedReference[] references() { return new NamedReference[] { column }; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/BinaryFilter.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/BinaryFilter.java
index bb4445a16a948..85785b1178866 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/BinaryFilter.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/BinaryFilter.java
@@ -20,41 +20,46 @@
 import java.util.Objects;
 
 import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.Literal;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
 /**
- * Base class for {@link EqualNullSafe}, {@link EqualTo}, {@link GreaterThan},
- * {@link GreaterThanOrEqual}, {@link LessThan}, {@link LessThanOrEqual}
+ * Base class for {@link And}, {@link Or}
  *
  * @since 3.3.0
  */
 @Evolving
-public class BinaryFilter extends Filter {
-  protected final NamedReference column;
-  protected final Literal<?> value;
+public abstract class BinaryFilter extends Filter {
+  protected final Filter left;
+  protected final Filter right;
 
-  protected BinaryFilter(NamedReference column, Literal<?> value) {
-    this.column = column;
-    this.value = value;
+  protected BinaryFilter(Filter left, Filter right) {
+    this.left = left;
+    this.right = right;
   }
 
-  public NamedReference column() { return column; }
-  public Literal<?> value() { return value; }
+  public Filter left() { return left; }
+  public Filter right() { return right; }
 
   @Override
   public boolean equals(Object o) {
     if (this == o) return true;
     if (o == null || getClass() != o.getClass()) return false;
-    BinaryFilter that = (BinaryFilter) o;
-    return Objects.equals(column, that.column) && Objects.equals(value, that.value);
+    BinaryFilter and = (BinaryFilter) o;
+    return Objects.equals(left, and.left) && Objects.equals(right, and.right);
   }
 
   @Override
   public int hashCode() {
-    return Objects.hash(column, value);
+    return Objects.hash(left, right);
   }
 
   @Override
-  public NamedReference[] references() { return new NamedReference[]{column}; }
+  public NamedReference[] references() {
+    NamedReference[] refLeft = left.references();
+    NamedReference[] refRight = right.references();
+    NamedReference[] arr = new NamedReference[refLeft.length + refRight.length];
+    System.arraycopy(refLeft, 0, arr, 0, refLeft.length);
+    System.arraycopy(refRight, 0, arr, refLeft.length, refRight.length);
+    return arr;
+  }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/CompoundFilter.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/CompoundFilter.java
deleted file mode 100644
index d22cd1600ba66..0000000000000
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/CompoundFilter.java
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.spark.sql.connector.expressions.filter;
-
-import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.NamedReference;
-
-import java.util.Objects;
-
-/**
- * Base class for {@link And}, {@link Or}
- *
- * @since 3.3.0
- */
-@Evolving
-public class CompoundFilter extends Filter {
-  protected final Filter left;
-  protected final Filter right;
-
-  protected CompoundFilter(Filter left, Filter right) {
-    this.left = left;
-    this.right = right;
-  }
-
-  public Filter left() { return left; }
-  public Filter right() { return right; }
-
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) return true;
-    if (o == null || getClass() != o.getClass()) return false;
-    CompoundFilter and = (CompoundFilter) o;
-    return Objects.equals(left, and.left) && Objects.equals(right, and.right);
-  }
-
-  @Override
-  public int hashCode() {
-    return Objects.hash(left, right);
-  }
-
-  @Override
-  public NamedReference[] references() {
-    NamedReference[] refLeft = left.references();
-    NamedReference[] refRight = right.references();
-    NamedReference[] arr = new NamedReference[refLeft.length + refRight.length];
-    System.arraycopy(refLeft, 0, arr, 0, refLeft.length);
-    System.arraycopy(refRight, 0, arr, refLeft.length, refRight.length);
-    return arr;
-  }
-}
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
index b9560b0f0c395..34b529194e075 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualNullSafe.java
@@ -29,7 +29,7 @@
  * @since 3.3.0
  */
 @Evolving
-public final class EqualNullSafe extends BinaryFilter {
+public final class EqualNullSafe extends BinaryComparison {
 
   public EqualNullSafe(NamedReference column, Literal<?> value) {
     super(column, value);
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
index 3396738208241..b9c4fe053b83c 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/EqualTo.java
@@ -28,7 +28,7 @@
  * @since 3.3.0
  */
 @Evolving
-public final class EqualTo extends BinaryFilter {
+public final class EqualTo extends BinaryComparison {
 
   public EqualTo(NamedReference column, Literal<?> value) {
     super(column, value);
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
index 562c5f3a7796c..7f50589ffc0ce 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
@@ -28,7 +28,7 @@
  * @since 3.3.0
  */
 @Evolving
-public final class GreaterThan  extends BinaryFilter {
+public final class GreaterThan  extends BinaryComparison {
 
   public GreaterThan(NamedReference column, Literal<?> value) {
     super(column, value);
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
index 2be9b73d62121..4ee921014da41 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThanOrEqual.java
@@ -28,7 +28,7 @@
  * @since 3.3.0
  */
 @Evolving
-public final class GreaterThanOrEqual extends BinaryFilter {
+public final class GreaterThanOrEqual extends BinaryComparison {
 
   public GreaterThanOrEqual(NamedReference column, Literal<?> value) {
     super(column, value);
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
index e5074c91df667..d9f6c717cdba1 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
@@ -71,5 +71,5 @@ public String toString() {
   }
 
   @Override
-  public NamedReference[] references() { return new NamedReference[]{column}; }
+  public NamedReference[] references() { return new NamedReference[] { column }; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
index 2c482f4cbcd79..2cf000e99878e 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNotNull.java
@@ -17,6 +17,8 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
+import java.util.Objects;
+
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
@@ -26,12 +28,31 @@
  * @since 3.3.0
  */
 @Evolving
-public final class IsNotNull extends NullCmpFilter {
+public final class IsNotNull extends Filter {
+  private final NamedReference column;
 
   public IsNotNull(NamedReference column) {
-    super(column);
+    this.column = column;
   }
 
+  public NamedReference column() { return column; }
+
   @Override
   public String toString() { return column.describe() + " IS NOT NULL"; }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    IsNotNull isNotNull = (IsNotNull) o;
+    return Objects.equals(column, isNotNull.column);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(column);
+  }
+
+  @Override
+  public NamedReference[] references() { return new NamedReference[] { column }; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
index 28ded5627789d..1cd497c02242e 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/IsNull.java
@@ -17,6 +17,8 @@
 
 package org.apache.spark.sql.connector.expressions.filter;
 
+import java.util.Objects;
+
 import org.apache.spark.annotation.Evolving;
 import org.apache.spark.sql.connector.expressions.NamedReference;
 
@@ -26,12 +28,31 @@
  * @since 3.3.0
  */
 @Evolving
-public final class IsNull extends NullCmpFilter {
+public final class IsNull extends Filter {
+  private final NamedReference column;
 
   public IsNull(NamedReference column) {
-    super(column);
+    this.column = column;
   }
 
+  public NamedReference column() { return column; }
+
   @Override
   public String toString() { return column.describe() + " IS NULL"; }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    IsNull isNull = (IsNull) o;
+    return Objects.equals(column, isNull.column);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(column);
+  }
+
+  @Override
+  public NamedReference[] references() { return new NamedReference[] { column }; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
index bc79988c61cd1..9fa5cfb87f527 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThan.java
@@ -28,7 +28,7 @@
  * @since 3.3.0
  */
 @Evolving
-public final class LessThan extends BinaryFilter {
+public final class LessThan extends BinaryComparison {
 
   public LessThan(NamedReference column, Literal<?> value) {
     super(column, value);
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
index 035722f28dc15..a41b3c8045d5a 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/LessThanOrEqual.java
@@ -28,7 +28,7 @@
  * @since 3.3.0
  */
 @Evolving
-public final class LessThanOrEqual extends BinaryFilter {
+public final class LessThanOrEqual extends BinaryComparison {
 
   public LessThanOrEqual(NamedReference column, Literal<?> value) {
     super(column, value);
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
index 683ec516220de..baa33d849feef 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/Or.java
@@ -26,7 +26,7 @@
  * @since 3.3.0
  */
 @Evolving
-public final class Or extends CompoundFilter {
+public final class Or extends BinaryFilter {
 
   public Or(Filter left, Filter right) {
     super(left, right);
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
index fa5dc939a57a0..9a01e4d574888 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringContains.java
@@ -28,7 +28,7 @@
  * @since 3.3.0
  */
 @Evolving
-public final class StringContains extends StringCmpFilter {
+public final class StringContains extends StringPredicate {
 
   public StringContains(NamedReference column, UTF8String value) {
     super(column, value);
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
index c92af14abb5f4..11b8317ba4895 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringEndsWith.java
@@ -28,7 +28,7 @@
  * @since 3.3.0
  */
 @Evolving
-public final class StringEndsWith extends StringCmpFilter {
+public final class StringEndsWith extends StringPredicate {
 
   public StringEndsWith(NamedReference column, UTF8String value) {
     super(column, value);
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringCmpFilter.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringPredicate.java
similarity index 90%
rename from sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringCmpFilter.java
rename to sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringPredicate.java
index dd583fb2485d8..228c509a03990 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringCmpFilter.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringPredicate.java
@@ -30,11 +30,11 @@
  * @since 3.3.0
  */
 @Evolving
-public class StringCmpFilter extends Filter {
+public abstract class StringPredicate extends Filter {
   protected final NamedReference column;
   protected final UTF8String value;
 
-  protected StringCmpFilter(NamedReference column, UTF8String value) {
+  protected StringPredicate(NamedReference column, UTF8String value) {
     this.column = column;
     this.value = value;
   }
@@ -46,7 +46,7 @@ protected StringCmpFilter(NamedReference column, UTF8String value) {
   public boolean equals(Object o) {
     if (this == o) return true;
     if (o == null || getClass() != o.getClass()) return false;
-    StringCmpFilter that = (StringCmpFilter) o;
+    StringPredicate that = (StringPredicate) o;
     return Objects.equals(column, that.column) && Objects.equals(value, that.value);
   }
 
@@ -56,5 +56,5 @@ public int hashCode() {
   }
 
   @Override
-  public NamedReference[] references() { return new NamedReference[]{column}; }
+  public NamedReference[] references() { return new NamedReference[] { column }; }
 }
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
index 381b11a6eb6b6..38a5de1921cdc 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringStartsWith.java
@@ -28,7 +28,7 @@
  * @since 3.3.0
  */
 @Evolving
-public final class StringStartsWith extends StringCmpFilter {
+public final class StringStartsWith extends StringPredicate {
 
   public StringStartsWith(NamedReference column, UTF8String value) {
     super(column, value);
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/TrueFalseFilter.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/TrueFalseFilter.java
deleted file mode 100644
index 5a323013d71b3..0000000000000
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/TrueFalseFilter.java
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.spark.sql.connector.expressions.filter;
-
-import java.util.Objects;
-
-import org.apache.spark.annotation.Evolving;
-import org.apache.spark.sql.connector.expressions.NamedReference;
-
-/**
- * Base class for {@link AlwaysFalse}, {@link AlwaysTrue}
- *
- * @since 3.3.0
- */
-@Evolving
-public class TrueFalseFilter extends Filter {
-
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) return true;
-    if (o == null || getClass() != o.getClass()) return false;
-    return true;
-  }
-
-  @Override
-  public int hashCode() {
-    return Objects.hash();
-  }
-
-  @Override
-  public NamedReference[] references() { return EMPTY_REFERENCE; }
-}

From 2cf8ebe041e0279e030acec1eda7be7dce473de0 Mon Sep 17 00:00:00 2001
From: Huaxin Gao <huaxin_gao@apple.com>
Date: Thu, 9 Sep 2021 07:35:04 -0700
Subject: [PATCH 23/24] address comments

---
 .../sql/connector/expressions/filter/BinaryComparison.java      | 2 +-
 .../spark/sql/connector/expressions/filter/BinaryFilter.java    | 2 +-
 .../spark/sql/connector/expressions/filter/GreaterThan.java     | 2 +-
 .../spark/sql/connector/expressions/filter/StringPredicate.java | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/BinaryComparison.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/BinaryComparison.java
index dd70831357edb..0ae6e5af3ca1a 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/BinaryComparison.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/BinaryComparison.java
@@ -30,7 +30,7 @@
  * @since 3.3.0
  */
 @Evolving
-public abstract class BinaryComparison extends Filter {
+abstract class BinaryComparison extends Filter {
   protected final NamedReference column;
   protected final Literal<?> value;
 
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/BinaryFilter.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/BinaryFilter.java
index 85785b1178866..ac4b9f281e9ca 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/BinaryFilter.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/BinaryFilter.java
@@ -28,7 +28,7 @@
  * @since 3.3.0
  */
 @Evolving
-public abstract class BinaryFilter extends Filter {
+abstract class BinaryFilter extends Filter {
   protected final Filter left;
   protected final Filter right;
 
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
index 7f50589ffc0ce..a3374f359ea29 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/GreaterThan.java
@@ -28,7 +28,7 @@
  * @since 3.3.0
  */
 @Evolving
-public final class GreaterThan  extends BinaryComparison {
+public final class GreaterThan extends BinaryComparison {
 
   public GreaterThan(NamedReference column, Literal<?> value) {
     super(column, value);
diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringPredicate.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringPredicate.java
index 228c509a03990..ffe5d5dba45b3 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringPredicate.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/StringPredicate.java
@@ -30,7 +30,7 @@
  * @since 3.3.0
  */
 @Evolving
-public abstract class StringPredicate extends Filter {
+abstract class StringPredicate extends Filter {
   protected final NamedReference column;
   protected final UTF8String value;
 

From d30b1a128f100d65418a7260267c6dbe844e8817 Mon Sep 17 00:00:00 2001
From: Huaxin Gao <huaxin_gao@apple.com>
Date: Fri, 10 Sep 2021 12:08:12 -0700
Subject: [PATCH 24/24] address comments

---
 .../apache/spark/sql/connector/expressions/filter/In.java    | 5 +++--
 .../spark/sql/execution/datasources/v2/V2FiltersSuite.scala  | 4 ++--
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
index d9f6c717cdba1..8d6490b8984fd 100644
--- a/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
+++ b/sql/catalyst/src/main/java/org/apache/spark/sql/connector/expressions/filter/In.java
@@ -50,7 +50,8 @@ public boolean equals(Object o) {
     if (this == o) return true;
     if (o == null || getClass() != o.getClass()) return false;
     In in = (In) o;
-    return Objects.equals(column, in.column) && Arrays.equals(values, in.values);
+    return Objects.equals(column, in.column) && values.length == in.values.length
+      && Arrays.asList(values).containsAll(Arrays.asList(in.values));
   }
 
   @Override
@@ -64,7 +65,7 @@ public int hashCode() {
   public String toString() {
     String res = Arrays.stream(values).limit((MAX_LEN_TO_PRINT)).map(Literal::describe)
       .collect(Collectors.joining(", "));
-    if(values.length > MAX_LEN_TO_PRINT) {
+    if (values.length > MAX_LEN_TO_PRINT) {
       res += "...";
     }
     return column.describe() + " IN (" + res + ")";
diff --git a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
index 7f9c09999ff82..b457211b7f89f 100644
--- a/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
+++ b/sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/v2/V2FiltersSuite.scala
@@ -109,8 +109,8 @@ class FiltersV2Suite extends SparkFunSuite {
       Array(LiteralValue(1, IntegerType), LiteralValue(2, IntegerType),
         LiteralValue(3, IntegerType), LiteralValue(4, IntegerType)))
     val filter2 = new In(ref("a"),
-      Array(LiteralValue(1, IntegerType), LiteralValue(2, IntegerType),
-        LiteralValue(3, IntegerType), LiteralValue(4, IntegerType)))
+      Array(LiteralValue(4, IntegerType), LiteralValue(2, IntegerType),
+        LiteralValue(3, IntegerType), LiteralValue(1, IntegerType)))
     assert(filter1.equals(filter2))
     assert(filter1.references.map(_.describe()).toSeq == Seq("a"))
     assert(filter1.describe.equals("a IN (1, 2, 3, 4)"))