mirror of
https://github.com/firebase/firebase-ios-sdk
synced 2026-11-10 22:45:59 +05:45
649 lines
23 KiB
Swift
649 lines
23 KiB
Swift
//
|
|
// Copyright 2021 Google LLC
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//
|
|
|
|
// MARK: This file is used to evaluate the experience of using the Firebase Database APIs in Swift.
|
|
|
|
import Foundation
|
|
|
|
import FirebaseCore
|
|
import FirebaseDatabase
|
|
|
|
final class DatabaseAPITests {
|
|
func usage() {
|
|
// MARK: - Database
|
|
|
|
var url = "url"
|
|
let path = "path"
|
|
let host = "host"
|
|
let port = 0
|
|
let yes = true
|
|
|
|
// Retrieve Database Instance
|
|
var database = Database.database()
|
|
|
|
database = Database.database(url: url)
|
|
|
|
if let app = FirebaseApp.app() {
|
|
database = Database.database(app: app, url: url)
|
|
database = Database.database(app: app)
|
|
}
|
|
|
|
// Retrieve FirebaseApp
|
|
let /* app */ _: FirebaseApp? = database.app
|
|
|
|
// Retrieve DatabaseReference
|
|
var databaseReference: DatabaseReference = database.reference()
|
|
databaseReference = database.reference(withPath: path)
|
|
databaseReference = database.reference(fromURL: url)
|
|
|
|
// Instance methods
|
|
database.purgeOutstandingWrites()
|
|
database.goOffline()
|
|
database.goOnline()
|
|
database.useEmulator(withHost: host, port: port)
|
|
|
|
// Instance members
|
|
let /* isPersistenceEnabled */ _: Bool = database.isPersistenceEnabled
|
|
let /* persistenceCacheSizeBytes */ _: UInt = database.persistenceCacheSizeBytes
|
|
let /* callbackQueue */ _: DispatchQueue = database.callbackQueue
|
|
|
|
// Class methods
|
|
Database.setLoggingEnabled(yes)
|
|
let /* sdkVersion */ _: String = Database.sdkVersion()
|
|
|
|
// MARK: - DatabaseQuery
|
|
|
|
let uint: UInt = 0
|
|
let dataEventType: DataEventType = .value
|
|
let child = "child"
|
|
let childKey: String? = "key"
|
|
let value: Any? = "value"
|
|
let priority: Any? = "priority"
|
|
|
|
var databaseHandle: DatabaseHandle = uint
|
|
var databaseQuery = DatabaseQuery()
|
|
|
|
// Observe for data
|
|
|
|
// observe(_ eventType:with block:)
|
|
databaseHandle = databaseQuery.observe(dataEventType) { dataSnapshot in
|
|
let /* dataSnapshot */ _: DataSnapshot = dataSnapshot
|
|
}
|
|
|
|
// observe(_ eventType:andPreviousSiblingKeyWith block:)
|
|
databaseHandle = databaseQuery.observe(dataEventType) { dataSnapshot, optionalString in
|
|
let /* dataSnapshot */ _: DataSnapshot = dataSnapshot
|
|
let /* optionalString */ _: String? = optionalString
|
|
}
|
|
|
|
// observe(_ eventType:with block:withCancel cancelBlock:)
|
|
databaseHandle = databaseQuery.observe(dataEventType) { dataSnapshot in
|
|
let /* dataSnapshot */ _: DataSnapshot = dataSnapshot
|
|
} withCancel: { error in
|
|
let /* error */ _: Error = error
|
|
}
|
|
|
|
// observe(_ eventType:andPreviousSiblingKeyWith block:withCancel cancelBlock:)
|
|
databaseHandle = databaseQuery.observe(dataEventType) { dataSnapshot, optionalString in
|
|
let /* dataSnapshot */ _: DataSnapshot = dataSnapshot
|
|
let /* optionalString */ _: String? = optionalString
|
|
} withCancel: { error in
|
|
let /* error */ _: Error = error
|
|
}
|
|
|
|
// Get data
|
|
|
|
// getData(completion block:)
|
|
databaseQuery.getData { optionalError, dataSnapshot in
|
|
let /* optionalError */ _: Error? = optionalError
|
|
let /* dataSnapshot */ _: DataSnapshot? = dataSnapshot
|
|
}
|
|
|
|
if #available(iOS 13.0, macOS 10.15, macCatalyst 13.0, tvOS 13.0, watchOS 7.0, *) {
|
|
// async/await is a Swift Concurrency feature available on iOS 13+ and macOS 10.15+
|
|
Task {
|
|
do {
|
|
let /* dataSnapshot */ _: DataSnapshot = try await DatabaseQuery().getData()
|
|
} catch {
|
|
// ...
|
|
}
|
|
}
|
|
}
|
|
|
|
// Observe Single Event
|
|
|
|
// observeSingleEvent(of eventType:with block:)
|
|
databaseQuery.observeSingleEvent(of: dataEventType) { dataSnapshot in
|
|
let /* dataSnapshot */ _: DataSnapshot = dataSnapshot
|
|
}
|
|
|
|
// observeSingleEvent(of eventType:andPreviousSiblingKeyWith block:)
|
|
databaseQuery.observeSingleEvent(of: dataEventType) { dataSnapshot, optionalString in
|
|
let /* dataSnapshot */ _: DataSnapshot = dataSnapshot
|
|
let /* optionalString */ _: String? = optionalString
|
|
}
|
|
|
|
if #available(iOS 13.0, macOS 10.15, macCatalyst 13.0, tvOS 13.0, watchOS 7.0, *) {
|
|
// async/await is a Swift Concurrency feature available on iOS 13+ and macOS 10.15+
|
|
Task {
|
|
// observeSingleEvent(of eventType:)
|
|
let _: (DataSnapshot, String?) = await DatabaseQuery()
|
|
.observeSingleEventAndPreviousSiblingKey(of: dataEventType)
|
|
}
|
|
}
|
|
|
|
// observeSingleEvent(of eventType:with block:withCancel cancelBlock:)
|
|
databaseQuery.observeSingleEvent(of: dataEventType) { dataSnapshot in
|
|
let /* dataSnapshot */ _: DataSnapshot = dataSnapshot
|
|
} withCancel: { error in
|
|
let /* error */ _: Error = error
|
|
}
|
|
|
|
// observeSingleEvent(of eventType:andPreviousSiblingKeyWith block:withCancel cancelBlock:)
|
|
databaseQuery.observeSingleEvent(of: dataEventType) { dataSnapshot, optionalString in
|
|
let /* dataSnapshot */ _: DataSnapshot = dataSnapshot
|
|
let /* optionalString */ _: String? = optionalString
|
|
} withCancel: { error in
|
|
let /* error */ _: Error = error
|
|
}
|
|
|
|
// Remove Observers
|
|
databaseQuery.removeObserver(withHandle: databaseHandle)
|
|
databaseQuery.removeAllObservers()
|
|
|
|
// Keep Synced
|
|
databaseQuery.keepSynced(yes)
|
|
|
|
// Limited Views of Data
|
|
databaseQuery = databaseQuery.queryLimited(toFirst: databaseHandle)
|
|
databaseQuery = databaseQuery.queryLimited(toLast: databaseHandle)
|
|
databaseQuery = databaseQuery.queryOrdered(byChild: child)
|
|
databaseQuery = databaseQuery.queryOrderedByKey()
|
|
databaseQuery = databaseQuery.queryOrderedByValue()
|
|
databaseQuery = databaseQuery.queryOrderedByPriority()
|
|
databaseQuery = databaseQuery.queryStarting(atValue: value)
|
|
databaseQuery = databaseQuery.queryStarting(atValue: value, childKey: childKey)
|
|
databaseQuery = databaseQuery.queryStarting(afterValue: value)
|
|
databaseQuery = databaseQuery.queryStarting(afterValue: value, childKey: childKey)
|
|
databaseQuery = databaseQuery.queryEnding(atValue: value)
|
|
databaseQuery = databaseQuery.queryEnding(beforeValue: value)
|
|
databaseQuery = databaseQuery.queryEnding(beforeValue: value, childKey: childKey)
|
|
databaseQuery = databaseQuery.queryEqual(toValue: value)
|
|
databaseQuery = databaseQuery.queryEqual(toValue: value, childKey: childKey)
|
|
|
|
// Retrieve DatabaseReference Instance
|
|
databaseReference = databaseQuery.ref
|
|
|
|
// MARK: - DatabaseReference
|
|
|
|
let priorityAny: Any = "priority"
|
|
let values = [AnyHashable: Any]()
|
|
var transactionResult = TransactionResult()
|
|
|
|
// Retrieve Child DatabaseReference
|
|
databaseReference = databaseReference.child(child)
|
|
databaseReference = databaseReference.childByAutoId()
|
|
|
|
// Set value
|
|
databaseReference.setValue(value)
|
|
|
|
// setValue(_ value:withCompletionBlock block:)
|
|
databaseReference.setValue(value) { optionalError, databaseReference in
|
|
let /* optionalError */ _: Error? = optionalError
|
|
let /* databaseReference */ _: DatabaseReference = databaseReference
|
|
}
|
|
|
|
if #available(iOS 13.0, macOS 10.15, macCatalyst 13.0, tvOS 13.0, watchOS 7.0, *) {
|
|
// async/await is a Swift Concurrency feature available on iOS 13+ and macOS 10.15+
|
|
Task {
|
|
do {
|
|
// setValue(_ value:)
|
|
let /* ref */ _: DatabaseReference = try await DatabaseReference().setValue(value)
|
|
} catch {
|
|
// ...
|
|
}
|
|
}
|
|
}
|
|
|
|
databaseReference.setValue(value, andPriority: priority)
|
|
|
|
// setValue(_ value:andPriority priority:withCompletionBlock block:)
|
|
databaseReference.setValue(value, andPriority: priority) { optionalError, databaseReference in
|
|
let /* optionalError */ _: Error? = optionalError
|
|
let /* databaseReference */ _: DatabaseReference = databaseReference
|
|
}
|
|
|
|
if #available(iOS 13.0, macOS 10.15, macCatalyst 13.0, tvOS 13.0, watchOS 7.0, *) {
|
|
// async/await is a Swift Concurrency feature available on iOS 13+ and macOS 10.15+
|
|
Task {
|
|
do {
|
|
// setValue(_ value:andPriority priority:)
|
|
let /* ref */ _: DatabaseReference = try await DatabaseReference()
|
|
.setValue(value, andPriority: priority)
|
|
} catch {
|
|
// ...
|
|
}
|
|
}
|
|
}
|
|
|
|
// Remove value
|
|
databaseReference.removeValue()
|
|
|
|
// removeValue(completionBlock block:)
|
|
databaseReference.removeValue { optionalError, databaseReference in
|
|
let /* optionalError */ _: Error? = optionalError
|
|
let /* databaseReference */ _: DatabaseReference = databaseReference
|
|
}
|
|
|
|
if #available(iOS 13.0, macOS 10.15, macCatalyst 13.0, tvOS 13.0, watchOS 7.0, *) {
|
|
// async/await is a Swift Concurrency feature available on iOS 13+ and macOS 10.15+
|
|
Task {
|
|
do {
|
|
let /* ref */ _: DatabaseReference = try await DatabaseReference().removeValue()
|
|
} catch {
|
|
// ...
|
|
}
|
|
}
|
|
}
|
|
|
|
// Set priority
|
|
databaseReference.setPriority(priority)
|
|
|
|
// setPriority(_ priority:withCompletionBlock block:)
|
|
databaseReference.setPriority(priority) { optionalError, databaseReference in
|
|
let /* optionalError */ _: Error? = optionalError
|
|
let /* databaseReference */ _: DatabaseReference = databaseReference
|
|
}
|
|
|
|
if #available(iOS 13.0, macOS 10.15, macCatalyst 13.0, tvOS 13.0, watchOS 7.0, *) {
|
|
// async/await is a Swift Concurrency feature available on iOS 13+ and macOS 10.15+
|
|
Task {
|
|
do {
|
|
// setPriority(_ priority:)
|
|
let /* ref */ _: DatabaseReference = try await DatabaseReference().setPriority(priority)
|
|
} catch {
|
|
// ...
|
|
}
|
|
}
|
|
}
|
|
|
|
// Update child values
|
|
databaseReference.updateChildValues(values)
|
|
|
|
// updateChildValues(_ values:withCompletionBlock block:)
|
|
databaseReference.updateChildValues(values) { optionalError, databaseReference in
|
|
let /* optionalError */ _: Error? = optionalError
|
|
let /* databaseReference */ _: DatabaseReference = databaseReference
|
|
}
|
|
|
|
if #available(iOS 13.0, macOS 10.15, macCatalyst 13.0, tvOS 13.0, watchOS 7.0, *) {
|
|
// async/await is a Swift Concurrency feature available on iOS 13+ and macOS 10.15+
|
|
Task {
|
|
do {
|
|
// updateChildValues(_ values:)
|
|
let /* ref */ _: DatabaseReference = try await DatabaseReference()
|
|
.updateChildValues(values)
|
|
} catch {
|
|
// ...
|
|
}
|
|
}
|
|
}
|
|
|
|
// Observe for data
|
|
|
|
// observe(_ eventType:with block:)
|
|
databaseHandle = databaseReference.observe(dataEventType) { dataSnapshot in
|
|
let /* dataSnapshot */ _: DataSnapshot = dataSnapshot
|
|
}
|
|
|
|
// observe(_ eventType:andPreviousSiblingKeyWith block:)
|
|
databaseHandle = databaseReference.observe(dataEventType) { dataSnapshot, optionalString in
|
|
let /* dataSnapshot */ _: DataSnapshot = dataSnapshot
|
|
let /* optionalString */ _: String? = optionalString
|
|
}
|
|
|
|
// observe(_ eventType:with block:withCancel cancelBlock:)
|
|
databaseHandle = databaseReference.observe(dataEventType) { dataSnapshot in
|
|
let /* dataSnapshot */ _: DataSnapshot = dataSnapshot
|
|
} withCancel: { error in
|
|
let /* error */ _: Error = error
|
|
}
|
|
|
|
// observe(_ eventType:andPreviousSiblingKeyWith block:withCancel cancelBlock:)
|
|
databaseHandle = databaseReference.observe(dataEventType) { dataSnapshot, optionalString in
|
|
let /* dataSnapshot */ _: DataSnapshot = dataSnapshot
|
|
let /* optionalString */ _: String? = optionalString
|
|
} withCancel: { error in
|
|
let /* error */ _: Error = error
|
|
}
|
|
|
|
// Observe Single Event
|
|
|
|
// observeSingleEvent(of eventType:with block:)
|
|
databaseReference.observeSingleEvent(of: dataEventType) { dataSnapshot in
|
|
let /* dataSnapshot */ _: DataSnapshot = dataSnapshot
|
|
}
|
|
|
|
// observeSingleEvent(of eventType:andPreviousSiblingKeyWith block:)
|
|
databaseReference.observeSingleEvent(of: dataEventType) { dataSnapshot, optionalString in
|
|
let /* dataSnapshot */ _: DataSnapshot = dataSnapshot
|
|
let /* optionalString */ _: String? = optionalString
|
|
}
|
|
|
|
if #available(iOS 13.0, macOS 10.15, macCatalyst 13.0, tvOS 13.0, watchOS 7.0, *) {
|
|
// async/await is a Swift Concurrency feature available on iOS 13+ and macOS 10.15+
|
|
Task {
|
|
// observeSingleEvent(of eventType:)
|
|
let _: (DataSnapshot, String?) = await DatabaseReference()
|
|
.observeSingleEventAndPreviousSiblingKey(of: dataEventType)
|
|
}
|
|
}
|
|
|
|
// observeSingleEvent(of eventType:with block:withCancel cancelBlock:)
|
|
databaseReference.observeSingleEvent(of: dataEventType) { dataSnapshot in
|
|
let /* dataSnapshot */ _: DataSnapshot = dataSnapshot
|
|
} withCancel: { error in
|
|
let /* error */ _: Error = error
|
|
}
|
|
|
|
// observeSingleEvent(of eventType:andPreviousSiblingKeyWith block:withCancel cancelBlock:)
|
|
databaseReference.observeSingleEvent(of: dataEventType) { dataSnapshot, optionalString in
|
|
let /* dataSnapshot */ _: DataSnapshot = dataSnapshot
|
|
let /* optionalString */ _: String? = optionalString
|
|
} withCancel: { error in
|
|
let /* error */ _: Error = error
|
|
}
|
|
|
|
// Get data
|
|
|
|
// getData(completion block:)
|
|
databaseReference.getData { optionalError, dataSnapshot in
|
|
let /* optionalError */ _: Error? = optionalError
|
|
let /* dataSnapshot */ _: DataSnapshot? = dataSnapshot
|
|
}
|
|
|
|
if #available(iOS 13.0, macOS 10.15, macCatalyst 13.0, tvOS 13.0, watchOS 7.0, *) {
|
|
// async/await is a Swift Concurrency feature available on iOS 13+ and macOS 10.15+
|
|
Task {
|
|
do {
|
|
let /* dataSnapshot */ _: DataSnapshot = try await DatabaseReference().getData()
|
|
} catch {
|
|
// ...
|
|
}
|
|
}
|
|
}
|
|
|
|
// Remove Observers
|
|
databaseReference.removeObserver(withHandle: databaseHandle)
|
|
databaseReference.removeAllObservers()
|
|
|
|
// Keep Synced
|
|
databaseReference.keepSynced(yes)
|
|
|
|
// Limited Views of Data
|
|
databaseQuery = databaseReference.queryLimited(toFirst: databaseHandle)
|
|
databaseQuery = databaseReference.queryLimited(toLast: databaseHandle)
|
|
databaseQuery = databaseReference.queryOrdered(byChild: child)
|
|
databaseQuery = databaseReference.queryOrderedByKey()
|
|
databaseQuery = databaseReference.queryOrderedByPriority()
|
|
databaseQuery = databaseReference.queryStarting(atValue: value)
|
|
databaseQuery = databaseReference.queryStarting(atValue: value, childKey: childKey)
|
|
databaseQuery = databaseReference.queryStarting(afterValue: value)
|
|
databaseQuery = databaseReference.queryStarting(afterValue: value, childKey: childKey)
|
|
databaseQuery = databaseReference.queryEnding(atValue: value)
|
|
databaseQuery = databaseReference.queryEnding(atValue: value, childKey: childKey)
|
|
databaseQuery = databaseReference.queryEqual(toValue: value)
|
|
databaseQuery = databaseReference.queryEqual(toValue: value, childKey: childKey)
|
|
|
|
// onDisconnectSetValue
|
|
databaseReference.onDisconnectSetValue(value)
|
|
|
|
// onDisconnectSetValue(_ value:withCompletionBlock block:)
|
|
databaseReference.onDisconnectSetValue(value) { optionalError, databaseReference in
|
|
let /* optionalError */ _: Error? = optionalError
|
|
let /* databaseReference */ _: DatabaseReference = databaseReference
|
|
}
|
|
|
|
if #available(iOS 13.0, macOS 10.15, macCatalyst 13.0, tvOS 13.0, watchOS 7.0, *) {
|
|
// async/await is a Swift Concurrency feature available on iOS 13+ and macOS 10.15+
|
|
Task {
|
|
do {
|
|
// onDisconnectSetValue(_ value:)
|
|
let /* ref */ _: DatabaseReference = try await DatabaseReference()
|
|
.onDisconnectSetValue(value)
|
|
} catch {
|
|
// ...
|
|
}
|
|
}
|
|
}
|
|
|
|
databaseReference.onDisconnectSetValue(value, andPriority: priorityAny)
|
|
|
|
// onDisconnectSetValue(_ value:andPriority priority:withCompletionBlock block:)
|
|
databaseReference
|
|
.onDisconnectSetValue(value, andPriority: priority) { optionalError, databaseReference in
|
|
let /* optionalError */ _: Error? = optionalError
|
|
let /* databaseReference */ _: DatabaseReference = databaseReference
|
|
}
|
|
|
|
if #available(iOS 13.0, macOS 10.15, macCatalyst 13.0, tvOS 13.0, watchOS 7.0, *) {
|
|
// async/await is a Swift Concurrency feature available on iOS 13+ and macOS 10.15+
|
|
Task {
|
|
do {
|
|
// onDisconnectSetValue(_ value:andPriority priority:)
|
|
let /* ref */ _: DatabaseReference = try await DatabaseReference().onDisconnectSetValue(
|
|
value,
|
|
andPriority: priority
|
|
)
|
|
} catch {
|
|
// ...
|
|
}
|
|
}
|
|
}
|
|
|
|
// onDisconnectRemoveValue
|
|
databaseReference.onDisconnectRemoveValue()
|
|
|
|
// onDisconnectRemoveValue(completionBlock block:)
|
|
databaseReference.onDisconnectRemoveValue { optionalError, databaseReference in
|
|
let /* optionalError */ _: Error? = optionalError
|
|
let /* databaseReference */ _: DatabaseReference = databaseReference
|
|
}
|
|
|
|
if #available(iOS 13.0, macOS 10.15, macCatalyst 13.0, tvOS 13.0, watchOS 7.0, *) {
|
|
// async/await is a Swift Concurrency feature available on iOS 13+ and macOS 10.15+
|
|
Task {
|
|
do {
|
|
let /* ref */ _: DatabaseReference = try await DatabaseReference()
|
|
.onDisconnectRemoveValue()
|
|
} catch {
|
|
// ...
|
|
}
|
|
}
|
|
}
|
|
|
|
// onDisconnectUpdateChildValues
|
|
databaseReference.onDisconnectUpdateChildValues(values)
|
|
|
|
// onDisconnectUpdateChildValues(_ values:withCompletionBlock block:)
|
|
databaseReference.onDisconnectUpdateChildValues(values) { optionalError, databaseReference in
|
|
let /* optionalError */ _: Error? = optionalError
|
|
let /* databaseReference */ _: DatabaseReference = databaseReference
|
|
}
|
|
|
|
if #available(iOS 13.0, macOS 10.15, macCatalyst 13.0, tvOS 13.0, watchOS 7.0, *) {
|
|
// async/await is a Swift Concurrency feature available on iOS 13+ and macOS 10.15+
|
|
Task {
|
|
do {
|
|
// onDisconnectUpdateChildValues(_ values:)
|
|
let /* ref */ _: DatabaseReference = try await DatabaseReference()
|
|
.onDisconnectUpdateChildValues(values)
|
|
} catch {
|
|
// ...
|
|
}
|
|
}
|
|
}
|
|
|
|
// cancelDisconnectOperations
|
|
databaseReference.cancelDisconnectOperations()
|
|
|
|
// cancelDisconnectOperations(completionBlock block:)
|
|
databaseReference.cancelDisconnectOperations { optionalError, databaseReference in
|
|
let /* optionalError */ _: Error? = optionalError
|
|
let /* databaseReference */ _: DatabaseReference = databaseReference
|
|
}
|
|
|
|
if #available(iOS 13.0, macOS 10.15, macCatalyst 13.0, tvOS 13.0, watchOS 7.0, *) {
|
|
// async/await is a Swift Concurrency feature available on iOS 13+ and macOS 10.15+
|
|
Task {
|
|
do {
|
|
let /* ref */ _: DatabaseReference = try await DatabaseReference()
|
|
.cancelDisconnectOperations()
|
|
} catch {
|
|
// ...
|
|
}
|
|
}
|
|
}
|
|
|
|
// runTransactionBlock
|
|
|
|
// runTransactionBlock(_ block:)
|
|
databaseReference.runTransactionBlock { mutableData in
|
|
let /* mutableData */ _: MutableData = mutableData
|
|
return transactionResult
|
|
}
|
|
|
|
// runTransactionBlock(_ block:andCompletionBlock completionBlock:)
|
|
databaseReference.runTransactionBlock { mutableData in
|
|
let /* mutableData */ _: MutableData = mutableData
|
|
return transactionResult
|
|
} andCompletionBlock: { optionalError, bool, optionalDataSnapshot in
|
|
let /* optionalError */ _: Error? = optionalError
|
|
let /* bool */ _: Bool = bool
|
|
let /* optionalDataSnapshot */ _: DataSnapshot? = optionalDataSnapshot
|
|
}
|
|
|
|
if #available(iOS 13.0, macOS 10.15, macCatalyst 13.0, tvOS 13.0, watchOS 7.0, *) {
|
|
// async/await is a Swift Concurrency feature available on iOS 13+ and macOS 10.15+
|
|
Task {
|
|
do {
|
|
// runTransactionBlock(_ block:)
|
|
let _: (Bool, DataSnapshot) = try await DatabaseReference()
|
|
.runTransactionBlock { mutableData in
|
|
let /* mutableData */ _: MutableData = mutableData
|
|
return TransactionResult()
|
|
}
|
|
} catch {
|
|
// ...
|
|
}
|
|
}
|
|
}
|
|
|
|
// runTransactionBlock(_ block:andCompletionBlock completionBlock:withLocalEvents localEvents:)
|
|
databaseReference.runTransactionBlock({ mutableData in
|
|
let /* mutableData */ _: MutableData = mutableData
|
|
return transactionResult
|
|
}, andCompletionBlock: { optionalError, bool, optionalDataSnapshot in
|
|
let /* optionalError */ _: Error? = optionalError
|
|
let /* bool */ _: Bool = bool
|
|
let /* optionalDataSnapshot */ _: DataSnapshot? = optionalDataSnapshot
|
|
}, withLocalEvents: yes)
|
|
|
|
// description
|
|
let /* description */ _: String = databaseReference.description()
|
|
|
|
// Class methods
|
|
DatabaseReference.goOffline()
|
|
DatabaseReference.goOnline()
|
|
|
|
// Instance properties
|
|
let /* parent */ _: DatabaseReference? = databaseReference.parent
|
|
let /* childKey */ _: String? = databaseReference.key
|
|
databaseReference = databaseReference.root
|
|
url = databaseReference.url
|
|
database = databaseReference.database
|
|
|
|
// MARK: - DataEventType
|
|
|
|
let optionalDataEventType = DataEventType(rawValue: 0)
|
|
|
|
switch optionalDataEventType {
|
|
case .childAdded:
|
|
break
|
|
case .childRemoved:
|
|
break
|
|
case .childChanged:
|
|
break
|
|
case .childMoved:
|
|
break
|
|
case .value:
|
|
break
|
|
case .none, .some:
|
|
break
|
|
}
|
|
|
|
// MARK: - DataSnapshot
|
|
|
|
var dataSnapshot = DataSnapshot()
|
|
|
|
// Navigating and inspecting a snapshot
|
|
dataSnapshot = dataSnapshot.childSnapshot(forPath: path)
|
|
let /* hasChild */ _: Bool = dataSnapshot.hasChild(child)
|
|
let /* hasChildren */ _: Bool = dataSnapshot.hasChildren()
|
|
let /* exists */ _: Bool = dataSnapshot.exists()
|
|
|
|
// Data export
|
|
let /* value */ _: Any? = dataSnapshot.valueInExportFormat()
|
|
|
|
// Properties
|
|
databaseReference = dataSnapshot.ref
|
|
let /* value */ _: Any? = dataSnapshot.value
|
|
let /* uint */ _: UInt = dataSnapshot.childrenCount
|
|
let /* child */ _: String? = dataSnapshot.key
|
|
let /* children */ _: NSEnumerator = dataSnapshot.children
|
|
let /* priority */ _: Any? = dataSnapshot.priority
|
|
|
|
// MARK: - MutableData
|
|
|
|
var mutableData = MutableData()
|
|
|
|
// Inspecting and navigating the data
|
|
let /* hasChildren */ _: Bool = mutableData.hasChildren()
|
|
let /* hasChild */ _: Bool = mutableData.hasChild(atPath: path)
|
|
mutableData = mutableData.childData(byAppendingPath: path)
|
|
|
|
// Properties
|
|
let /* value */ _: Any? = mutableData.value
|
|
let /* priority */ _: Any? = mutableData.priority
|
|
|
|
let /* uint */ _: UInt = mutableData.childrenCount
|
|
let /* children */ _: NSEnumerator = mutableData.children
|
|
let /* childKey */ _: String? = mutableData.key
|
|
|
|
// MARK: - ServerValue
|
|
|
|
let nsNumber: NSNumber = 0
|
|
|
|
let /* values */ _: [AnyHashable: Any] = ServerValue.timestamp()
|
|
let /* values */ _: [AnyHashable: Any] = ServerValue.increment(nsNumber)
|
|
|
|
// MARK: - TransactionResult
|
|
|
|
transactionResult = TransactionResult.success(withValue: mutableData)
|
|
transactionResult = TransactionResult.abort()
|
|
}
|
|
}
|