Java CompositeFilterOperator.and方法代码示例

import com.google.appengine.api.datastore.Query.CompositeFilterOperator; //导入方法依赖的package包/类
@Test
public void queryRestrictions_compositeFilter_isInvalid() throws Exception {
  long minBirthYear = 1940;
  long maxHeight = 200;
  // [START inequality_filters_one_property_invalid_example]
  Filter birthYearMinFilter =
      new FilterPredicate("birthYear", FilterOperator.GREATER_THAN_OR_EQUAL, minBirthYear);

  Filter heightMaxFilter =
      new FilterPredicate("height", FilterOperator.LESS_THAN_OR_EQUAL, maxHeight);

  Filter invalidFilter = CompositeFilterOperator.and(birthYearMinFilter, heightMaxFilter);

  Query q = new Query("Person").setFilter(invalidFilter);
  // [END inequality_filters_one_property_invalid_example]

  // Note: The local devserver behavior is different than the production
  // version of Cloud Datastore, so there aren't any assertions we can make
  // in this test.  The query appears to work with the local test runner,
  // but will fail in production.
}
 

import com.google.appengine.api.datastore.Query.CompositeFilterOperator; //导入方法依赖的package包/类
@Override
public Connection<?> getConnection(ConnectionKey connectionKey) {
	final CompositeFilter filter = CompositeFilterOperator.and(
		FilterOperator.EQUAL.of("providerId", connectionKey.getProviderId()),
		FilterOperator.EQUAL.of("providerUserId", connectionKey.getProviderUserId())
	);
	final Query query = new Query(getKind())
		.setAncestor(userKey)
		.setFilter(filter);
	Entity singleEntity;
	try {
		singleEntity = datastore.prepare(query).asSingleEntity();			
	} catch (TooManyResultsException ex) {
		log.warning("Too many results were found for query " + query.toString());
		throw new NoSuchConnectionException(connectionKey);
	}
	if (singleEntity == null) throw new NoSuchConnectionException(connectionKey);
	return connectionMapper.mapEntity(singleEntity);
}
 

import com.google.appengine.api.datastore.Query.CompositeFilterOperator; //导入方法依赖的package包/类
@Override
public List<String> findUserIdsWithConnection(Connection<?> connection) {
	ConnectionKey key = connection.getKey();
	final CompositeFilter filter = CompositeFilterOperator.and(
		FilterOperator.EQUAL.of("providerId", key.getProviderId()),
		FilterOperator.EQUAL.of("providerUserId", key.getProviderUserId())
	);
       // fetch and return only keys, not full entities.
	Query query = new Query(getKind()).setFilter(filter).setKeysOnly();
	List<String> localUserIds = DatastoreUtils.queryForList(datastore.prepare(query), userIdMapper);
	if (localUserIds.size() == 0 && connectionSignUp != null) {			
			String newUserId = connectionSignUp.execute(connection);
			if (newUserId != null) {
				createConnectionRepository(newUserId).addConnection(connection);
				return Arrays.asList(newUserId);
			}
	}
	return localUserIds;
}
 

import com.google.appengine.api.datastore.Query.CompositeFilterOperator; //导入方法依赖的package包/类
@Test
public void queryRestrictions_compositeFilter_returnsMatchedEntities() throws Exception {
  // Arrange
  Entity a = new Entity("Person", "a");
  a.setProperty("birthYear", 1930);
  Entity b = new Entity("Person", "b");
  b.setProperty("birthYear", 1960);
  Entity c = new Entity("Person", "c");
  c.setProperty("birthYear", 1990);
  datastore.put(ImmutableList.<Entity>of(a, b, c));

  // Act
  long minBirthYear = 1940;
  long maxBirthYear = 1980;
  // [START inequality_filters_one_property_valid_example_1]
  Filter birthYearMinFilter =
      new FilterPredicate("birthYear", FilterOperator.GREATER_THAN_OR_EQUAL, minBirthYear);

  Filter birthYearMaxFilter =
      new FilterPredicate("birthYear", FilterOperator.LESS_THAN_OR_EQUAL, maxBirthYear);

  Filter birthYearRangeFilter =
      CompositeFilterOperator.and(birthYearMinFilter, birthYearMaxFilter);

  Query q = new Query("Person").setFilter(birthYearRangeFilter);
  // [END inequality_filters_one_property_valid_example_1]

  // Assert
  List<Entity> results =
      datastore.prepare(q.setKeysOnly()).asList(FetchOptions.Builder.withDefaults());
  assertThat(results).named("query results").containsExactly(b);
}
 

