public final class AdminDatastoreService extends java.lang.Object implements AsyncDatastoreService
ApiProxy.getCurrentEnvironment().getAppId()
and the "current" namespace provided by NamespaceManager.get()
. Note, this is particularly important in the following methods:
AsyncDatastoreService.getIndexes()
AsyncDatastoreService.getDatastoreAttributes()
AsyncDatastoreService.allocateIds(String, long)
Query
, Entity
and Key
that
are pinned to the same appId/namespace.
Note: users should not access this class directly.
Modifier and Type | Class and Description |
---|---|
static class |
AdminDatastoreService.EntityBuilder
|
static class |
AdminDatastoreService.KeyBuilder
|
static class |
AdminDatastoreService.QueryBuilder
|
Modifier and Type | Method and Description |
---|---|
java.util.concurrent.Future<KeyRange> |
allocateIds(Key parent,
java.lang.String kind,
long num) |
java.util.concurrent.Future<KeyRange> |
allocateIds(java.lang.String kind,
long num) |
java.util.concurrent.Future<Transaction> |
beginTransaction() |
java.util.concurrent.Future<Transaction> |
beginTransaction(TransactionOptions options) |
java.util.Set<Index> |
compositeIndexesForQuery(Query query) |
Index |
compositeIndexForQuery(Query query) |
java.util.concurrent.Future<java.lang.Void> |
delete(java.lang.Iterable<Key> keys) |
java.util.concurrent.Future<java.lang.Void> |
delete(Key... keys) |
java.util.concurrent.Future<java.lang.Void> |
delete(Transaction txn,
java.lang.Iterable<Key> keys) |
java.util.concurrent.Future<java.lang.Void> |
delete(Transaction txn,
Key... keys) |
java.util.concurrent.Future<java.util.Map<Key,Entity>> |
get(java.lang.Iterable<Key> keys) |
java.util.concurrent.Future<Entity> |
get(Key key) |
java.util.concurrent.Future<java.util.Map<Key,Entity>> |
get(Transaction txn,
java.lang.Iterable<Key> keys) |
java.util.concurrent.Future<Entity> |
get(Transaction txn,
Key key) |
java.util.Collection<Transaction> |
getActiveTransactions() |
java.lang.String |
getAppId() |
Transaction |
getCurrentTransaction()
Returns the current transaction for this thread, or throws an exception if there is no current
transaction.
|
Transaction |
getCurrentTransaction(Transaction returnedIfNoTxn)
Returns the current transaction for this thread, or returns the parameter if there is no
current transaction.
|
java.util.concurrent.Future<DatastoreAttributes> |
getDatastoreAttributes() |
java.util.concurrent.Future<java.util.Map<Index,Index.IndexState>> |
getIndexes() |
static AdminDatastoreService |
getInstance(DatastoreServiceConfig config,
java.lang.String appId)
Returns an AdminUtils instance for the given
appId and the "" (empty) namespace. |
static AdminDatastoreService |
getInstance(DatastoreServiceConfig config,
java.lang.String appId,
java.lang.String namespace)
Returns an AdminUtils instance for the given
appId and namespace . |
static AdminDatastoreService |
getInstance(java.lang.String appId)
Returns an AdminUtils instance for the given
appId and the "" (empty) namespace. |
static AdminDatastoreService |
getInstance(java.lang.String appId,
java.lang.String namespace)
Returns an AdminUtils instance for the given
appId and namespace . |
java.lang.String |
getNamespace() |
java.util.Set<Index> |
minimumCompositeIndexesForQuery(Query query,
java.util.Collection<Index> indexes) |
Index |
minimumCompositeIndexForQuery(Query query,
java.util.Collection<Index> indexes) |
AdminDatastoreService.EntityBuilder |
newEntityBuilder(java.lang.String kind) |
AdminDatastoreService.KeyBuilder |
newKeyBuilder(java.lang.String kind) |
AdminDatastoreService.QueryBuilder |
newQueryBuilder() |
AdminDatastoreService.QueryBuilder |
newQueryBuilder(java.lang.String kind) |
PreparedQuery |
prepare(Query query)
Prepares a query for execution.
|
PreparedQuery |
prepare(Transaction txn,
Query query)
Exhibits the same behavior as
BaseDatastoreService.prepare(Query) , but executes within the provided
transaction. |
java.util.concurrent.Future<Key> |
put(Entity entity) |
java.util.concurrent.Future<java.util.List<Key>> |
put(java.lang.Iterable<Entity> entities) |
java.util.concurrent.Future<Key> |
put(Transaction txn,
Entity entity) |
java.util.concurrent.Future<java.util.List<Key>> |
put(Transaction txn,
java.lang.Iterable<Entity> entities) |
public static AdminDatastoreService getInstance(java.lang.String appId)
appId
and the "" (empty) namespace.public static AdminDatastoreService getInstance(java.lang.String appId, java.lang.String namespace)
appId
and namespace
.public static AdminDatastoreService getInstance(DatastoreServiceConfig config, java.lang.String appId)
appId
and the "" (empty) namespace.public static AdminDatastoreService getInstance(DatastoreServiceConfig config, java.lang.String appId, java.lang.String namespace)
appId
and namespace
.public java.lang.String getAppId()
public java.lang.String getNamespace()
public AdminDatastoreService.QueryBuilder newQueryBuilder()
public AdminDatastoreService.QueryBuilder newQueryBuilder(java.lang.String kind)
public AdminDatastoreService.KeyBuilder newKeyBuilder(java.lang.String kind)
public AdminDatastoreService.EntityBuilder newEntityBuilder(java.lang.String kind)
public Index minimumCompositeIndexForQuery(Query query, java.util.Collection<Index> indexes)
public java.util.Set<Index> minimumCompositeIndexesForQuery(Query query, java.util.Collection<Index> indexes)
public PreparedQuery prepare(Query query)
BaseDatastoreService
This method returns a PreparedQuery
which can be used to execute and retrieve
results from the datastore for query
.
This operation will not execute in a transaction even if there is a current transaction and
the provided query is an ancestor query. This operation also ignores the ImplicitTransactionManagementPolicy
. If you are preparing an ancestory query and you want it
to execute in a transaction, use BaseDatastoreService.prepare(Transaction, Query)
.
prepare
in interface BaseDatastoreService
query
- a not null Query
.null PreparedQuery
.public PreparedQuery prepare(Transaction txn, Query query)
BaseDatastoreService
BaseDatastoreService.prepare(Query)
, but executes within the provided
transaction. It is up to the caller to commit or rollback. Transaction can be null.prepare
in interface BaseDatastoreService
public Transaction getCurrentTransaction()
BaseDatastoreService
Use this method for when you expect there to be a current transaction and consider it an error if there isn't.
getCurrentTransaction
in interface BaseDatastoreService
public Transaction getCurrentTransaction(Transaction returnedIfNoTxn)
BaseDatastoreService
null
or provide your own object to represent null. See
BaseDatastoreService.getCurrentTransaction()
for a definition of "current transaction."
Use this method when you're not sure if there is a current transaction.
getCurrentTransaction
in interface BaseDatastoreService
returnedIfNoTxn
- The return value of this method if there is no current transaction. Can
be null.public java.util.Collection<Transaction> getActiveTransactions()
getActiveTransactions
in interface BaseDatastoreService
Transaction
s started by this thread upon which no attempt to commit or
rollback has been made.public java.util.concurrent.Future<Transaction> beginTransaction()
beginTransaction
in interface AsyncDatastoreService
DatastoreService.beginTransaction()
public java.util.concurrent.Future<Transaction> beginTransaction(TransactionOptions options)
beginTransaction
in interface AsyncDatastoreService
DatastoreService.beginTransaction(TransactionOptions)
public java.util.concurrent.Future<Entity> get(Key key)
get
in interface AsyncDatastoreService
DatastoreService.get(Key)
public java.util.concurrent.Future<Entity> get(Transaction txn, Key key)
get
in interface AsyncDatastoreService
DatastoreService.get(Transaction, Key)
public java.util.concurrent.Future<java.util.Map<Key,Entity>> get(java.lang.Iterable<Key> keys)
get
in interface AsyncDatastoreService
DatastoreService.get(Iterable)
public java.util.concurrent.Future<java.util.Map<Key,Entity>> get(Transaction txn, java.lang.Iterable<Key> keys)
get
in interface AsyncDatastoreService
DatastoreService.get(Transaction, Iterable)
public java.util.concurrent.Future<Key> put(Entity entity)
put
in interface AsyncDatastoreService
DatastoreService.put(Entity)
public java.util.concurrent.Future<Key> put(Transaction txn, Entity entity)
put
in interface AsyncDatastoreService
DatastoreService.put(Transaction, Entity)
public java.util.concurrent.Future<java.util.List<Key>> put(java.lang.Iterable<Entity> entities)
put
in interface AsyncDatastoreService
DatastoreService.put(Iterable)
public java.util.concurrent.Future<java.util.List<Key>> put(Transaction txn, java.lang.Iterable<Entity> entities)
put
in interface AsyncDatastoreService
DatastoreService.put(Transaction, Iterable)
public java.util.concurrent.Future<java.lang.Void> delete(Key... keys)
delete
in interface AsyncDatastoreService
DatastoreService.delete(Key...)
public java.util.concurrent.Future<java.lang.Void> delete(Transaction txn, Key... keys)
delete
in interface AsyncDatastoreService
DatastoreService.delete(Transaction, Iterable)
public java.util.concurrent.Future<java.lang.Void> delete(java.lang.Iterable<Key> keys)
delete
in interface AsyncDatastoreService
DatastoreService.delete(Iterable)
public java.util.concurrent.Future<java.lang.Void> delete(Transaction txn, java.lang.Iterable<Key> keys)
delete
in interface AsyncDatastoreService
DatastoreService.delete(Transaction, Iterable)
public java.util.concurrent.Future<KeyRange> allocateIds(java.lang.String kind, long num)
allocateIds
in interface AsyncDatastoreService
DatastoreService.allocateIds(String, long)
public java.util.concurrent.Future<KeyRange> allocateIds(Key parent, java.lang.String kind, long num)
allocateIds
in interface AsyncDatastoreService
DatastoreService.allocateIds(Key, String, long)
public java.util.concurrent.Future<DatastoreAttributes> getDatastoreAttributes()
getDatastoreAttributes
in interface AsyncDatastoreService
DatastoreService.getDatastoreAttributes()
public java.util.concurrent.Future<java.util.Map<Index,Index.IndexState>> getIndexes()
getIndexes
in interface AsyncDatastoreService
DatastoreService.getIndexes()