private Builder(Key copyFrom) { super(copyFrom); if (copyFrom.hasId()) { id = copyFrom.getId(); } else { name = copyFrom.getName(); } }
private void verifyKey(Key key, Long id, String namespace, PathElement... ancestors) { assertEquals(id, key.getId()); verifyIncompleteKey(key, namespace, ancestors); }
@Test public void testAllocateIdArray() { KeyFactory keyFactory = DATASTORE.newKeyFactory().setKind(KIND1); IncompleteKey incompleteKey1 = keyFactory.newKey(); IncompleteKey incompleteKey2 = keyFactory.setKind(KIND2).addAncestors(PathElement.of(KIND1, 10)).newKey(); List<Key> result = DATASTORE.allocateId(incompleteKey1, incompleteKey2, incompleteKey1); assertEquals(3, result.size()); assertEquals(Key.newBuilder(incompleteKey1, result.get(0).getId()).build(), result.get(0)); assertEquals(Key.newBuilder(incompleteKey1, result.get(2).getId()).build(), result.get(2)); assertEquals(Key.newBuilder(incompleteKey2, result.get(1).getId()).build(), result.get(1)); }
/** * @return the id associated with this key, or 0 if this key has a name. */ public long getId() { return this.raw.getId(); }
@Test public void testAllocateIdArray() { KeyFactory keyFactory = datastore.newKeyFactory().setKind(KIND1); IncompleteKey incompleteKey1 = keyFactory.newKey(); IncompleteKey incompleteKey2 = keyFactory.setKind(KIND2).addAncestor(PathElement.of(KIND1, 10)).newKey(); Key key3 = keyFactory.newKey("name"); List<Key> result1 = datastore.allocateId(incompleteKey1, incompleteKey2, incompleteKey1); assertEquals(3, result1.size()); assertEquals(Key.newBuilder(incompleteKey1, result1.get(0).getId()).build(), result1.get(0)); assertEquals(Key.newBuilder(incompleteKey1, result1.get(2).getId()).build(), result1.get(2)); assertEquals(Key.newBuilder(incompleteKey2, result1.get(1).getId()).build(), result1.get(1)); try { datastore.allocateId(incompleteKey1, incompleteKey2, key3); fail("expecting a failure"); } catch (IllegalArgumentException expected) { assertEquals(expected.getMessage(), "keys must be IncompleteKey instances"); } }
private static void addParentToBuilder(Key parent, Builder builder) { builder.setNamespace(parent.getNamespace()); builder.addAncestors(parent.getAncestors()); if (parent.hasId()) { builder.addAncestors(PathElement.of(parent.getKind(), parent.getId())); } else { builder.addAncestors(PathElement.of(parent.getKind(), parent.getName())); } } }
/** * Converts a list of task entities to a list of formatted task strings. * * @param tasks An iterator over task entities * @return A list of tasks strings, one per entity */ static List<String> formatTasks(Iterator<Entity> tasks) { List<String> strings = new ArrayList<>(); while (tasks.hasNext()) { Entity task = tasks.next(); if (task.getBoolean("done")) { strings.add( String.format("%d : %s (done)", task.getKey().getId(), task.getString("description"))); } else { strings.add(String.format("%d : %s (created %s)", task.getKey().getId(), task.getString("description"), task.getTimestamp("created"))); } } return strings; }
@Test public void testAllocateId() { KeyFactory keyFactory = datastore.newKeyFactory().setKind(KIND1); IncompleteKey pk1 = keyFactory.newKey(); Key key1 = datastore.allocateId(pk1); assertEquals(key1.getProjectId(), pk1.getProjectId()); assertEquals(key1.getNamespace(), pk1.getNamespace()); assertEquals(key1.getAncestors(), pk1.getAncestors()); assertEquals(key1.getKind(), pk1.getKind()); assertTrue(key1.hasId()); assertFalse(key1.hasName()); assertEquals(Key.newBuilder(pk1, key1.getId()).build(), key1); Key key2 = datastore.allocateId(pk1); assertNotEquals(key1, key2); assertEquals(Key.newBuilder(pk1, key2.getId()).build(), key2); try { datastore.allocateId(key1); fail("Expecting a failure"); } catch (IllegalArgumentException expected) { assertEquals(expected.getMessage(), "keys must be IncompleteKey instances"); } }
@Test public void testAllocateId() { KeyFactory keyFactory = DATASTORE.newKeyFactory().setKind(KIND1); IncompleteKey pk1 = keyFactory.newKey(); Key key1 = DATASTORE.allocateId(pk1); assertEquals(key1.getProjectId(), pk1.getProjectId()); assertEquals(key1.getNamespace(), pk1.getNamespace()); assertEquals(key1.getAncestors(), pk1.getAncestors()); assertEquals(key1.getKind(), pk1.getKind()); assertTrue(key1.hasId()); assertFalse(key1.hasName()); assertEquals(Key.newBuilder(pk1, key1.getId()).build(), key1); Key key2 = DATASTORE.allocateId(pk1); assertNotEquals(key1, key2); assertEquals(Key.newBuilder(pk1, key2.getId()).build(), key2); }
@Override protected Map<Key<E>, E> wrap(List<com.google.cloud.datastore.Key> base) { Map<Key<E>, E> result = new LinkedHashMap<>(base.size() * 2); // One pass through the translated pojos to patch up any generated ids in the original objects // Iterator order should be exactly the same for keys and values Iterator<com.google.cloud.datastore.Key> keysIt = base.iterator(); for (E obj: original) { com.google.cloud.datastore.Key k = keysIt.next(); if (!(obj instanceof FullEntity<?>)) { KeyMetadata<E> metadata = factory().keys().getMetadataSafe(obj); if (metadata.isIdGeneratable()) metadata.setLongId(obj, k.getId()); } Key<E> key = Key.create(k); result.put(key, obj); // Also stuff this in the session session.addValue(key, obj); } log.trace("Saved {}", base); return result; } };
/** * Gets the String or Long id from the key as a Value, or null if incomplete */ @SuppressWarnings("unchecked") public static <S> Value<S> getIdValue(final IncompleteKey key) { if (key instanceof com.google.cloud.datastore.Key) { final com.google.cloud.datastore.Key completeKey = (com.google.cloud.datastore.Key)key; if (completeKey.hasId()) return (Value<S>)LongValue.of(completeKey.getId()); else return (Value<S>)StringValue.of(completeKey.getName()); } else { return null; } }
@Override public long id() { return key.getId(); }
elementMessageBuilder.setField(elementDescriptor.findFieldByName("name"), key.getName()); } else { elementMessageBuilder.setField(elementDescriptor.findFieldByName("id"), key.getId());
private Builder(Key copyFrom) { super(copyFrom); if (copyFrom.hasId()) { id = copyFrom.getId(); } else { name = copyFrom.getName(); } }
public static PathElement keyToPathElement(Key key) { Assert.notNull(key, "A non-null key is required"); return (key.getName() != null) ? PathElement.of(key.getKind(), key.getName()) : PathElement.of(key.getKind(), key.getId()); }
public static PathElement keyToPathElement(Key key) { Assert.notNull(key, "A non-null key is required"); return (key.getName() != null) ? PathElement.of(key.getKind(), key.getName()) : PathElement.of(key.getKind(), key.getId()); }
private static void addParentToBuilder(Key parent, Builder builder) { builder.setNamespace(parent.getNamespace()); builder.addAncestors(parent.getAncestors()); if (parent.hasId()) { builder.addAncestors(PathElement.of(parent.getKind(), parent.getId())); } else { builder.addAncestors(PathElement.of(parent.getKind(), parent.getName())); } } }