An individual postgrest parameter.

A collection of parameters that make up a postgrest request.

A type representing which attributes and resources you want to select.

A type to specify whether you want an order to be ascending or descending.

A type that represents the clause of a query. In name=eq.John the clause would be the part after the equal sign.

A constructor for the select parameter.

P.select
    [ P.attribute "id"
    , P.attribute "title"
    , P.resource "user" <|
        P.attributes
            [ "email"
            , "name"
            ]
    ]

When you want to select all attributes. This is only useful when used to select attributes of a resource or override default parameters in another function since postgrest returns all attributes by default.

When you want to select a certain column.

Shorthand for attributes, when you don't need to specify nested resources:

-- Short version
attributes [ "id" "name" ]


-- Long version
[ attribute "id"
, attribute "name"
]

When you want to select a nested resource with no special parameters for the nested resources. If you do, see resourceWithParams.

When you want to select a nested resource with special praameters.

[ P.select
    [ P.resource "sites"
        [ P.resourceWithParams "streams"
            [ P.order [ P.asc "name" ]
            ]
            allAttributes
        ]
    ]
]
    |> toQueryString


-- select=sites(streams(*))&sites.streams.order=name.asc

Takes a default set of params and a custom set of params and prefers the second set. Useful when you're constructing reusable functions that make similar queries.

Takes Params and returns the parameters as a list of (Key, Value) strings.

Takes Params and returns a query string such as foo=eq.bar&baz=is.true

A constructor for an individual postgrest parameter.

param "name" (eq (string "John"))

Join multiple conditions together with or.

Join multiple conditions together with and.

When you want to specify an operator for a nested resource manually. It is recommended to use resourceWithParams though.

[ select
    [ attribute "*"
    , resource "actors" allAttributes
    ]
, nestedParam [ "actors" ] <| limit 10
, nestedParam [ "actors" ] <| offset 2
]
|> toQueryString
-- "select=*,actors(*)&actors.limit=10&actors.offset=2"

Used to indicate you need a column to be equal to a certain value.

Used to indicate you need a column to be greater than a certain value.

Used to indicate you need a column to be greater than or equal than a certain value.

Used to indicate you need a column to be within a certain list of values.

A constructor for the limit parameter.

limit 10

Used to indicate you need a column to be less than a certain value.

Used to indicate you need a column to be less than or equal than a certain value.

Used to indicate you need a column to be not equal to a certain value.

Negate a condition.

When you need a column value to be true

When you need a column value to be false

When a value needs to be null

param "age" <| null

When you don't want to use a specific type after the equals sign in the query, you can use value to set anything you want.

Offset

ILIKE operator (use * in place of %)

param "text" <| ilike "foo*bar"

LIKE operator (use * in place of %)

param "text" <| like "foo*bar"

Normalize a string into a postgrest value.

Normalize an int into a postgrest value.

This is available if you need it, but more likely you'll want to use inList.

A constructor for the limit parameter.

order (asc "name")


order (desc "name")

Used in combination with order to sort results ascending.

Used in combination with order to sort results descending.

Sort nulls first.

order [ asc "age" |> nullsfirst ]

Sort nulls last.

order [ asc "age" |> nullslast ]

Full-Text Search using plainto_tsquery

Full-Text Search using phraseto_tsquery

Full-Text Search using to_tsquery

[ param "my_tsv" <| fts (Just "french") "amusant" ]
    |> toQueryString


"my_tsv=fts(french).amusant"