Creates, caches, and returns the defaultFirestore using the defaultFirebaseApp. Each subsequent invocation returns the sameFirestore object.

Declaration

classfuncfirestore()->Self

Return Value

The defaultFirestore instance.

Creates, caches, and returns the defaultFirestore object for the specifiedapp. Each subsequent invocation returns the sameFirestore object.

Declaration

classfuncfirestore(app:FIRApp)->Self

Parameters

Return Value

The defaultFirestore instance.

This method is in preview. API signature and functionality are subject to change.

Creates, caches, and returns namedFirestore object for the specifiedFirebaseApp. Each subsequent invocation returns the sameFirestore object.

Declaration

classfuncfirestore(app:FIRApp,database:String)->Self

Parameters

Return Value

The namedFirestore instance.

This method is in preview. API signature and functionality are subject to change.

Creates, caches, and returns namedFirestore object for the defaultapp. Each subsequent invocation returns the sameFirestore object.

Declaration

classfuncfirestore(database:String)->Self

Parameters

Return Value

The namedFirestore instance.

Custom settings used to configure thisFirestore object.

Declaration

@NSCopyingvarsettings:FIRFirestoreSettings{getset}

The Firebase App associated with this Firestore instance.

Declaration

varapp:FIRApp{get}

A PersistentCacheIndexManager which you can config persistent cache indexes used forlocal query execution.

Declaration

varpersistentCacheIndexManager:FIRPersistentCacheIndexManager?{get}

Deprecated

Instead of creating cache indexes manually, consider usingPersistentCacheIndexManager.enableIndexAutoCreation() to let the SDK decide whether to create cache indexes for queries running locally.

NOTE: This preview method will be deprecated in a future major release. Consider usingPersistentCacheIndexManager.enableIndexAutoCreation() to let the SDK decide whether to create cache indexes for queries running locally.

Configures indexing for local query execution. Any previous index configuration is overridden.

The index entries themselves are created asynchronously. You can continue to use queries that require indexing even if the indices are not yet available. Query execution will automatically start using the index once the index entries have been written.

The method accepts the JSON format exported by the Firebase CLI (firebase firestore:indexes). If the JSON format is invalid, the completion block will be invoked with an NSError.

Declaration

funcsetIndexConfiguration(_json:String)asyncthrows

Parameters

Deprecated

Instead of creating cache indexes manually, consider usingPersistentCacheIndexManager.enableIndexAutoCreation() to let the SDK decide whether to create cache indexes for queries running locally.

NOTE: This preview method will be deprecated in a future major release. Consider usingPersistentCacheIndexManager.enableIndexAutoCreation() to let the SDK decide whether to create cache indexes for queries running locally.

Configures indexing for local query execution. Any previous index configuration is overridden.

The index entries themselves are created asynchronously. You can continue to use queries that require indexing even if the indices are not yet available. Query execution will automatically start using the index once the index entries have been written.

Indexes are only supported with LevelDB persistence. Invokeset_persistence_enabled(true) before setting an index configuration. If LevelDB is not enabled, any index configuration will be rejected.

The method accepts the JSON format exported by the Firebase CLI (firebase firestore:indexes). If the JSON format is invalid, this method ignores the changes.

Declaration

funcsetIndexConfiguration(_stream:InputStream)asyncthrows

Parameters

Gets aCollectionReference referring to the collection at the specified path within the database.

Declaration

funccollection(_collectionPath:String)->FIRCollectionReference

Parameters

Return Value

TheCollectionReference at the specifiedcollectionPath.

Gets aDocumentReference referring to the document at the specified path within the database.

Declaration

funcdocument(_documentPath:String)->FIRDocumentReference

Parameters

Return Value

TheDocumentReference for the specifieddocumentPath.

Creates and returns a newQuery that includes all documents in the database that are contained in a collection or subcollection with the given collectionID.

Declaration

funccollectionGroup(_collectionID:String)->FIRQuery

Parameters

Return Value

The createdQuery.

Executes the given updateBlock and then attempts to commit the changes applied within an atomic transaction.

The maximum number of writes allowed in a single transaction is 500, but note that each usage ofFieldValue.serverTimestamp(),FieldValue.arrayUnion(),FieldValue.arrayRemove(), orFieldValue.increment() inside a transaction counts as an additional write.

In the updateBlock, a set of reads and writes can be performed atomically using theTransaction object passed to the block. After the updateBlock is run, Firestore will attempt to apply the changes to the server. If any of the data read has been modified outside of this transaction since being read, then the transaction will be retried by executing the updateBlock again. If the transaction still fails after 5 retries, then the transaction will fail.

Since the updateBlock may be executed multiple times, it should avoiding doing anything that would cause side effects.

