# Working with Managed Database

In this guide, you'll learn how to perform CRUD (Create, Read, Update, Delete) operations on your Blockflow Managed Databases. The process involves the following steps:

1. Initialize the Database Connection
2. Perform CRUD Operations

## Initialize the Database Connection

To interact with your Managed Database, you need to initialize a database connection within your Instance or API logic. 

Blockflow provides a `bind` function that allows you to establish a connection to your database.

First, import the necessary dependencies:

<pre class="language-typescript"><code class="lang-typescript">import { IEventContext, IBind } from "@blockflow-labs/utils";

<strong>export const handler = async (context: IEventContext, bind: IBind) => {
</strong>  // Implement your event handler logic for Issue here 
}
</code></pre>

Then, in your event handler function in the instance logic, initialize the database connection using the `bind` function:

```typescript
export const handler = async (context: IEventContext, bind: IBind) => {
  // Implement your event handler logic for Issue here 
}
```

`bind` is your gateway to the managed database.&#x20;

To initialize the database connection for the database named "Balances" in your Instance:

```typescript
import { IEventContext, Instance, IBind } from "@blockflow-labs/utils";

export const handler = async (context: IEventContext, bind: IBind) => {
  // Implement your event handler logic for Issue here 
  const balancesDB: Instance = bind(Balances);
}
```

* Inside the event handler function, we initialize the database connection by calling `bind("Balances")` and assign it to the `balancesDB` variable.
* We can then use the `balancesDB` connection to perform various database operations using the available methods.
* Make sure to replace `"Balances"` with the actual name of your database.

## Perform CRUD Operations

Once you have initialized the database connection, you can perform various CRUD operations using the MongoDB-compatible methods provided by Blockflow.

#### Example: Combining CRUD Operations

```typescript
const balancesDB: Instance = bind(Balances);
const user = "0xdac17f958d2ee523a2206206994597c13d831ec7";
let userBalance = await balancesDB.findOne({id: user.toLowerCase()});
if(!userBalance) userBalance = await balancesDB.create({id: user.toLowerCase()});
```

In this example, we demonstrate how to combine different CRUD operations to handle a specific use case:

1. We initialize the `balancesDB` connection using `bind("Balances")`.
2. We define a `user` variable to store the Ethereum address of the user we want to query or create.
3. We use the `findOne` method to check if a document with the specified `id` (converted to lowercase) exists in the database. This is a read operation.
4. If the `userBalance` document doesn't exist (`!userBalance`), we create a new document using the `create` method, passing an object with the `id` (converted to lowercase) and an initial `balance` field set to `"0"`. This is a create operation.

After this, we can perform further operations with the `userBalance` document, such as updating the balance or reading other fields.

### Creating Documents

To create a new document in your database, use the `create` method:

```typescript
const newUser = await db.create({
  id: "user123",
  name: "John Doe",
  email: "john@example.com"
});
```

### Reading Documents

To retrieve documents from your database, you can use methods like `findOne` or `find`:

```typescript
// Find a single document by ID
const user = await db.findOne({ id: "user123" });

// Find multiple documents based on a query
const activeUsers = await db.find({ status: "active" });
```

### Updating Documents

To update existing documents in your database, you can use methods like `updateOne`, `updateMany`, or `save.`

```typescript
  userBalance.balance = new BigNumber("1").toString();
  await balancesDB.save(userBalance);
```

### Deleting Documents

To delete documents from your database, use the `deleteOne` or `deleteMany` methods:

```typescript
await balancesDB.deleteOne({id: user.toLowerCase()});
```

### Best Practices

* Use lowercase for the `id` field to ensure consistent querying and indexing. If it doesn't exist it creates an empty Mongo document and returns it.&#x20;
* Include appropriate error handling and data validation in your code.
* Consider using transactions when performing multiple database operations that need to be atomic.
* You can use various MongoDB functions like `findOne()`, `updateOne()`, `save()`, `insertMany()`, `exists()`, `updateMany()`, `findOneAndUpdate()`, `replaceOne()`, `findOneAndReplace()`, `deleteOne()`, `deleteMany()`, `findOneAndDelete()` for performing CRUD operations on your managed database.
* Make sure to use `await` before calling any of the aforementioned methods, as all of them return a promise. This ensures that the operation completes before proceeding to the next line of code.

Remember to replace `"Balances"` with the actual name of your database and adjust the code according to your specific use case.

Have any questions? \
Let us know on our discord!\
<https://discord.gg/Sa2MjMNkm3>