[jira] [Updated] (CALCITE-3482) Equality of nested ROWs returns false for identical literal value

["Ruben Q L (Jira)" <ji...@apache.org>]

     [ https://issues.apache.org/jira/browse/CALCITE-3482?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]

Ruben Q L updated CALCITE-3482:
-------------------------------
    Description: 
Similar to CALCITE-3021.
Problem can be reproduced via:
{code}
select * from
(values
    (1, ROW(1,1)),
    (2, ROW(2,2)),
    (3, ROW(1,1)),
    (4, ROW(2,2))) as t(id,struct)
where t.struct = ROW(2,2);
{code}
which returns no results, instead of the expected (I have run the same query in PostgreSQL, and it returns this result):
{code}
+----+--------+
| ID | STRUCT |
+----+--------+
|  2 | {2, 2} |
|  4 | {2, 2} |
+----+--------+
{code}

The issue is that the comparison is done via {{SqlFunctions#eq(Object b0, Object b1)}}
{code}
  public static boolean eq(Object b0, Object b1) {
    return b0.equals(b1);
  }
{code}
And in this case we have two different Object[], with the same content, so they should be identified as equals (but they are not based on {{Object#equals}}). Probably the simplest solution would be overloading the {{eq}} method for Object[] parameters:
{code}
  public static boolean eq(Object[] b0, Object[] b1) {
    return Arrays.deepEquals(b0, b1);
  }
{code}

  was:
Similar to CALCITE-3021.
Problem can be reproduced via:
{code}
select * from
(values
    (1, ROW(1,1)),
    (2, ROW(2,2)),
    (3, ROW(1,1)),
    (4, ROW(2,2))) as t(id,struct)
where t.struct = ROW(2,2);
{code}
which returns no results, instead of the expected (I have run the same query in PostgreSQL, and it returns this result):
{code}
+----+--------+
| ID | STRUCT |
+----+--------+
|  2 | {2, 2} |
|  4 | {2, 2} |
+----+--------+
{code}

The issue is that the comparison is done via SqlFuynctions#eq(Object b0, Object b1)
{code}
  public static boolean eq(Object b0, Object b1) {
    return b0.equals(b1);
  }
{code}
And in this case we have two different Object[], with the same content, so the should be identified as equals. Probably the simples solution would be overloading the eq method:
{code}
  public static boolean eq(Object[] b0, Object[] b1) {
    return Arrays.deepEquals(b0, b1);
  }
{code}


> Equality of nested ROWs returns false for identical literal value
> -----------------------------------------------------------------
>
>                 Key: CALCITE-3482
>                 URL: https://issues.apache.org/jira/browse/CALCITE-3482
>             Project: Calcite
>          Issue Type: Bug
>    Affects Versions: 1.21.0
>            Reporter: Ruben Q L
>            Assignee: Ruben Q L
>            Priority: Minor
>             Fix For: 1.22.0
>
>
> Similar to CALCITE-3021.
> Problem can be reproduced via:
> {code}
> select * from
> (values
>     (1, ROW(1,1)),
>     (2, ROW(2,2)),
>     (3, ROW(1,1)),
>     (4, ROW(2,2))) as t(id,struct)
> where t.struct = ROW(2,2);
> {code}
> which returns no results, instead of the expected (I have run the same query in PostgreSQL, and it returns this result):
> {code}
> +----+--------+
> | ID | STRUCT |
> +----+--------+
> |  2 | {2, 2} |
> |  4 | {2, 2} |
> +----+--------+
> {code}
> The issue is that the comparison is done via {{SqlFunctions#eq(Object b0, Object b1)}}
> {code}
>   public static boolean eq(Object b0, Object b1) {
>     return b0.equals(b1);
>   }
> {code}
> And in this case we have two different Object[], with the same content, so they should be identified as equals (but they are not based on {{Object#equals}}). Probably the simplest solution would be overloading the {{eq}} method for Object[] parameters:
> {code}
>   public static boolean eq(Object[] b0, Object[] b1) {
>     return Arrays.deepEquals(b0, b1);
>   }
> {code}



--
This message was sent by Atlassian Jira
(v8.3.4#803005)