Any value maybe be returned from the updateBlock. If the transaction is successfully committed, then the completion block will be passed that value. The updateBlock also has anNSErrorPointer out parameter. If this is set, then the transaction will not attempt to commit, and the given error will be passed to the completion block.

TheTransaction object passed to the updateBlock contains methods for accessing documents and collections. Unlike other firestore access, data accessed with the transaction will not reflect local changes that have not been committed. For this reason, it is required that all reads are performed before any writes. Transactions must be performed while online. Otherwise, reads will fail, the final commit will fail, and the completion block will return an error.

Declaration

funcrunTransaction(_updateBlock:@escaping(FIRTransaction,NSErrorPointer)->Any?,completion:@escaping(Any?,(anyError)?)->Void)

Parameters

Executes the given updateBlock and then attempts to commit the changes applied within an atomic transaction.

The maximum number of writes allowed in a single transaction is 500, but note that each usage ofFieldValue.serverTimestamp(),FieldValue.arrayUnion(),FieldValue.arrayRemove(), orFieldValue.increment() inside a transaction counts as an additional write.

In the updateBlock, a set of reads and writes can be performed atomically using theTransaction object passed to the block. After the updateBlock is run, Firestore will attempt to apply the changes to the server. If any of the data read has been modified outside of this transaction since being read, then the transaction will be retried by executing the updateBlock again. If the transaction still fails after the attempting the number of times specified by themax_attempts property of the givenTransactionOptions object, then the transaction will fail. If the givenTransactionOptions isnil, then the defaultmax_attempts of 5 will be used.

Since the updateBlock may be executed multiple times, it should avoiding doing anything that would cause side effects.

Any value maybe be returned from the updateBlock. If the transaction is successfully committed, then the completion block will be passed that value. The updateBlock also has anNSErrorPointer out parameter. If this is set, then the transaction will not attempt to commit, and the given error will be passed to the completion block.

TheTransaction object passed to the updateBlock contains methods for accessing documents and collections. Unlike other firestore access, data accessed with the transaction will not reflect local changes that have not been committed. For this reason, it is required that all reads are performed before any writes. Transactions must be performed while online. Otherwise, reads will fail, the final commit will fail, and the completion block will return an error.

Declaration

funcrunTransaction(withoptions:FIRTransactionOptions?,blockupdateBlock:@escaping(FIRTransaction,NSErrorPointer)->Any?,completion:@escaping(Any?,(anyError)?)->Void)

Parameters

Creates a write batch, used for performing multiple writes as a single atomic operation.

The maximum number of writes allowed in a single batch is 500, but note that each usage ofFieldValue.serverTimestamp(),FieldValue.arrayUnion(),FieldValue.arrayRemove(), orFieldValue.increment() inside a batch counts as an additional write.

Unlike transactions, write batches are persisted offline and therefore are preferable when you don’t need to condition your writes on read data.

Declaration

funcbatch()->FIRWriteBatch

Enables or disables logging from the Firestore client.

Declaration

classfuncenableLogging(_logging:Bool)

Configures Firestore to connect to an emulated host instead of the default remote backend. AfterFirestore has been used (i.e. a document reference has been instantiated), this value cannot bechanged.

Declaration

funcuseEmulator(withHosthost:String,port:Int)

Re-enables usage of the network by this Firestore instance after a prior call todisableNetwork(completion:). Completion block, if provided, will be called once network uasgehas been enabled.

Declaration

funcenableNetwork()asyncthrows

Disables usage of the network by this Firestore instance. It can be re-enabled by viaenableNetwork. While the network is disabled, any snapshot listeners or get calls will returnresults from cache and any write operations will be queued until the network is restored. Thecompletion block, if provided, will be called once network usage has been disabled.

Declaration

funcdisableNetwork()asyncthrows

Clears the persistent storage. This includes pending writes and cached documents.

Must be called while the firestore instance is not started (after the app is shutdown or when the app is first initialized). On startup, this method must be called before other methods (other thanFirestore.settings). If the firestore instance is still running, the function will complete with an error code ofFailedPrecondition.

Note:clearPersistence(completion:) is primarily intended to help write reliable tests that use Firestore. It uses the most efficient mechanism possible for dropping existing data but does not attempt to securely overwrite or otherwise make cached data unrecoverable. For applications that are sensitive to the disclosure of cache data in between user sessions we strongly recommend not to enable persistence in the first place.

Declaration

funcclearPersistence()asyncthrows

Waits until all currently pending writes for the active user have been acknowledged by the backend.

The completion block is called immediately without error if there are no outstanding writes. Otherwise, the completion block is called when all previously issued writes (including those written in a previous app session) have been acknowledged by the backend. The completion block does not wait for writes that were added after the method is called. If you wish to wait for additional writes, you have to callwaitForPendingWrites again.

Any outstandingwaitForPendingWrites(completion:) completion blocks are called with an error during user change.

