com.google.appengine.api.datastore

## Class AdminDatastoreService

- java.lang.Object
- - com.google.appengine.api.datastore.AdminDatastoreService

- All Implemented Interfaces:
    AsyncDatastoreService, BaseDatastoreService

      public final class AdminDatastoreService
      extends java.lang.Object
      implements AsyncDatastoreService

  An AsyncDatastoreService implementation that is pinned to a specific appId and namesapce. This implementation ignores the "current" appId provided by `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)`
  In addition this class provides ways to create `Query`, `Entity` and `Key` that are pinned to the same appId/namespace.

  Note: users should not access this class directly.

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `AdminDatastoreService.EntityBuilder` An `Entity` builder that pins it to the AdminUtils `appId` and `namespace`.
    `static class` | `AdminDatastoreService.KeyBuilder` A `Key` builder that pins it to the AdminUtils `appId` and `namespace`.
    `static class` | `AdminDatastoreService.QueryBuilder` A `Query` builder that pins it to the AdminUtils `appId` and `namespace`.

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    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)`

    - ### Methods inherited from class java.lang.Object

      `equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Method Detail

    - #### getInstance

          public static AdminDatastoreService getInstance(java.lang.String appId)

      Returns an AdminUtils instance for the given `appId` and the "" (empty) namespace.

    - #### getInstance

          public static AdminDatastoreService getInstance(java.lang.String appId,
                                                          java.lang.String namespace)

      Returns an AdminUtils instance for the given `appId` and `namespace`.

    - #### getInstance

          public static AdminDatastoreService getInstance(DatastoreServiceConfig config,
                                                          java.lang.String appId)

      Returns an AdminUtils instance for the given `appId` and the "" (empty) namespace.

    - #### getInstance

          public static AdminDatastoreService getInstance(DatastoreServiceConfig config,
                                                          java.lang.String appId,
                                                          java.lang.String namespace)

      Returns an AdminUtils instance for the given `appId` and `namespace`.

    - #### getAppId

          public java.lang.String getAppId()

    - #### getNamespace

          public java.lang.String getNamespace()

    - #### newQueryBuilder

          public AdminDatastoreService.QueryBuilder newQueryBuilder()

    - #### newQueryBuilder

          public AdminDatastoreService.QueryBuilder newQueryBuilder(java.lang.String kind)

    - #### newKeyBuilder

          public AdminDatastoreService.KeyBuilder newKeyBuilder(java.lang.String kind)

    - #### newEntityBuilder

          public AdminDatastoreService.EntityBuilder newEntityBuilder(java.lang.String kind)

    - #### compositeIndexForQuery

          public Index compositeIndexForQuery(Query query)

    - #### compositeIndexesForQuery

          public java.util.Set<Index> compositeIndexesForQuery(Query query)

    - #### minimumCompositeIndexForQuery

          public Index minimumCompositeIndexForQuery(Query query,
                                                     java.util.Collection<Index> indexes)

    - #### minimumCompositeIndexesForQuery

          public java.util.Set<Index> minimumCompositeIndexesForQuery(Query query,
                                                                      java.util.Collection<Index> indexes)

    - #### prepare

          public PreparedQuery prepare(Query query)

      Description copied from interface: `BaseDatastoreService`
      Prepares a query for execution.

      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)`.

      Specified by:
        `prepare` in interface `BaseDatastoreService`
      Parameters:
        `query` - a not `null Query`.
      Returns:
        a not `null PreparedQuery`.

    - #### prepare

          public PreparedQuery prepare(Transaction txn,
                                       Query query)

      Description copied from interface: `BaseDatastoreService`
      Exhibits the same behavior as `BaseDatastoreService.prepare(Query)`, but executes within the provided transaction. It is up to the caller to commit or rollback. Transaction can be null.
      Specified by:
        `prepare` in interface `BaseDatastoreService`

    - #### getCurrentTransaction

          public Transaction getCurrentTransaction()

      Description copied from interface: `BaseDatastoreService`
      Returns the current transaction for this thread, or throws an exception if there is no current transaction. The current transaction is defined as the result of the most recent, same-thread invocation of beginTransaction() that has not been committed or rolled back.

      Use this method for when you expect there to be a current transaction and consider it an error if there isn't.

      Specified by:
        `getCurrentTransaction` in interface `BaseDatastoreService`
      Returns:
        The current transaction.

    - #### getCurrentTransaction

          public Transaction getCurrentTransaction(Transaction returnedIfNoTxn)

      Description copied from interface: `BaseDatastoreService`
      Returns the current transaction for this thread, or returns the parameter if there is no current transaction. You can use `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.

      Specified by:
        `getCurrentTransaction` in interface `BaseDatastoreService`
      Parameters:
        `returnedIfNoTxn` - The return value of this method if there is no current transaction. Can be null.
      Returns:
        The current transaction, or the parameter that was passed in if there is no current transaction.

    - #### getActiveTransactions

          public java.util.Collection<Transaction> getActiveTransactions()

      Specified by:
        `getActiveTransactions` in interface `BaseDatastoreService`
      Returns:
        All `Transaction`s started by this thread upon which no attempt to commit or rollback has been made.

    - #### beginTransaction

          public java.util.concurrent.Future<Transaction> beginTransaction()

      Specified by:
        `beginTransaction` in interface `AsyncDatastoreService`
      See Also:
        `DatastoreService.beginTransaction()`

    - #### beginTransaction

          public java.util.concurrent.Future<Transaction> beginTransaction(TransactionOptions options)

      Specified by:
        `beginTransaction` in interface `AsyncDatastoreService`
      See Also:
        `DatastoreService.beginTransaction(TransactionOptions)`

    - #### get

          public java.util.concurrent.Future<Entity> get(Key key)

      Specified by:
        `get` in interface `AsyncDatastoreService`
      See Also:
        `DatastoreService.get(Key)`

    - #### get

          public java.util.concurrent.Future<Entity> get(Transaction txn,
                                                         Key key)

      Specified by:
        `get` in interface `AsyncDatastoreService`
      See Also:
        `DatastoreService.get(Transaction, Key)`

    - #### get

          public java.util.concurrent.Future<java.util.Map<Key,Entity>> get(java.lang.Iterable<Key> keys)

      Specified by:
        `get` in interface `AsyncDatastoreService`
      See Also:
        `DatastoreService.get(Iterable)`

    - #### get

          public java.util.concurrent.Future<java.util.Map<Key,Entity>> get(Transaction txn,
                                                                            java.lang.Iterable<Key> keys)

      Specified by:
        `get` in interface `AsyncDatastoreService`
      See Also:
        `DatastoreService.get(Transaction, Iterable)`

    - #### put

          public java.util.concurrent.Future<Key> put(Entity entity)

      Specified by:
        `put` in interface `AsyncDatastoreService`
      See Also:
        `DatastoreService.put(Entity)`

    - #### put

          public java.util.concurrent.Future<Key> put(Transaction txn,
                                                      Entity entity)

      Specified by:
        `put` in interface `AsyncDatastoreService`
      See Also:
        `DatastoreService.put(Transaction, Entity)`

    - #### put

          public java.util.concurrent.Future<java.util.List<Key>> put(java.lang.Iterable<Entity> entities)

      Specified by:
        `put` in interface `AsyncDatastoreService`
      See Also:
        `DatastoreService.put(Iterable)`

    - #### put

          public java.util.concurrent.Future<java.util.List<Key>> put(Transaction txn,
                                                                      java.lang.Iterable<Entity> entities)

      Specified by:
        `put` in interface `AsyncDatastoreService`
      See Also:
        `DatastoreService.put(Transaction, Iterable)`

    - #### delete

          public java.util.concurrent.Future<java.lang.Void> delete(Key... keys)

      Specified by:
        `delete` in interface `AsyncDatastoreService`
      See Also:
        `DatastoreService.delete(Key...)`

    - #### delete

          public java.util.concurrent.Future<java.lang.Void> delete(Transaction txn,
                                                                    Key... keys)

      Specified by:
        `delete` in interface `AsyncDatastoreService`
      See Also:
        `DatastoreService.delete(Transaction, Iterable)`

    - #### delete

          public java.util.concurrent.Future<java.lang.Void> delete(java.lang.Iterable<Key> keys)

      Specified by:
        `delete` in interface `AsyncDatastoreService`
      See Also:
        `DatastoreService.delete(Iterable)`

    - #### delete

          public java.util.concurrent.Future<java.lang.Void> delete(Transaction txn,
                                                                    java.lang.Iterable<Key> keys)

      Specified by:
        `delete` in interface `AsyncDatastoreService`
      See Also:
        `DatastoreService.delete(Transaction, Iterable)`

    - #### allocateIds

          public java.util.concurrent.Future<KeyRange> allocateIds(java.lang.String kind,
                                                                   long num)

      Specified by:
        `allocateIds` in interface `AsyncDatastoreService`
      See Also:
        `DatastoreService.allocateIds(String, long)`

    - #### allocateIds

          public java.util.concurrent.Future<KeyRange> allocateIds(Key parent,
                                                                   java.lang.String kind,
                                                                   long num)

      Specified by:
        `allocateIds` in interface `AsyncDatastoreService`
      See Also:
        `DatastoreService.allocateIds(Key, String, long)`

    - #### getDatastoreAttributes

          public java.util.concurrent.Future<DatastoreAttributes> getDatastoreAttributes()

      Specified by:
        `getDatastoreAttributes` in interface `AsyncDatastoreService`
      See Also:
        `DatastoreService.getDatastoreAttributes()`

    - #### getIndexes

          public java.util.concurrent.Future<java.util.Map<Index,Index.IndexState>> getIndexes()

      Specified by:
        `getIndexes` in interface `AsyncDatastoreService`
      See Also:
        `DatastoreService.getIndexes()`