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.sql.gen;
  
  
  import java.util.Arrays;
  import java.util.List;
  import java.util.Objects;
  import java.util.Set;
  
  import static com.facebook.presto.SessionTestUtils.TEST_SESSION;
  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.DateTimeEncoding.packDateTimeWithZone;
  import static com.facebook.presto.spi.type.DoubleType.DOUBLE;
  import static com.facebook.presto.spi.type.TimeZoneKey.UTC_KEY;
  import static com.facebook.presto.spi.type.TimestampType.TIMESTAMP;
  import static com.facebook.presto.spi.type.TimestampWithTimeZoneType.TIMESTAMP_WITH_TIME_ZONE;
  import static com.facebook.presto.spi.type.VarcharType.VARCHAR;
  import static com.facebook.presto.type.JsonType.JSON;
  import static com.google.common.collect.Iterables.transform;
  import static com.google.common.util.concurrent.MoreExecutors.listeningDecorator;
  import static com.google.common.util.concurrent.MoreExecutors.sameThreadExecutor;
  import static io.airlift.concurrent.Threads.daemonThreadsNamed;
  import static io.airlift.slice.Slices.utf8Slice;
  import static java.lang.Math.cos;
  import static java.lang.Runtime.getRuntime;
  import static java.nio.charset.StandardCharsets.UTF_8;
  import static java.util.concurrent.Executors.newFixedThreadPool;
  import static org.joda.time.DateTimeZone.UTC;
  import static org.testng.Assert.assertTrue;
  
  @Test(singleThreaded = true)
  public class TestExpressionCompiler
  {
      private static final Boolean[] booleanValues = {truefalsenull};
      private static final Long[] longLefts = {9L, 10L, 11L, -9L, -10L, -11L, 10151082135029368L, /*Long.MIN_VALUE,*/ .null};
      private static final Long[] longRights = {3L, -3L, 10151082135029369L, null};
      private static final Long[] longMiddle = {9L, -3L, 88L, null};
      private static final Double[] doubleLefts = {9.0, 10.0, 11.0, -9.0, -10.0, -11.0, 9.1, 10.1, 11.1, -9.1, -10.1, -11.1,
                                                   ...null};
      private static final Double[] doubleRights = {3.0, -3.0, 3.1, -3.1, null};
      private static final Double[] doubleMiddle = {9.0, -3.1, 88.0, null};
      private static final String[] stringLefts = {"hello""foo""mellow""fellow"""null};
      private static final String[] stringRights = {"hello""foo""bar""baz"""null};
  
      private static final DateTime[] dateTimeValues = {
              new DateTime(2001, 1, 22, 3, 4, 5, 321, ),
             new DateTime(1960, 1, 22, 3, 4, 5, 321, ),
             new DateTime(1970, 1, 1, 0, 0, 0, 0, ),
             null
     };
 
     private static final String[] jsonValues = {
             "{}",
             "{\"fuu\": {\"bar\": 1}}",
             "{\"fuu\": null}",
             "{\"fuu\": 1}",
             "{\"fuu\": 1, \"bar\": \"abc\"}",
             null
     };
     private static final String[] jsonPatterns = {
             "$",
             "$.fuu",
             "$.fuu[0]",
             "$.bar",
             null
     };
 
     private static final Logger log = Logger.get(TestExpressionCompiler.class);
     private static final boolean PARALLEL = true;
 
     private long start;
     private List<ListenableFuture<Void>> futures;
 
     @BeforeSuite
     public void setupClass()
     {
         Logging.initialize();
         if () {
              = listeningDecorator(newFixedThreadPool(getRuntime().availableProcessors() * 2, daemonThreadsNamed("completer-%s")));
         }
         else {
              = listeningDecorator(sameThreadExecutor());
         }
          = new FunctionAssertions();
     }
 
     @AfterSuite
     public void tearDownClass()
     {
         if ( != null) {
             .shutdownNow();
              = null;
         }
     }
 
     @BeforeMethod
     public void setUp()
     {
          = System.nanoTime();
          = new ArrayList<>();
     }
 
     @AfterMethod
     public void tearDown(Method method)
             throws Exception
     {
         assertTrue(Futures.allAsList().isDone(), "Expression test futures are not complete");
         .info("FINISHED %s in %s verified %s expressions"method.getName(), Duration.nanosSince(), .size());
     }
 
     @Test
     public void smokedTest()
             throws Exception
     {
         assertExecute("cast(true as boolean)"true);
         assertExecute("true"true);
         assertExecute("false"false);
         assertExecute("42", 42L);
         assertExecute("'foo'""foo");
         assertExecute("4.2", 4.2);
         assertExecute("1 + 1", 2L);
         assertExecute("bound_long", 1234L);
         assertExecute("bound_string""hello");
         assertExecute("bound_double", 12.34);
         assertExecute("bound_boolean"true);
         assertExecute("bound_timestamp"new DateTime(2001, 8, 22, 3, 4, 5, 321, ).getMillis());
         assertExecute("bound_pattern""%el%");
         assertExecute("bound_null_string"null);
 
         // todo enable when null output type is supported
         // assertExecute("null", null);
 
         Futures.allAsList().get();
     }
 
     @Test
     public void filterFunction()
             throws Exception
     {
         assertFilter("true"true);
         assertFilter("false"false);
         assertFilter("bound_long = 1234"true);
         assertFilter("bound_long = 5678"false);
         assertFilter("bound_null_string is null"true);
         assertFilter("bound_null_string = 'foo'"false);
 
         // todo enable when null output type is supported
         // assertFilter("null", false);
         assertFilter("cast(null as boolean)"false);
         assertFilter("nullif(true, true)"false);
 
         assertFilter("true AND cast(null as boolean) AND true"false);
 
         Futures.allAsList().get();
     }
 
     @Test
     public void testUnaryOperators()
             throws Exception
     {
         assertExecute("cast(null as boolean) is null"true);
 
         for (Boolean value : ) {
             assertExecute(generateExpression("%s"value), value == null ? null : (value ? true : false));
             assertExecute(generateExpression("%s is null"value), , (value == null ? true : false));
             assertExecute(generateExpression("%s is not null"value), , (value != null ? true : false));
         }
 
         for (Long value : ) {
             assertExecute(generateExpression("%s"value), value == null ? null : value);
             assertExecute(generateExpression("- (%s)"value), value == null ? null : -value);
             assertExecute(generateExpression("%s is null"value), , (value == null ? true : false));
             assertExecute(generateExpression("%s is not null"value), , (value != null ? true : false));
         }
 
         for (Double value : ) {
             assertExecute(generateExpression("%s"value), value == null ? null : value);
             assertExecute(generateExpression("- (%s)"value), value == null ? null : -value);
             assertExecute(generateExpression("%s is null"value), , (value == null ? true : false));
             assertExecute(generateExpression("%s is not null"value), , (value != null ? true : false));
         }
 
         for (String value : ) {
             assertExecute(generateExpression("%s"value), value == null ? null : value);
             assertExecute(generateExpression("%s is null"value), , (value == null ? true : false));
             assertExecute(generateExpression("%s is not null"value), , (value != null ? true : false));
         }
 
         Futures.allAsList().get();
     }
 
     @Test
     public void testFilterEmptyInput()
             throws Exception
     {
         assertFilterWithNoInputColumns("true"true);
 
         Futures.allAsList().get();
     }
 
     @Test
     public void testBinaryOperatorsBoolean()
             throws Exception
     {
         assertExecute("nullif(cast(null as boolean), true)"null);
         for (Boolean left : ) {
             for (Boolean right : ) {
                 assertExecute(generateExpression("%s = %s"leftright), left == null || right == null ? null : left == right);
                 assertExecute(generateExpression("%s <> %s"leftright), left == null || right == null ? null : left != right);
 
                 assertExecute(generateExpression("nullif(%s, %s)"leftright), nullIf(leftright));
                 assertExecute(generateExpression("%s is distinct from %s"leftright), , !Objects.equals(leftright));
             }
         }
 
         Futures.allAsList().get();
     }
 
     @Test
     public void testBinaryOperatorsLongLong()
             throws Exception
     {
         for (Long left : ) {
             for (Long right : ) {
                 assertExecute(generateExpression("%s = %s"leftright), left == null || right == null ? null : (longleft == right);
                 assertExecute(generateExpression("%s <> %s"leftright), left == null || right == null ? null : (longleft != right);
                 assertExecute(generateExpression("%s > %s"leftright), left == null || right == null ? null : (longleft > right);
                 assertExecute(generateExpression("%s < %s"leftright), left == null || right == null ? null : (longleft < right);
                 assertExecute(generateExpression("%s >= %s"leftright), left == null || right == null ? null : (longleft >= right);
                 assertExecute(generateExpression("%s <= %s"leftright), left == null || right == null ? null : (longleft <= right);
 
                 assertExecute(generateExpression("nullif(%s, %s)"leftright), nullIf(leftright));
                 assertExecute(generateExpression("%s is distinct from %s"leftright), , !Objects.equals(leftright));
 
                 assertExecute(generateExpression("%s + %s"leftright), left == null || right == null ? null : left + right);
                 assertExecute(generateExpression("%s - %s"leftright), left == null || right == null ? null : left - right);
                 assertExecute(generateExpression("%s * %s"leftright), left == null || right == null ? null : left * right);
                 assertExecute(generateExpression("%s / %s"leftright), left == null || right == null ? null : left / right);
                 assertExecute(generateExpression("%s %% %s"leftright), left == null || right == null ? null : left % right);
             }
         }
 
         Futures.allAsList().get();
     }
 
     @Test
     public void testBinaryOperatorsLongDouble()
             throws Exception
     {
         for (Long left : ) {
             for (Double right : ) {
                 assertExecute(generateExpression("%s = %s"leftright), left == null || right == null ? null : (doubleleft == right);
                 assertExecute(generateExpression("%s <> %s"leftright), left == null || right == null ? null : (doubleleft != right);
                 assertExecute(generateExpression("%s > %s"leftright), left == null || right == null ? null : (doubleleft > right);
                 assertExecute(generateExpression("%s < %s"leftright), left == null || right == null ? null : (doubleleft < right);
                 assertExecute(generateExpression("%s >= %s"leftright), left == null || right == null ? null : (doubleleft >= right);
                 assertExecute(generateExpression("%s <= %s"leftright), left == null || right == null ? null : (doubleleft <= right);
 
                 Object expectedNullIf = nullIf(leftright);
                 for (String expression : generateExpression("nullif(%s, %s)"leftright)) {
                     .assertFunction(expressionexpectedNullIf);
                 }
 
                 assertExecute(generateExpression("%s is distinct from %s"leftright), , !Objects.equals(left == null ? null : left.doubleValue(), right));
 
                 assertExecute(generateExpression("%s + %s"leftright), left == null || right == null ? null : left + right);
                 assertExecute(generateExpression("%s - %s"leftright), left == null || right == null ? null : left - right);
                 assertExecute(generateExpression("%s * %s"leftright), left == null || right == null ? null : left * right);
                 assertExecute(generateExpression("%s / %s"leftright), left == null || right == null ? null : left / right);
                 assertExecute(generateExpression("%s %% %s"leftright), left == null || right == null ? null : left % right);
             }
         }
 
         Futures.allAsList().get();
     }
 
     @Test
     public void testBinaryOperatorsDoubleLong()
             throws Exception
     {
         for (Double left : ) {
             for (Long right : ) {
                 assertExecute(generateExpression("%s = %s"leftright), left == null || right == null ? null : left == (doubleright);
                 assertExecute(generateExpression("%s <> %s"leftright), left == null || right == null ? null : left != (doubleright);
                 assertExecute(generateExpression("%s > %s"leftright), left == null || right == null ? null : left > (doubleright);
                 assertExecute(generateExpression("%s < %s"leftright), left == null || right == null ? null : left < (doubleright);
                 assertExecute(generateExpression("%s >= %s"leftright), left == null || right == null ? null : left >= (doubleright);
                 assertExecute(generateExpression("%s <= %s"leftright), left == null || right == null ? null : left <= (doubleright);
 
                 assertExecute(generateExpression("nullif(%s, %s)"leftright), nullIf(leftright));
                 assertExecute(generateExpression("%s is distinct from %s"leftright), , !Objects.equals(leftright == null ? null : right.doubleValue()));
 
                 assertExecute(generateExpression("%s + %s"leftright), left == null || right == null ? null : left + right);
                 assertExecute(generateExpression("%s - %s"leftright), left == null || right == null ? null : left - right);
                 assertExecute(generateExpression("%s * %s"leftright), left == null || right == null ? null : left * right);
                 assertExecute(generateExpression("%s / %s"leftright), left == null || right == null ? null : left / right);
                 assertExecute(generateExpression("%s %% %s"leftright), left == null || right == null ? null : left % right);
             }
         }
 
         Futures.allAsList().get();
     }
 
     @Test
     public void testBinaryOperatorsDoubleDouble()
             throws Exception
     {
         for (Double left : ) {
             for (Double right : ) {
                 assertExecute(generateExpression("%s = %s"leftright), left == null || right == null ? null : (doubleleft == right);
                 assertExecute(generateExpression("%s <> %s"leftright), left == null || right == null ? null : (doubleleft != right);
                 assertExecute(generateExpression("%s > %s"leftright), left == null || right == null ? null : (doubleleft > right);
                 assertExecute(generateExpression("%s < %s"leftright), left == null || right == null ? null : (doubleleft < right);
                 assertExecute(generateExpression("%s >= %s"leftright), left == null || right == null ? null : (doubleleft >= right);
                 assertExecute(generateExpression("%s <= %s"leftright), left == null || right == null ? null : (doubleleft <= right);
 
                 assertExecute(generateExpression("nullif(%s, %s)"leftright), nullIf(leftright));
                 assertExecute(generateExpression("%s is distinct from %s"leftright), , !Objects.equals(leftright));
 
                 assertExecute(generateExpression("%s + %s"leftright), left == null || right == null ? null : left + right);
                 assertExecute(generateExpression("%s - %s"leftright), left == null || right == null ? null : left - right);
                 assertExecute(generateExpression("%s * %s"leftright), left == null || right == null ? null : left * right);
                 assertExecute(generateExpression("%s / %s"leftright), left == null || right == null ? null : left / right);
                 assertExecute(generateExpression("%s %% %s"leftright), left == null || right == null ? null : left % right);
             }
         }
 
         Futures.allAsList().get();
     }
 
     @Test
     public void testBinaryOperatorsString()
             throws Exception
     {
         for (String left : ) {
             for (String right : ) {
                 assertExecute(generateExpression("%s = %s"leftright), left == null || right == null ? null : left.equals(right));
                 assertExecute(generateExpression("%s <> %s"leftright), left == null || right == null ? null : !left.equals(right));
                 assertExecute(generateExpression("%s > %s"leftright), left == null || right == null ? null : left.compareTo(right) > 0);
                 assertExecute(generateExpression("%s < %s"leftright), left == null || right == null ? null : left.compareTo(right) < 0);
                 assertExecute(generateExpression("%s >= %s"leftright), left == null || right == null ? null : left.compareTo(right) >= 0);
                 assertExecute(generateExpression("%s <= %s"leftright), left == null || right == null ? null : left.compareTo(right) <= 0);
 
                 assertExecute(generateExpression("%s || %s"leftright), left == null || right == null ? null : left + right);
                 assertExecute(generateExpression("%s is distinct from %s"leftright), , !Objects.equals(leftright));
 
                 assertExecute(generateExpression("nullif(%s, %s)"leftright), nullIf(leftright));
             }
         }
 
         Futures.allAsList().get();
     }
 
     private static Object nullIf(Object leftObject right)
     {
         if (left == null) {
             return null;
         }
         if (right == null) {
             return left;
         }
 
         if (left.equals(right)) {
             return null;
         }
 
         if ((left instanceof Double || right instanceof Double) && ((Numberleft).doubleValue() == ((Numberright).doubleValue()) {
             return null;
         }
 
         return left;
     }
 
     @Test
     public void testTernaryOperatorsLongLong()
             throws Exception
     {
         for (Long first : ) {
             for (Long second : ) {
                 for (Long third : ) {
                     assertExecute(generateExpression("%s between %s and %s"firstsecondthird),
                             ,
                             first == null || second == null || third == null ? null : second <= first && first <= third);
                 }
             }
         }
 
         Futures.allAsList().get();
     }
 
     @Test
     public void testTernaryOperatorsLongDouble()
             throws Exception
     {
         for (Long first : ) {
             for (Double second : ) {
                 for (Long third : ) {
                     assertExecute(generateExpression("%s between %s and %s"firstsecondthird),
                             ,
                             first == null || second == null || third == null ? null : second <= first && first <= third);
                 }
             }
         }
 
         Futures.allAsList().get();
     }
 
     @Test
     public void testTernaryOperatorsDoubleDouble()
             throws Exception
     {
         for (Double first : ) {
             for (Double second : ) {
                 for (Long third : ) {
                     assertExecute(generateExpression("%s between %s and %s"firstsecondthird),
                             ,
                             first == null || second == null || third == null ? null : second <= first && first <= third);
                 }
             }
         }
 
         Futures.allAsList().get();
     }
 
     @Test
     public void testTernaryOperatorsString()
             throws Exception
     {
         for (String first : ) {
             for (String second : ) {
                 for (String third : ) {
                     assertExecute(generateExpression("%s between %s and %s"firstsecondthird),
                             ,
                             first == null || second == null || third == null ? null : second.compareTo(first) <= 0 && first.compareTo(third) <= 0);
                 }
             }
         }
 
         Futures.allAsList().get();
     }
 
     @Test
     public void testCast()
             throws Exception
     {
         for (Boolean value : ) {
             assertExecute(generateExpression("cast(%s as boolean)"value), value == null ? null : (value ? true : false));
             assertExecute(generateExpression("cast(%s as bigint)"value), value == null ? null : (value ? 1L : 0L));
             assertExecute(generateExpression("cast(%s as double)"value), value == null ? null : (value ? 1.0 : 0.0));
             assertExecute(generateExpression("cast(%s as varchar)"value), value == null ? null : (value ? "true" : "false"));
         }
 
         for (Long value : ) {
             assertExecute(generateExpression("cast(%s as boolean)"value), value == null ? null : (value != 0L ? true : false));
             assertExecute(generateExpression("cast(%s as bigint)"value), value == null ? null : value);
             assertExecute(generateExpression("cast(%s as double)"value), value == null ? null : value.doubleValue());
             assertExecute(generateExpression("cast(%s as varchar)"value), value == null ? null : String.valueOf(value));
         }
 
         for (Double value : ) {
             assertExecute(generateExpression("cast(%s as boolean)"value), value == null ? null : (value != 0.0 ? true : false));
             assertExecute(generateExpression("cast(%s as bigint)"value), value == null ? null : value.longValue());
             assertExecute(generateExpression("cast(%s as double)"value), value == null ? null : value);
             assertExecute(generateExpression("cast(%s as varchar)"value), value == null ? null : String.valueOf(value));
         }
 
         assertExecute("cast('true' as boolean)"true);
         assertExecute("cast('true' as BOOLEAN)"true);
         assertExecute("cast('tRuE' as BOOLEAN)"true);
         assertExecute("cast('false' as BOOLEAN)"false);
         assertExecute("cast('fAlSe' as BOOLEAN)"false);
         assertExecute("cast('t' as BOOLEAN)"true);
         assertExecute("cast('T' as BOOLEAN)"true);
         assertExecute("cast('f' as BOOLEAN)"false);
         assertExecute("cast('F' as BOOLEAN)"false);
         assertExecute("cast('1' as BOOLEAN)"true);
         assertExecute("cast('0' as BOOLEAN)"false);
 
         for (Long value : ) {
             if (value != null) {
                 assertExecute(generateExpression("cast(%s as bigint)", String.valueOf(value)), value == null ? null : value);
             }
         }
         for (Double value : ) {
             if (value != null) {
                 assertExecute(generateExpression("cast(%s as double)", String.valueOf(value)), value == null ? null : value);
             }
         }
         for (String value : ) {
             assertExecute(generateExpression("cast(%s as varchar)"value), value == null ? null : value);
         }
 
         Futures.allAsList().get();
     }
 
     @Test
     public void testTryCast()
             throws Exception
     {
         assertExecute("try_cast(null as bigint)"null);
         assertExecute("try_cast('123' as bigint)", 123L);
         assertExecute("try_cast('foo' as varchar)""foo");
         assertExecute("try_cast('foo' as bigint)"null);
         assertExecute("try_cast('2001-08-22' as timestamp)"new SqlTimestamp(new DateTime(2001, 8, 22, 0, 0, 0, 0, ).getMillis(), ));
         assertExecute("try_cast(bound_string as bigint)"null);
         assertExecute("try_cast(cast(null as varchar) as bigint)"null);
         assertExecute("try_cast(bound_long / 13  as bigint)", 94);
         assertExecute("coalesce(try_cast('123' as bigint), 456)", 123L);
         assertExecute("coalesce(try_cast('foo' as bigint), 456)", 456L);
         assertExecute("concat('foo', cast('bar' as varchar))""foobar");
         assertExecute("try_cast(try_cast(123 as varchar) as bigint)", 123L);
         assertExecute("try_cast('foo' as varchar) || try_cast('bar' as varchar)""foobar");
 
         Futures.allAsList().get();
     }
 
     @Test
     public void testAnd()
             throws Exception
     {
         assertExecute("true and true"true);
         assertExecute("true and false"false);
         assertExecute("false and true"false);
         assertExecute("false and false"false);
 
         assertExecute("true and cast(null as boolean)"null);
         assertExecute("false and cast(null as boolean)"false);
         assertExecute("cast(null as boolean) and true"null);
         assertExecute("cast(null as boolean) and false"false);
         assertExecute("cast(null as boolean) and cast(null as boolean)"null);
 
         assertExecute("true and null"null);
         assertExecute("false and null"false);
         assertExecute("null and true"null);
         assertExecute("null and false"false);
         assertExecute("null and null"null);
 
         Futures.allAsList().get();
     }
 
     @Test
     public void testOr()
             throws Exception
     {
         assertExecute("true or true"true);
         assertExecute("true or false"true);
         assertExecute("false or true"true);
         assertExecute("false or false"false);
 
         assertExecute("true or cast(null as boolean)"true);
         assertExecute("false or cast(null as boolean)"null);
         assertExecute("cast(null as boolean) or true"true);
         assertExecute("cast(null as boolean) or false"null);
         assertExecute("cast(null as boolean) or cast(null as boolean)"null);
 
         assertExecute("true or null"true);
         assertExecute("false or null"null);
         assertExecute("null or true"true);
         assertExecute("null or false"null);
         assertExecute("null or null"null);
 
         Futures.allAsList().get();
     }
 
     @Test
     public void testNot()
             throws Exception
     {
         assertExecute("not true"false);
         assertExecute("not false"true);
 
         assertExecute("not cast(null as boolean)"null);
 
         assertExecute("not null"null);
 
         Futures.allAsList().get();
     }
 
     @Test
     public void testIf()
             throws Exception
     {
         // todo enable when null output type is supported
         //assertExecute("if(null and true, 1, 0)", 0L);
         for (Boolean condition : ) {
             for (String trueValue : ) {
                 for (String falseValue : ) {
                     assertExecute(generateExpression("if(%s, %s, %s)"conditiontrueValuefalseValue), condition != null && condition ? trueValue : falseValue);
                 }
             }
         }
 
         Futures.allAsList().get();
     }
 
     @Test
     public void testSimpleCase()
             throws Exception
     {
         for (Double value : ) {
             for (Double firstTest : ) {
                 for (Double secondTest : ) {
                     String expected;
                     if (value == null) {
                         expected = "else";
                     }
                     else if (firstTest != null && (doublevalue == firstTest) {
                         expected = "first";
                     }
                     else if (secondTest != null && (doublevalue == secondTest) {
                         expected = "second";
                     }
                     else {
                         expected = "else";
                     }
                     assertExecute(generateExpression("case %s when %s then 'first' when %s then 'second' else 'else' end"valuefirstTestsecondTest), expected);
                 }
             }
         }
         for (Long value : ) {
             for (Long firstTest : ) {
                 for (Long secondTest : ) {
                     String expected;
                     if (value == null) {
                         expected = null;
                     }
                     else if (firstTest != null && firstTest.equals(value)) {
                         expected = "first";
                     }
                     else if (secondTest != null && secondTest.equals(value)) {
                         expected = "second";
                     }
                     else {
                         expected = null;
                     }
                     assertExecute(generateExpression("case %s when %s then 'first' when %s then 'second' end"valuefirstTestsecondTest), expected);
                 }
             }
         }
 
         Futures.allAsList().get();
     }
 
     @Test
     public void testSearchCaseSingle()
             throws Exception
     {
         // assertExecute("case when null and true then 1 else 0 end", 0L);
         for (Double value : ) {
             for (Long firstTest : ) {
                 for (Double secondTest : ) {
                     String expected;
                     if (value == null) {
                         expected = "else";
                     }
                     else if (firstTest != null && (doublevalue == firstTest) {
                         expected = "first";
                     }
                     else if (secondTest != null && (doublevalue == secondTest) {
                         expected = "second";
                     }
                     else {
                         expected = "else";
                     }
                     List<Stringexpressions = formatExpression("case when %s = %s then 'first' when %s = %s then 'second' else 'else' end",
                             Arrays.<Object>asList(valuefirstTestvaluesecondTest),
                             ImmutableList.of("double""bigint""double""double"));
                     assertExecute(expressionsexpected);
                 }
             }
         }
 
         Futures.allAsList().get();
     }
 
     @Test
     public void testSearchCaseMultiple()
             throws Exception
     {
         for (Double value : ) {
             for (Long firstTest : ) {
                 for (Double secondTest : ) {
                     String expected;
                     if (value == null) {
                         expected = null;
                     }
                     else if (firstTest != null && (doublevalue == firstTest) {
                         expected = "first";
                     }
                     else if (secondTest != null && (doublevalue == secondTest) {
                         expected = "second";
                     }
                     else {
                         expected = null;
                     }
                     List<Stringexpressions = formatExpression("case when %s = %s then 'first' when %s = %s then 'second' end",
                             Arrays.<Object>asList(valuefirstTestvaluesecondTest),
                             ImmutableList.of("double""bigint""double""double"));
                     assertExecute(expressionsexpected);
                 }
             }
         }
 
         Futures.allAsList().get();
     }
 
     @Test
     public void testIn()
             throws Exception
     {
         for (Boolean value : ) {
             assertExecute(generateExpression("%s in (true)"value), value == null ? null : value == .);
             assertExecute(generateExpression("%s in (null, true)"value), value == null ? null : value == . ? true : null);
             assertExecute(generateExpression("%s in (true, null)"value), value == null ? null : value == . ? true : null);
             assertExecute(generateExpression("%s in (false)"value), value == null ? null : value == .);
             assertExecute(generateExpression("%s in (null, false)"value), value == null ? null : value == . ? true : null);
             assertExecute(generateExpression("%s in (null)"value), null);
         }
 
         for (Long value : ) {
             List<LongtestValues = Arrays.asList(33L, 9L, -9L, -33L);
             assertExecute(generateExpression("%s in (33, 9, -9, -33)"value),
                     ,
                     value == null ? null : testValues.contains(value));
             assertExecute(generateExpression("%s in (null, 33, 9, -9, -33)"value),
                     ,
                     value == null ? null : testValues.contains(value) ? true : null);
 
             assertExecute(generateExpression("%s in (33, null, 9, -9, -33)"value),
                     ,
                     value == null ? null : testValues.contains(value) ? true : null);
 
             // compare a long to in containing doubles
             assertExecute(generateExpression("%s in (33, 9.0, -9, -33)"value),
                     ,
                     value == null ? null : testValues.contains(value));
             assertExecute(generateExpression("%s in (null, 33, 9.0, -9, -33)"value),
                     ,
                     value == null ? null : testValues.contains(value) ? true : null);
             assertExecute(generateExpression("%s in (33.0, null, 9.0, -9, -33)"value),
                     ,
                     value == null ? null : testValues.contains(value) ? true : null);
 
         }
 
         for (Double value : ) {
             List<DoubletestValues = Arrays.asList(33.0, 9.0, -9.0, -33.0);
             assertExecute(generateExpression("%s in (33.0, 9.0, -9.0, -33.0)"value),
                     ,
                     value == null ? null : testValues.contains(value));
             assertExecute(generateExpression("%s in (null, 33.0, 9.0, -9.0, -33.0)"value),
                     ,
                     value == null ? null : testValues.contains(value) ? true : null);
             assertExecute(generateExpression("%s in (33.0, null, 9.0, -9.0, -33.0)"value),
                     ,
                     value == null ? null : testValues.contains(value) ? true : null);
 
             // compare a double to in containing longs
             assertExecute(generateExpression("%s in (33.0, 9, -9, -33.0)"value),
                     ,
                     value == null ? null : testValues.contains(value));
             assertExecute(generateExpression("%s in (null, 33.0, 9, -9, -33.0)"value),
                     ,
                     value == null ? null : testValues.contains(value) ? true : null);
             assertExecute(generateExpression("%s in (33.0, null, 9, -9, -33.0)"value),
                     ,
                     value == null ? null : testValues.contains(value) ? true : null);
 
             // compare to dynamically computed values
             testValues = Arrays.asList(33.0, cos(9.0), cos(-9.0), -33.0);
             assertExecute(generateExpression("cos(%s) in (33.0, cos(9.0), cos(-9.0), -33.0)"value),
                     ,
                     value == null ? null : testValues.contains(cos(value)));
             assertExecute(generateExpression("cos(%s) in (null, 33.0, cos(9.0), cos(-9.0), -33.0)"value),
                     ,
                     value == null ? null : testValues.contains(cos(value)) ? true : null);
         }
 
         for (String value : ) {
             List<StringtestValues = Arrays.asList("what?""foo""mellow""end");
             assertExecute(generateExpression("%s in ('what?', 'foo', 'mellow', 'end')"value),
                     ,
                     value == null ? null : testValues.contains(value));
             assertExecute(generateExpression("%s in (null, 'what?', 'foo', 'mellow', 'end')"value),
                     ,
                     value == null ? null : testValues.contains(value) ? true : null);
             assertExecute(generateExpression("%s in ('what?', null, 'foo', 'mellow', 'end')"value),
                     ,
                     value == null ? null : testValues.contains(value) ? true : null);
         }
 
         Futures.allAsList().get();
     }
 
     @Test
     public void testHugeIn()
             throws Exception
     {
         ContiguousSet<IntegerlongValues = ContiguousSet.create(Range.openClosed(2000, 7000), DiscreteDomain.integers());
         assertExecute("bound_long in (1234, " + Joiner.on(", ").join(longValues) + ")"true);
         assertExecute("bound_long in (" + Joiner.on(", ").join(longValues) + ")"false);
 
         Iterable<ObjectdoubleValues = transform(ContiguousSet.create(Range.openClosed(2000, 7000), DiscreteDomain.integers()), i -> (doublei);
         assertExecute("bound_double in (12.34, " + Joiner.on(", ").join(doubleValues) + ")"true);
         assertExecute("bound_double in (" + Joiner.on(", ").join(doubleValues) + ")"false);
 
         Iterable<ObjectstringValues = transform(ContiguousSet.