---
title: Query Parser
description: Accept raw user-provided query strings
canonical: https://www.paradedb.com/docs/documentation/query-builder/compound/query-parser
---

The parse query accepts a [Tantivy query string](https://docs.rs/tantivy/latest/tantivy/query/struct.QueryParser.html).
The intended use case is for accepting raw query strings provided by the end user.

To use it, pass the [key field](/documentation/indexing/create-index#choosing-a-key-field) to the left-hand side of `@@@` and `pdb.parse('<query>')` to the right-hand side.

<CodeGroup>
```sql SQL
SELECT description, rating, category FROM mock_items
WHERE id @@@ pdb.parse('description:(sleek shoes) AND rating:>3');
```

```ts Drizzle
import { search } from "@paradedb/drizzle-paradedb";

await db
  .select({
    description: mockItems.description,
    rating: mockItems.rating,
    category: mockItems.category,
  })
  .from(mockItems)
  .where(search.parse(mockItems.id, "description:(sleek shoes) AND rating:>3"));
```

```python Django
from paradedb import ParadeDB, Parse

MockItem.objects.filter(
    id=ParadeDB(Parse('description:(sleek shoes) AND rating:>3'))
).values('description', 'rating', 'category')
```

```python SQLAlchemy
from sqlalchemy import select
from sqlalchemy.orm import Session
from paradedb.sqlalchemy import search

stmt = (
    select(MockItem.description, MockItem.rating, MockItem.category)
    .where(search.parse(MockItem.id, "description:(sleek shoes) AND rating:>3"))
)

with Session(engine) as session:
    session.execute(stmt).all()
```

```ruby Rails
MockItem.search(:id)
        .parse("description:(sleek shoes) AND rating:>3")
        .select(:description, :rating, :category)
```

```cs EF Core
await dbContext
    .MockItems.Where(item =>
        EF.Functions.Parse(item.Id, "description:(sleek shoes) AND rating:>3")
    )
    .Select(item => new { item.Description, item.Rating, item.Category })
    .ToListAsync();
```

</CodeGroup>

Please refer to the [Tantivy docs](https://docs.rs/tantivy/latest/tantivy/query/struct.QueryParser.html) for an overview of
the query string language.

## Lenient Parsing

By default, strict syntax parsing is used. This means that if any part of the query does not conform to Tantivy’s query string syntax, the query fails. For instance, a valid field name must be provided before every query (i.e. `category:footwear`).
By setting `lenient` to `true`, the query is executed on a best-effort basis. For example, if no field names are provided, the query is executed over all fields in the index.

<CodeGroup>
```sql SQL
SELECT description, rating, category FROM mock_items
WHERE id @@@ pdb.parse('description:(sleek shoes) AND rating:>3', lenient => true);
```

```ts Drizzle
import { search } from "@paradedb/drizzle-paradedb";

await db
  .select({
    description: mockItems.description,
    rating: mockItems.rating,
    category: mockItems.category,
  })
  .from(mockItems)
  .where(
    search.parse(mockItems.id, "description:(sleek shoes) AND rating:>3", {
      lenient: true,
    }),
  );
```

```python Django
from paradedb import ParadeDB, Parse

MockItem.objects.filter(
    id=ParadeDB(Parse('description:(sleek shoes) AND rating:>3', lenient=True))
).values('description', 'rating', 'category')
```

```python SQLAlchemy
from sqlalchemy import select
from sqlalchemy.orm import Session
from paradedb.sqlalchemy import search

stmt = (
    select(MockItem.description, MockItem.rating, MockItem.category)
    .where(search.parse(MockItem.id, "description:(sleek shoes) AND rating:>3", lenient=True))
)

with Session(engine) as session:
    session.execute(stmt).all()
```

```ruby Rails
MockItem.search(:id)
        .parse("description:(sleek shoes) AND rating:>3", lenient: true)
        .select(:description, :rating, :category)
```

```cs EF Core
await dbContext
    .MockItems.Where(item =>
        EF.Functions.Parse(
            item.Id,
            "description:(sleek shoes) AND rating:>3",
            lenient: true
        )
    )
    .Select(item => new { item.Description, item.Rating, item.Category })
    .ToListAsync();
```

</CodeGroup>

## Conjunction Mode

By default, terms in the query string are `OR`ed together. With `conjunction_mode` set to `true`, they are instead `AND`ed together.
For instance, the following query returns documents containing both `sleek` and `shoes`.

<CodeGroup>
```sql SQL
SELECT description, rating, category FROM mock_items
WHERE id @@@ pdb.parse('description:(sleek shoes)', conjunction_mode => true);
```

```ts Drizzle
import { search } from "@paradedb/drizzle-paradedb";

await db
  .select({
    description: mockItems.description,
    rating: mockItems.rating,
    category: mockItems.category,
  })
  .from(mockItems)
  .where(
    search.parse(mockItems.id, "description:(sleek shoes)", {
      conjunctionMode: true,
    }),
  );
```

```python Django
from paradedb import ParadeDB, Parse

MockItem.objects.filter(
    id=ParadeDB(Parse('description:(sleek shoes)', conjunction_mode=True))
).values('description', 'rating', 'category')
```

```python SQLAlchemy
from sqlalchemy import select
from sqlalchemy.orm import Session
from paradedb.sqlalchemy import search

stmt = (
    select(MockItem.description, MockItem.rating, MockItem.category)
    .where(search.parse(MockItem.id, "description:(sleek shoes)", conjunction_mode=True))
)

with Session(engine) as session:
    session.execute(stmt).all()
```

```ruby Rails
MockItem.search(:id)
        .parse("description:(sleek shoes)", conjunction_mode: true)
        .select(:description, :rating, :category)
```

```cs EF Core
await dbContext
    .MockItems.Where(item =>
        EF.Functions.Parse(
            item.Id,
            "description:(sleek shoes)",
            null,
            true
        )
    )
    .Select(item => new { item.Description, item.Rating, item.Category })
    .ToListAsync();
```

</CodeGroup>
