@Override public Key createKey(String kind, long id) { return KeyFactory.createKey(kind, id); }
@Override public Key createKey(String kind, String name) { return KeyFactory.createKey(kind, name); }
@Override public Key createKey(Key parent, String kind, long id) { return KeyFactory.createKey(parent, kind, id); }
@Override public void deleteUser(String username) { Key userKey = KeyFactory.createKey(AUTH_FLOWS_USER_DB_KIND, username); datastore.delete(userKey); }
/** * Returns all the associated PipelineModelObject for a root pipeline. * * @throws IllegalArgumentException if root pipeline was not found. */ public static PipelineObjects queryFullPipeline(String rootJobHandle) { Key rootJobKey = KeyFactory.createKey(JobRecord.DATA_STORE_KIND, rootJobHandle); return backEnd.queryFullPipeline(rootJobKey); }
/** Create a key with a parent and a String name */ public Key(Key<?> parent, Class<? extends T> kindClass, String name) { this.raw = KeyFactory.createKey(raw(parent), getKind(kindClass), name); this.parent = parent; }
@Override public void delete(String userId, Credential credential) { DatastoreService datastore = DatastoreServiceFactory.getDatastoreService(); Key key = KeyFactory.createKey(KIND, userId); datastore.delete(key); }
protected static Key generateKey(Key parentKey, String kind) { String name = GUIDGenerator.nextGUID(); Key key; if (null == parentKey) { key = KeyFactory.createKey(kind, name); } else { key = parentKey.getChild(kind, name); } return key; }
public static Key instantiate(SerializationStreamReader streamReader) throws SerializationException { Key parent = (Key) streamReader.readObject(); String kind = streamReader.readString(); long id = streamReader.readLong(); String name = streamReader.readString(); if (name == null) return KeyFactory.createKey(parent, kind, id); else return KeyFactory.createKey(parent, kind, name); }
private Key makeKey(String bucket, String object) { String origNamespace = NamespaceManager.get(); try { NamespaceManager.set(""); return KeyFactory.createKey(ENTITY_KIND_PREFIX + bucket, object); } finally { NamespaceManager.set(origNamespace); } }
void storePKIdField(int fieldNumber, Object value) { AbstractMemberMetaData mmd = getMetaData(fieldNumber); if (!mmd.getType().equals(Long.class)) { throw new NucleusFatalUserException( "Field with \"" + DatastoreManager.PK_ID + "\" extension must be of type Long"); } Key key = null; if (value != null) { key = KeyFactory.createKey(datastoreEntity.getKind(), (Long) value); } storeKeyPK(key); }
@Test(expected = EntityNotFoundException.class) public void getThrowsNotFoundExceptionWhenKeyIsNotFound() throws Exception { Key nonExistingKey = KeyFactory.createKey("NonExistingKey", 1); service.get(nonExistingKey); }
protected Entity createTestEntity(String kind, long id) { Key key = KeyFactory.createKey(kind, id); Entity entity = new Entity(key); entity.setProperty("text", "Some text."); return entity; }
@Test public void batchGetReturnsOnlyExistingKeysInMap() throws Exception { Key existingKey = KeyFactory.createKey("batch", "existing"); Key nonExistingKey = KeyFactory.createKey("batch", "nonExisting"); service.put(new Entity(existingKey)); Map<Key, Entity> map = service.get(Arrays.asList(existingKey, nonExistingKey)); assertEquals(1, map.size()); assertTrue(map.containsKey(existingKey)); }
@Test public void testQueryWithAncestorAndInequalityFilterOnKeyPropertyDoesNotRequireConfiguredIndex() throws Exception { executeQuery( new Query("Unindexed") .setAncestor(KeyFactory.createKey("Ancestor", 1)) .setFilter(new Query.FilterPredicate(Entity.KEY_RESERVED_PROPERTY, GREATER_THAN, KeyFactory.createKey("Unindexed", 1)))); }
@Test public void testQueryWithEqalityAndInequalityFilterOnKeyPropertyDoesNotRequireConfiguredIndex() throws Exception { executeQuery( new Query("Unindexed") .setFilter( and(new Query.FilterPredicate(Entity.KEY_RESERVED_PROPERTY, GREATER_THAN, KeyFactory.createKey("Unindexed", 1)), new Query.FilterPredicate(Entity.KEY_RESERVED_PROPERTY, EQUAL, KeyFactory.createKey("Unindexed", 2))))); }
@Test public void testQueryOnSomePropertyWithKeyInDifferentNamespace() { NamespaceManager.set("one"); Key keyInNamespaceOne = KeyFactory.createKey("kind", 1); NamespaceManager.set("two"); Query query = new Query("kind").setFilter(new Query.FilterPredicate("someProperty", EQUAL, keyInNamespaceOne)); PreparedQuery preparedQuery = service.prepare(query); preparedQuery.asSingleEntity(); // should not throw IllegalArgumentException as in previous test preparedQuery.asIterator().hasNext(); // should not throw IllegalArgumentException as in previous test preparedQuery.asList(withDefaults()).size(); // should not throw IllegalArgumentException as in previous test } }
@Test public void testQueryWithInequalityFilterOnKeyPropertyAndEqualityFilterOnOtherPropertyDoesNotRequireConfiguredIndex() throws Exception { executeQuery( new Query("Unindexed") .setFilter( and(new Query.FilterPredicate(Entity.KEY_RESERVED_PROPERTY, GREATER_THAN, KeyFactory.createKey("Unindexed", 1)), new Query.FilterPredicate("otherProperty", EQUAL, "b")))); }