Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed 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 com.facebook.presto.type;
 
 
 import static com.facebook.presto.SessionTestUtils.TEST_SESSION;
 import static com.facebook.presto.spi.StandardErrorCode.FUNCTION_NOT_FOUND;
 import static com.facebook.presto.spi.StandardErrorCode.INVALID_CAST_ARGUMENT;
 import static com.facebook.presto.spi.StandardErrorCode.INVALID_FUNCTION_ARGUMENT;
 import static com.facebook.presto.spi.StandardErrorCode.NOT_SUPPORTED;
 import static com.facebook.presto.spi.type.BigintType.BIGINT;
 import static com.facebook.presto.spi.type.BooleanType.BOOLEAN;
 import static com.facebook.presto.spi.type.DoubleType.DOUBLE;
 import static com.facebook.presto.spi.type.TimestampType.TIMESTAMP;
 import static com.facebook.presto.spi.type.VarcharType.VARCHAR;
 import static com.facebook.presto.type.ArrayType.toStackRepresentation;
 import static com.facebook.presto.type.JsonType.JSON;
 import static com.facebook.presto.type.UnknownType.UNKNOWN;
 import static java.lang.Double.NEGATIVE_INFINITY;
 import static java.lang.Double.NaN;
 import static java.lang.Double.POSITIVE_INFINITY;
 import static java.util.Arrays.asList;
 import static java.util.Collections.singletonList;
 import static org.testng.Assert.assertEquals;
 import static org.testng.Assert.assertTrue;
 import static org.testng.Assert.fail;
 
 public class TestArrayOperators
         extends AbstractTestFunctions
 {
     public TestArrayOperators()
     {
         registerScalar(TestingRowConstructor.class);
     }
 
     @Test
     public void testStackRepresentation()
             throws Exception
     {
         Slice slice = toStackRepresentation(ImmutableList.of(
                 toStackRepresentation(ImmutableList.of(1L, 2L), ),
                 toStackRepresentation(ImmutableList.of(3L), )), new ArrayType(new ArrayType()));
 
         DynamicSliceOutput output = new DynamicSliceOutput(100);
         output.appendInt(2) // size of root array
                 .appendInt(33) // length of the first sub array bytes
                 .appendInt(21) // length of the second sub array bytes
                 .appendByte(0) // null flags
                 .appendInt(54) // length of root array bytes
 
                     .appendInt(2) // size of the first array
                     .appendInt(8) // length of long value 1
                     .appendInt(8) // length of long value 2
                     .appendByte(0) // null flags
                     .appendInt(16) // length of values
                     .appendLong(1) // value 1
                     .appendLong(2) // value 2
 
                     .appendInt(1) // size of the second array
                     .appendInt(8) // length of long value 3
                     .appendByte(0) // null flags
                     .appendInt(8) // length of values
                     .appendLong(3); // value 3
 
         assertEquals(sliceoutput.slice());
     }
 
     @Test
     public void testArrayElements()
             throws Exception
     {
         assertFunction("CAST(ARRAY [1, 2, 3] AS ARRAY<BIGINT>)"new ArrayType(), ImmutableList.of(1L, 2L, 3L));
         assertFunction("CAST(ARRAY [1, null, 3] AS ARRAY<BIGINT>)"new ArrayType(), asList(1L, null, 3L));
 
         assertFunction("CAST(ARRAY [1, 2, 3] AS ARRAY<DOUBLE>)"new ArrayType(), ImmutableList.of(1.0, 2.0, 3.0));
        assertFunction("CAST(ARRAY [1, null, 3] AS ARRAY<DOUBLE>)"new ArrayType(), asList(1.0, null, 3.0));
        assertFunction("CAST(ARRAY ['1', '2'] AS ARRAY<VARCHAR>)"new ArrayType(), ImmutableList.of("1""2"));
        assertFunction("CAST(ARRAY ['1', '2'] AS ARRAY<DOUBLE>)"new ArrayType(), ImmutableList.of(1.0, 2.0));
        assertFunction("CAST(ARRAY [true, false] AS ARRAY<BOOLEAN>)"new ArrayType(), ImmutableList.of(truefalse));
        assertFunction("CAST(ARRAY [true, false] AS ARRAY<VARCHAR>)"new ArrayType(), ImmutableList.of("true""false"));
        assertFunction("CAST(ARRAY [1, 0] AS ARRAY<BOOLEAN>)"new ArrayType(), ImmutableList.of(truefalse));
        assertFunction("CAST(ARRAY [ARRAY[1], ARRAY[2, 3]] AS ARRAY<ARRAY<DOUBLE>>)"new ArrayType(new ArrayType()), asList(asList(1.0), asList(2.0, 3.0)));
        assertInvalidFunction("CAST(ARRAY [1, null, 3] AS ARRAY<TIMESTAMP>)");
        assertInvalidFunction("CAST(ARRAY [1, null, 3] AS ARRAY<ARRAY<TIMESTAMP>>)");
        assertInvalidFunction("CAST(ARRAY ['puppies', 'kittens'] AS ARRAY<BIGINT>)");
    }
    @Test
    public void testArrayToJson()
            throws Exception
    {
        assertFunction("CAST(ARRAY [1, 2, 3] AS JSON)""[1,2,3]");
        assertFunction("CAST(ARRAY [1, NULL, 3] AS JSON)""[1,null,3]");
        assertFunction("CAST(ARRAY [1, 2.0, 3] AS JSON)""[1.0,2.0,3.0]");
        assertFunction("CAST(ARRAY [1.0, 2.5, 3.0] AS JSON)""[1.0,2.5,3.0]");
        assertFunction("CAST(ARRAY ['puppies', 'kittens'] AS JSON)""[\"puppies\",\"kittens\"]");
        assertFunction("CAST(ARRAY [TRUE, FALSE] AS JSON)""[true,false]");
        assertFunction("CAST(ARRAY [from_unixtime(1)] AS JSON)""[\"" + sqlTimestamp(1000) + "\"]");
    }
    @Test
    public void testJsonToArray()
            throws Exception
    {
        assertFunction("CAST(CAST('[1, 2, 3]' AS JSON) AS ARRAY<BIGINT>)"new ArrayType(), ImmutableList.of(1L, 2L, 3L));
        assertFunction("CAST(CAST('[1, null, 3]' AS JSON) AS ARRAY<BIGINT>)"new ArrayType(), asList(1L, null, 3L));
        assertFunction("CAST(CAST('[1, 2.0, 3]' AS JSON) AS ARRAY<DOUBLE>)"new ArrayType(), ImmutableList.of(1.0, 2.0, 3.0));
        assertFunction("CAST(CAST('[1.0, 2.5, 3.0]' AS JSON) AS ARRAY<DOUBLE>)"new ArrayType(), ImmutableList.of(1.0, 2.5, 3.0));
        assertFunction("CAST(CAST('[\"puppies\", \"kittens\"]' AS JSON) AS ARRAY<VARCHAR>)"new ArrayType(), ImmutableList.of("puppies""kittens"));
        assertFunction("CAST(CAST('[true, false]' AS JSON) AS ARRAY<BOOLEAN>)"new ArrayType(), ImmutableList.of(truefalse));
        assertFunction("CAST(CAST('[[1], [null]]' AS JSON) AS ARRAY<ARRAY<BIGINT>>)"new ArrayType(new ArrayType()), asList(asList(1L), asList((Longnull)));
        assertFunction("CAST(CAST('null' AS JSON) AS ARRAY<BIGINT>)"new ArrayType(), null);
        assertInvalidCast("CAST(CAST('[1, null, 3]' AS JSON) AS ARRAY<TIMESTAMP>)");
        assertInvalidCast("CAST(CAST('[1, null, 3]' AS JSON) AS ARRAY<ARRAY<TIMESTAMP>>)");
        assertInvalidCast("CAST(CAST('[1, 2, 3]' AS JSON) AS ARRAY<BOOLEAN>)");
        assertInvalidCast("CAST(CAST('[\"puppies\", \"kittens\"]' AS JSON) AS ARRAY<BIGINT>)");
    }
    @Test
    public void testConstructor()
            throws Exception
    {
        assertFunction("ARRAY []"new ArrayType(), ImmutableList.of());
        assertFunction("ARRAY [NULL]"new ArrayType(), Lists.newArrayList((Objectnull));
        assertFunction("ARRAY [1, 2, 3]"new ArrayType(), ImmutableList.of(1L, 2L, 3L));
        assertFunction("ARRAY [1, NULL, 3]"new ArrayType(), Lists.newArrayList(1L, null, 3L));
        assertFunction("ARRAY [NULL, 2, 3]"new ArrayType(), Lists.newArrayList(null, 2L, 3L));
        assertFunction("ARRAY [1, 2.0, 3]"new ArrayType(), ImmutableList.of(1.0, 2.0, 3.0));
        assertFunction("ARRAY [ARRAY[1, 2], ARRAY[3]]"new ArrayType(new ArrayType()), ImmutableList.of(ImmutableList.of(1L, 2L), ImmutableList.of(3L)));
        assertFunction("ARRAY [ARRAY[1, 2], NULL, ARRAY[3]]"new ArrayType(new ArrayType()), Lists.newArrayList(ImmutableList.of(1L, 2L), null, ImmutableList.of(3L)));
        assertFunction("ARRAY [1.0, 2.5, 3.0]"new ArrayType(), ImmutableList.of(1.0, 2.5, 3.0));
        assertFunction("ARRAY [1, 2.5, 3]"new ArrayType(), ImmutableList.of(1.0, 2.5, 3.0));
        assertFunction("ARRAY ['puppies', 'kittens']"new ArrayType(), ImmutableList.of("puppies""kittens"));
        assertFunction("ARRAY [TRUE, FALSE]"new ArrayType(), ImmutableList.of(truefalse));
        assertFunction("ARRAY [from_unixtime(1), from_unixtime(100)]"new ArrayType(), ImmutableList.of(
                sqlTimestamp(1000), sqlTimestamp(100_000)));
        assertFunction("ARRAY [sqrt(-1)]"new ArrayType(), ImmutableList.of());
        assertFunction("ARRAY [pow(infinity(), 2)]"new ArrayType(), ImmutableList.of());
        assertFunction("ARRAY [pow(-infinity(), 1)]"new ArrayType(), ImmutableList.of());
    }
    @Test
    public void testArrayToArrayConcat()
            throws Exception
    {
        assertFunction("ARRAY [1, NULL] || ARRAY [3]"new ArrayType(), Lists.newArrayList(1L, null, 3L));
        assertFunction("ARRAY [1, 2] || ARRAY[3, 4]"new ArrayType(), ImmutableList.of(1L, 2L, 3L, 4L));
        assertFunction("ARRAY [NULL] || ARRAY[NULL]"new ArrayType(), Lists.newArrayList(nullnull));
        assertFunction("ARRAY ['puppies'] || ARRAY ['kittens']"new ArrayType(), ImmutableList.of("puppies""kittens"));
        assertFunction("ARRAY [TRUE] || ARRAY [FALSE]"new ArrayType(), ImmutableList.of(truefalse));
        assertFunction("concat(ARRAY [1] , ARRAY[2,3])"new ArrayType(), ImmutableList.of(1L, 2L, 3L));
        assertFunction("ARRAY [from_unixtime(1)] || ARRAY[from_unixtime(100)]"new ArrayType(), ImmutableList.of(
                sqlTimestamp(1000), sqlTimestamp(100_000)));
        assertFunction("ARRAY [ARRAY[ARRAY[1]]] || ARRAY [ARRAY[ARRAY[2]]]",
                new ArrayType(new ArrayType(new ArrayType())),
                asList(singletonList(Longs.asList(1)), singletonList(Longs.asList(2))));
        assertFunction("ARRAY [] || ARRAY []"new ArrayType(), ImmutableList.of());
        assertFunction("ARRAY [TRUE] || ARRAY [FALSE] || ARRAY [TRUE]"new ArrayType(), ImmutableList.of(truefalsetrue));
        assertFunction("ARRAY [1] || ARRAY [2] || ARRAY [3] || ARRAY [4]"new ArrayType(), ImmutableList.of(1L, 2L, 3L, 4L));
        assertFunction("ARRAY [1] || ARRAY [2.0] || ARRAY [3] || ARRAY [4.0]"new ArrayType(), ImmutableList.of(1.0, 2.0, 3.0, 4.0));
        assertInvalidFunction("ARRAY [ARRAY[1]] || ARRAY[ARRAY[true], ARRAY[false]]".toErrorCode());
        try {
            assertFunction("ARRAY [ARRAY[1]] || ARRAY[NULL]"new ArrayType(new ArrayType()), null);
            fail("arrays must be of the same type");
        }
        catch (RuntimeException e) {
            // Expected
        }
    }
    @Test
    public void testElementArrayConcat()
            throws Exception
    {
        assertFunction("CAST (ARRAY [DATE '2001-08-22'] || DATE '2001-08-23' AS JSON)""[\"2001-08-22\",\"2001-08-23\"]");
        assertFunction("CAST (DATE '2001-08-23' || ARRAY [DATE '2001-08-22'] AS JSON)""[\"2001-08-23\",\"2001-08-22\"]");
        assertFunction("1 || ARRAY [2]"new ArrayType(), Lists.newArrayList(1L, 2L));
        assertFunction("ARRAY [2] || 1"new ArrayType(), Lists.newArrayList(2L, 1L));
        assertFunction("TRUE || ARRAY [FALSE]"new ArrayType(), Lists.newArrayList(truefalse));
        assertFunction("ARRAY [FALSE] || TRUE"new ArrayType(), Lists.newArrayList(falsetrue));
        assertFunction("1.0 || ARRAY [2.0]"new ArrayType(), Lists.newArrayList(1.0, 2.0));
        assertFunction("ARRAY [2.0] || 1.0"new ArrayType(), Lists.newArrayList(2.0, 1.0));
        assertFunction("'puppies' || ARRAY ['kittens']"new ArrayType(), Lists.newArrayList("puppies""kittens"));
        assertFunction("ARRAY ['kittens'] || 'puppies'"new ArrayType(), Lists.newArrayList("kittens""puppies"));
        assertFunction("ARRAY [from_unixtime(1)] || from_unixtime(100)"new ArrayType(), ImmutableList.of(
                sqlTimestamp(1000), sqlTimestamp(100_000)));
        assertFunction("from_unixtime(100) || ARRAY [from_unixtime(1)]"new ArrayType(), ImmutableList.of(
                sqlTimestamp(100_000), sqlTimestamp(1000)));
    }
    @Test
    public void testArrayContains()
            throws Exception
    {
        assertFunction("CONTAINS(ARRAY [1, 2, 3], 2)"true);
        assertFunction("CONTAINS(ARRAY [1, 2, 3], 5)"false);
        assertFunction("CONTAINS(ARRAY [1, NULL, 3], 1)"true);
        assertFunction("CONTAINS(ARRAY [NULL, 2, 3], 1)"null);
        assertFunction("CONTAINS(ARRAY [1, 2.0, 3], 3.0)"true);
        assertFunction("CONTAINS(ARRAY [1.0, 2.5, 3.0], 2.2)"false);
        assertFunction("CONTAINS(ARRAY ['puppies', 'kittens'], 'kittens')"true);
        assertFunction("CONTAINS(ARRAY ['puppies', 'kittens'], 'lizards')"false);
        assertFunction("CONTAINS(ARRAY [TRUE, FALSE], TRUE)"true);
        assertFunction("CONTAINS(ARRAY [FALSE], TRUE)"false);
    }
    @Test
    public void testArrayJoin()
            throws Exception
    {
        assertFunction("array_join(ARRAY[1, NULL, 2], ',')""1,2");
        assertFunction("ARRAY_JOIN(ARRAY [1, 2, 3], ';', 'N/A')""1;2;3");
        assertFunction("ARRAY_JOIN(ARRAY [1, 2, null], ';', 'N/A')""1;2;N/A");
        assertFunction("ARRAY_JOIN(ARRAY [1, 2, 3], 'x')""1x2x3");
        assertFunction("ARRAY_JOIN(ARRAY [null], '=')""");
        assertFunction("ARRAY_JOIN(ARRAY [null,null], '=')""");
        assertFunction("ARRAY_JOIN(ARRAY [], 'S')""");
        assertFunction("ARRAY_JOIN(ARRAY [''], '', '')""");
        assertFunction("ARRAY_JOIN(ARRAY [1, 2, 3, null, 5], ',', '*')""1,2,3,*,5");
        assertFunction("ARRAY_JOIN(ARRAY ['a', 'b', 'c', null, null, 'd'], '-', 'N/A')""a-b-c-N/A-N/A-d");
        assertFunction("ARRAY_JOIN(ARRAY ['a', 'b', 'c', null, null, 'd'], '-')""a-b-c-d");
        assertFunction("ARRAY_JOIN(ARRAY [null, null, null, null], 'X')""");
        assertFunction("ARRAY_JOIN(ARRAY [true, false], 'XX')""trueXXfalse");
        assertFunction("ARRAY_JOIN(ARRAY [sqrt(-1), infinity()], ',')""NaN,Infinity");
        assertFunction("ARRAY_JOIN(ARRAY [from_unixtime(1), from_unixtime(10)], '|')"sqlTimestamp(1000).toString() + "|" + sqlTimestamp(10_000).toString());
        assertFunction("ARRAY_JOIN(ARRAY [null, from_unixtime(10)], '|')"sqlTimestamp(10_000).toString());
        assertFunction("ARRAY_JOIN(ARRAY [null, from_unixtime(10)], '|', 'XYZ')""XYZ|" + sqlTimestamp(10_000).toString());
        assertInvalidFunction("ARRAY_JOIN(ARRAY [ARRAY [1], ARRAY [2]], '-')");
        assertInvalidFunction("ARRAY_JOIN(ARRAY [MAP(ARRAY [1], ARRAY [2])], '-')");
        assertInvalidFunction("ARRAY_JOIN(ARRAY [test_row(1, 2)], '-')");
    }
    @Test
    public void testCardinality()
            throws Exception
    {
        assertFunction("CARDINALITY(ARRAY [])", 0);
        assertFunction("CARDINALITY(ARRAY [NULL])", 1);
        assertFunction("CARDINALITY(ARRAY [1, 2, 3])", 3);
        assertFunction("CARDINALITY(ARRAY [1, NULL, 3])", 3);
        assertFunction("CARDINALITY(ARRAY [1, 2.0, 3])", 3);
        assertFunction("CARDINALITY(ARRAY [ARRAY[1, 2], ARRAY[3]])", 2);
        assertFunction("CARDINALITY(ARRAY [1.0, 2.5, 3.0])", 3);
        assertFunction("CARDINALITY(ARRAY ['puppies', 'kittens'])", 2);
        assertFunction("CARDINALITY(ARRAY [TRUE, FALSE])", 2);
    }
    @Test
    public void testArrayPosition()
            throws Exception
    {
        assertFunction("ARRAY_POSITION(ARRAY [10, 20, 30, 40], 30)", 3);
        assertFunction("ARRAY_POSITION(cast(cast('[]' as json) as array<bigint>), 30)", 0);
        assertFunction("ARRAY_POSITION(ARRAY [cast(NULL as bigint)], 30)", 0);
        assertFunction("ARRAY_POSITION(ARRAY [cast(NULL as bigint), NULL, NULL], 30)", 0);
        assertFunction("ARRAY_POSITION(ARRAY [NULL, NULL, 30, NULL], 30)", 3);
        assertFunction("ARRAY_POSITION(ARRAY [1.1, 2.1, 3.1, 4.1], 3.1)", 3);
        assertFunction("ARRAY_POSITION(ARRAY [false, false, true, true], true)", 3);
        assertFunction("ARRAY_POSITION(ARRAY ['10', '20', '30', '40'], '30')", 3);
        assertFunction("ARRAY_POSITION(ARRAY [DATE '2000-01-01', DATE '2000-01-02', DATE '2000-01-03', DATE '2000-01-04'], DATE '2000-01-03')", 3);
        assertFunction("ARRAY_POSITION(ARRAY [ARRAY [1, 11], ARRAY [2, 12], ARRAY [3, 13], ARRAY [4, 14]], ARRAY [3, 13])", 3);
    }
    @Test
    public void testSubscript()
            throws Exception
    {
        String outOfBounds = "Index out of bounds";
        assertInvalidFunction("ARRAY [][1]"outOfBounds);
        assertInvalidFunction("ARRAY [null][-1]"outOfBounds);
        assertInvalidFunction("ARRAY [1, 2, 3][0]"outOfBounds);
        assertInvalidFunction("ARRAY [1, 2, 3][-1]"outOfBounds);
        assertInvalidFunction("ARRAY [1, 2, 3][4]"outOfBounds);
        try {
            assertFunction("ARRAY [1, 2, 3][1.1]"null);
            fail("Access to array with double subscript should fail");
        }
        catch (SemanticException e) {
            assertTrue(e.getCode() == .);
        }
        assertFunction("ARRAY[NULL][1]"null);
        assertFunction("ARRAY[NULL, NULL, NULL][3]"null);
        assertFunction("1 + ARRAY [2, 1, 3][2]", 2);
        assertFunction("ARRAY [2, 1, 3][2]", 1);
        assertFunction("ARRAY [2, NULL, 3][2]"null);
        assertFunction("ARRAY [1.0, 2.5, 3.5][3]", 3.5);
        assertFunction("ARRAY [ARRAY[1, 2], ARRAY[3]][2]"new ArrayType(), ImmutableList.of(3L));
        assertFunction("ARRAY [ARRAY[1, 2], NULL, ARRAY[3]][2]"new ArrayType(), null);
        assertFunction("ARRAY [ARRAY[1, 2], ARRAY[3]][2][1]", 3);
        assertFunction("ARRAY ['puppies', 'kittens'][2]""kittens");
        assertFunction("ARRAY ['puppies', 'kittens', NULL][3]"null);
        assertFunction("ARRAY [TRUE, FALSE][2]"false);
        assertFunction("ARRAY [from_unixtime(1), from_unixtime(100)][1]"sqlTimestamp(1000));
        assertFunction("ARRAY [infinity()][1]");
        assertFunction("ARRAY [-infinity()][1]");
        assertFunction("ARRAY [sqrt(-1)][1]");
    }
    @Test
    public void testSort()
            throws Exception
    {
        assertFunction("ARRAY_SORT(ARRAY[2, 3, 4, 1])"new ArrayType(), ImmutableList.of(1L, 2L, 3L, 4L));
        assertFunction("ARRAY_SORT(ARRAY['z', 'f', 's', 'd', 'g'])"new ArrayType(), ImmutableList.of("d""f""g""s""z"));
        assertFunction("ARRAY_SORT(ARRAY[TRUE, FALSE])"new ArrayType(), ImmutableList.of(falsetrue));
        assertFunction("ARRAY_SORT(ARRAY[22.1, 11.1, 1.1, 44.1])"new ArrayType(), ImmutableList.of(1.1, 11.1, 22.1, 44.1));
        assertFunction("ARRAY_SORT(ARRAY [from_unixtime(100), from_unixtime(1), from_unixtime(200)])",
                new ArrayType(),
                ImmutableList.of(sqlTimestamp(1000), sqlTimestamp(100 * 1000), sqlTimestamp(200 * 1000)));
        assertFunction("ARRAY_SORT(ARRAY [ARRAY [1], ARRAY [2]])",
                new ArrayType(new ArrayType()),
                ImmutableList.of(ImmutableList.of(1L), ImmutableList.of(2L)));
        assertInvalidFunction("ARRAY_SORT(ARRAY[color('red'), color('blue')])".toErrorCode());
    }
    @Test void testDistinct()
            throws Exception
    {
        assertFunction("ARRAY_DISTINCT(ARRAY [])"new ArrayType(), ImmutableList.of());
        // Order matters here. Result should be stable.
        assertFunction("ARRAY_DISTINCT(ARRAY [2, 3, 4, 3, 1, 2, 3])"new ArrayType(), ImmutableList.of(2L, 3L, 4L, 1L));
        assertFunction("ARRAY_DISTINCT(ARRAY [2.2, 3.3, 4.4, 3.3, 1, 2.2, 3.3])"new ArrayType(), ImmutableList.of(2.2, 3.3, 4.4, 1.0));
        assertFunction("ARRAY_DISTINCT(ARRAY [TRUE, TRUE, TRUE])"new ArrayType(), ImmutableList.of(true));
        assertFunction("ARRAY_DISTINCT(ARRAY [TRUE, FALSE, FALSE, TRUE])"new ArrayType(), ImmutableList.of(truefalse));
        assertFunction("ARRAY_DISTINCT(ARRAY [from_unixtime(100), from_unixtime(1), from_unixtime(100)])"new ArrayType(),
                ImmutableList.of(sqlTimestamp(100 * 1000), sqlTimestamp(1000)));
        assertFunction("ARRAY_DISTINCT(ARRAY ['2', '3', '2'])"new ArrayType(), ImmutableList.of("2""3"));
        assertFunction("ARRAY_DISTINCT(ARRAY ['BB', 'CCC', 'BB'])"new ArrayType(), ImmutableList.of("BB""CCC"));
        assertFunction("ARRAY_DISTINCT(ARRAY [NULL, 2.2, 3.3, 4.4, 3.3, 1, 2.2, 3.3])"new ArrayType(), asList(null, 2.2, 3.3, 4.4, 1.0));
        assertFunction("ARRAY_DISTINCT(ARRAY [2, 3, NULL, 4, 3, 1, 2, 3])"new ArrayType(), asList(2L, 3L, null, 4L, 1L));
        assertFunction("ARRAY_DISTINCT(ARRAY ['BB', 'CCC', 'BB', NULL])"new ArrayType(), asList("BB""CCC"null));
        assertFunction("ARRAY_DISTINCT(ARRAY [NULL])"new ArrayType(), asList((Objectnull));
        assertFunction("ARRAY_DISTINCT(ARRAY [NULL, NULL])"new ArrayType(), asList((Objectnull));
        assertFunction("ARRAY_DISTINCT(ARRAY [NULL, NULL, NULL])"new ArrayType(), asList((Objectnull));
    }
    @Test
    public void testArrayIntersect()
            throws Exception
    {
        assertFunction("ARRAY_INTERSECT(ARRAY [12], ARRAY [10])"new ArrayType(), ImmutableList.of());
        assertFunction("ARRAY_INTERSECT(ARRAY ['foo', 'bar', 'baz'], ARRAY ['foo', 'test', 'bar'])"new ArrayType(), ImmutableList.of("bar""foo"));
        assertFunction("ARRAY_INTERSECT(ARRAY [NULL], ARRAY [NULL, NULL])"new ArrayType(), asList((Objectnull));
        assertFunction("ARRAY_INTERSECT(ARRAY ['abc', NULL, 'xyz', NULL], ARRAY [NULL, 'abc', NULL, NULL])"new ArrayType(), asList(null"abc"));
        assertFunction("ARRAY_INTERSECT(ARRAY [1, 5], ARRAY [1])"new ArrayType(), ImmutableList.of(1L));
        assertFunction("ARRAY_INTERSECT(ARRAY [1, 1, 2, 4], ARRAY [1, 1, 4, 4])"new ArrayType(), ImmutableList.of(1L, 4L));
        assertFunction("ARRAY_INTERSECT(ARRAY [2, 8], ARRAY [8, 3])"new ArrayType(), ImmutableList.of(8L));
        assertFunction("ARRAY_INTERSECT(ARRAY [IF (RAND() < 1.0, 7, 1) , 2], ARRAY [7])"new ArrayType(), ImmutableList.of(7L));
        assertFunction("ARRAY_INTERSECT(ARRAY [1, 5], ARRAY [1.0])"new ArrayType(), ImmutableList.of(1.0));
        assertFunction("ARRAY_INTERSECT(ARRAY [8.3, 1.6, 4.1, 5.2], ARRAY [4.0, 5.2, 8.3, 9.7, 3.5])"new ArrayType(), ImmutableList.of(5.2, 8.3));
        assertFunction("ARRAY_INTERSECT(ARRAY [5.1, 7, 3.0, 4.8, 10], ARRAY [6.5, 10.0, 1.9, 5.1, 3.9, 4.8])"new ArrayType(), ImmutableList.of(4.8, 5.1, 10.0));
    }
    @Test
    public void testComparison()
            throws Exception
    {
        assertFunction("ARRAY [1, 2, 3] = ARRAY [1, 2, 3]"true);
        assertFunction("ARRAY [TRUE, FALSE] = ARRAY [TRUE, FALSE]"true);
        assertFunction("ARRAY [1.1, 2.2, 3.3, 4.4] = ARRAY [1.1, 2.2, 3.3, 4.4]"true);
        assertFunction("ARRAY ['puppies', 'kittens'] = ARRAY ['puppies', 'kittens']"true);
        assertFunction(
                "ARRAY [TIME '01:02:03.456 America/Los_Angeles', TIME '10:20:30.456 America/Los_Angeles'] = ARRAY [TIME '01:02:03.456 America/Los_Angeles', TIME '10:20:30.456 America/Los_Angeles']",
                ,
                true);
        assertFunction("ARRAY [timestamp '2012-10-31 08:00 UTC'] = ARRAY [timestamp '2012-10-31 01:00 America/Los_Angeles']"true);
        assertFunction("ARRAY [1, 2, 3] = ARRAY [3, 2, 1]"false);
        assertFunction("ARRAY [TRUE, FALSE] = ARRAY [FALSE, FALSE]"false);
        assertFunction("ARRAY [1.1, 2.2, 3.3] = ARRAY [11.1, 22.1, 1.1, 44.1]"false);
        assertFunction("ARRAY ['puppies', 'kittens'] = ARRAY ['z', 'f', 's', 'd', 'g']"false);
        assertFunction("ARRAY [TIME '01:02:03.456 America/Los_Angeles', TIME '10:20:30.456 America/Los_Angeles'] = ARRAY [TIME '04:05:06.456 America/Los_Angeles', TIME '10:20:30.456 America/Los_Angeles']"false);
        assertFunction("ARRAY [10, 20, 30] < ARRAY [10, 20, 40, 50]"true);
        assertFunction("ARRAY [10, 20, 30] < ARRAY [10, 40]"true);
        assertFunction("ARRAY [10, 20] < ARRAY [10, 20, 30]"true);
        assertFunction("ARRAY [TRUE, FALSE] < ARRAY [TRUE, TRUE, TRUE]"true);
        assertFunction("ARRAY [TRUE, FALSE, FALSE] < ARRAY [TRUE, TRUE]"true);
        assertFunction("ARRAY [TRUE, FALSE] < ARRAY [TRUE, FALSE, FALSE]"true);
        assertFunction("ARRAY[1.1, 2.2, 3.3, 4.4] < ARRAY[1.1, 2.2, 4.4, 4.4]"true);
        assertFunction("ARRAY[1.1, 2.2, 3.3, 4.4] < ARRAY[1.1, 2.2, 5.5]"true);
        assertFunction("ARRAY[1.1, 2.2] < ARRAY[1.1, 2.2, 5.5]"true);
        assertFunction("ARRAY['puppies', 'kittens', 'lizards'] < ARRAY ['puppies', 'lizards', 'lizards']"true);
        assertFunction("ARRAY['puppies', 'kittens', 'lizards'] < ARRAY ['puppies', 'lizards']"true);
        assertFunction("ARRAY['puppies', 'kittens'] < ARRAY ['puppies', 'kittens', 'lizards']"true);
        assertFunction("ARRAY [TIME '01:02:03.456 America/Los_Angeles', TIME '10:20:30.456 America/Los_Angeles'] < ARRAY [TIME '04:05:06.456 America/Los_Angeles', TIME '10:20:30.456 America/Los_Angeles']"true);
        assertFunction("ARRAY [TIME '01:02:03.456 America/Los_Angeles', TIME '10:20:30.456 America/Los_Angeles', TIME '10:20:30.456 America/Los_Angeles'] < ARRAY [TIME '04:05:06.456 America/Los_Angeles', TIME '10:20:30.456 America/Los_Angeles']"true);
        assertFunction("ARRAY [TIME '01:02:03.456 America/Los_Angeles', TIME '10:20:30.456 America/Los_Angeles'] < ARRAY [TIME '01:02:03.456 America/Los_Angeles', TIME '10:20:30.456 America/Los_Angeles', TIME '10:20:30.456 America/Los_Angeles']"true);
        assertFunction("ARRAY [10, 20, 30] > ARRAY [10, 20, 20]"true);
        assertFunction("ARRAY [10, 20, 30] > ARRAY [10, 20]"true);
        assertFunction("ARRAY [TRUE, TRUE, TRUE] > ARRAY [TRUE, TRUE, FALSE]"true);
        assertFunction("ARRAY [TRUE, TRUE, FALSE] > ARRAY [TRUE, TRUE]"true);
        assertFunction("ARRAY[1.1, 2.2, 3.3, 4.4] > ARRAY[1.1, 2.2, 2.2, 4.4]"true);
        assertFunction("ARRAY[1.1, 2.2, 3.3, 4.4] > ARRAY[1.1, 2.2, 3.3]"true);
        assertFunction("ARRAY['puppies', 'kittens', 'lizards'] > ARRAY ['puppies', 'kittens', 'kittens']"true);
        assertFunction("ARRAY['puppies', 'kittens', 'lizards'] > ARRAY ['puppies', 'kittens']"true);
        assertFunction("ARRAY [TIME '01:02:03.456 America/Los_Angeles', TIME '10:20:30.456 America/Los_Angeles', TIME '10:20:30.456 America/Los_Angeles'] > ARRAY [TIME '01:02:03.456 America/Los_Angeles', TIME '10:20:30.456 America/Los_Angeles']"true);
        assertFunction("ARRAY [TIME '01:02:03.456 America/Los_Angeles', TIME '10:20:30.456 America/Los_Angeles'] > ARRAY [TIME '01:02:03.456 America/Los_Angeles', TIME '10:20:20.456 America/Los_Angeles']"true);
        assertFunction("ARRAY [10, 20, 30] <= ARRAY [50]"true);
        assertFunction("ARRAY [10, 20, 30] <= ARRAY [10, 20, 30]"true);
        assertFunction("ARRAY [TRUE, FALSE] <= ARRAY [TRUE, FALSE, true]"true);
        assertFunction("ARRAY [TRUE, FALSE] <= ARRAY [TRUE, FALSE]"true);
        assertFunction("ARRAY[1.1, 2.2, 3.3, 4.4] <= ARRAY[2.2, 5.5]"true);
        assertFunction("ARRAY[1.1, 2.2, 3.3, 4.4] <= ARRAY[1.1, 2.2, 3.3, 4.4]"true);
        assertFunction("ARRAY['puppies', 'kittens', 'lizards'] <= ARRAY ['puppies', 'lizards']"true);
        assertFunction("ARRAY['puppies', 'kittens'] <= ARRAY['puppies', 'kittens']"true);
        assertFunction("ARRAY [TIME '01:02:03.456 America/Los_Angeles', TIME '10:20:30.456 America/Los_Angeles'] <= ARRAY [TIME '04:05:06.456 America/Los_Angeles', TIME '10:20:30.456 America/Los_Angeles']"true);
        assertFunction("ARRAY [TIME '01:02:03.456 America/Los_Angeles', TIME '10:20:30.456 America/Los_Angeles'] <= ARRAY [TIME '01:02:03.456 America/Los_Angeles', TIME '10:20:30.456 America/Los_Angeles']"true);
        assertFunction("ARRAY [10, 20, 30] >= ARRAY [10, 20, 30]"true);
        assertFunction("ARRAY [TRUE, FALSE, TRUE] >= ARRAY [TRUE, FALSE, TRUE]"true);
        assertFunction("ARRAY [TRUE, FALSE, TRUE] >= ARRAY [TRUE]"true);
        assertFunction("ARRAY[1.1, 2.2, 3.3, 4.4] >= ARRAY[1.1, 2.2]"true);
        assertFunction("ARRAY[1.1, 2.2, 3.3, 4.4] >= ARRAY[1.1, 2.2, 3.3, 4.4]"true);
        assertFunction("ARRAY['puppies', 'kittens', 'lizards'] >= ARRAY ['puppies', 'kittens', 'kittens']"true);
        assertFunction("ARRAY['puppies', 'kittens'] >= ARRAY['puppies', 'kittens']"true);
        assertFunction("ARRAY [TIME '01:02:03.456 America/Los_Angeles', TIME '10:20:30.456 America/Los_Angeles', TIME '10:20:30.456 America/Los_Angeles'] >= ARRAY [TIME '01:02:03.456 America/Los_Angeles', TIME '10:20:30.456 America/Los_Angeles']"true);
        assertFunction("ARRAY [10, 20, 30] != ARRAY [5]"true);
        assertFunction("ARRAY [TRUE, FALSE, TRUE] != ARRAY [TRUE]"true);
        assertFunction("ARRAY[1.1, 2.2, 3.3, 4.4] != ARRAY[1.1, 2.2]"true);
        assertFunction("ARRAY['puppies', 'kittens', 'lizards'] != ARRAY ['puppies', 'kittens']"true);
        assertFunction("ARRAY [TIME '01:02:03.456 America/Los_Angeles', TIME '10:20:30.456 America/Los_Angeles', TIME '10:20:30.456 America/Los_Angeles'] != ARRAY [TIME '01:02:03.456 America/Los_Angeles', TIME '10:20:30.456 America/Los_Angeles']"true);
        assertInvalidFunction("ARRAY[1, NULL] = ARRAY[1, 2]".toErrorCode());
    }
    public void assertInvalidFunction(String projectionErrorCode errorCode)
    {
        try {
            assertFunction(projectionnull);
            fail("Expected error " + errorCode + " from " + projection);
        }
        catch (PrestoException e) {
            assertEquals(e.getErrorCode(), errorCode);
        }
    }
    private SqlTimestamp sqlTimestamp(long millisUtc)
    {
        return new SqlTimestamp(millisUtc.getTimeZoneKey());
    }
New to GrepCode? Check out our FAQ X