import com.google.appengine.api.datastore.Query.CompositeFilterOperator; //导入方法依赖的package包/类
private static Filter getSourceFilter(final PageId source) {
    final int number = source.getNumber();
    final Filter numberFilter = getSourceNumberFilter(number);
    final String version = source.getVersion();
    final Filter versionFilter = getSourceVersionFilter(version);
    return CompositeFilterOperator.and(numberFilter, versionFilter);
}
 

import com.google.appengine.api.datastore.Query.CompositeFilterOperator; //导入方法依赖的package包/类
private DatastoreQuery getQueryMatchingSourceAndIndex() {
    final DatastoreQuery query = new DatastoreQuery(KIND_NAME);
    final PageId source = getSource();
    final Filter sourceFilter = getSourceFilter(source);
    final int listIndex = getListIndex();
    final Filter listIndexFilter = getListIndexFilter(listIndex);
    final Filter filter;
    filter = CompositeFilterOperator.and(sourceFilter, listIndexFilter);
    return query.setFilter(filter);
}
 

import com.google.appengine.api.datastore.Query.CompositeFilterOperator; //导入方法依赖的package包/类
private static Filter getIdFilter(final PageId id) {
    final int num = id.getNumber();
    final Filter numFilter = getIdNumFilter(num);
    final String version = id.getVersion();
    final Filter versionFilter = getIdVersionFilter(version);
    return CompositeFilterOperator.and(numFilter, versionFilter);
}
 

import com.google.appengine.api.datastore.Query.CompositeFilterOperator; //导入方法依赖的package包/类
public static int countNewNotificationsForRecipient(
        final String recipientId) {
    final DatastoreQuery query = new DatastoreQuery(KIND_NAME);
    final Filter recipientFilter = getRecipientFilter(recipientId);
    final boolean isNew = true;
    final Filter isNewFilter = getIsNewFilter(isNew);
    final Filter filter;
    filter = CompositeFilterOperator.and(recipientFilter, isNewFilter);
    query.setFilter(filter);
    final Store store = new Store();
    final PreparedQuery preparedQuery = store.prepare(query);
    final FetchOptions fetchOptions = FetchOptions.Builder.withDefaults();
    return preparedQuery.countEntities(fetchOptions);
}
 

import com.google.appengine.api.datastore.Query.CompositeFilterOperator; //导入方法依赖的package包/类
private DatastoreQuery getQueryByRecipientAndTime() {
    final DatastoreQuery query = new DatastoreQuery(KIND_NAME);
    final String recipientId = getRecipientId();
    final Filter recipientFilter = getRecipientFilter(recipientId);
    final Date time = getTime();
    final Filter timeFilter = getTimeFilter(time);
    final Filter filter;
    filter = CompositeFilterOperator.and(recipientFilter, timeFilter);
    query.setFilter(filter);
    return query;
}
 

import com.google.appengine.api.datastore.Query.CompositeFilterOperator; //导入方法依赖的package包/类
public Entity getMarker(String marker) {
    DatastoreService service = DatastoreServiceFactory.getDatastoreService();
    FilterPredicate testRunFilter = new FilterPredicate(TEST_RUN_ID, FilterOperator.EQUAL, testRunId);
    FilterPredicate markerFilter = new FilterPredicate(MARKER, FilterOperator.EQUAL, marker);
    CompositeFilter filter = CompositeFilterOperator.and(testRunFilter, markerFilter);
    Query query = new Query(entityName).setFilter(filter);
    return service.prepare(query).asSingleEntity();
}
 

import com.google.appengine.api.datastore.Query.CompositeFilterOperator; //导入方法依赖的package包/类
/**
 * Gets the player entity by player's Google+ Id.
 *
 * @param plusId User's Google+ Id.
 * @return player entity or null if there is no player entity with this email.
 */
protected PlayerEntity getByPlusId(String plusId) {
  Filter plusFilter =
      new FilterPredicate(PlayerEntity.GOOGLEPLUSID_PROPERTY, FilterOperator.EQUAL, plusId);
  Filter activeFilter =
      new FilterPredicate(PlayerEntity.ACTIVE_PROPERTY, FilterOperator.EQUAL, true);
  Filter filter = CompositeFilterOperator.and(activeFilter, plusFilter);

  Query query = new Query(PlayerEntity.KIND).setFilter(filter);
  PreparedQuery preparedQuery = dataStore.prepare(query);

  Entity entity = preparedQuery.asSingleEntity();

  return entity == null ? null : new PlayerEntity(entity);
}
 

