/tests/com/google/appengine/datanucleus/query/JDOQLQueryTest.java

Large files files are truncated, but you can click here to view the full file

/**********************************************************************
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.
**********************************************************************/
package com.google.appengine.datanucleus.query;

import static com.google.appengine.datanucleus.test.jdo.Flight.newFlightEntity;

import com.google.appengine.api.datastore.DatastoreFailureException;
import com.google.appengine.api.datastore.DatastoreTimeoutException;
import com.google.appengine.api.datastore.Entity;
import com.google.appengine.api.datastore.Key;
import com.google.appengine.api.datastore.KeyFactory;
import com.google.appengine.api.datastore.Query.FilterOperator;
import com.google.appengine.api.datastore.Query.FilterPredicate;
import com.google.appengine.api.datastore.Query.SortDirection;
import com.google.appengine.api.datastore.Query.SortPredicate;
import com.google.appengine.api.datastore.ShortBlob;
import com.google.appengine.api.datastore.dev.LocalDatastoreService;
import com.google.appengine.api.users.User;
import com.google.appengine.datanucleus.DatastoreManager;
import com.google.appengine.datanucleus.DatastoreServiceFactoryInternal;
import com.google.appengine.datanucleus.DatastoreServiceInterceptor;
import com.google.appengine.datanucleus.ExceptionThrowingDatastoreDelegate;
import com.google.appengine.datanucleus.PrimitiveArrays;
import com.google.appengine.datanucleus.TestUtils;
import com.google.appengine.datanucleus.Utils;
import com.google.appengine.datanucleus.WriteBlocker;
import com.google.appengine.datanucleus.jdo.JDOTestCase;
import com.google.appengine.datanucleus.test.jdo.AbstractBaseClassesJDO.Base1;
import com.google.appengine.datanucleus.test.jdo.BidirectionalChildListJDO;
import com.google.appengine.datanucleus.test.jdo.BidirectionalChildLongPkListJDO;
import com.google.appengine.datanucleus.test.jdo.BidirectionalGrandchildListJDO;
import com.google.appengine.datanucleus.test.jdo.Flight;
import com.google.appengine.datanucleus.test.jdo.HasBytesJDO;
import com.google.appengine.datanucleus.test.jdo.HasEmbeddedJDO;
import com.google.appengine.datanucleus.test.jdo.HasEncodedStringPkJDO;
import com.google.appengine.datanucleus.test.jdo.HasEncodedStringPkSeparateIdFieldJDO;
import com.google.appengine.datanucleus.test.jdo.HasEncodedStringPkSeparateNameFieldJDO;
import com.google.appengine.datanucleus.test.jdo.HasEnumJDO;
import com.google.appengine.datanucleus.test.jdo.HasKeyAncestorKeyPkJDO;
import com.google.appengine.datanucleus.test.jdo.HasKeyAncestorStringPkJDO;
import com.google.appengine.datanucleus.test.jdo.HasKeyPkJDO;
import com.google.appengine.datanucleus.test.jdo.HasLongPkJDO;
import com.google.appengine.datanucleus.test.jdo.HasMultiValuePropsJDO;
import com.google.appengine.datanucleus.test.jdo.HasOneToManyKeyPkListJDO;
import com.google.appengine.datanucleus.test.jdo.HasOneToManyKeyPkSetJDO;
import com.google.appengine.datanucleus.test.jdo.HasOneToManyListJDO;
import com.google.appengine.datanucleus.test.jdo.HasOneToManyLongPkListJDO;
import com.google.appengine.datanucleus.test.jdo.HasOneToManyLongPkSetJDO;
import com.google.appengine.datanucleus.test.jdo.HasOneToManyUnencodedStringPkListJDO;
import com.google.appengine.datanucleus.test.jdo.HasOneToManyUnencodedStringPkSetJDO;
import com.google.appengine.datanucleus.test.jdo.HasOneToOneJDO;
import com.google.appengine.datanucleus.test.jdo.HasOneToOneParentJDO;
import com.google.appengine.datanucleus.test.jdo.HasStringAncestorStringPkJDO;
import com.google.appengine.datanucleus.test.jdo.HasUnencodedStringPkJDO;
import com.google.appengine.datanucleus.test.jdo.KitchenSink;
import com.google.appengine.datanucleus.test.jdo.NullDataJDO;
import com.google.appengine.datanucleus.test.jdo.Person;
import com.google.appengine.datanucleus.test.jdo.UnidirectionalSuperclassTableChildJDO.UnidirTop;
import com.google.appengine.datanucleus.test.jpa.Book;
import com.google.apphosting.api.ApiProxy;
import com.google.apphosting.api.DatastorePb;

import junit.framework.Assert;

import org.datanucleus.api.jdo.JDOPersistenceManagerFactory;
import org.datanucleus.api.jdo.JDOQuery;
import org.datanucleus.exceptions.NucleusUserException;
import org.datanucleus.query.expression.Expression;
import org.datanucleus.store.query.cache.QueryResultsCache;
import org.easymock.EasyMock;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Future;

import javax.jdo.Extent;
import javax.jdo.JDODataStoreException;
import javax.jdo.JDOException;
import javax.jdo.JDOFatalUserException;
import javax.jdo.JDOUserException;
import javax.jdo.Query;
import javax.jdo.listener.InstanceLifecycleEvent;
import javax.jdo.listener.LoadLifecycleListener;

/**
 * @author Max Ross <maxr@google.com>
 */
