> ## Documentation Index
> Fetch the complete documentation index at: https://www.paradedb.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Indexing Text Arrays

> Add text arrays to the index

The ParadeDB index accepts arrays of type `text[]` or `varchar[]`.

```sql theme={null}
CREATE TABLE array_demo (id SERIAL PRIMARY KEY, categories TEXT[]);
INSERT INTO array_demo (categories) VALUES
    ('{"food","groceries and produce"}'),
    ('{"electronics","computers"}'),
    ('{"books","fiction","mystery"}');
```

```sql SQL theme={null}
CREATE INDEX search_idx ON array_demo
USING paradedb (id, categories);
```

```ts Drizzle theme={null}
import { indexing } from "@paradedb/drizzle-paradedb";

indexing.paradedbIndex("search_idx").on(arrayDemo.id, arrayDemo.categories);
```

```python Django theme={null}
from django.db import connection
from paradedb.indexes import ParadeDBIndex

with connection.schema_editor() as schema_editor:
    schema_editor.add_index(
        ArrayDemo,
        ParadeDBIndex(
            fields={
                "id": {},
                "categories": {},
            },
            name="search_idx",
        ),
    )
```

```python SQLAlchemy theme={null}
from sqlalchemy import Index
from paradedb.sqlalchemy import indexing

idx = Index(
    "search_idx",
    indexing.ParadeDBField(ArrayDemo.id),
    indexing.ParadeDBField(ArrayDemo.categories),
    postgresql_using="paradedb",
)

with engine.begin() as conn:
    idx.create(conn)
```

```ruby Rails theme={null}
ActiveRecord::Base.connection.add_paradedb_index(
  :array_demo,
  fields: {
    id: {},
    categories: {}
  },
  name: :search_idx
)
```

```cs EF Core theme={null}
modelBuilder.Entity<ArrayDemo>()
    .HasParadeDbIndex("search_idx", e => e.Id)
    .HasField(e => e.Categories);
```

Under the hood, each element in the array is indexed as a separate entry. This means that an array is considered a
match if **any** of its entries is a match.

```sql theme={null}
SELECT * FROM array_demo WHERE categories === 'food';
```

```ini Expected Response theme={null}
 id |           categories
----+--------------------------------
  1 | {food,"groceries and produce"}
(1 row)
```

Text arrays can be [tokenized](https://www.paradedb.com/docs/reference/tokenizers/overview.md) and [filtered](https://www.paradedb.com/docs/reference/token-filters/overview.md) in the same way as text fields:

```sql SQL theme={null}
CREATE INDEX search_idx ON array_demo
USING paradedb (id, (categories::pdb.literal));
```

```ts Drizzle theme={null}
import { indexing, tokenizer } from "@paradedb/drizzle-paradedb";

indexing
  .paradedbIndex("search_idx")
  .on(
    arrayDemo.id,
    indexing.paradedbField(arrayDemo.categories, tokenizer.literal()),
  );
```

```python Django theme={null}
from django.db import connection
from paradedb.indexes import ParadeDBIndex
from paradedb.search import Tokenizer

with connection.schema_editor() as schema_editor:
    schema_editor.add_index(
        ArrayDemo,
        ParadeDBIndex(
            fields={
                "id": {},
                "categories": {"tokenizer": Tokenizer.literal()},
            },
            name="search_idx",
        ),
    )
```

```python SQLAlchemy theme={null}
from sqlalchemy import Index
from paradedb.sqlalchemy import indexing, tokenizer

idx = Index(
    "search_idx",
    indexing.ParadeDBField(ArrayDemo.id),
    indexing.ParadeDBField(ArrayDemo.categories, tokenizer=tokenizer.literal()),
    postgresql_using="paradedb",
)

with engine.begin() as conn:
    idx.create(conn)
```

```ruby Rails theme={null}
ActiveRecord::Base.connection.add_paradedb_index(
  :array_demo,
  fields: {
    id: {},
    categories: { tokenizer: ParadeDB::Tokenizer.literal() }
  },
  name: :search_idx
)
```

```cs EF Core theme={null}
modelBuilder.Entity<ArrayDemo>()
    .HasParadeDbIndex("search_idx", e => e.Id)
    .HasField(e => e.Categories, Tokenizer.Literal());
```


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.