Declaration

funcwaitForPendingWrites()asyncthrows

Attaches a listener for a snapshots-in-sync event. The snapshots-in-sync event indicates that all listeners affected by a given change have fired, even if a single server-generated change affects multiple listeners.

NOTE: The snapshots-in-sync event only indicates that listeners are in sync with each other, but does not relate to whether those snapshots are in sync with the server. Use SnapshotMetadata in the individual listeners to determine if a snapshot is from the cache or the server.

Declaration

funcaddSnapshotsInSyncListener(_listener:@escaping()->Void)->anyListenerRegistration

Parameters

Return Value

AListenerRegistration object that can be used to remove the listener.

Terminates thisFirestore instance.

After callingterminate only theclearPersistence method may be used. Any other method will throw an error.

To restart after termination, simply create a new instance ofFirestore with thefirestore method.

Termination does not cancel any pending writes and any tasks that are awaiting a response from the server will not be resolved. The next time you start this instance, it will resume attempting to send these writes to the server.

Note: Under normal circumstances, calling this method is not required. This method is useful only when you want to force this instance to release all of its resources or in combination withclearPersistence to ensure that all local state is destroyed between test runs.

Declaration

functerminate()asyncthrows

Parameters

Loads a Firestore bundle into the local cache.

Declaration

funcloadBundle(_bundleData:Data)->FIRLoadBundleTask

Parameters

Return Value

ALoadBundleTask which allows registered observersto receive progress updates and completion or error events.

Loads a Firestore bundle into the local cache.

Declaration

funcloadBundle(_bundleData:Data,completion:((FIRLoadBundleTaskProgress?,(anyError)?)->Void)?=nil)->FIRLoadBundleTask

Parameters

Return Value

ALoadBundleTask which allows registered observers to receive progress updates andcompletion or error events.

Loads a Firestore bundle into the local cache.

Declaration

funcloadBundle(_bundleStream:InputStream)->FIRLoadBundleTask

Parameters

Return Value

ALoadBundleTask which allows registered observers to receive progress updates andcompletion or error events.

Loads a Firestore bundle into the local cache.

Declaration

funcloadBundle(_bundleStream:InputStream,completion:((FIRLoadBundleTaskProgress?,(anyError)?)->Void)?=nil)->FIRLoadBundleTask

Parameters

Return Value

ALoadBundleTask which allow registering observers to receive progress updates, andcompletion or error events.

Reads aQuery from the local cache, identified by the given name.

Named queries are packaged into bundles on the server side (along with the resulting documents) and loaded into local cache usingloadBundle. Once in the local cache, you can use this method to extract a query by name.

Declaration

funcgetQuery(namedname:String)async->FIRQuery?

Parameters

Loads a Firestore bundle into the local cache.

Declaration

funcloadBundle(_bundleData:Data)asyncthrows->LoadBundleTaskProgress

Parameters

Return Value

The finalLoadBundleTaskProgress that contains the total number of documentsloaded.

Loads a Firestore bundle into the local cache.

Declaration

funcloadBundle(_bundleStream:InputStream)asyncthrows->LoadBundleTaskProgress

Parameters

Return Value

The finalLoadBundleTaskProgress that contains the total number of documentsloaded.

Executes the given updateBlock and then attempts to commit the changes applied within anatomictransaction.

The maximum number of writes allowed in a single transaction is 500, but note that eachusage ofFieldValue.serverTimestamp(),FieldValue.arrayUnion(),FieldValue.arrayRemove(), orFieldValue.increment() inside a transaction counts as an additional write.

In theupdateBlock, a set of reads and writes can be performed atomically using theTransaction object passed to the block. After theupdateBlock is run, Firestore willattemptto apply the changes to the server. If any of the data read has been modified outside ofthistransaction since being read, then the transaction will be retried by executing theupdateBlockagain. If the transaction still fails after 5 retries, then the transaction will fail.

Since theupdateBlock may be executed multiple times, it should avoiding doing anythingthatwould cause side effects.

Any value maybe be returned from theupdateBlock. If the transaction is successfullycommitted,then the completion block will be passed that value. TheupdateBlock also has anNSErroroutparameter. If this is set, then the transaction will not attempt to commit, and the givenerrorwill be returned.

TheTransaction object passed to theupdateBlock contains methods for accessingdocumentsand collections. Unlike other firestore access, data accessed with the transaction will notreflect local changes that have not been committed. For this reason, it is required that allreads are performed before any writes. Transactions must be performed while online.Otherwise,reads will fail, the final commit will fail, and this function will return an error.

Declaration

funcrunTransaction(_updateBlock:@escaping(Transaction,NSErrorPointer)->Any?)asyncthrows->Any?

Undocumented

Declaration

classEncoder

Undocumented

Declaration

classDecoder