Skip to main content

Database Service

Hive SDK uploads unstructured data to the corresponding Vault through DatabaseService class. Unstructured database type data is one of the data types supported by Hive SDK. DatabaseService class is one of the derived sub-services in Vault Service, which is used to support operations on unstructured data types, such as insert/update/query of the CRUD functions. Once the unstructured data is saved in Hive Node, it will be persisted in the corresponding MongoDB service.

Insert a Document​

An example of inserted data is as follows:

let vault = try Vault(context, providerAddress)
let databaseServic = vault.databaseService

let docNode = ["author" : "john doe1", "title" : "Eve for Dummies1"]

_databaseService.insertOne(YOUR_COLLECT_NAME, docNode, InsertOptions()
.bypassDocumentValidation(false))
.done{ insertResult in
    print("Inserted a document to database in success.")
 }
.catch{ error in
    print("Failed to insert a document.")
    print(error)
}

To insert data, you need to construct Json data first and then insert it into the specified data table (COLLECTION_NAME). At the same time, you can specify the InsertOptions, which are derived from the corresponding functions of MongoDB database.

Create Collection​

In MongoDB, collection represents a data table where one with a specified name is created. After creation, user data can be inserted.

databaseService!.createCollection("your_collection")
.done { success in
  print("Create the collection successfully")
}
.catch { error in
    print("Failed to create the collection")
   print(error)
}

Delete Collection​

Delete the MongoDB data table and all the data within will be deleted.

databaseService!.deleteCollection("your_collection")
.done { success in
   print("Delete the collection successfully")
}
.catch { error in
    print("Failed to delete the collection.")
   print(error)
}

Insert​

Insert data into the data table, which can be a single or multiple pieces of data. As shown in the example above, the insert option InsertOptions originates from MongoDB’s option to insert document. Please refer to the definition of InsertOptions for specific options. Here is an example of inserting multiple pieces of data:

 let nodes = [
                ["author" : "john doe2", "title" : "Eve for Dummies2"],
                ["author" : "john doe3", "title" : "Eve for Dummies3"],
            ]
databaseService.insertMany("your_collection", nodes, InsertOptions().bypassDocumentValidation(false).ordered(true))
.done { insertResult in
   print("Inserted two documents successfully.")
}
.catch { error in
  print("Failed to insert documents.")
  print(error)
}

Update​

Just like inserting data, updating data also provides two versions of interfaces: updating the first or multiple pieces of data that meet the conditions, and updating data also supports providing update options. Update a single piece of data as follows:

let filter = ["author" : "john doe1"]
let doc = ["author" : "john doe1", "title" : "Eve for Dummies1_1"]
let update = ["$set" : doc]
databaseService!.updateOne("your_collection", filter, update, UpdateOptions()
.setBypassDocumentValidation(false).setUpsert(true))
.done { updateResult in
   print("Update the document successfully.")
}
.catch { error in
    print("Failed to update the document.")
   print(error)
}

Example of updating multiple pieces of data:​

let filter = ["author" : "john doe1"]
let doc = ["author" : "john doe1", "title" : "Eve for Dummies1_2"]
let update = ["$set" : doc]

databaseService!.updateMany("your_collection", filter, update, UpdateOptions()
.setBypassDocumentValidation(true))
.done { updateResult in
   print("Update the documents successfully.")
}
.catch { error in
   print("Failed to update the documents.")
   print(error)
}

Delete​

The method of deleting data is the same - two versions are provided. Only by providing indication and deletion conditions, the data that meets the conditions will be deleted. The following is an example of deleting the first piece of data that meets the conditions:

let filter = ["author" : "john doe2"]
databaseService!.deleteOne("your_collection", filter)
.done { success in
  print("Delete the document successfully.")
}
.catch { error in
  print("Failed to delete the document.")
  print(error)
}

Example of deleting multiple pieces of data that meet the conditions are as follows:​

let filter = ["author" : "john doe2"]
databaseService!.deleteMany("your_collection", filter)
.done { success in
   print("Delete the documents successfully.")
}
.catch { error in
  print("Failed to delete the documents.")
  print(error)
}

Count​

The following methods can be used to calculate the amount of data in the table. You need to specify the table name, query conditions, and parameters.

let filter = ["author" : "john doe1"]
databaseService!.countDocuments("your_collection", filter, CountOptions().setLimit(1).setSkip(0).setMaxTimeMS(1000000000))
.done { count in
   print("Count the documents successfully.")
   print("count => \(count)")
}
.catch { error in
    print("Failed to count the documents.")
   print(error)
}

Find and Query​

There are three ways to search data: search the first piece of data that meets the conditions, search multiple pieces of data that meet the conditions, and return version of multiple pieces of data with multiple query conditions. All three methods are required: table name, query conditions and query options.

let query = ["author" : "john doe1"]
databaseService!.findOne("your_collection", query, FindOptions().setSkip(0).setLimit(0))
.done { document in
   print("Find the document successfully.")
   print("author => \(document["author"])")
   print("title => \(document["title"])")
}
.catch { error in
   print("Failed to find the document.")
   print(error)
}

An example of multiple search results is as follows:​

let query = ["author" : "john doe1"]
databaseService!.findMany("your_collection", query, FindOptions().setSkip(0).setLimit(0))
.done { list in
   print("Find the documents successfully.")
   print("author => \(document[author])")
   print("title => \(document["title"])")
}.catch { error in
   print("Failed to find the documents.")
   print(error)
}

Below is an example of more query options that can be used when finding multiple results is as follows:

let query = ["author" : "john doe1"]
databaseService!.query("your_collection", query, nil)
.done { list in
   print("Find the documents successfully.")
   print("author => \(document["author"])")
   print("title => \(document["title"])")
}
.catch { error in
   print("Failed to find the documents.")
   print(error)
}