import com.google.appengine.api.datastore.Query.CompositeFilterOperator; //导入方法依赖的package包/类
private Connection<?> findPrimaryConnection(String providerId) {
	final CompositeFilter filter = CompositeFilterOperator.and(
		FilterOperator.EQUAL.of("providerId", providerId), 
		FilterOperator.EQUAL.of("rank", 1L)
	);
	final Query query = new Query(getKind())
		.setAncestor(userKey)
		.setFilter(filter);
	List<Connection<?>> resultList = DatastoreUtils.queryForList(
			datastore.prepare(query), connectionMapper);
	return resultList.size() > 0 ? resultList.get(0) : null;				
}
 

import com.google.appengine.api.datastore.Query.CompositeFilterOperator; //导入方法依赖的package包/类
@Override
public Set<String> findUserIdsConnectedTo(String providerId, Set<String> providerUserIds) {
	final CompositeFilter filter = CompositeFilterOperator.and(
		FilterOperator.EQUAL.of("providerId", providerId),
		FilterOperator.IN.of("providerUserId", providerUserIds)
	);
       // fetch and return only keys, not full entities.
	Query query = new Query(getKind()).setFilter(filter).setKeysOnly();
	List<String> resultList = DatastoreUtils.queryForList(datastore.prepare(query), userIdMapper);
	return new HashSet<String>(resultList);
}
 

import com.google.appengine.api.datastore.Query.CompositeFilterOperator; //导入方法依赖的package包/类
@Test
public void queryRestrictions_compositeEqualFilter_returnsMatchedEntities() throws Exception {
  // Arrange
  Entity a = new Entity("Person", "a");
  a.setProperty("birthYear", 1930);
  a.setProperty("city", "Somewhere");
  a.setProperty("lastName", "Someone");
  Entity b = new Entity("Person", "b");
  b.setProperty("birthYear", 1960);
  b.setProperty("city", "Somewhere");
  b.setProperty("lastName", "Someone");
  Entity c = new Entity("Person", "c");
  c.setProperty("birthYear", 1990);
  c.setProperty("city", "Somewhere");
  c.setProperty("lastName", "Someone");
  Entity d = new Entity("Person", "d");
  d.setProperty("birthYear", 1960);
  d.setProperty("city", "Nowhere");
  d.setProperty("lastName", "Someone");
  Entity e = new Entity("Person", "e");
  e.setProperty("birthYear", 1960);
  e.setProperty("city", "Somewhere");
  e.setProperty("lastName", "Noone");
  datastore.put(ImmutableList.<Entity>of(a, b, c, d, e));
  long minBirthYear = 1940;
  long maxBirthYear = 1980;
  String targetCity = "Somewhere";
  String targetLastName = "Someone";

  // [START inequality_filters_one_property_valid_example_2]
  Filter lastNameFilter = new FilterPredicate("lastName", FilterOperator.EQUAL, targetLastName);

  Filter cityFilter = new FilterPredicate("city", FilterOperator.EQUAL, targetCity);

  Filter birthYearMinFilter =
      new FilterPredicate("birthYear", FilterOperator.GREATER_THAN_OR_EQUAL, minBirthYear);

  Filter birthYearMaxFilter =
      new FilterPredicate("birthYear", FilterOperator.LESS_THAN_OR_EQUAL, maxBirthYear);

  Filter validFilter =
      CompositeFilterOperator.and(
          lastNameFilter, cityFilter, birthYearMinFilter, birthYearMaxFilter);

  Query q = new Query("Person").setFilter(validFilter);
  // [END inequality_filters_one_property_valid_example_2]

  // Assert
  List<Entity> results =
      datastore.prepare(q.setKeysOnly()).asList(FetchOptions.Builder.withDefaults());
  assertThat(results).named("query results").containsExactly(b);
}
 

import com.google.appengine.api.datastore.Query.CompositeFilterOperator; //导入方法依赖的package包/类
private CompositeFilter getTestMethodFilter(String testMethodTag) {
    FilterPredicate testRunFilter = new FilterPredicate(TEST_RUN_ID, FilterOperator.EQUAL, testRunId);
    FilterPredicate method = new FilterPredicate(TEST_METHOD_TAG, FilterOperator.EQUAL, testMethodTag);
    return CompositeFilterOperator.and(testRunFilter, method);
}