Copyright (c) 2009 Google Inc.

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.

**********************************************************************/

* @author Max Ross <maxr@google.com>

*/

  private static final List<SortPredicate> NO_SORTS = Collections.emptyList();

  private static final List<FilterPredicate> NO_FILTERS = Collections.emptyList();

  private static final FilterPredicate ORIGIN_EQ_2 =

      new FilterPredicate("origin", FilterOperator.EQUAL, 2);

  private static final FilterPredicate ORIGIN_EQ_2_LITERAL =

      new FilterPredicate("origin", FilterOperator.EQUAL, 2L);

  private static final FilterPredicate ORIGIN_NEQ_NULL_LITERAL =

      new FilterPredicate("origin", FilterOperator.NOT_EQUAL, null);

  private static final FilterPredicate ORIGIN_EQ_2STR =

      new FilterPredicate("origin", FilterOperator.EQUAL, "2");

  private static final FilterPredicate ORIGIN_NEQ_2_LITERAL =

      new FilterPredicate("origin", FilterOperator.NOT_EQUAL, 2L);

  private static final FilterPredicate DEST_EQ_4_LITERAL =

      new FilterPredicate("dest", FilterOperator.EQUAL, 4L);

  private static final FilterPredicate ORIG_GT_2_LITERAL =

      new FilterPredicate("origin", FilterOperator.GREATER_THAN, 2L);

  private static final FilterPredicate ORIG_GTE_2_LITERAL =

      new FilterPredicate("origin", FilterOperator.GREATER_THAN_OR_EQUAL, 2L);

  private static final FilterPredicate DEST_LT_4_LITERAL =

      new FilterPredicate("dest", FilterOperator.LESS_THAN, 4L);

  private static final FilterPredicate DEST_LTE_4_LITERAL =

      new FilterPredicate("dest", FilterOperator.LESS_THAN_OR_EQUAL, 4L);

  private static final SortPredicate ORIG_ASC =

      new SortPredicate("origin", SortDirection.ASCENDING);

  private static final SortPredicate DESC_DESC =

      new SortPredicate("dest", SortDirection.DESCENDING);

  private static final FilterPredicate ORIGIN_IN_2_ARGS =

      new FilterPredicate("origin", FilterOperator.IN, Arrays.asList("2", 2L));

  private static final FilterPredicate ORIGIN_IN_3_ARGS =

      new FilterPredicate("origin", FilterOperator.IN, Arrays.asList("2", 2L, false));

  @Override

  protected void setUp() throws Exception {

    super.setUp();

    DatastoreServiceInterceptor.install(getStoreManager(), new WriteBlocker());

    beginTxn();

  }

  @Override

  protected void tearDown() throws Exception {

    if (!pm.isClosed() && pm.currentTransaction().isActive()) {

      commitTxn();

    }

    try {

      super.tearDown();

    } finally {

      DatastoreServiceInterceptor.uninstall();

    }

  }

  public void testUnsupportedFilters() {

    Set<Expression.Operator> unsupportedOps = Utils.newHashSet(DatastoreQuery.UNSUPPORTED_OPERATORS);

    assertQueryUnsupportedByOrm(Flight.class, "!origin", Expression.OP_NOT, unsupportedOps);

    assertQueryUnsupportedByOrm(Flight.class, "(origin + dest) == 4", Expression.OP_ADD, unsupportedOps);

    assertQueryUnsupportedByOrm(Flight.class, "origin + dest == 4", Expression.OP_ADD, unsupportedOps);

    assertQueryUnsupportedByOrm(Flight.class, "(origin - dest) == 4", Expression.OP_SUB, unsupportedOps);

    assertQueryUnsupportedByOrm(Flight.class, "origin - dest == 4", Expression.OP_SUB, unsupportedOps);

    assertQueryUnsupportedByOrm(Flight.class, "(origin / dest) == 4", Expression.OP_DIV, unsupportedOps);

    assertQueryUnsupportedByOrm(Flight.class, "origin / dest == 4", Expression.OP_DIV, unsupportedOps);

    assertQueryUnsupportedByOrm(Flight.class, "(origin * dest) == 4", Expression.OP_MUL, unsupportedOps);

    assertQueryUnsupportedByOrm(Flight.class, "origin * dest == 4", Expression.OP_MUL, unsupportedOps);

    assertQueryUnsupportedByOrm(Flight.class, "(origin % dest) == 4", Expression.OP_MOD, unsupportedOps);

    assertQueryUnsupportedByOrm(Flight.class, "origin % dest == 4", Expression.OP_MOD, unsupportedOps);

    assertQueryUnsupportedByOrm(Flight.class, "~origin == 4", Expression.OP_COM, unsupportedOps);

    assertQueryUnsupportedByOrm(Flight.class, "!origin == 4", Expression.OP_NOT, unsupportedOps);

    assertQueryUnsupportedByOrm(Flight.class, "-origin == 4", Expression.OP_NEG, unsupportedOps);

    assertQueryUnsupportedByOrm(Flight.class, "origin instanceof " + Flight.class.getName(),

        Expression.OP_IS, unsupportedOps);

    assertEquals(Utils.<Expression.Operator>newHashSet(Expression.OP_CONCAT, Expression.OP_LIKE,

        Expression.OP_ISNOT), unsupportedOps);

    String baseQuery = "select from " + Flight.class.getName() + " where ";

    // multiple inequality filters

    // TODO(maxr) Make this pass against the real datastore.

    // We need to have it return BadRequest instead of NeedIndex for that to

    // happen.

    assertQueryUnsupportedByDatastore(baseQuery + "(origin > 2 && dest < 4)");

    // inequality filter prop is not the same as the first order by prop

    assertQueryUnsupportedByDatastore(baseQuery + "origin > 2 order by dest");

    // gets split into multiple inequality filters

    assertQueryUnsupportedByDatastore(baseQuery + "origin != 2 && dest != 4");

    // can't have 'or' on multiple properties

    assertQueryRequiresUnsupportedDatastoreFeature(baseQuery + "origin == 'yar' || dest == null");

    assertQueryRequiresUnsupportedDatastoreFeature(baseQuery + "origin == 4 && (dest == 'yar' || name == 'yam')");

    // TODO This query is flawed - defines a parameter but doesn't provide it (now an error in DN 3.x)

//    assertQueryRequiresUnsupportedDatastoreFeature(baseQuery + ":p1.contains(origin) || name == 'yam'");

    // can only check equality

    assertQueryRequiresUnsupportedDatastoreFeature(baseQuery + "origin > 5 || origin < 2");

  }

  private void assertQueryRequiresUnsupportedDatastoreFeature(String query) {

    Query q = pm.newQuery(query);

    q.addExtension(DatastoreManager.QUERYEXT_INMEMORY_WHEN_UNSUPPORTED, "false");

    try {

      q.execute();

      fail("expected JDOUserException->UnsupportedDatastoreFeatureException for query <" + query + ">");

    } catch (JDOUserException jdoe) {

        if (jdoe.getCause() instanceof DatastoreQuery.UnsupportedDatastoreFeatureException) {

          // good

        }

        else {

          throw jdoe;

        }

    }

  }

  public void testEvaluateInMemory() {

    ds.put(null, newFlightEntity("1", "yar", "bam", 1, 2));

    ds.put(null, newFlightEntity("1", "yam", null, 1, 2));

    // This is impossible in the datastore, so run totally in-memory

    String query = "SELECT FROM " + Flight.class.getName() + " WHERE origin == 'yar' || dest == null";

    Query q = pm.newQuery(query);

    q.addExtension("datanucleus.query.evaluateInMemory", "true");

    try {

      List<Flight> results = (List<Flight>) q.execute();

      Assert.assertEquals("Number of results was wrong", 2, results.size());

    } catch (JDOException jdoe) {

      fail("Threw exception when evaluating query in-memory, but should have run");

    }

  }

  public void testCacheQueryResults() {