FaunaDB is a global serverless database that gives you ubiquitous, low latency access to app data, without sacrificing data correctness. It eliminates layers of app code for manually handling data anomalies, security, and scale, creating a friendlier dev experience for you and better app experience for your users.

Fauna is inspired by [Calvin](https://blog.acolyer.org/2019/03/29/calvin-fast-distributed-transactions-for-partitioned-database-systems/), has [built-in GraphQL integration](https://docs.fauna.com/fauna/current/api/graphql/), and a query language based on lambda calculus. Be sure to check out the [Jepsen analysis](https://jepsen.io/analyses/faunadb-2.5.4) and the associated [chart of consistency models](https://jepsen.io/consistency)

FaunaDB is a Calvin inspired hosted database marketed towards JAMStack and serverless users. It is geo-replicated across multiple providers (AWS, GCP, and soon Azure), uses a lambda calculus based query language (FQL) or the built-in GraphQL support, and is quick to get started with. Don't worry about the vocabulary here (Consistency, lambda calculus, etc), FaunaDB can be quickly put to work without reading any papers and without knowing what lambda calculus is.

* [Calvin Paper](http://cs.yale.edu/homes/thomson/publications/calvin-sigmod12.pdf) (warning: pdf link)
  - [Morning Paper Overview of Calvin Paper](https://blog.acolyer.org/2019/03/29/calvin-fast-distributed-transactions-for-partitioned-database-systems/) if you don't want to read the whole paper
* [jepsen report](https://jepsen.io/analyses/faunadb-2.5.4)

An Introduction to FaunaDB

We walk through creating a new Database in the FaunaDB console complete with some demo data. We do some exploration of the data, introducing concepts like Collections and Indexes, before showing an example FQL query that runs against the database. This sets us up to talk about FQL in future videos

Creating your first FaunaDB database

FQL is the main query language for interacting with FaunaDB. It supports all JSON types, plus some additional types like Ref, Date, and Set. FQL is based in expressions and as such everything returns a value. This makes it easy to compose logic into larger queries.

Code shown in the shell:

```
Match(Index("all_customers"))
```

Overview of the FaunaDB Query Language (FQL)

When working with FQL it's often the case that you'll encounter Refs. Refs don't have any fields on them though! So how do we access the fields? Get.

```
Collections()
```

```
Collection("customers")
```

```
Ref(Collection("customers"), "244075679454331401")
```

```
Get(Ref(Collection("customers"), "244075679454331401"))
```

```
Get(Collection("customers"))
```

Getting fields out of Refs with Get

FQL Page objects have additional fields like before, and data, that may make it seem like you need to Select to get at the underlying array of results. However, FQL supports passing Page objects directly to functions that operate on arrays and the function will transparently operate on the contained data field.

```
Paginate(Match(Index("all_customers")))
```

```
Drop(1, Paginate(Match(Index("all_customers"))))
```

```
Take(1, Paginate(Match(Index("all_customers"))))
```

FQL Page objects can be arguments to Array functions

Paginate can be used with options to move forward or backward in the list of results. We can also limit or expand the number of results we get in a Page.

```
Paginate(Match(Index("all_customers")))
```

```
Paginate(Match(Index("all_customers")), { size: 2 })
```

```
Paginate(
  Match(Index("all_customers")),
  {
    size: 2,
    after: Ref(Collection("customers"), "244075679455381001)
  }
)
```

Paginating and passing other options with Paginate

Lambdas allow you to use functions like Map or Filter effectively in FQL. In this lesson we should the Lambda syntax by operating on some paginated results.

```
Paginate(Match(Index("all_customers")))
```

```
Map(
  Paginate(Match(Index("all_customers"))),
  Lambda("X", Get(Var("X")))
)
```

Using FQL Lambda in Array functions

`Ref`s are opaque. To access the fields on a document associated with a `Ref`, we first need to run `Get` on our results and then we can access fields using `Select`

```
Map(
  Paginate(Match(Index("all_customers"))),
  Lambda("X", Get(Var("X")))
)
```

```
Map(
  Paginate(Match(Index("all_customers"))),
  Lambda("X", Select(["data", "firstName"], Get(Var("X"))))
)
```

Accessing fields through Refs with Select

FaunaDB supports access keys with four sets of permissions, or roles. You need an access token to use a language driver like the Go driver to access FaunaDB. It is not exposed by default. The four roles are: Admin, Server, Server-ReadOnly, and Client. We'll go over what these roles are and how to choose one for your use case.

Creating an access token and choosing a role for it

How to create a document in a collection using the FaunaDB shell. Note that when sending the document in, you have to make it a value of the `data` key.

```
Create(
  Collection("customers"),
  {
    data: {
      firstName: "Jane",
      lastName: "Doe",
      address: {
        street: "87856 Mendota Court",
        city: "Idaho Falls",
        state: "ID",
        zipCode: "83405"
      },
      telephone: "208-346-0715",
      creditCard: {
        network: "Visa",
        number: "4556781272473393"
      }
    }
  }
)
```

Inserting a document

You can use array and object literals to compose multiple selections into a single query, such as within a lambda.

```
Map(
  Paginate(Match(Index("all_customers"))),
  Lambda(
    "X",
    Select(["data", "firstName"], Get(Var("X")))
  )
)
```

with arrays

```
Map(
  Paginate(Match(Index("all_customers"))),
  Lambda(
    "X",
    [
      Select(["data", "firstName"], Get(Var("X"))),
      Select(["data", "lastName"], Get(Var("X")))
    ]
  )
)
```

with objects

```
Map(
  Paginate(Match(Index("all_customers"))),
  Lambda(
    "X",
    [
      Select(["data", "firstName"], Get(Var("X"))),
      Select(["data", "lastName"], Get(Var("X")))
    ]
  )
)
``````
Map(
  Paginate(Match(Index("all_customers"))),
  Lambda(
    "X",
    {
      firstName: Select(["data", "firstName"], Get(Var("X"))),
      lastName: Select(["data", "lastName"], Get(Var("X")))
    }
  )
)
```

Selecting multiple fields in an FQL query

The FaunaDB CLI is distributed on NPM and includes an interactive shell as well as the ability to send queries from a file.

```
npm i -g fauna-shell
fauna cloud-login
fauna -h
fauna list-databases
```

open a shell to a database:

```
fauna shell test-demo
```

```
Match(Index("all_customers"))
```

```
Paginate(Match(Index("all_customers")))
```

Running queries from a file

```
fauna eval test-demo --file=./fauna.fql
```






Installing the FaunaDB CLI and using it to send queries from a local file

The FaunaDB [hosted product pricing](https://fauna.com/pricing) charges you based on read ops (in addition to write ops, storage, and data transfer). This can make it important to reduce the number of read ops in a heavily used query to stay within your expected limits on a given day.

```
Map(
  Paginate(Match(Index("all_customers"))),
  Lambda("X", Get(Var("X")))
)
```

```
Paginate(Match(Index("all_customers_with_fields"))),
```

The number of read ops can be found by inspecting the headers for a given query.

```
X-Read-Ops: 4
```

Reducing the number of read ops in a query using indexes

There are a couple of different way to execute multiple expressions in FQL. `Do` is a function that lets us execute expressions in order and fail the entire query if one of the expressions fails.

```
Do(
  Create(Collection("products")), {
    data: {
      "name": "Bacon",
      "description": "crispy, hot",
      "price": 4.27,
      "quantity": 1000,
      "warehouse": Ref(Collection("warehouses"), "244075679449088521"),
      "backorderLimit": 15,
      "backordered": false
    }
  }),
  Paginate(Match(Index("all_products")))
)
```

Orchestrating multiple dependent expressions in the same transaction with Do

FaunaDB has native support for a GraphQL API backed by FQL. In this video we'll cover the limitations, importing a GraphQL schema, and executing our first mutations and queries.

```graphql
type Todo {
    title: String!
    completed: Boolean
}

type Query {
    allTodos: [Todo!]
    todosByCompletedFlag(completed: Boolean!): [Todo!]
}
```

```graphql
mutation CreateTodo {
  createTodo(data: {
    title: "Finish Video on GraphQL"
  }) {
    _id
    completed
  }
}
```

```graphql
mutation CreateTodo {
  createTodo(data: {
    title: "Add Second Todo",
    completed: false
  }) {
    _id
    completed
  }
}
```

```graphql
mutation UpdateTodo {
  updateTodo (
    id: "245273222698762765"
    data: {
      title: "A Different Todo",
      completed: false
    }) {
    title
    completed
  }
}
```

```graphql
query AllTodosQuery {
  allTodos {
    data { _id title completed }
  }
}
```

```graphql
query AllTodosQuery {
  todosByCompletedFlag(completed: false) {
    data {
      _id
      title
    }
  }
}
```

The Complete Guide to FaunaDB

Instructor

Course content (15 lessons)

Instructor