-
{state.messages.map((msg, index) => (
| Operator | Name | Description | Use Cases |
|---|---|---|---|
| \<-> | vector\_l2\_ops | L2 distance. Measure of the straight-line distance between two points in a multi-dimensional space. It calculates the length of the shortest path between the points, which corresponds to the hypotenuse of a right triangle. | Used in clustering, k-means clustering, and distance-based classification algorithms |
| \<#> | vector\_ip\_ops | Inner product. The inner product, also known as the dot product, measures the similarity or alignment between two vectors. It calculates the sum of the products of corresponding elements in the vectors. | Used in similarity comparison or feature selection. Note that for normalized vectors, inner product will result in the same ranking as cosine distance, but is more efficient to calculate. So this is a good choice if you use an embedding algorith that produces normalized vectors (such as OpenAI's) |
| \<=> | vector\_cosine\_ops | Cosine distance. Cosine distance, often used as cosine similarity when measuring similarity, quantifies the cosine of the angle between two vectors in a multi-dimensional space. It focuses on the direction rather than the magnitude of the vectors. | Used in text similarity, recommendation systems, and any context where you want to compare the direction of vectors |
| \<+> | vector\_l1\_ops | L1 distance. The L1 distance, also known as the Manhattan distance, measures the distance between two points in a grid-like path (like a city block). It is the distance between two points measured along axes at right angles. | Less sensitive to outliers than L2 distance and according to some research, better for high-dimensional data. |
| \<\~> | bit\_hamming\_ops | Hamming distance. The Hamming distance measures the number of positions at which the corresponding symbols are different. | Used with binary vectors. Mostly for discrete data like categories. Also used for error-correcting codes and data compression. |
| \<%> | bit\_jaccard\_ops | Jaccard distance. Measures similarity between sets by calculating the ratio of the intersection to the union of the two sets (how many positions are the same out of the total positions). | Used with binary vectors. Useful for comparing customers purchase history, recommendation systems, similarites in terms used in different texts, etc. |
{setup?.method === 'authenticator' && setup.scope === 'setup' ? (
console.error('MFA error', msg)}
onSuccess={(scope) => scope === 'setup' && window.location.reload()}
/>
) : null}
{errorType ?
);
}
```
Unable to start MFA ({errorType})
: null}
{setup?.method === 'email' && setup.scope === 'setup' ? (
scope === 'setup' && window.location.reload()}
/>
) : null}
{errorType ?
);
}
```
## Challenge content (sign-in or disable)
`Unable to start MFA ({errorType})
: null}
{setup && setup.scope === 'challenge' ? (
window.location.replace('/app')}
/>
) : null}
);
}
```
{error}
)}
Something went wrong.
You have selected a provider, but you have previously logged into the
app with a different one.
You are not logged in.
; } returnYou are logged in
; } export default Profile; ``` You can access the session server side by using `nile.auth.getSession`. ```jsx theme={null} import { Nile } from '@niledatabase/server'; const nile = Nile(); app.get('/some-path', async (req, res) => { const session = await nile.auth.getSession(req); if (!session) { res.status(401).json({ message: 'Unauthorized', }); return; } res.json({ message: 'You are authorized', }); }); ``` ## Session Expiry The default expiry time is 30 days. When a session expires, the user will need to log in again to create a new session. ## Revoking sessions You can revoke a database session by deleting it from the database. This will cause the user to be logged out of *all* tenants the next time they make a request. JWT sessions exist on the client side, so they cannot be revoked. ## Related Topics * [JWT](/auth/concepts/jwt) * [Users](/auth/concepts/users) * [Cookies](/auth/concepts/cookies) # Tenants Source: https://thenile.dev/docs/auth/concepts/tenants Learn about tenant management in Nile Auth This guide explains the concept of tenants in Nile Auth and how to manage them effectively within your application. ## What is a Tenant? A **tenant** in Nile Auth represents a logical partition of the system, allowing for isolated user data and configurations. Each tenant operates independently with its own set of users, resources, and configurations, while sharing common underlying infrastructure. This is a fundamental feature for multi-tenant applications. ## Tenant Features * **Multi-tenancy support**: Handle multiple tenants within the same application without interference. * **Tenant isolation**: Each tenant's data is isolated, ensuring privacy and security. * **Tenant-specific configurations**: Customize settings, resources, and behavior per tenant. ## Working with Tenants To manage tenants, you can interact with Nile Auth's API and middleware. Below is an example of how you can set the `tenantId` based on the URL parameter and handle tenant-specific tasks: ```typescript theme={null} // Middleware to set the tenantId from the URL parameter app.param('tenantId', (req, res, next, tenantId) => { nile.withContext({ tenantId }); next(); }); // get all tasks for tenant app.get('/api/tenants/:tenantId/todos', async (req, res) => { // No need for a "where" clause here because we are setting the tenant ID in the context const todos = await nile.query( `SELECT * FROM todos ORDER BY title`, ); res.json(todos.rows); }); ``` It is also possible to set a tenant id in a header using `niledb-tenant-id` ## Best Practices * **Ensure proper tenant isolation**: Use tenant-specific identifiers (e.g., `tenantId`) in all queries and resource access to prevent cross-tenant data leakage. * **Handle authentication per tenant**: Authenticate users and sessions per tenant to maintain secure access controls. * **Configure tenant-specific limits**: For example, limit the number of tasks per tenant or customize resource allocations. ## Related Concepts * [Users](/auth/concepts/users) * [Sessions](/auth/concepts/sessions) * [JWT](/auth/concepts/jwt) *** # Users Source: https://thenile.dev/docs/auth/concepts/users Understanding user management in Nile Auth Learn about user management concepts in Nile Auth, including how to create, update, and manage users and their sessions. ## User Model The `User` model in Nile Auth defines the structure of a user object. It includes both basic and custom properties to meet the needs of your application. ```typescript theme={null} interface User { id: string; email: string; name?: string | null; familyName?: string | null; givenName?: string | null; picture?: string | null; created: string; updated?: string; emailVerified?: string | null; tenants: { id: string }[]; } ``` ## User Properties ### Basic Properties * **Email**: The user's email address. This is true across all users of a database * **Profile information**: Includes details like the user's name, contact info, and other relevant data, along with any tenants the user is associated. ## User Operations ### Creating Users To create a new user, you can make a POST request to the `/users` endpoint. ```typescript theme={null} const newUser = await nile.users.createUser({ email: 'user@example.com', password: 'user1', }); ``` ### Adding users When a user is created, they are not automatically added to a tenant, unless `newTenant` is present. Users can only add other users to tenants of which they are a member. To add a user to a tenant, use `linkUser` ```typescript theme={null} const user1 = await nile.users.createUser({ email: 'user1@example.com', password: 'user1', newTenant: 'myTenant', }); const user2 = await nile.users.createUser({ email: 'user2@example.com', password: 'user2', }); // make user1 and user2 part of the same tenant const updated2 = await nile.tenants.addMember(user2.id); ``` ### Updating Users Because users are isolated to their own session, existing user update themselves via `PUT` method. A custom endpoint would need to be created in order for one user to update the information of another. ```typescript theme={null} const updatedUser = await nile.users.updateSelf({ name: 'user1' }); ``` ### Deleting Users Because user accounts are isolated, one user is unable to delete another. It is possible remove a user from a tenant from the built-in API. In order to to that, use `unlinkUser` ```typescript theme={null} const unlinked = await nile.tenants.removeMember(user2.id); ``` ## User Authentication ### Password-based AuthenticationDear ${user.email}
Reset Your Password
{/*A table for pending invites*/}
{/*A table for of existing users*/}
);
}
```
Session data: {session ? JSON.stringify(session) : null}
);
}
```
## Related topics
* [SDK reference](../sdk-reference/javascript/overview)
# Nitro
Source: https://thenile.dev/docs/auth/frameworks/nitro
Integrate Nile Auth with Nitro applications
This guide will help you get started with Nile Auth and Nitro. This guide outlines the steps required to configure and integrate authentication in your application. This guide uses the `Nuxt` layouts, and can be adjusted for any `Nitro` application
No soup for you!
;
}
return Loading...
;
}
return Current Tenant: {tenantId ?? 'None'}
Loading tenants...
; if (error) returnError loading tenants
; return (-
{tenants?.map((tenant) => (
- {tenant.name} ))}
Loading...
; returnWelcome, {user.name}!
;
}
```
| Name | Type | Default | Description |
| ---------- | --------------------------- | ----------- | ----------------------------------------------- |
| `fetchUrl` | `string` | `/api/me` | API endpoint to fetch the user data. |
| `user` | `User \| undefined \| null` | `undefined` | Initial user data, avoids fetching if provided. |
* If a `user` is passed in props, it is set immediately.
* If `user` is not provided, the hook fetches from `fetchUrl` and updates the state.
* The request runs **only once** when the component mounts.
### useResetPassword
The `useResetPassword` hook provides a way to handle password reset functionality. It sends reset requests to an authentication API and supports optional callbacks and preprocessing of request data.
```tsx theme={null}
import { useResetPassword } from '@niledatabase/react';
export default function ResetPasswordForm() {
const resetPassword = useResetPassword({
onSuccess: () => alert('Password reset successful'),
onError: (err) => console.error('Error resetting password:', err),
});
const handleSubmit = (e: React.FormEvent) => {
e.preventDefault();
const formData = new FormData(e.target as HTMLFormElement);
resetPassword({
email: formData.get('email') as string,
});
};
return (
);
}
```
| Name | Type | Default | Description |
| -------- | -------- | ----------- | --------------------------- |
| `params` | `Params` | `undefined` | Hook configuration options. |
```ts theme={null}
export type Params = {
onSuccess?: (data: Response) => void;
onError?: (error: Error) => void;
beforeMutate?: (data: MutateFnParams) => MutateFnParams;
callbackUrl?: string;
baseUrl?: string;
fetchUrl?: string;
};
```
* Calls the API at `${baseUrl}/api/auth/reset-password` (or a custom `fetchUrl`).
* Uses **PUT** for password updates and **POST** for reset requests.
* Calls `onSuccess` or `onError` based on the request outcome.
* Runs a CSRF request when the hook is initialized.
* Allows modifying data before sending using `beforeMutate`.
### useSignUp
The `useSignUp` hook provides a way to handle user sign-up requests. It supports tenant creation, API customization, and session updates after successful registration.
```tsx theme={null}
import { useSignUp } from '@niledatabase/react';
export default function SignUpForm() {
const signUp = useSignUp({
onSuccess: () => alert('Sign-up successful!'),
onError: (err) => console.error('Sign-up failed:', err),
createTenant: true, // Optionally create a tenant with the email of the user
});
const handleSubmit = (e: React.FormEvent) => {
e.preventDefault();
const formData = new FormData(e.target as HTMLFormElement);
signUp({
email: formData.get('email') as string,
password: formData.get('password') as string,
});
};
return (
);
}
```
| Name | Type | Default | Description |
| -------- | ------------------------ | ----------- | ---------------------------- |
| `params` | `Props` | `undefined` | Hook configuration options. |
| `client` | `QueryClient` (optional) | `undefined` | React Query client instance. |
```ts theme={null}
export type Props = {
onSuccess?: (data: Response, variables: unknown) => void; // success callback
onError?: (error: Error) => void; // error callback
beforeMutate?: (data: SignUpInfo) => SignUpInfo; // optional modifications to the data prior to the API call
callbackUrl?: string; // where the server should redirect users upon successful login
baseUrl?: string; // configure fetch origin
createTenant?: boolean | string; // if boolean, will create a tenant named with the user's email, else will be whatever name is provided (maps to /api/tenants?newTenantName={message ? <>{message} : null}
| Operator | Name | Description | Use Cases |
|---|---|---|---|
| \<-> | vector\_l2\_ops | L2 distance. Measure of the straight-line distance between two points in a multi-dimensional space. It calculates the length of the shortest path between the points, which corresponds to the hypotenuse of a right triangle. | Used in clustering, k-means clustering, and distance-based classification algorithms |
| \<#> | vector\_ip\_ops | Inner product. The inner product, also known as the dot product, measures the similarity or alignment between two vectors. It calculates the sum of the products of corresponding elements in the vectors. | Used in similarity comparison or feature selection. Note that for normalized vectors, inner product will result in the same ranking as cosine distance, but is more efficient to calculate. So this is a good choice if you use an embedding algorith that produces normalized vectors (such as OpenAI's) |
| \<=> | vector\_cosine\_ops | Cosine distance. Cosine distance, often used as cosine similarity when measuring similarity, quantifies the cosine of the angle between two vectors in a multi-dimensional space. It focuses on the direction rather than the magnitude of the vectors. | Used in text similarity, recommendation systems, and any context where you want to compare the direction of vectors |
| \<+> | vector\_l1\_ops | L1 distance. The L1 distance, also known as the Manhattan distance, measures the distance between two points in a grid-like path (like a city block). It is the distance between two points measured along axes at right angles. | Less sensitive to outliers than L2 distance and according to some research, better for high-dimensional data. |
| \<\~> | bit\_hamming\_ops | Hamming distance. The Hamming distance measures the number of positions at which the corresponding symbols are different. | Used with binary vectors. Mostly for discrete data like categories. Also used for error-correcting codes and data compression. |
| \<%> | bit\_jaccard\_ops | Jaccard distance. Measures similarity between sets by calculating the ratio of the intersection to the union of the two sets (how many positions are the same out of the total positions). | Used with binary vectors. Useful for comparing customers purchase history, recommendation systems, similarites in terms used in different texts, etc. |
{tenants.map((tenant: any) => (
))}
```
It looks a bit like magic, but [NextJS server fetching](https://nextjs.org/docs/app/building-your-application/data-fetching/fetching-caching-and-revalidating#fetching-data-on-the-server-with-third-party-libraries) and Nile SDK are integrated together to make this happen.
### Creating a tenant
When you click on the "Create Tenant" button, we pop out a modal form. The form is defined in `app/tenants/add-form.tsx` and uses [NextJS server actions](https://nextjs.org/docs/app/building-your-application/data-fetching/forms-and-mutations).
Create tenant logic is in `app/tenants/tenant-actions.tsx`.
In `createTenant` method, we use Nile SDK to create a new tenant and link it to the current user.
```typescript theme={null}
const createTenantResponse = await nile.tenants.create({
name: tenantName,
});
```
This call inserts a new tenant to `tenants` table, and also inserts a new row to `tenant_users` table, linking the current user to the new tenant.
You can see the new tenant in the Nile console by running `select * from tenants`.
Because the user is authenticated to the API, Nile automatically adds the user to the tenant they are creating.
### Listing tasks
When you create a tenant or select an existing tenant, you are taken to the tenant's todo list.
The code for this page is in `app/tenants/[tenantid]/todos/page.tsx`.
Since there is no API for listing specific data in your database, it is now time to being writing queries. Normally, you would write a `where` clause to accomplish some tenant-level isolation (and you still can), the Nile SDK does it a little bit differently.
Instead of using SQL `where` clauses to get only todos for this specific tenant, we are relying on Nile's tenant isolation feature:
```typescript theme={null}
const _nile = await nile.withContext({ tenantId });
// no need for where clause because we previously set Nile context
const todos = await _nile.query('select * from todos');
```
Note that this time we are configuring Nile with the tenant ID too. Previously called `configureNile` without parameters because there was no tenant yet.
Behind the scenes, Nile does two things:
* Check that the user is a member of the tenant and indeed has access to these todos
* Apply tenant isolation and execute the query in a "virtual tenant DB".
This also means that you don't need to implement the 3-way join between `todo`, `tenants` and `tenant_users`, so the code is simpler and more performant.
### Adding a task
When you click on the "+" to add a new task or on the checkbox to mark it as done, we again rely on NextJS server actions to make things simple.
You can find the logic for adding a task in `app/tenants/[tenantid]/todos/todo-actions.tsx`.
As you can see, we again use the tenant context to insert the new task:
```typescript theme={null}
const _nile = await nile.withContext({ tenantId });
await _nile.query(
`INSERT INTO todos (tenant_id, title, estimate, embedding, complete)
VALUES ($1, $2, $3, $4, $5)`,
[
tenantNile.tenantId,
title,
estimate?.substring(0, 255),
embeddingToSQL(embedding),
false,
],
);
```
or update an existing one:
```typescript theme={null}
const _nile = await nile.withContext({ tenantId });
await _nile.query(
`UPDATE todos
SET complete = $1
WHERE id = $2`,
[complete, id],
);
```
By setting the context, Nile will validate that the user indeed has permission to add tasks for this tenant,
and will make sure we only update tasks for the current tenant.
We don't want just anyone handing us tasks and telling us to do them, right?
### AI-driven time estimates
This example uses AI chat and embedding models to generate automated time estimates for each task in the todo list. We handle the time estimates in
`app/tenants/[tenantid]/todos/todo-actions.tsx`, when we add a new task.
When you add a new task, we use the embedding model to generate an embedding for the task text:
```typescript theme={null}
const embedding = await embedTask(title.toString());
```
The `embedTask` function is defined in `lib/AiUtils.tsx` and uses the embedding model to generate the embedding.
We wrap the call to the model since some vendors have slightly different inputs and outputs. This will let us switch vendors easily in the future.
```typescript theme={null}
// generate embeddings
let resp = await ai.embeddings.create({
model: embedding_model,
input: title,
});
```
Then we use the AI model to generate a time estimate for the task. We also wrapped this in a utility function, so the `addTodo` handler calls it:
```typescript theme={null}
const estimate = await aiEstimate(tenantNile, title.toString());
```
The `aiEstimate` function is defined in `lib/AiUtils.tsx` and first it looks up similar tasks using embeddings. Because we are still in the tenant
context (see the use of `tenantNile` client), we only look up tasks for this tenant:
```typescript theme={null}
const similarTasks = await tenantNile.query(
`SELECT title, estimate FROM todos WHERE embedding <-> $1 < 1`,
[embeddingToSQL(embedding)],
);
```
and finally, we use the AI model to generate the estimate. We include the similar tasks in the prompt to the model, so it can use them as reference:
```typescript theme={null}
const aiEstimate = await ai.chat.completions.create({
messages: [
{
role: 'user',
content: `you are an amazing project manager. I need to ${title}. How long do you think this will take?
I have a few similar tasks with their estimates, please use them as reference: ${similarTasks}.
respond with just the estimate, no yapping.`,
},
],
model: model,
});
```
This estimate is then stored in the database along with the task and its vector embedding.
# Build AI-Native B2B application with Postgres, NodeJS and React
Source: https://thenile.dev/docs/getting-started/languages/node
In this tutorial, you will learn to build a multi-tenant AI-native todo list application, using Nile with NodeJS, React and OpenAI's client.
We'll use Nile to provide us with virtual-tenant databases - isolating the tasks for each tenant, and we'll use the AI models to generate automated time estimates
for each task in the todo list. The estimates will be based on the task title, and estimates of similar tasks in the tenant's history.
This technique is known as [RAG architecture](https://www.thenile.dev/docs/ai-embeddings/rag).
Get Started with Sales Assistant
# Netlify
Source: https://thenile.dev/docs/integrations/netlify
Netlify is a platform for delivering modern web applications. It supports a wide range of frameworks and provides a comprehensive set of tools for building, deploying,
and managing web apps.
## Using Netlify and Nile together
Netlify supports deployment of various web frameworks and of serverless functions.
Nile's serverless database is a great fit for frameworks like NextJS and for Netlify serverless functions. Together they can be used to build B2B applications that are entirely serverless.
With Nile's tenant virtualization, you can store private data and embeddings for each of your customers in a secure and scalable manner.
In this example, we'll show you how we deploy a NextJS application to Netlify that uses Nile as a database.
### Setting Up Nile
Start by signing up for [Nile](https://console.thenile.dev/). Once you've signed up for Nile, you'll be promoted to create your first database. Go ahead and do so.
You'll be redirected to the "Query Editor" pageof your new database. This is a good time to create the table we'll be using in this example:
```sql theme={null}
CREATE TABLE todos (
id uuid DEFAULT (gen_random_uuid()),
tenant_id uuid,
title varchar(256),
estimate varchar(256),
embedding vector(768), -- must match the embedding model dimension
complete boolean);
```
Once you've created the table, you'll see it on the left-hand side of the screen. You'll also see the `tenants` table that is built-in to Nile.
**Note:** You can also start by setting up a new Netlify project and enabling the Nile integration from there. If you choose this route, make sure you still create the `todos` table.
### Setting Up Netlify
If you don't already have a Netlify account, go ahead and create one [here](https://www.netlify.com/). Pretty simple.
In your Netlify dashboard, navigate to "Extensions", choose "Nile" and click on the Tile.
You'll see a page that looks like this:
| Statement | Description | What Nile Recommends |
|---|---|---|
| CREATE FUNCTION | User defined functions are not supported yet | Push the logic to the application |
| CREATE TRIGGER | Triggers are not supported yet since UDF support is not tdere | We hope to support real time events soon |
| CREATE SEQUENCE | Not supported for tenant tables. Supported for shared tables | |
| CREATE POLICY | Nile will have the ability to define policies through a more powerful permission system that is in progress | Would love to hear your use case for this in our github discussion forum |
| CREATE ROLE | Ability to define granular roles for developers using the database | Developer roles can be supported in Nile's console when we support it |
| CREATE USER | Ability to create a new developer for a database | Creating a new developer to use the database is supported in Nile's console (and API/CLI in the future) |
| CREATE DATABASE | Ability to create a new databasee | You can do this from Nile's console |
| Transactional writes between tenant and shared tables | Writes across a tenant and shared in the same transaction | this is not common from the users we have spoken to. Usually shared tables are loaded separately from an external source. Would love to hear your use case for this in our github discussion forum |
| Foreign keys from tenant table referencing shared table | Referencing a column from a tenant table to a shared table | Would love to hear your use case for this in our github discussion forum |
| Transactional writes across different tenants | Writes across two or more tenants in the same transaction | this is not common from the users we have spoken to. Most usecases have transactions with the same tenant. Would love to hear your use case for this in our github discussion forum |
| id | name | created | updated | deleted |
|---|
| id | name | created | updated | deleted |
|---|---|---|---|---|
| 018ac98e-b37a-731b-b03a-6617e8fd5266 | customer1 | 2023-09-24 23:38:07.097633 | 2023-09-24 23:38:07.097633 |
| id | name | created | updated | deleted |
|---|---|---|---|---|
| 018ac98e-b37a-731b-b03a-6617e8fd5266 | customer1 | 2023-09-24 23:38:07.097633 | 2023-09-24 23:38:07.097633 | |
| 018aca35-b8c4-7674-882c-30ae56d7b479 | customer2 | 2023-09-25 02:40:32.964067 | 2023-09-25 02:40:32.964067 |
| tenant\_id | id | name | age | address | start\_date | title |
|---|---|---|---|---|---|---|
| 018ac98e-b37a-731b-b03a-6617e8fd5266 | 1345 | Jason | 30 | Sunnyvale,California | 2016-12-22 19:10:25 | software engineer |
| 018ac98e-b37a-731b-b03a-6617e8fd5266 | 2423 | Minnie | 24 | Seattle,Washington | 2018-11-11 12:09:22 | sales engineer |
| 018ac98e-b37a-731b-b03a-6617e8fd5266 | 4532 | Shiva | 32 | Fremont, California | 2019-09-05 04:03:12 | product manager |
| 018aca35-b8c4-7674-882c-30ae56d7b479 | 5643 | John | 36 | London,UK | 2017-12-12 19:10:25 | senior software engineer |
| 018aca35-b8c4-7674-882c-30ae56d7b479 | 1532 | Mark | 27 | Manchester,UK | 2022-10-10 12:09:22 | support engineer |
| 018aca35-b8c4-7674-882c-30ae56d7b479 | 8645 | Sam | 42 | Liverpool,UK | 2015-08-04 04:03:12 | product manager |
| tenant\_id | id | name | age | address | start\_date | title |
|---|---|---|---|---|---|---|
| 018ac98e-b37a-731b-b03a-6617e8fd5266 | 1345 | Jason | 30 | Sunnyvale,California | 2016-12-22 19:10:25 | software engineer |
| 018ac98e-b37a-731b-b03a-6617e8fd5266 | 2423 | Minnie | 24 | Seattle,Washington | 2018-11-11 12:09:22 | sales engineer |
| 018ac98e-b37a-731b-b03a-6617e8fd5266 | 4532 | Shiva | 32 | Fremont, California | 2019-09-05 04:03:12 | product manager |
| id | name | region | deployment\_mode | status | created | updated | deleted |
|---|---|---|---|---|---|---|---|
| 018ac98e-b37a-731b-b03a-6617e8fd5266 | customer1 | aws-us-east1 | dedicated | provisioning | 2023-09-24 23:38:07.097633 | 2023-09-24 23:38:07.097633 |
| id | name | region | deployment\_mode | status | created | updated | deleted |
|---|---|---|---|---|---|---|---|
| 018ac98e-b37a-731b-b03a-6617e8fd5266 | customer1 | aws-us-east1 | dedicated | ready | 2023-09-24 23:38:07.097633 | 2023-09-24 23:38:07.097633 |
| id | name | from\_location | to\_location | departure\_time | arrival\_time |
|---|---|---|---|---|---|
| 643 | United | SFO | NY | 2023-12-22 19:10:25 | 2016-12-23 05:10:25 |
| id | name | from\_location | address |
|---|---|---|---|
| 643 | United | SFO | San Francisco, CA 94128 |
| booking\_id | employee\_id | name | from\_destination | to\_destination | departure\_time | arrival\_time | total\_price |
|---|---|---|---|---|---|---|---|
| 1345 | 2 | United | SFO | NY | 2023-12-22 19:10:25 | 2016-12-23 05:10:25 | 200.00 |
| 2456 | 3 | Indian Airways | Mumbai | Delhi | 2024-11-23 19:10:25 | 2024-11-23 01:10:25 | 150.00 |
| 3240 | 4 | Indian Airways | Mumbai | Delhi | 2024-11-23 19:10:25 | 2024-11-23 01:10:25 | 250.00 |