public class JDOQLQueryTest extends JDOTestCase {

  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() {
    ds.put(null, newFlightEntity("1", "yar", "bam", 1, 2));
    ds.put(null, newFlightEntity("1", "yam", null, 1, 2));

    QueryResultsCache cache = null;
    try {
      String query = "SELECT FROM " + Flight.class.getName();
      Query q = pm.newQuery(query);
      q.addExtension("datanucleus.query.results.cached", "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 and caching results : " + jdoe.getMessage());
      }
      q.closeAll();
      if (pm.currentTransaction().isActive()) {
        pm.currentTransaction().rollback();
      }
      pm.close();
      cache = 
        ((JDOPersistenceManagerFactory)pmf).getNucleusContext().getStoreManager().getQueryManager().getQueryResultsCache();
      assertEquals("Number of entries in the query results cache is wrong", 1, cache.size());

      pm = pmf.getPersistenceManager();
      Query q2 = pm.newQuery(query);
      try {
        List<Flight> results = (List<Flight>) q2.execute();
        Assert.assertEquals("Number of results was wrong", 2, results.size());
      } catch (JDOException jdoe) {
        fail("Threw exception when evaluating query with cached results : " + jdoe.getMessage());
      }
      q2.closeAll();
    } finally {
      // Evict the cached results
      cache.evictAll();
    }
  }

  public void testCandidateCollectionInMemory() {
    ds.put(null, newFlightEntity("1", "yar", "bam", 1, 2));
    ds.put(null, newFlightEntity("1", "yam", null, 1, 2));

    Collection<Flight> coll = new HashSet<Flight>();
    Iterator<Flight> iter = pm.getExtent(Flight.class).iterator();
    while (iter.hasNext()) {
      coll.add(iter.next());
    }

    // Query is impossible in-datastore, and run against candidates so has to be in-memory
    String query = "SELECT FROM " + Flight.class.getName() + " WHERE origin == 'yar' || dest == null";
    Query q = pm.newQuery(query);
    q.setCandidates(coll);
    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 testSupportedFilters() {
    assertQuerySupported(Flight.class, "", NO_FILTERS, NO_SORTS);
    assertQuerySupported(Flight.class, "origin == 2", Utils.newArrayList(ORIGIN_EQ_2_LITERAL), NO_SORTS);
    assertQuerySupported(
        Flight.class, "origin == \"2\"", Utils.newArrayList(ORIGIN_EQ_2STR), NO_SORTS);
    assertQuerySupported(Flight.class, "(origin == 2)", Utils.newArrayList(ORIGIN_EQ_2_LITERAL), NO_SORTS);
    assertQuerySupported(Flight.class, "origin == 2 && dest == 4", Utils.newArrayList(ORIGIN_EQ_2_LITERAL,
        DEST_EQ_4_LITERAL), NO_SORTS);
    assertQuerySupported(Flight.class, "(origin == 2 && dest == 4)", Utils.newArrayList(ORIGIN_EQ_2_LITERAL,
        DEST_EQ_4_LITERAL), NO_SORTS);
    assertQuerySupported(Flight.class, "(origin == 2) && (dest == 4)", Utils.newArrayList(
        ORIGIN_EQ_2_LITERAL, DEST_EQ_4_LITERAL), NO_SORTS);

    assertQuerySupported(Flight.class, "origin > 2", Utils.newArrayList(ORIG_GT_2_LITERAL), NO_SORTS);
    assertQuerySupported(Flight.class, "origin >= 2", Utils.newArrayList(ORIG_GTE_2_LITERAL), NO_SORTS);
    assertQuerySupported(Flight.class, "dest < 4", Utils.newArrayList(DEST_LT_4_LITERAL), NO_SORTS);
    assertQuerySupported(Flight.class, "dest <= 4", Utils.newArrayList(DEST_LTE_4_LITERAL), NO_SORTS);

    assertQuerySupported("select from " + Flight.class.getName() + " order by origin asc",
        NO_FILTERS, Utils.newArrayList(ORIG_ASC));
    assertQuerySupported("select from " + Flight.class.getName() + " order by dest desc",
        NO_FILTERS, Utils.newArrayList(DESC_DESC));
    assertQuerySupported("select from " + Flight.class.getName()
        + " order by origin asc, dest desc", NO_FILTERS, Utils.newArrayList(ORIG_ASC, DESC_DESC));

    assertQuerySupported("select from " + Flight.class.getName()
        + " where origin == 2 && dest == 4 order by origin asc, dest desc",
        Utils.newArrayList(ORIGIN_EQ_2_LITERAL, DEST_EQ_4_LITERAL), Utils.newArrayList(ORIG_ASC, DESC_DESC));
    assertQuerySupported(Flight.class, "origin != 2", Utils.newArrayList(ORIGIN_NEQ_2_LITERAL), NO_SORTS);
    assertQuerySupported("select from " + Flight.class.getName() + " where origin != null",
        Utils.newArrayList(ORIGIN_NEQ_NULL_LITERAL), NO_SORTS);
    assertQuerySupported(Flight.class, "origin == '2' || origin == 2",
                         Utils.newArrayList(ORIGIN_IN_2_ARGS), NO_SORTS);
    assertQuerySupported(Flight.class, "origin == '2' || origin == 2 || origin == false",
                         Utils.newArrayList(ORIGIN_IN_3_ARGS), NO_SORTS);
    assertQuerySupported(Flight.class, ":p1.contains(origin)",
                         Utils.newArrayList(ORIGIN_IN_2_ARGS), NO_SORTS, Arrays.asList("2", 2L));
    assertQuerySupported(Flight.class, ":p1.contains(origin)",
                         Utils.newArrayList(ORIGIN_IN_3_ARGS), NO_SORTS, Arrays.asList("2", 2L, false));
    assertQuerySupported(Flight.class, "(origin == '2' || origin == 2) && dest == 4",
                         Utils.newArrayList(DEST_EQ_4_LITERAL, ORIGIN_IN_2_ARGS), NO_SORTS);
    assertQuerySupported(Flight.class, ":p1.contains(origin) && dest == 4",
                         Utils.newArrayList(ORIGIN_IN_2_ARGS, DEST_EQ_4_LITERAL), NO_SORTS, Arrays.asList("2", 2L));
    assertQuerySupported(Flight.class, "(origin == '2' || origin == 2 || origin == false) && dest == 4",
                         Utils.newArrayList(DEST_EQ_4_LITERAL, ORIGIN_IN_3_ARGS), NO_SORTS);
    assertQuerySupported(Flight.class, ":p1.contains(origin) && dest == 4",
                         Utils.newArrayList(ORIGIN_IN_3_ARGS, DEST_EQ_4_LITERAL), NO_SORTS, Arrays.asList("2", 2L, false));
  }

  public void testBindVariables() {
    String queryStr = "select from " + Flight.class.getName() + " where origin == two ";
    assertQuerySupported(queryStr + " parameters String two",
        Utils.newArrayList(ORIGIN_EQ_2STR), NO_SORTS, "2");
    assertQuerySupportedWithExplicitParams(queryStr,
        Utils.newArrayList(ORIGIN_EQ_2STR), NO_SORTS, "String two", "2");

    queryStr = "select from " + Flight.class.getName() + " where origin == two && dest == four ";
    assertQuerySupported(queryStr + "parameters int two, int four",
        Utils.newArrayList(ORIGIN_EQ_2, DEST_EQ_4_LITERAL), NO_SORTS, 2, 4L);
    assertQuerySupportedWithExplicitParams(queryStr,
        Utils.newArrayList(ORIGIN_EQ_2, DEST_EQ_4_LITERAL), NO_SORTS, "int two, int four", 2, 4L);

    queryStr = "select from " + Flight.class.getName() + " where origin == two && dest == four ";
    String orderStr = "order by origin asc, dest desc";
    assertQuerySupported(queryStr + "parameters int two, int four " + orderStr,
        Utils.newArrayList(ORIGIN_EQ_2, DEST_EQ_4_LITERAL),
        Utils.newArrayList(ORIG_ASC, DESC_DESC), 2, 4L);
    assertQuerySupportedWithExplicitParams(queryStr + orderStr,
        Utils.newArrayList(ORIGIN_EQ_2, DEST_EQ_4_LITERAL),
        Utils.newArrayList(ORIG_ASC, DESC_DESC), "int two, int four", 2, 4L);
  }

  public void test2Equals2OrderBy() {
    ds.put(null, newFlightEntity("1", "yam", "bam", 1, 2));
    ds.put(null, newFlightEntity("2", "yam", "bam", 1, 1));
    ds.put(null, newFlightEntity("3", "yam", "bam", 2, 1));
    ds.put(null ,newFlightEntity("4", "yam", "bam", 2, 2));
    ds.put(null, newFlightEntity("5", "notyam", "bam", 2, 2));
    ds.put(null, newFlightEntity("5", "yam", "notbam", 2, 2));
    Query q = pm.newQuery(
        "select from " + Flight.class.getName()
            + " where origin == \"yam\" && dest == \"bam\""
            + " order by you asc, me desc");
    @SuppressWarnings("unchecked")
    List<Flight> result = (List<Flight>) q.execute();
    assertEquals(4, result.size());

    assertEquals("1", result.get(0).getName());
    assertEquals("2", result.get(1).getName());
    assertEquals("4", result.get(2).getName());
    assertEquals("3", result.get(3).getName());
  }

  public void testSetFilter() {
    ds.put(null, newFlightEntity("1", "yam", "bam", 1, 1));
    ds.put(null, newFlightEntity("2", "yam", "bam", 2, 2));
    Query q = pm.newQuery(
        "select from " + Flight.class.getName());
    q.setFilter("origin == \"yam\" && you == 2");
    @SuppressWarnings("unchecked")
    List<Flight> result = (List<Flight>) q.execute();
    assertEquals(1, result.size());
  }

  public void testSetInvalidFilter() {
    Query q = pm.newQuery(
        "select from " + Flight.class.getName());
    q.setFilter("origin == \"yam\" AND you == 2");
    try {
      q.execute();
      fail("expected exception");
    } catch (JDOUserException e) {
      // good
    }
  }

  public void testDefaultOrderingIsAsc() {
    ds.put(null, newFlightEntity("1", "yam", "bam", 1, 2));
    ds.put(null, newFlightEntity("2", "yam", "bam", 1, 1));
    ds.put(null, newFlightEntity("3", "yam", "bam", 2, 1));
    ds.put(null, newFlightEntity("4", "yam", "bam", 2, 2));
    ds.put(null, newFlightEntity("5", "notyam", "bam", 2, 2));
    ds.put(null, newFlightEntity("5", "yam", "notbam", 2, 2));
    Query q = pm.newQuery(
        "select from " + Flight.class.getName()
            + " where origin == \"yam\" && dest == \"bam\""
            + " order by you");
    @SuppressWarnings("unchecked")
    List<Flight> result = (List<Flight>) q.execute();
    assertEquals(4, result.size());

    assertEquals("1", result.get(0).getName());
    assertEquals("2", result.get(1).getName());
    assertEquals("3", result.get(2).getName());
    assertEquals("4", result.get(3).getName());
  }

  public void testLimitQuery() {
    ds.put(null, newFlightEntity("1", "yam", "bam", 1, 2));
    ds.put(null, newFlightEntity("2", "yam", "bam", 1, 1));
    ds.put(null, newFlightEntity("3", "yam", "bam", 2, 1));
    ds.put(null, newFlightEntity("4", "yam", "bam", 2, 2));
    ds.put(null, newFlightEntity("5", "notyam", "bam", 2, 2));
    ds.put(null, newFlightEntity("5", "yam", "notbam", 2, 2));
    Query q = pm.newQuery(
        "select from " + Flight.class.getName()
            + " where origin == \"yam\" && dest == \"bam\""
            + " order by you asc, me desc");

    q.setRange(0, 1);
    @SuppressWarnings("unchecked")
    List<Flight> result1 = (List<Flight>) q.execute();
    assertEquals(1, result1.size());
    assertEquals("1", result1.get(0).getName());

    q.setRange(0, Long.MAX_VALUE);
    @SuppressWarnings("unchecked")
    List<Flight> result2 = (List<Flight>) q.execute();
    assertEquals(4, result2.size());
    assertEquals("1", result2.get(0).getName());

    q.setRange(0, 0);
    @SuppressWarnings("unchecked")
    List<Flight> result3 = (List<Flight>) q.execute();
    assertEquals(0, result3.size());
  }

  public void testOffsetQuery() {
    ds.put(null, newFlightEntity("1", "yam", "bam", 1, 2));
    ds.put(null, newFlightEntity("2", "yam", "bam", 1, 1));
    ds.put(null, newFlightEntity("3", "yam", "bam", 2, 1));
    ds.put(null, newFlightEntity("4", "yam", "bam", 2, 2));
    ds.put(null, newFlightEntity("5", "notyam", "bam", 2, 2));
    ds.put(null, newFlightEntity("5", "yam", "notbam", 2, 2));
    Query q = pm.newQuery(
        "select from " + Flight.class.getName()
            + " where origin == \"yam\" && dest == \"bam\""
            + " order by you asc, me desc");

    q.setRange(0, Long.MAX_VALUE);
    @SuppressWarnings("unchecked")
    List<Flight> result1 = (List<Flight>) q.execute();
    assertEquals(4, result1.size());
    assertEquals("1", result1.get(0).getName());

    q.setRange(1, Long.MAX_VALUE);
    @SuppressWarnings("unchecked")
    List<Flight> result2 = (List<Flight>) q.execute();
    assertEquals(3, result2.size());
    assertEquals("2", result2.get(0).getName());

    q.setRange(0, Long.MAX_VALUE);
    @SuppressWarnings("unchecked")
    List<Flight> result3 = (List<Flight>) q.execute();
    assertEquals(4, result3.size());
    assertEquals("1", result3.get(0).getName());
  }

  public void testOffsetLimitQuery() {
    ds.put(null, newFlightEntity("1", "yam", "bam", 1, 2));
    ds.put(null, newFlightEntity("2", "yam", "bam", 1, 1));
    ds.put(null, newFlightEntity("3", "yam", "bam", 2, 1));
    ds.put(null, newFlightEntity("4", "yam", "bam", 2, 2));
    ds.put(null, newFlightEntity("5", "notyam", "bam", 2, 2));
    ds.put(null, newFlightEntity("5", "yam", "notbam", 2, 2));
    Query q = pm.newQuery(
        "select from " + Flight.class.getName()
            + " where origin == \"yam\" && dest == \"bam\""
            + " order by you asc, me desc");

    q.setRange(0, 0);
    @SuppressWarnings("unchecked")
    List<Flight> result1 = (List<Flight>) q.execute();
    assertEquals(0, result1.size());

    q.setRange(1, 0);
    @SuppressWarnings("unchecked")
    List<Flight> result2 = (List<Flight>) q.execute();
    assertEquals(0, result2.size());

    q.setRange(0, 1);
    @SuppressWarnings("unchecked")
    List<Flight> result3 = (List<Flight>) q.execute();
    assertEquals(1, result3.size());
    assertEquals("1", result3.get(0).getName());

    q.setRange(0, 2);
    @SuppressWarnings("unchecked")
    List<Flight> result4 = (List<Flight>) q.execute();
    assertEquals(2, result4.size());
    assertEquals("1", result4.get(0).getName());

    q.setRange(1, 2);
    @SuppressWarnings("unchecked")
    List<Flight> result5 = (List<Flight>) q.execute();
    assertEquals(1, result5.size());
    assertEquals("2", result5.get(0).getName());

    q.setRange(2, 5);
    @SuppressWarnings("unchecked")
    List<Flight> result6 = (List<Flight>) q.execute();
    assertEquals(2, result6.size());
    assertEquals("4", result6.get(0).getName());

    q.setRange(2, 2);
    @SuppressWarnings("unchecked")
    List<Flight> result7 = (List<Flight>) q.execute();
    assertEquals(0, result7.size());

    q.setRange(2, 1);
    @SuppressWarnings("unchecked")
    List<Flight> result8 = (List<Flight>) q.execute();
    assertEquals(0, result8.size());
  }

  public void testOffsetLimitSingleStringQuery() {
    ds.put(null, newFlightEntity("1", "yam", "bam", 1, 2));
    ds.put(null, newFlightEntity("2", "yam", "bam", 1, 1));
    ds.put(null, newFlightEntity("3", "yam", "bam", 2, 1));
    ds.put(null, newFlightEntity("4", "yam", "bam", 2, 2));
    ds.put(null, newFlightEntity("5", "notyam", "bam", 2, 2));
    ds.put(null, newFlightEntity("5", "yam", "notbam", 2, 2));
    String queryFormat =
        "select from " + Flight.class.getName()
            + " where origin == \"yam\" && dest == \"bam\""
            + " order by you asc, me desc range %d,%d";
    Query q = pm.newQuery(String.format(queryFormat, 0, 0));
    @SuppressWarnings("unchecked")
    List<Flight> result1 = (List<Flight>) q.execute();
    assertEquals(0, result1.size());

    q = pm.newQuery(String.format(queryFormat, 1, 0));
    @SuppressWarnings("unchecked")
    List<Flight> result2 = (List<Flight>) q.execute();
    assertEquals(0, result2.size());

    q = pm.newQuery(String.format(queryFormat, 0, 1));
    @SuppressWarnings("unchecked")
    List<Flight> result3 = (List<Flight>) q.execute();
    assertEquals(1, result3.size());

    q = pm.newQuery(String.format(queryFormat, 0, 2));
    @SuppressWarnings("unchecked")
    List<Flight> result4 = (List<Flight>) q.execute();
    assertEquals(2, result4.size());
    assertEquals("1", result4.get(0).getName());

    q = pm.newQuery(String.format(queryFormat, 1, 2));
    @SuppressWarnings("unchecked")
    List<Flight> result5 = (List<Flight>) q.execute();
    assertEquals(1, result5.size());
    assertEquals("2", result5.get(0).getName());

    q = pm.newQuery(String.format(queryFormat, 2, 5));
    @SuppressWarnings("unchecked")
    List<Flight> result6 = (List<Flight>) q.execute();
    assertEquals(2, result6.size());
    assertEquals("4", result6.get(0).getName());

    q = pm.newQuery(String.format(queryFormat, 2, 2));
    @SuppressWarnings("unchecked")
    List<Flight> result7 = (List<Flight>) q.execute();
    assertEquals(0, result7.size());

    q = pm.newQuery(String.format(queryFormat, 2, 1));
    @SuppressWarnings("unchecked")
    List<Flight> result8 = (List<Flight>) q.execute();
    assertEquals(0, result8.size());
  }

  public void testSerialization() throws IOException {
    Query q = pm.newQuery("select from " + Flight.class.getName());
    q.execute();

    JDOQLQuery innerQuery = (JDOQLQuery)((JDOQuery)q).getInternalQuery();
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    ObjectOutputStream oos = new ObjectOutputStream(baos);
    // the fact that this doesn't blow up is the test
    oos.writeObject(innerQuery);
  }

  public void testKeyQuery_StringPk() {
    Entity flightEntity = newFlightEntity("1", "yam", "bam", 1, 2);
    ds.put(null, flightEntity);

    Query q = pm.newQuery(
        "select from " + Flight.class.getName() + " where id == key parameters String key");
    @SuppressWarnings("unchecked")
    List<Flight> flights = (List<Flight>) q.execute(KeyFactory.keyToString(flightEntity.getKey()));
    assertEquals(1, flights.size());
    assertEquals(flightEntity.getKey(), KeyFactory.stringToKey(flights.get(0).getId()));
  }

  public void testKeyQuery_KeyPk() {
    Entity entityWithName = new Entity(HasKeyPkJDO.class.getSimpleName(), "blarg");
    Entity entityWithId = new Entity(HasKeyPkJDO.class.getSimpleName());
    ds.put(null, entityWithName);
    ds.put(null, entityWithId);

    Query q = pm.newQuery(
        "select from " + HasKeyPkJDO.class.getName() +
        " where key == mykey parameters " + Key.class.getName() + " mykey");
    @SuppressWarnings("unchecked")
    List<HasKeyPkJDO> result = (List<HasKeyPkJDO>) q.execute(entityWithName.getKey());
    assertEquals(1, result.size());
    assertEquals(entityWithName.getKey(), result.get(0).getKey());

    q = pm.newQuery(
        "select from " + HasKeyPkJDO.class.getName() +
        " where key == mykey parameters " + Key.class.getName() + " mykey");
    @SuppressWarnings("unchecked")
    List<HasKeyPkJDO> result2 = (List<HasKeyPkJDO>) q.execute(entityWithId.getKey());
    assertEquals(1, result2.size());
    assertEquals(entityWithId.getKey(), result2.get(0).getKey());

    q = pm.newQuery(
        "select from " + HasKeyPkJDO.class.getName() +
        " where key == mykeyname parameters " + String.class.getName() + " mykeyname");
    @SuppressWarnings("unchecked")
    List<HasKeyPkJDO> result3 = (List<HasKeyPkJDO>) q.execute(entityWithName.getKey().getName());
    assertEquals(1, result3.size());
    assertEquals(entityWithName.getKey(), result3.get(0).getKey());

    q = pm.newQuery(
        "select from " + HasKeyPkJDO.class.getName() +
        " where key == mykeyid parameters " + String.class.getName() + " mykeyid");
    @SuppressWarnings("unchecked")
    List<HasKeyPkJDO> result4 = (List<HasKeyPkJDO>) q.execute(entityWithId.getKey().getId());
    assertEquals(1, result4.size());
    assertEquals(entityWithId.getKey(), result4.get(0).getKey());
  }

  public void testKeyQueryWithSorts() {
    Entity flightEntity = newFlightEntity("1", "yam", "bam", 1, 2);
    ds.put(null, flightEntity);

    Query q = pm.newQuery(
        "select from " + Flight.class.getName()
            + " where id == key parameters String key order by id asc");
    @SuppressWarnings("unchecked")
    List<Flight> flights = (List<Flight>) q.execute(KeyFactory.keyToString(flightEntity.getKey()));
    assertEquals(1, flights.size());
    assertEquals(flightEntity.getKey(), KeyFactory.stringToKey(flights.get(0).getId()));
  }

  public void testKeyQuery_MultipleFilters() {
    Entity flightEntity = newFlightEntity("1", "yam", "bam", 1, 2);
    ds.put(null, flightEntity);

    Query q = pm.newQuery(
        "select from " + Flight.class.getName()
            + " where id == key && origin == \"yam\" parameters String key");
    @SuppressWarnings("unchecked")
    List<Flight> flights = (List<Flight>) q.execute(KeyFactory.keyToString(flightEntity.getKey()));
    assertEquals(1, flights.size());
    assertEquals(flightEntity.getKey(), KeyFactory.stringToKey(flights.get(0).getId()));
  }

  public void testKeyQuery_NonEqualityFilter() {
    Entity flightEntity1 = newFlightEntity("1", "yam", "bam", 1, 2);
    ds.put(null, flightEntity1);
    Entity flightEntity2 = newFlightEntity("1", "yam", "bam", 1, 2);
    ds.put(null, flightEntity2);

    Query q = pm.newQuery(
        "select from " + Flight.class.getName() + " where id > key parameters String key");
    @SuppressWarnings("unchecked")
    List<Flight> flights = (List<Flight>) q.execute(KeyFactory.keyToString(flightEntity1.getKey()));
    assertEquals(1, flights.size());
    assertEquals(flightEntity2.getKey(), KeyFactory.stringToKey(flights.get(0).getId()));
  }

  public void testKeyQuery_SortByKey() {
    Entity flightEntity1 = newFlightEntity("1", "yam", "bam", 1, 2);
    ds.put(null, flightEntity1);

    Entity flightEntity2 = newFlightEntity("1", "yam", "bam", 1, 2);
    ds.put(null, flightEntity2);

    Query q = pm.newQuery(
        "select from " + Flight.class.getName() + " where origin == 'yam' order by id DESC");
    @SuppressWarnings("unchecked")
    List<Flight> flights = (List<Flight>) q.execute();
    assertEquals(2, flights.size());
    assertEquals(flightEntity2.getKey(), KeyFactory.stringToKey(flights.get(0).getId()));
    assertEquals(flightEntity1.getKey(), KeyFactory.stringToKey(flights.get(1).getId()));
  }

  public void testKeyQuery_FilterAndSortByKeyComponent() {
    // filter by pk-id
    assertQueryUnsupportedByDatastore(
        "select from " + HasEncodedStringPkSeparateIdFieldJDO.class.getName() + " where id == 4");
    // sort by pk-id
    assertQueryUnsupportedByDatastore(
        "select from " + HasEncodedStringPkSeparateIdFieldJDO.class.getName() + " order by id");
    // filter by pk-id
    assertQueryUnsupportedByDatastore(
        "select from " + HasEncodedStringPkSeparateNameFieldJDO.class.getName() + " where name == 4");
    // sort by pk-id
    assertQueryUnsupportedByDatastore(
        "select from " + HasEncodedStringPkSeparateNameFieldJDO.class.getName() + " order by name");
  }

  public void testAncestorQueryWithStringAncestor() {
    Entity flightEntity = newFlightEntity("1", "yam", "bam", 1, 2);
    ds.put(null, flightEntity);
    Entity hasAncestorEntity = new Entity(HasStringAncestorStringPkJDO.class.getSimpleName(), flightEntity.getKey());
    ds.put(null, hasAncestorEntity);

    Query q = pm.newQuery(
        "select from " + HasStringAncestorStringPkJDO.class.getName()
            + " where ancestorId == ancId parameters String ancId");
    @SuppressWarnings("unchecked")
    List<HasStringAncestorStringPkJDO> haList =
        (List<HasStringAncestorStringPkJDO>) q.execute(KeyFactory.keyToString(flightEntity.getKey()));
    assertEquals(1, haList.size());
    assertEquals(flightEntity.getKey(), KeyFactory.stringToKey(haList.get(0).getAncestorId()));

    assertEquals(
        flightEntity.getKey(), getDatastoreQuery(q).getLatestDatastoreQuery().getAncestor());
    assertEquals(NO_FILTERS, getFilterPredicates(q));
    assertEquals(NO_SORTS, getSortPredicates(q));
  }

  public void testAncestorQueryWithKeyAncestor() {
    Entity e = new Entity("parent");
    ds.put(null, e);
    Entity childEntity = new Entity(HasKeyAncestorStringPkJDO.class.getSimpleName(), e.getKey());
    ds.put(null, childEntity);

    Query q = pm.newQuery(
        "select from " + HasKeyAncestorStringPkJDO.class.getName()
            + " where ancestorKey == ancId parameters " + Key.class.getName() + " ancId");
    @SuppressWarnings("unchecked")
    List<HasKeyAncestorStringPkJDO> result =
        (List<HasKeyAncestorStringPkJDO>) q.execute(e.getKey());
    assertEquals(1, result.size());
    assertEquals(e.getKey(), result.get(0).getAncestorKey());
  }

  public void testIllegalAncestorQuery_BadOperator() {
    Entity flightEntity = newFlightEntity("1", "yam", "bam", 1, 2);
    ds.put(null, flightEntity);
    Entity hasAncestorEntity = new Entity(HasStringAncestorStringPkJDO.class.getName(), flightEntity.getKey());
    ds.put(null, hasAncestorEntity);

    Query q = pm.newQuery(
        "select from " + HasStringAncestorStringPkJDO.class.getName()
            + " where ancestorId > ancId parameters String ancId");
    q.addExtension(DatastoreManager.QUERYEXT_INMEMORY_WHEN_UNSUPPORTED, "false");
    try {
      q.execute(KeyFactory.keyToString(flightEntity.getKey()));
      fail ("expected udfe");
    } catch (JDOUserException jdoe) {
        if (jdoe.getCause() instanceof DatastoreQuery.UnsupportedDatastoreFeatureException) {
          // good
        }
        else {
          throw jdoe;
        }
    }
  }

  public void testSortByFieldWithCustomColumn() {
    ds.put(null, newFlightEntity("1", "yam", "bam", 1, 2, 400));
    ds.put(null, newFlightEntity("2", "yam", "bam", 1, 1, 300));
    ds.put(null, newFlightEntity("3", "yam", "bam", 2, 1, 200));
    Query q = pm.newQuery(
        "select from " + Flight.class.getName()
            + " where origin == \"yam\" && dest == \"bam\""
            + " order by flightNumber asc");
    @SuppressWarnings("unchecked")
    List<Flight> result = (List<Flight>) q.execute();
    assertEquals(3, result.size());

    assertEquals("3", result.get(0).getName());
    assertEquals("2", result.get(1).getName());
    assertEquals("1", result.get(2).getName());
  }

  public void testIllegalAncestorQuery_SortByAncestor() {
    Entity flightEntity = newFlightEntity("1", "yam", "bam", 1, 2);
    ds.put(null, flightEntity);
    Entity hasAncestorEntity = new Entity(HasStringAncestorStringPkJDO.class.getName(), flightEntity.getKey());
    ds.put(null, hasAncestorEntity);

    Query q = pm.newQuery(
        "select from " + HasStringAncestorStringPkJDO.class.getName()
            + " where ancestorId == ancId parameters String ancId order by ancestorId ASC");
    q.addExtension(DatastoreManager.QUERYEXT_INMEMORY_WHEN_UNSUPPORTED, "false");
    try {
      q.execute(KeyFactory.keyToString(flightEntity.getKey()));
      fail ("expected udfe");
    } catch (JDOUserException jdoe) {
        if (jdoe.getCause() instanceof DatastoreQuery.UnsupportedDatastoreFeatureException) {
          // good
        }
        else {
          throw jdoe;
        }
    }
  }

  private interface FlightProvider {
    Flight getFlight(Key key);
  }

  private class AttachedFlightProvider implements FlightProvider {
    public Flight getFlight(Key key) {
      return pm.getObjectById(Flight.class, key);
    }
  }

  private class TransientFlightProvider implements FlightProvider {
    public Flight getFlight(Key key) {
      Flight f = new Flight();
      f.setId(KeyFactory.keyToString(key));
      return f;
    }
  }

  private void testFilterByChildObject(FlightProvider fp) {
    Entity parentEntity = new Entity(HasOneToOneJDO.class.getSimpleName());
    ds.put(null, parentEntity);
    Entity flightEntity = newFlightEntity(parentEntity.getKey(), null, "f", "bos", "mia", 2, 4, 33);
    ds.put(null, flightEntity);

    Flight flight = fp.getFlight(flightEntity.getKey());
    Query q = pm.newQuery(
        "select from " + HasOneToOneJDO.class.getName()
        + " where flight == f parameters " + Flight.class.getName() + " f");
    List<HasOneToOneJDO> result = (List<HasOneToOneJDO>) q.execute(flight);
    assertEquals(1, result.size());
    assertEquals(parentEntity.getKey(), KeyFactory.stringToKey(result.get(0).getId()));
  }

  public void testFilterByChildObject() {
    testFilterByChildObject(new AttachedFlightProvider());
    commitTxn();
    beginTxn();
    testFilterByChildObject(new TransientFlightProvider());
  }

  public void testFilterByNullChildObject() {
    Entity parentEntity = new Entity(HasOneToOneJDO.class.getSimpleName());
    ds.put(null, parentEntity);
    Entity flightEntity = newFlightEntity(parentEntity.getKey(), null, "f", "bos", "mia", 2, 4, 33);
    ds.put(null, flightEntity);

    Query q = pm.newQuery(
        "select from " + HasOneToOneJDO.class.getName()
        + " where flight == f parameters " + Flight.class.getName() + " f");
    q.addExtension(DatastoreManager.QUERYEXT_INMEMORY_WHEN_UNSUPPORTED, "false");
    try {
      q.execute(null);
      fail("expected exception");
    } catch (JDOFatalUserException e) {
      // good
    }
  }

  public void testContains() {
    Entity e = Flight.newFlightEntity("name1", "bos1", "mia1", 23, 24);
    Entity e2 = Flight.newFlightEntity("name2", "bos2", null, 25, 26);
    Entity e3 = Flight.newFlightEntity("name3", "bos3", "mia2", 27, 28);
    ds.put(null, Arrays.asList(e, e2, e3));

    Query q = pm.newQuery("select from " + Flight.class.getName() + " where :p1.contains(name)");
    List<Flight> flights = (List<Flight>) q.execute(Arrays.asList("name1", "name3"));
    assertEquals(2, flights.size());
    assertEquals(KeyFactory.keyToString(e.getKey()), flights.get(0).getId());
    assertEquals(KeyFactory.keyToString(e3.getKey()), flights.get(1).getId());

    // Same but using executeWithMap
    Query q2 = pm.newQuery("select from " + Flight.class.getName() + " where :p1.contains(name)");
    Map params = new HashMap();
    params.put("p1", Arrays.asList("name1", "name3"));
    List<Flight> flights2 = (List<Flight>) q2.executeWithMap(params);
    assertEquals(2, flights2.size());
    assertEquals(KeyFactory.keyToString(e.getKey()), flights2.get(0).getId());
    assertEquals(KeyFactory.keyToString(e3.getKey()), flights2.get(1).getId());

    q = pm.newQuery("select from " + Flight.class.getName() + " where :p1.contains(dest)");
    flights = (List<Flight>) q.execute(Arrays.asList(null, "mia1"));
    assertEquals(2, flights.size());
    assertEquals(KeyFactory.keyToString(e2.getKey()), flights.get(0).getId());
    assertEquals(KeyFactory.keyToString(e.getKey()), flights.get(1).getId());

    q = pm.newQuery("select from " + Flight.class.getName() + " where :p1.contains(dest) || :p2.contains(dest)");
    flights = (List<Flight>) q.execute(Arrays.asList(null, "mia1"), Arrays.asList("mia2"));
    assertEquals(3, flights.size());
    assertEquals(KeyFactory.keyToString(e2.getKey()), flights.get(0).getId());
    assertEquals(KeyFactory.keyToString(e.getKey()), flights.get(1).getId());
    assertEquals(KeyFactory.keyToString(e3.getKey()), flights.get(2).getId());
  }

  public void testContainsOnlyForCollection() {
    Entity e = Flight.newFlightEntity("name1", "bos1", "mia1", 23, 24);
    Entity e2 = Flight.newFlightEntity("name2", "bos2", null, 25, 26);
    Entity e3 = Flight.newFlightEntity("name3", "bos3", "mia2", 27, 28);
    ds.put(null, Arrays.asList(e, e2, e3));

    try {
      Query q = pm.newQuery("select from " + Flight.class.getName() + " where name.contains(:param)");
      q.addExtension(DatastoreManager.QUERYEXT_INMEMORY_WHEN_UNSUPPORTED, "false");
      q.execute("na");
      fail("Should have thrown an exception when invoking 'contains' on a String");
    } catch (JDOUserException ue) {
      // Expected
    }
  }

  public void testMultipleIn_Params() {
    Entity e = Flight.newFlightEntity("name1", "mia1", "bos1", 23, 24);
    Entity e2 = Flight.newFlightEntity("name2", "mia2", "bos2", 25, 26);
    Entity e3 = Flight.newFlightEntity("name3", "mia3", "bos3", 27, 28);
    ds.put(null, Arrays.asList(e, e2, e3));
    Query q = pm.newQuery("select from " + Flight.class.getName() + " where :p1.contains(name) && :p2.contains(origin)");
    List<Flight> flights =
        (List<Flight>) q.execute(Utils.newArrayList("name1", "name3"), Utils.newArrayList("mia3", "mia2"));
    assertEquals(1, flights.size());
    assertEquals(KeyFactory.keyToString(e3.getKey()), flights.get(0).getId());

    q = pm.newQuery("select from " + Flight.class.getName() + " where :p1.contains(name) || :p2.contains(name)");
    flights =
        (List<Flight>) q.execute(Utils.newArrayList("name1", "name3"), Utils.newArrayList("name4", "name5"));

    assertEquals(2, flights.size());
    assertEquals(KeyFactory.keyToString(e.getKey()), flights.get(0).getId());
    assertEquals(KeyFactory.keyToString(e3.getKey()), flights.get(1).getId());
  }

  public void testMultipleIn_Params_KeyFilter() {
    Entity e = Flight.newFlightEntity("name1", "mia1", "bos1", 23, 24);
    Entity e2 = Flight.newFlightEntity("name2", "mia2", "bos2", 25, 26);
    Entity e3 = Flight.newFlightEntity("name3", "mia3", "bos3", 27, 28);
    ds.put(null, Arrays.asList(e, e2, e3));
    Query q = pm.newQuery(
        "select from " + Flight.class.getName() + " where :p1.contains(id) && :p2.contains(origin)");
    @SuppressWarnings("unchecked")
    List<Flight> flights = (List<Flight>) q.execute(
        Utils.newArrayList(KeyFactory.keyToString(e2.getKey())), Utils.newArrayList("mia3", "mia2"));
    assertEquals(1, flights.size());
    assertEquals(KeyFactory.keyToString(e2.getKey()), flights.get(0).getId());

    q = pm.newQuery(
      "select from " + Flight.class.getName() + " where (id == :p1 || id ==:p2) && :p3.contains(origin)");
    @SuppressWarnings("unchecked")
    List<Flight> flights2 = (List<Flight>) q.execute(
        e2.getKey(), e3.getKey(), Utils.newArrayList("mia3", "dne"));
    assertEquals(1, flights2.size());
  }

  public void testOr_Literals() {
    Entity e = Flight.newFlightEntity("name1", "bos1", "mia1", 23, 24);
    Entity e2 = Flight.newFlightEntity("name2", "bos2", null, 25, 26);
    Entity e3 = Flight.newFlightEntity("name3", "bos3", "mia2", 27, 28);
    ds.put(null, Arrays.asList(e, e2, e3));
    Query q = pm.newQuery("select from " + Flight.class.getName() +
                             " where name == 'name1' || name == 'name3'");
    List<Flight> flights = (List<Flight>) q.execute();
    assertEquals(2, flights.size());
    assertEquals(KeyFactory.keyToString(e.getKey()), flights.get(0).getId());
    assertEquals(KeyFactory.keyToString(e3.getKey()), flights.get(1).getId());

    q = pm.newQuery("select from " + Flight.class.getName() +
                       " where dest == null || dest == 'mia1'");
    flights = (List<Flight>) q.execute();
    assertEquals(2, flights.size());
    assertEquals(KeyFactory.keyToString(e2.getKey()), flights.get(0).getId());
    assertEquals(KeyFactory.keyToString(e.getKey()), flights.get(1).getId());
  }

  public void testOr_Params() {
    Entity e = Flight.newFlightEntity("name1", "bos1", "mia1", 23, 24);
    Entity e2 = Flight.newFlightEntity("name2", "bos2", "mia2", 25, 26);
    Entity e3 = Flight.newFlightEntity("name3", "bos3", "mia3", 27, 28);
    ds.put(null, Arrays.asList(e, e2, e3));
    Query q = pm.newQuery("select from " + Flight.class.getName() +
                             " where name == :p1 || name == :p2");
    List<Flight> flights = (List<Flight>) q.execute("name1", "name3");
    assertEquals(2, flights.size());
    assertEquals(KeyFactory.keyToString(e.getKey()), flights.get(0).getId());
    assertEquals(KeyFactory.keyToString(e3.getKey()), flights.get(1).getId());
  }

  public void testMultipleOr_Literals() {
    Entity e = Flight.newFlightEntity("name1", "bos1", "mia1", 23, 24);
    Entity e2 = Flight.newFlightEntity("name2", "bos2", "mia2", 25, 26);
    Entity e3 = Flight.newFlightEntity("name3", "bos3", "mia3", 27, 28);
    ds.put(null, Arrays.asList(e, e2, e3));
    Query q = pm.newQuery("select from " + Flight.class.getName() + " where "
                             + "(name  == 'name1' || name == 'name3') && "
                             + "(origin == 'bos3' || origin == 'bos2')");
    List<Flight> flights = (List<Flight>) q.execute();
    assertEquals(1, flights.size());
    assertEquals(KeyFactory.keyToString(e3.getKey()), flights.get(0).getId());
  }

  public void testMultipleOr_Params() {
    Entity e = Flight.newFlightEntity("name1", "bos1", "mia1", 23, 24);
    Entity e2 = Flight.newFlightEntity("name2", "bos2", "mia2", 25, 26);
    Entity e3 = Flight.newFlightEntity("name3", "bos3", "mia3", 27, 28);
    ds.put(null, Arrays.asList(e, e2, e3));
    Query q = pm.newQuery("select from " + Flight.class.getName() + " where "
                             + "(name == :p1 || name == :p2) && "
                             + "(origin == :p3 || origin == :p4)");
    Map<String, String> paramMap = Utils.newHashMap();
    paramMap.put("p1", "name1");
    paramMap.put("p2", "name3");
    paramMap.put("p3", "bos3");
    paramMap.put("p4", "bos2");
    List<Flight> flights = (List<Flight>) q.executeWithMap(paramMap);
    assertEquals(1, flights.size());
    assertEquals(KeyFactory.keyToString(e3.getKey()), flights.get(0).getId());
  }

  public void testExecuteWithArray() {
    Entity e = Flight.newFlightEntity("name1", "bos1", "mia1", 23, 24);
    Entity e2 = Flight.newFlightEntity("name2", "bos2", "mia2", 25, 26);
    Entity e3 = Flight.newFlightEntity("name3", "bos3", "mia3", 27, 28);
    ds.put(null, Arrays.asList(e, e2, e3));
    Query q = pm.newQuery("select from " + Flight.class.getName() + " where "
                             + "(name == :p1 || name == :p2) && "
                             + "(origin == :p3 || origin == :p4)");
    Map<String, String> paramMap = Utils.newHashMap();
    paramMap.put("p1", "name1");
    paramMap.put("p2", "name3");
    paramMap.put("p3", "bos3");
    paramMap.put("p4", "bos2");
    List<Flight> flights = (List<Flight>) q.executeWithArray("name1", "name3", "bos3", "bos2");
    assertEquals(1, flights.size());
 …