# Working with scalar lists (Prisma ORM v7) (/docs/orm/v7/prisma-client/special-fields-and-types/working-with-scalar-lists-arrays)

> For the complete Prisma documentation index, see [llms.txt](https://www.prisma.io/docs/llms.txt). A markdown version of any docs page is available by appending `.md` to its URL.

How to read, write, and filter by scalar lists / arrays

Location: ORM > v7 > Prisma Client > Special Fields and Types > Working with scalar lists

[Scalar lists](https://www.prisma.io/docs/orm/v7/reference/prisma-schema-reference#-modifier) are represented by the `[]` modifier and are only available if the underlying database supports scalar lists. The following example has one scalar `String` list named `pets`:

  

#### Relational databases

```prisma highlight=4;normal 
model User {
  id   Int      @id @default(autoincrement())
  name String
  pets String[] // [!code highlight]
}
```

#### MongoDB

```prisma highlight=4;normal 
model User {
  id   String   @id @default(auto()) @map("_id") @db.ObjectId
  name String
  pets String[] // [!code highlight]
}
```

Example field value:

```json5
["Fido", "Snoopy", "Brian"]
```

## Setting the value of a scalar list [#setting-the-value-of-a-scalar-list]

The following example demonstrates how to [`set`](https://www.prisma.io/docs/orm/v7/reference/prisma-client-reference) the value of a scalar list (`coinflips`) when you create a model:

```ts
const createdUser = await prisma.user.create({
  data: {
    email: "eloise@prisma.io",
    coinflips: [true, true, true, false, true],
  },
});
```

## Unsetting the value of a scalar list [#unsetting-the-value-of-a-scalar-list]

> [!WARNING]
> This method is available on MongoDB only.

The following example demonstrates how to [`unset`](https://www.prisma.io/docs/orm/v7/reference/prisma-client-reference#unset) the value of a scalar list (`coinflips`):

```ts
const createdUser = await prisma.user.create({
  data: {
    email: "eloise@prisma.io",
    coinflips: {
      unset: true,
    },
  },
});
```

Unlike `set: null`, `unset` removes the list entirely.

## Adding items to a scalar list [#adding-items-to-a-scalar-list]

> [!NOTE]
> Available for PostgreSQL, CockroachDB, and MongoDB.

Use the [`push`](https://www.prisma.io/docs/orm/v7/reference/prisma-client-reference#push) method to add a single value to a scalar list:

```ts
const userUpdate = await prisma.user.update({
  where: {
    id: 9,
  },
  data: {
    coinflips: {
      push: true,
    },
  },
});
```

In earlier versions, you have to overwrite the entire value. The following example retrieves user, uses `push()` to add three new coin flips, and overwrites the `coinflips` field in an `update`:

```ts
const user = await prisma.user.findUnique({
  where: {
    email: "eloise@prisma.io",
  },
});

if (user) {
  console.log(user.coinflips);

  user.coinflips.push(true, true, false);

  const updatedUser = await prisma.user.update({
    where: {
      email: "eloise@prisma.io",
    },
    data: {
      coinflips: user.coinflips,
    },
  });

  console.log(updatedUser.coinflips);
}
```

## Filtering scalar lists [#filtering-scalar-lists]

> [!NOTE]
> Available for PostgreSQL, CockroachDB, and MongoDB.

Use [scalar list filters](https://www.prisma.io/docs/orm/v7/reference/prisma-client-reference#scalar-list-filters) to filter for records with scalar lists that match a specific condition. The following example returns all posts where the tags list includes `databases` *and* `typescript`:

```ts
const posts = await prisma.post.findMany({
  where: {
    tags: {
      hasEvery: ["databases", "typescript"],
    },
  },
});
```

### `NULL` values in arrays [#null-values-in-arrays]

> [!NOTE]
> This section applies to PostgreSQL and CockroachDB.

When using scalar list filters with a relational database connector, array fields with a `NULL` value are not considered by the following conditions:

* `NOT` (array does not contain X)
* `isEmpty` (array is empty)

This means that records you might expect to see are not returned. Consider the following examples:

* The following query returns all posts where the `tags` **do not** include `databases`:

  ```ts
  const posts = await prisma.post.findMany({
    where: {
      NOT: {
        tags: {
          has: "databases",
        },
      },
    },
  });
  ```

  * ✔ Arrays that do not contain `"databases"`, such as `{"typescript", "graphql"}`
  * ✔ Empty arrays, such as `[]`

  The query does not return:

  * ✘ `NULL` arrays, even though they do not contain `"databases"`

The following query returns all posts where `tags` is empty:

```ts
const posts = await prisma.post.findMany({
  where: {
    tags: {
      isEmpty: true,
    },
  },
});
```

The query returns:

* ✔ Empty arrays, such as `[]`

The query does not return:

* ✘ `NULL` arrays, even though they could be considered empty

To work around this issue, you can set the default value of array fields to `[]`.

## Related pages

- [`Composite types`](https://www.prisma.io/docs/orm/v7/prisma-client/special-fields-and-types/composite-types): Work with composite types and embedded documents in MongoDB
- [`Null and undefined`](https://www.prisma.io/docs/orm/v7/prisma-client/special-fields-and-types/null-and-undefined): How Prisma Client handles null and undefined
- [`Working with compound IDs and unique constraints`](https://www.prisma.io/docs/orm/v7/prisma-client/special-fields-and-types/working-with-composite-ids-and-constraints): How to read, write, and filter by compound IDs and unique constraints
- [`Working with Json fields`](https://www.prisma.io/docs/orm/v7/prisma-client/special-fields-and-types/working-with-json-fields): How to read, write, and filter by Json fields